/*
* 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.Activity;
import android.content.ComponentName;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.content.ContextWrapper;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.content.res.Resources;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.ColorFilter;
import android.graphics.ColorMatrix;
import android.graphics.ColorMatrixColorFilter;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PixelFormat;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.Environment;
import android.os.ParcelFileDescriptor;
import android.os.RemoteException;
import android.provider.MediaStore;
import android.provider.Settings;
import android.text.TextUtils;
import android.text.format.Time;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.SubMenu;
import android.view.View;
import android.view.Window;
import android.widget.TabWidget;
import android.widget.TextView;
import android.widget.Toast;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Formatter;
import java.util.HashMap;
import java.util.Locale;
public class MusicUtils {
private static final String TAG = "MusicUtils";
public interface Defs {
public final static int OPEN_URL = 0;
public final static int ADD_TO_PLAYLIST = 1;
public final static int USE_AS_RINGTONE = 2;
public final static int PLAYLIST_SELECTED = 3;
public final static int NEW_PLAYLIST = 4;
public final static int PLAY_SELECTION = 5;
public final static int GOTO_START = 6;
public final static int GOTO_PLAYBACK = 7;
public final static int PARTY_SHUFFLE = 8;
public final static int SHUFFLE_ALL = 9;
public final static int DELETE_ITEM = 10;
public final static int SCAN_DONE = 11;
public final static int QUEUE = 12;
public final static int EFFECTS_PANEL = 13;
public final static int CHILD_MENU_BASE = 14; // this should be the last item
}
public static String makeAlbumsLabel(Context context, int numalbums, int numsongs, boolean isUnknown) {
// There are two formats for the albums/songs information:
// "N Song(s)" - used for unknown artist/album
// "N Album(s)" - used for known albums
StringBuilder songs_albums = new StringBuilder();
Resources r = context.getResources();
if (isUnknown) {
if (numsongs == 1) {
songs_albums.append(context.getString(R.string.onesong));
} else {
String f = r.getQuantityText(R.plurals.Nsongs, numsongs).toString();
sFormatBuilder.setLength(0);
sFormatter.format(f, Integer.valueOf(numsongs));
songs_albums.append(sFormatBuilder);
}
} else {
String f = r.getQuantityText(R.plurals.Nalbums, numalbums).toString();
sFormatBuilder.setLength(0);
sFormatter.format(f, Integer.valueOf(numalbums));
songs_albums.append(sFormatBuilder);
songs_albums.append(context.getString(R.string.albumsongseparator));
}
return songs_albums.toString();
}
/**
* This is now only used for the query screen
*/
public static String makeAlbumsSongsLabel(Context context, int numalbums, int numsongs, boolean isUnknown) {
// There are several formats for the albums/songs information:
// "1 Song" - used if there is only 1 song
// "N Songs" - used for the "unknown artist" item
// "1 Album"/"N Songs"
// "N Album"/"M Songs"
// Depending on locale, these may need to be further subdivided
StringBuilder songs_albums = new StringBuilder();
if (numsongs == 1) {
songs_albums.append(context.getString(R.string.onesong));
} else {
Resources r = context.getResources();
if (! isUnknown) {
String f = r.getQuantityText(R.plurals.Nalbums, numalbums).toString();
sFormatBuilder.setLength(0);
sFormatter.format(f, Integer.valueOf(numalbums));
songs_albums.append(sFormatBuilder);
songs_albums.append(context.getString(R.string.albumsongseparator));
}
String f = r.getQuantityText(R.plurals.Nsongs, numsongs).toString();
sFormatBuilder.setLength(0);
sFormatter.format(f, Integer.valueOf(numsongs));
songs_albums.append(sFormatBuilder);
}
return songs_albums.toString();
}
public static IMediaPlaybackService sService = null;
private static HashMap<Context, ServiceBinder> sConnectionMap = new HashMap<Context, ServiceBinder>();
public static class ServiceToken {
ContextWrapper mWrappedContext;
ServiceToken(ContextWrapper context) {
mWrappedContext = context;
}
}
public static ServiceToken bindToService(Activity context) {
return bindToService(context, null);
}
public static ServiceToken bindToService(Activity context, ServiceConnection callback) {
Activity realActivity = context.getParent();
if (realActivity == null) {
realActivity = context;
}
ContextWrapper cw = new ContextWrapper(realActivity);
cw.startService(new Intent(cw, MediaPlaybackService.class));
ServiceBinder sb = new ServiceBinder(callback);
if (cw.bindService((new Intent()).setClass(cw, MediaPlaybackService.class), sb, 0)) {
sConnectionMap.put(cw, sb);
return new ServiceToken(cw);
}
Log.e("Music", "Failed to bind to service");
return null;
}
public static void unbindFromService(ServiceToken token) {
if (token == null) {
Log.e("MusicUtils", "Trying to unbind with null token");
return;
}
ContextWrapper cw = token.mWrappedContext;
ServiceBinder sb = sConnectionMap.remove(cw);
if (sb == null) {
Log.e("MusicUtils", "Trying to unbind for unknown Context");
return;
}
cw.unbindService(sb);
if (sConnectionMap.isEmpty()) {
// presumably there is nobody interested in the service at this point,
// so don't hang on to the ServiceConnection
sService = null;
}
}
private static class ServiceBinder implements ServiceConnection {
ServiceConnection mCallback;
ServiceBinder(ServiceConnection callback) {
mCallback = callback;
}
public void onServiceConnected(ComponentName className, android.os.IBinder service) {
sService = IMediaPlaybackService.Stub.asInterface(service);
initAlbumArtCache();
if (mCallback != null) {
mCallback.onServiceConnected(className, service);
}
}
public void onServiceDisconnected(ComponentName className) {
if (mCallback != null) {
mCallback.onServiceDisconnected(className);
}
sService = null;
}
}
public static long getCurrentAlbumId() {
if (sService != null) {
try {
return sService.getAlbumId();
} catch (RemoteException ex) {
}
}
return -1;
}
public static long getCurrentArtistId() {
if (MusicUtils.sService != null) {
try {
return sService.getArtistId();
} catch (RemoteException ex) {
}
}
return -1;
}
public static long getCurrentAudioId() {
if (MusicUtils.sService != null) {
try {
return sService.getAudioId();
} catch (RemoteException ex) {
}
}
return -1;
}
public static int getCurrentShuffleMode() {
int mode = MediaPlaybackService.SHUFFLE_NONE;
if (sService != null) {
try {
mode = sService.getShuffleMode();
} catch (RemoteException ex) {
}
}
return mode;
}
public static void togglePartyShuffle() {
if (sService != null) {
int shuffle = getCurrentShuffleMode();
try {
if (shuffle == MediaPlaybackService.SHUFFLE_AUTO) {
sService.setShuffleMode(MediaPlaybackService.SHUFFLE_NONE);
} else {
sService.setShuffleMode(MediaPlaybackService.SHUFFLE_AUTO);
}
} catch (RemoteException ex) {
}
}
}
public static void setPartyShuffleMenuIcon(Menu menu) {
MenuItem item = menu.findItem(Defs.PARTY_SHUFFLE);
if (item != null) {
int shuffle = MusicUtils.getCurrentShuffleMode();
if (shuffle == MediaPlaybackService.SHUFFLE_AUTO) {
item.setIcon(R.drawable.ic_menu_party_shuffle);
item.setTitle(R.string.party_shuffle_off);
} else {
item.setIcon(R.drawable.ic_menu_party_shuffle);
item.setTitle(R.string.party_shuffle);
}
}
}
/*
* Returns true if a file is currently opened for playback (regardless
* of whether it's playing or paused).
*/
public static boolean isMusicLoaded() {
if (MusicUtils.sService != null) {
try {
return sService.getPath() != null;
} catch (RemoteException ex) {
}
}
return false;
}
private final static long [] sEmptyList = new long[0];
public static long [] getSongListForCursor(Cursor cursor) {
if (cursor == null) {
return sEmptyList;
}
int len = cursor.getCount();
long [] list = new long[len];
cursor.moveToFirst();
int colidx = -1;
try {
colidx = cursor.getColumnIndexOrThrow(MediaStore.Audio.Playlists.Members.AUDIO_ID);
} catch (IllegalArgumentException ex) {
colidx = cursor.getColumnIndexOrThrow(MediaStore.Audio.Media._ID);
}
for (int i = 0; i < len; i++) {
list[i] = cursor.getLong(colidx);
cursor.moveToNext();
}
return list;
}
public static long [] getSongListForArtist(Context context, long id) {
final String[] ccols = new String[] { MediaStore.Audio.Media._ID };
String where = MediaStore.Audio.Media.ARTIST_ID + "=" + id + " AND " +
MediaStore.Audio.Media.IS_MUSIC + "=1";
Cursor cursor = query(context, MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
ccols, where, null,
MediaStore.Audio.Media.ALBUM_KEY + "," + MediaStore.Audio.Media.TRACK);
if (cursor != null) {
long [] list = getSongListForCursor(cursor);
cursor.close();
return list;
}
return sEmptyList;
}
public static long [] getSongListForAlbum(Context context, long id) {
final String[] ccols = new String[] { MediaStore.Audio.Media._ID };
String where = MediaStore.Audio.Media.ALBUM_ID + "=" + id + " AND " +
MediaStore.Audio.Media.IS_MUSIC + "=1";
Cursor cursor = query(context, MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
ccols, where, null, MediaStore.Audio.Media.TRACK);
if (cursor != null) {
long [] list = getSongListForCursor(cursor);
cursor.close();
return list;
}
return sEmptyList;
}
public static long [] getSongListForPlaylist(Context context, long plid) {
final String[] ccols = new String[] { MediaStore.Audio.Playlists.Members.AUDIO_ID };
Cursor cursor = query(context, MediaStore.Audio.Playlists.Members.getContentUri("external", plid),
ccols, null, null, MediaStore.Audio.Playlists.Members.DEFAULT_SORT_ORDER);
if (cursor != null) {
long [] list = getSongListForCursor(cursor);
cursor.close();
return list;
}
return sEmptyList;
}
public static void playPlaylist(Context context, long plid) {
long [] list = getSongListForPlaylist(context, plid);
if (list != null) {
playAll(context, list, -1, false);
}
}
public static long [] getAllSongs(Context context) {
Cursor c = query(context, MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
new String[] {MediaStore.Audio.Media._ID}, MediaStore.Audio.Media.IS_MUSIC + "=1",
null, null);
try {
if (c == null || c.getCount() == 0) {
return null;
}
int len = c.getCount();
long [] list = new long[len];
for (int i = 0; i < len; i++) {
c.moveToNext();
list[i] = c.getLong(0);
}
return list;
} finally {
if (c != null) {
c.close();
}
}
}
/**
* Fills out the given submenu with items for "new playlist" and
* any existing playlists. When the user selects an item, the
* application will receive PLAYLIST_SELECTED with the Uri of
* the selected playlist, NEW_PLAYLIST if a new playlist
* should be created, and QUEUE if the "current playlist" was
* selected.
* @param context The context to use for creating the menu items
* @param sub The submenu to add the items to.
*/
public static void makePlaylistMenu(Context context, SubMenu sub) {
String[] cols = new String[] {
MediaStore.Audio.Playlists._ID,
MediaStore.Audio.Playlists.NAME
};
ContentResolver resolver = context.getContentResolver();
if (resolver == null) {
System.out.println("resolver = null");
} else {
String whereclause = MediaStore.Audio.Playlists.NAME + " != ''";
Cursor cur = resolver.query(MediaStore.Audio.Playlists.EXTERNAL_CONTENT_URI,
cols, whereclause, null,
MediaStore.Audio.Playlists.NAME);
sub.clear();
sub.add(1, Defs.QUEUE, 0, R.string.queue);
sub.add(1, Defs.NEW_PLAYLIST, 0, R.string.new_playlist);
if (cur != null && cur.getCount() > 0) {
//sub.addSeparator(1, 0);
cur.moveToFirst();
while (! cur.isAfterLast()) {
Intent intent = new Intent();
intent.putExtra("playlist", cur.getLong(0));
// if (cur.getInt(0) == mLastPlaylistSelected) {
// sub.add(0, MusicBaseActivity.PLAYLIST_SELECTED, cur.getString(1)).setIntent(intent);
// } else {
sub.add(1, Defs.PLAYLIST_SELECTED, 0, cur.getString(1)).setIntent(intent);
// }
cur.moveToNext();
}
}
if (cur != null) {
cur.close();
}
}
}
public static void clearPlaylist(Context context, int plid) {
Uri uri = MediaStore.Audio.Playlists.Members.getContentUri("external", plid);
context.getContentResolver().delete(uri, null, null);
return;
}
public static void deleteTracks(Context context, long [] list) {
String [] cols = new String [] { MediaStore.Audio.Media._ID,
MediaStore.Audio.Media.DATA, MediaStore.Audio.Media.ALBUM_ID };
StringBuilder where = new StringBuilder();
where.append(MediaStore.Audio.Media._ID + " IN (");
for (int i = 0; i < list.length; i++) {
where.append(list[i]);
if (i < list.length - 1) {
where.append(",");
}
}
where.append(")");
Cursor c = query(context, MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, cols,
where.toString(), null, null);
if (c != null) {
// step 1: remove selected tracks from the current playlist, as well
// as from the album art cache
try {
c.moveToFirst();
while (! c.isAfterLast()) {
// remove from current playlist
long id = c.getLong(0);
sService.removeTrack(id);
// remove from album art cache
long artIndex = c.getLong(2);
synchronized(sArtCache) {
sArtCache.remove(artIndex);
}
c.moveToNext();
}
} catch (RemoteException ex) {
}
// step 2: remove selected tracks from the database
context.getContentResolver().delete(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, where.toString(), null);
// step 3: remove files from card
c.moveToFirst();
while (! c.isAfterLast()) {
String name = c.getString(1);
File f = new File(name);
try { // File.delete can throw a security exception
if (!f.delete()) {
// I'm not sure if we'd ever get here (deletion would
// have to fail, but no exception thrown)
Log.e("MusicUtils", "Failed to delete file " + name);
}
c.moveToNext();
} catch (SecurityException ex) {
c.moveToNext();
}
}
c.close();
}
String message = context.getResources().getQuantityString(
R.plurals.NNNtracksdeleted, list.length, Integer.valueOf(list.length));
Toast.makeText(context, message, Toast.LENGTH_SHORT).show();
// We deleted a number of tracks, which could affect any number of things
// in the media content domain, so update everything.
context.getContentResolver().notifyChange(Uri.parse("content://media"), null);
}
public static void addToCurrentPlaylist(Context context, long [] list) {
if (sService == null) {
return;
}
try {
sService.enqueue(list, MediaPlaybackService.LAST);
String message = context.getResources().getQuantityString(
R.plurals.NNNtrackstoplaylist, list.length, Integer.valueOf(list.length));
Toast.makeText(context, message, Toast.LENGTH_SHORT).show();
} catch (RemoteException ex) {
}
}
private static ContentValues[] sContentValuesCache = null;
/**
* @param ids The source array containing all the ids to be added to the playlist
* @param offset Where in the 'ids' array we start reading
* @param len How many items to copy during this pass
* @param base The play order offset to use for this pass
*/
private static void makeInsertItems(long[] ids, int offset, int len, int base) {
// adjust 'len' if would extend beyond the end of the source array
if (offset + len > ids.length) {
len = ids.length - offset;
}
// allocate the ContentValues array, or reallocate if it is the wrong size
if (sContentValuesCache == null || sContentValuesCache.length != len) {
sContentValuesCache = new ContentValues[len];
}
// fill in the ContentValues array with the right values for this pass
for (int i = 0; i < len; i++) {
if (sContentValuesCache[i] == null) {
sContentValuesCache[i] = new ContentValues();
}
sContentValuesCache[i].put(MediaStore.Audio.Playlists.Members.PLAY_ORDER, base + offset + i);
sContentValuesCache[i].put(MediaStore.Audio.Playlists.Members.AUDIO_ID, ids[offset + i]);
}
}
public static void addToPlaylist(Context context, long [] ids, long playlistid) {
if (ids == null) {
// this shouldn't happen (the menuitems shouldn't be visible
// unless the selected item represents something playable
Log.e("MusicBase", "ListSelection null");
} else {
int size = ids.length;
ContentResolver resolver = context.getContentResolver();
// need to determine the number of items currently in the playlist,
// so the play_order field can be maintained.
String[] cols = new String[] {
"count(*)"
};
Uri uri = MediaStore.Audio.Playlists.Members.getContentUri("external", playlistid);
Cursor cur = resolver.query(uri, cols, null, null, null);
cur.moveToFirst();
int base = cur.getInt(0);
cur.close();
int numinserted = 0;
for (int i = 0; i < size; i += 1000) {
makeInsertItems(ids, i, 1000, base);
numinserted += resolver.bulkInsert(uri, sContentValuesCache);
}
String message = context.getResources().getQuantityString(
R.plurals.NNNtrackstoplaylist, numinserted, numinserted);
Toast.makeText(context, message, Toast.LENGTH_SHORT).show();
//mLastPlaylistSelected = playlistid;
}
}
public static Cursor query(Context context, Uri uri, String[] projection,
String selection, String[] selectionArgs, String sortOrder, int limit) {
try {
ContentResolver resolver = context.getContentResolver();
if (resolver == null) {
return null;
}
if (limit > 0) {
uri = uri.buildUpon().appendQueryParameter("limit", "" + limit).build();
}
return resolver.query(uri, projection, selection, selectionArgs, sortOrder);
} catch (UnsupportedOperationException ex) {
return null;
}
}
public static Cursor query(Context context, Uri uri, String[] projection,
String selection, String[] selectionArgs, String sortOrder) {
return query(context, uri, projection, selection, selectionArgs, sortOrder, 0);
}
public static boolean isMediaScannerScanning(Context context) {
boolean result = false;
Cursor cursor = query(context, MediaStore.getMediaScannerUri(),
new String [] { MediaStore.MEDIA_SCANNER_VOLUME }, null, null, null);
if (cursor != null) {
if (cursor.getCount() == 1) {
cursor.moveToFirst();
result = "external".equals(cursor.getString(0));
}
cursor.close();
}
return result;
}
public static void setSpinnerState(Activity a) {
if (isMediaScannerScanning(a)) {
// start the progress spinner
a.getWindow().setFeatureInt(
Window.FEATURE_INDETERMINATE_PROGRESS,
Window.PROGRESS_INDETERMINATE_ON);
a.getWindow().setFeatureInt(
Window.FEATURE_INDETERMINATE_PROGRESS,
Window.PROGRESS_VISIBILITY_ON);
} else {
// stop the progress spinner
a.getWindow().setFeatureInt(
Window.FEATURE_INDETERMINATE_PROGRESS,
Window.PROGRESS_VISIBILITY_OFF);
}
}
private static String mLastSdStatus;
public static void displayDatabaseError(Activity a) {
if (a.isFinishing()) {
// When switching tabs really fast, we can end up with a null
// cursor (not sure why), which will bring us here.
// Don't bother showing an error message in that case.
return;
}
String status = Environment.getExternalStorageState();
int title, message;
if (android.os.Environment.isExternalStorageRemovable()) {
title = R.string.sdcard_error_title;
message = R.string.sdcard_error_message;
} else {
title = R.string.sdcard_error_title_nosdcard;
message = R.string.sdcard_error_message_nosdcard;
}
if (status.equals(Environment.MEDIA_SHARED) ||
status.equals(Environment.MEDIA_UNMOUNTED)) {
if (android.os.Environment.isExternalStorageRemovable()) {
title = R.string.sdcard_busy_title;
message = R.string.sdcard_busy_message;
} else {
title = R.string.sdcard_busy_title_nosdcard;
message = R.string.sdcard_busy_message_nosdcard;
}
} else if (status.equals(Environment.MEDIA_REMOVED)) {
if (android.os.Environment.isExternalStorageRemovable()) {
title = R.string.sdcard_missing_title;
message = R.string.sdcard_missing_message;
} else {
title = R.string.sdcard_missing_title_nosdcard;
message = R.string.sdcard_missing_message_nosdcard;
}
} else if (status.equals(Environment.MEDIA_MOUNTED)){
// The card is mounted, but we didn't get a valid cursor.
// This probably means the mediascanner hasn't started scanning the
// card yet (there is a small window of time during boot where this
// will happen).
a.setTitle("");
Intent intent = new Intent();
intent.setClass(a, ScanningProgress.class);
a.startActivityForResult(intent, Defs.SCAN_DONE);
} else if (!TextUtils.equals(mLastSdStatus, status)) {
mLastSdStatus = status;
Log.d(TAG, "sd card: " + status);
}
a.setTitle(title);
View v = a.findViewById(R.id.sd_message);
if (v != null) {
v.setVisibility(View.VISIBLE);
}
v = a.findViewById(R.id.sd_icon);
if (v != null) {
v.setVisibility(View.VISIBLE);
}
v = a.findViewById(android.R.id.list);
if (v != null) {
v.setVisibility(View.GONE);
}
v = a.findViewById(R.id.buttonbar);
if (v != null) {
v.setVisibility(View.GONE);
}
TextView tv = (TextView) a.findViewById(R.id.sd_message);
tv.setText(message);
}
public static void hideDatabaseError(Activity a) {
View v = a.findViewById(R.id.sd_message);
if (v != null) {
v.setVisibility(View.GONE);
}
v = a.findViewById(R.id.sd_icon);
if (v != null) {
v.setVisibility(View.GONE);
}
v = a.findViewById(android.R.id.list);
if (v != null) {
v.setVisibility(View.VISIBLE);
}
}
static protected Uri getContentURIForPath(String path) {
return Uri.fromFile(new File(path));
}
/* Try to use String.format() as little as possible, because it creates a
* new Formatter every time you call it, which is very inefficient.
* Reusing an existing Formatter more than tripled the speed of
* makeTimeString().
* This Formatter/StringBuilder are also used by makeAlbumSongsLabel()
*/
private static StringBuilder sFormatBuilder = new StringBuilder();
private static Formatter sFormatter = new Formatter(sFormatBuilder, Locale.getDefault());
private static final Object[] sTimeArgs = new Object[5];
public static String makeTimeString(Context context, long secs) {
String durationformat = context.getString(
secs < 3600 ? R.string.durationformatshort : R.string.durationformatlong);
/* Provide multiple arguments so the format can be changed easily
* by modifying the xml.
*/
sFormatBuilder.setLength(0);
final Object[] timeArgs = sTimeArgs;
timeArgs[0] = secs / 3600;
timeArgs[1] = secs / 60;
timeArgs[2] = (secs / 60) % 60;
timeArgs[3] = secs;
timeArgs[4] = secs % 60;
return sFormatter.format(durationformat, timeArgs).toString();
}
public static void shuffleAll(Context context, Cursor cursor) {
playAll(context, cursor, 0, true);
}
public static void playAll(Context context, Cursor cursor) {
playAll(context, cursor, 0, false);
}
public static void playAll(Context context, Cursor cursor, int position) {
playAll(context, cursor, position, false);
}
public static void playAll(Context context, long [] list, int position) {
playAll(context, list, position, false);
}
private static void playAll(Context context, Cursor cursor, int position, boolean force_shuffle) {
long [] list = getSongListForCursor(cursor);
playAll(context, list, position, force_shuffle);
}
private static void playAll(Context context, long [] list, int position, boolean force_shuffle) {
if (list.length == 0 || sService == null) {
Log.d("MusicUtils", "attempt to play empty song list");
// Don't try to play empty playlists. Nothing good will come of it.
String message = context.getString(R.string.emptyplaylist, list.length);
Toast.makeText(context, message, Toast.LENGTH_SHORT).show();
return;
}
try {
if (force_shuffle) {
sService.setShuffleMode(MediaPlaybackService.SHUFFLE_NORMAL);
}
long curid = sService.getAudioId();
int curpos = sService.getQueuePosition();
if (position != -1 && curpos == position && curid == list[position]) {
// The selected file is the file that's currently playing;
// figure out if we need to restart with a new playlist,
// or just launch the playback activity.
long [] playlist = sService.getQueue();
if (Arrays.equals(list, playlist)) {
// we don't need to set a new list, but we should resume playback if needed
sService.play();
return; // the 'finally' block will still run
}
}
if (position < 0) {
position = 0;
}
sService.open(list, force_shuffle ? -1 : position);
sService.play();
} catch (RemoteException ex) {
} finally {
Intent intent = new Intent("com.android.music.PLAYBACK_VIEWER")
.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
context.startActivity(intent);
}
}
public static void clearQueue() {
try {
sService.removeTracks(0, Integer.MAX_VALUE);
} catch (RemoteException ex) {
}
}
// A really simple BitmapDrawable-like class, that doesn't do
// scaling, dithering or filtering.
private static class FastBitmapDrawable extends Drawable {
private Bitmap mBitmap;
public FastBitmapDrawable(Bitmap b) {
mBitmap = b;
}
@Override
public void draw(Canvas canvas) {
canvas.drawBitmap(mBitmap, 0, 0, null);
}
@Override
public int getOpacity() {
return PixelFormat.OPAQUE;
}
@Override
public void setAlpha(int alpha) {
}
@Override
public void setColorFilter(ColorFilter cf) {
}
}
private static int sArtId = -2;
private static Bitmap mCachedBit = null;
private static final BitmapFactory.Options sBitmapOptionsCache = new BitmapFactory.Options();
private static final BitmapFactory.Options sBitmapOptions = new BitmapFactory.Options();
private static final Uri sArtworkUri = Uri.parse("content://media/external/audio/albumart");
private static final HashMap<Long, Drawable> sArtCache = new HashMap<Long, Drawable>();
private static int sArtCacheId = -1;
static {
// for the cache,
// 565 is faster to decode and display
// and we don't want to dither here because the image will be scaled down later
sBitmapOptionsCache.inPreferredConfig = Bitmap.Config.RGB_565;
sBitmapOptionsCache.inDither = false;
sBitmapOptions.inPreferredConfig = Bitmap.Config.RGB_565;
sBitmapOptions.inDither = false;
}
public static void initAlbumArtCache() {
try {
int id = sService.getMediaMountedCount();
if (id != sArtCacheId) {
clearAlbumArtCache();
sArtCacheId = id;
}
} catch (RemoteException e) {
e.printStackTrace();
}
}
public static void clearAlbumArtCache() {
synchronized(sArtCache) {
sArtCache.clear();
}
}
public static Drawable getCachedArtwork(Context context, long artIndex, BitmapDrawable defaultArtwork) {
Drawable d = null;
synchronized(sArtCache) {
d = sArtCache.get(artIndex);
}
if (d == null) {
d = defaultArtwork;
final Bitmap icon = defaultArtwork.getBitmap();
int w = icon.getWidth();
int h = icon.getHeight();
Bitmap b = MusicUtils.getArtworkQuick(context, artIndex, w, h);
if (b != null) {
d = new FastBitmapDrawable(b);
synchronized(sArtCache) {
// the cache may have changed since we checked
Drawable value = sArtCache.get(artIndex);
if (value == null) {
sArtCache.put(artIndex, d);
} else {
d = value;
}
}
}
}
return d;
}
// Get album art for specified album. This method will not try to
// fall back to getting artwork directly from the file, nor will
// it attempt to repair the database.
private static Bitmap getArtworkQuick(Context context, long album_id, int w, int h) {
// NOTE: There is in fact a 1 pixel border on the right side in the ImageView
// used to display this drawable. Take it into account now, so we don't have to
// scale later.
w -= 1;
ContentResolver res = context.getContentResolver();
Uri uri = ContentUris.withAppendedId(sArtworkUri, album_id);
if (uri != null) {
ParcelFileDescriptor fd = null;
try {
fd = res.openFileDescriptor(uri, "r");
int sampleSize = 1;
// Compute the closest power-of-two scale factor
// and pass that to sBitmapOptionsCache.inSampleSize, which will
// result in faster decoding and better quality
sBitmapOptionsCache.inJustDecodeBounds = true;
BitmapFactory.decodeFileDescriptor(
fd.getFileDescriptor(), null, sBitmapOptionsCache);
int nextWidth = sBitmapOptionsCache.outWidth >> 1;
int nextHeight = sBitmapOptionsCache.outHeight >> 1;
while (nextWidth>w && nextHeight>h) {
sampleSize <<= 1;
nextWidth >>= 1;
nextHeight >>= 1;
}
sBitmapOptionsCache.inSampleSize = sampleSize;
sBitmapOptionsCache.inJustDecodeBounds = false;
Bitmap b = BitmapFactory.decodeFileDescriptor(
fd.getFileDescriptor(), null, sBitmapOptionsCache);
if (b != null) {
// finally rescale to exactly the size we need
if (sBitmapOptionsCache.outWidth != w || sBitmapOptionsCache.outHeight != h) {
Bitmap tmp = Bitmap.createScaledBitmap(b, w, h, true);
// Bitmap.createScaledBitmap() can return the same bitmap
if (tmp != b) b.recycle();
b = tmp;
}
}
return b;
} catch (FileNotFoundException e) {
} finally {
try {
if (fd != null)
fd.close();
} catch (IOException e) {
}
}
}
return null;
}
/** Get album art for specified album. You should not pass in the album id
* for the "unknown" album here (use -1 instead)
* This method always returns the default album art icon when no album art is found.
*/
public static Bitmap getArtwork(Context context, long song_id, long album_id) {
return getArtwork(context, song_id, album_id, true);
}
/** Get album art for specified album. You should not pass in the album id
* for the "unknown" album here (use -1 instead)
*/
public static Bitmap getArtwork(Context context, long song_id, long album_id,
boolean allowdefault) {
if (album_id < 0) {
// This is something that is not in the database, so get the album art directly
// from the file.
if (song_id >= 0) {
Bitmap bm = getArtworkFromFile(context, song_id, -1);
if (bm != null) {
return bm;
}
}
if (allowdefault) {
return getDefaultArtwork(context);
}
return null;
}
ContentResolver res = context.getContentResolver();
Uri uri = ContentUris.withAppendedId(sArtworkUri, album_id);
if (uri != null) {
InputStream in = null;
try {
in = res.openInputStream(uri);
return BitmapFactory.decodeStream(in, null, sBitmapOptions);
} catch (FileNotFoundException ex) {
// The album art thumbnail does not actually exist. Maybe the user deleted it, or
// maybe it never existed to begin with.
Bitmap bm = getArtworkFromFile(context, song_id, album_id);
if (bm != null) {
if (bm.getConfig() == null) {
bm = bm.copy(Bitmap.Config.RGB_565, false);
if (bm == null && allowdefault) {
return getDefaultArtwork(context);
}
}
} else if (allowdefault) {
bm = getDefaultArtwork(context);
}
return bm;
} finally {
try {
if (in != null) {
in.close();
}
} catch (IOException ex) {
}
}
}
return null;
}
// get album art for specified file
private static final String sExternalMediaUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI.toString();
private static Bitmap getArtworkFromFile(Context context, long songid, long albumid) {
Bitmap bm = null;
byte [] art = null;
String path = null;
if (albumid < 0 && songid < 0) {
throw new IllegalArgumentException("Must specify an album or a song id");
}
try {
if (albumid < 0) {
Uri uri = Uri.parse("content://media/external/audio/media/" + songid + "/albumart");
ParcelFileDescriptor pfd = context.getContentResolver().openFileDescriptor(uri, "r");
if (pfd != null) {
FileDescriptor fd = pfd.getFileDescriptor();
bm = BitmapFactory.decodeFileDescriptor(fd);
}
} else {
Uri uri = ContentUris.withAppendedId(sArtworkUri, albumid);
ParcelFileDescriptor pfd = context.getContentResolver().openFileDescriptor(uri, "r");
if (pfd != null) {
FileDescriptor fd = pfd.getFileDescriptor();
bm = BitmapFactory.decodeFileDescriptor(fd);
}
}
} catch (IllegalStateException ex) {
} catch (FileNotFoundException ex) {
}
if (bm != null) {
mCachedBit = bm;
}
return bm;
}
private static Bitmap getDefaultArtwork(Context context) {
BitmapFactory.Options opts = new BitmapFactory.Options();
opts.inPreferredConfig = Bitmap.Config.ARGB_8888;
return BitmapFactory.decodeStream(
context.getResources().openRawResource(R.drawable.albumart_mp_unknown), null, opts);
}
static int getIntPref(Context context, String name, int def) {
SharedPreferences prefs =
context.getSharedPreferences(context.getPackageName(), Context.MODE_PRIVATE);
return prefs.getInt(name, def);
}
static void setIntPref(Context context, String name, int value) {
SharedPreferences prefs =
context.getSharedPreferences(context.getPackageName(), Context.MODE_PRIVATE);
Editor ed = prefs.edit();
ed.putInt(name, value);
SharedPreferencesCompat.apply(ed);
}
static void setRingtone(Context context, long id) {
ContentResolver resolver = context.getContentResolver();
// Set the flag in the database to mark this as a ringtone
Uri ringUri = ContentUris.withAppendedId(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, id);
try {
ContentValues values = new ContentValues(2);
values.put(MediaStore.Audio.Media.IS_RINGTONE, "1");
values.put(MediaStore.Audio.Media.IS_ALARM, "1");
resolver.update(ringUri, values, null, null);
} catch (UnsupportedOperationException ex) {
// most likely the card just got unmounted
Log.e(TAG, "couldn't set ringtone flag for id " + id);
return;
}
String[] cols = new String[] {
MediaStore.Audio.Media._ID,
MediaStore.Audio.Media.DATA,
MediaStore.Audio.Media.TITLE
};
String where = MediaStore.Audio.Media._ID + "=" + id;
Cursor cursor = query(context, MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
cols, where , null, null);
try {
if (cursor != null && cursor.getCount() == 1) {
// Set the system setting to make this the current ringtone
cursor.moveToFirst();
Settings.System.putString(resolver, Settings.System.RINGTONE, ringUri.toString());
String message = context.getString(R.string.ringtone_set, cursor.getString(2));
Toast.makeText(context, message, Toast.LENGTH_SHORT).show();
}
} finally {
if (cursor != null) {
cursor.close();
}
}
}
static int sActiveTabIndex = -1;
static boolean updateButtonBar(Activity a, int highlight) {
final TabWidget ll = (TabWidget) a.findViewById(R.id.buttonbar);
boolean withtabs = false;
Intent intent = a.getIntent();
if (intent != null) {
withtabs = intent.getBooleanExtra("withtabs", false);
}
if (highlight == 0 || !withtabs) {
ll.setVisibility(View.GONE);
return withtabs;
} else if (withtabs) {
ll.setVisibility(View.VISIBLE);
}
for (int i = ll.getChildCount() - 1; i >= 0; i--) {
View v = ll.getChildAt(i);
boolean isActive = (v.getId() == highlight);
if (isActive) {
ll.setCurrentTab(i);
sActiveTabIndex = i;
}
v.setTag(i);
v.setOnFocusChangeListener(new View.OnFocusChangeListener() {
public void onFocusChange(View v, boolean hasFocus) {
if (hasFocus) {
for (int i = 0; i < ll.getTabCount(); i++) {
if (ll.getChildTabViewAt(i) == v) {
ll.setCurrentTab(i);
processTabClick((Activity)ll.getContext(), v, ll.getChildAt(sActiveTabIndex).getId());
break;
}
}
}
}});
v.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
processTabClick((Activity)ll.getContext(), v, ll.getChildAt(sActiveTabIndex).getId());
}});
}
return withtabs;
}
static void processTabClick(Activity a, View v, int current) {
int id = v.getId();
if (id == current) {
return;
}
final TabWidget ll = (TabWidget) a.findViewById(R.id.buttonbar);
activateTab(a, id);
if (id != R.id.nowplayingtab) {
ll.setCurrentTab((Integer) v.getTag());
setIntPref(a, "activetab", id);
}
}
static void activateTab(Activity a, int id) {
Intent intent = new Intent(Intent.ACTION_PICK);
switch (id) {
case R.id.artisttab:
intent.setDataAndType(Uri.EMPTY, "vnd.android.cursor.dir/artistalbum");
break;
case R.id.albumtab:
intent.setDataAndType(Uri.EMPTY, "vnd.android.cursor.dir/album");
break;
case R.id.songtab:
intent.setDataAndType(Uri.EMPTY, "vnd.android.cursor.dir/track");
break;
case R.id.playlisttab:
intent.setDataAndType(Uri.EMPTY, MediaStore.Audio.Playlists.CONTENT_TYPE);
break;
case R.id.nowplayingtab:
intent = new Intent(a, MediaPlaybackActivity.class);
a.startActivity(intent);
// fall through and return
default:
return;
}
intent.putExtra("withtabs", true);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
a.startActivity(intent);
a.finish();
a.overridePendingTransition(0, 0);
}
static void updateNowPlaying(Activity a) {
View nowPlayingView = a.findViewById(R.id.nowplaying);
if (nowPlayingView == null) {
return;
}
try {
boolean withtabs = false;
Intent intent = a.getIntent();
if (intent != null) {
withtabs = intent.getBooleanExtra("withtabs", false);
}
if (true && MusicUtils.sService != null && MusicUtils.sService.getAudioId() != -1) {
TextView title = (TextView) nowPlayingView.findViewById(R.id.title);
TextView artist = (TextView) nowPlayingView.findViewById(R.id.artist);
title.setText(MusicUtils.sService.getTrackName());
String artistName = MusicUtils.sService.getArtistName();
if (MediaStore.UNKNOWN_STRING.equals(artistName)) {
artistName = a.getString(R.string.unknown_artist_name);
}
artist.setText(artistName);
//mNowPlayingView.setOnFocusChangeListener(mFocuser);
//mNowPlayingView.setOnClickListener(this);
nowPlayingView.setVisibility(View.VISIBLE);
nowPlayingView.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
Context c = v.getContext();
c.startActivity(new Intent(c, MediaPlaybackActivity.class));
}});
return;
}
} catch (RemoteException ex) {
}
nowPlayingView.setVisibility(View.GONE);
}
static void setBackground(View v, Bitmap bm) {
if (bm == null) {
v.setBackgroundResource(0);
return;
}
int vwidth = v.getWidth();
int vheight = v.getHeight();
int bwidth = bm.getWidth();
int bheight = bm.getHeight();
float scalex = (float) vwidth / bwidth;
float scaley = (float) vheight / bheight;
float scale = Math.max(scalex, scaley) * 1.3f;
Bitmap.Config config = Bitmap.Config.ARGB_8888;
Bitmap bg = Bitmap.createBitmap(vwidth, vheight, config);
Canvas c = new Canvas(bg);
Paint paint = new Paint();
paint.setAntiAlias(true);
paint.setFilterBitmap(true);
ColorMatrix greymatrix = new ColorMatrix();
greymatrix.setSaturation(0);
ColorMatrix darkmatrix = new ColorMatrix();
darkmatrix.setScale(.3f, .3f, .3f, 1.0f);
greymatrix.postConcat(darkmatrix);
ColorFilter filter = new ColorMatrixColorFilter(greymatrix);
paint.setColorFilter(filter);
Matrix matrix = new Matrix();
matrix.setTranslate(-bwidth/2, -bheight/2); // move bitmap center to origin
matrix.postRotate(10);
matrix.postScale(scale, scale);
matrix.postTranslate(vwidth/2, vheight/2); // Move bitmap center to view center
c.drawBitmap(bm, matrix, paint);
v.setBackgroundDrawable(new BitmapDrawable(bg));
}
static int getCardId(Context context) {
ContentResolver res = context.getContentResolver();
Cursor c = res.query(Uri.parse("content://media/external/fs_id"), null, null, null, null);
int id = -1;
if (c != null) {
c.moveToFirst();
id = c.getInt(0);
c.close();
}
return id;
}
static class LogEntry {
Object item;
long time;
LogEntry(Object o) {
item = o;
time = System.currentTimeMillis();
}
void dump(PrintWriter out) {
sTime.set(time);
out.print(sTime.toString() + " : ");
if (item instanceof Exception) {
((Exception)item).printStackTrace(out);
} else {
out.println(item);
}
}
}
private static LogEntry[] sMusicLog = new LogEntry[100];
private static int sLogPtr = 0;
private static Time sTime = new Time();
static void debugLog(Object o) {
sMusicLog[sLogPtr] = new LogEntry(o);
sLogPtr++;
if (sLogPtr >= sMusicLog.length) {
sLogPtr = 0;
}
}
static void debugDump(PrintWriter out) {
for (int i = 0; i < sMusicLog.length; i++) {
int idx = (sLogPtr + i);
if (idx >= sMusicLog.length) {
idx -= sMusicLog.length;
}
LogEntry entry = sMusicLog[idx];
if (entry != null) {
entry.dump(out);
}
}
}
}