最近项目在用到Mp3播放器直接播放音乐,于是整理一个播放器工具类,记录下.以便日后使用.
①首先把使用到的MP3内容封装成的类列出来
/**
* map3内容
*/
public class Mp3 {
public int id;
public int playlistId;//列表id
public String albumName;//专辑名字
public String singerName;//歌手名字
public String url;//sd卡路径
public String name;//歌曲名字
public int pictureID;
public int Duration;
private long allSongIndex ;
public String picUrl;//图片路径
public int getSqlId() {
return id;
}
public void setSqlId(int sqlId) {
this.id = sqlId;
}
public int getPlaylistId() {
return playlistId;
}
public void setPlaylistId(int playlistId) {
this.playlistId = playlistId;
}
public int getDuration() {
return Duration;
}
public void setDuration(int duration) {
Duration = duration;
}
public String getAlbumName() {
return albumName;
}
public String getSingerName() {
return singerName;
}
public void setAlbumName(String albumName) {
this.albumName = albumName;
}
public void setSingerName(String singerName) {
this.singerName = singerName;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getName() {
return name;
}
public int getPictureID() {
return pictureID;
}
public void setPictureID(int pictureID) {
this.pictureID = pictureID;
}
public void setName(String name) {
this.name = name;
}
public long getAllSongIndex() {
return allSongIndex;
}
public void setAllSongIndex(long allSongIndex) {
this.allSongIndex = allSongIndex;
}
@Override
public String toString() {
return "Mp3 [id=" + id + ", playlistId=" + playlistId + ", albumName="
+ albumName + ", singerName=" + singerName + ", url=" + url
+ ", name=" + name + ", pictureID=" + pictureID + ", Duration="
+ Duration + ", allSongIndex=" + allSongIndex + "]";
}
public String getPicUrl() {
return picUrl;
}
public void setPicUrl(String picUrl) {
this.picUrl = picUrl;
}
}
/**
* 专辑类
*/
public class Album {
public String name;
public String singerName;
public Bitmap picture;
public String getSingerName() {
return singerName;
}
public void setSingerName(String singerName) {
this.singerName = singerName;
}
public String getName() {
return name;
}
public Bitmap getPicture() {
return picture;
}
public void setName(String name) {
this.name = name;
}
public void setPicture(Bitmap picture) {
this.picture = picture;
}
}
/**
* 内存卡缓存类
*/
public class MemoryCache {
private static final String TAG = "MemoryCache";
private Map<String, Bitmap> cache = Collections
.synchronizedMap(new LinkedHashMap<String, Bitmap>(10, 1.5f, true));
private long size = 0;// current allocated size
private long limit = 1000000;// max memory in bytes
public MemoryCache() {
// use 25% of available heap size
setLimit(Runtime.getRuntime().maxMemory() / 10);
}
public void setLimit(long new_limit) {
limit = new_limit;
Log.i(TAG, "MemoryCache will use up to " + limit / 1024. / 1024. + "MB");
}
public Bitmap get(String id) {
try {
if (!cache.containsKey(id))
return null;
return cache.get(id);
} catch (NullPointerException ex) {
return null;
}
}
public void put(String id, Bitmap bitmap) {
try {
if (cache.containsKey(id))
size -= getSizeInBytes(cache.get(id));
cache.put(id, bitmap);
size += getSizeInBytes(bitmap);
checkSize();
} catch (Throwable th) {
th.printStackTrace();
}
}
private void checkSize() {
Log.i(TAG, "cache size=" + size + " length=" + cache.size());
if (size > limit) {
// 先遍历最近最少使用的元素
Iterator<Entry<String, Bitmap>> iter = cache.entrySet().iterator();
while (iter.hasNext()) {
Entry<String, Bitmap> entry = iter.next();
size -= getSizeInBytes(entry.getValue());
iter.remove();
if (size <= limit)
break;
}
Log.i(TAG, "Clean cache. New size " + cache.size());
}
}
public void clear() {
cache.clear();
}
/**
* 图片占用的内存
*
*/
long getSizeInBytes(Bitmap bitmap) {
if (bitmap == null)
return 0;
return bitmap.getRowBytes() * bitmap.getHeight();
}
}
/**
* 图片加载
*/
public class ImageLoader {
private Context context; // 运行上下文
private MemoryCache memoryCache = new MemoryCache();
private Map<ImageView, String> imageViews = Collections
.synchronizedMap(new WeakHashMap<ImageView, String>());
// 线程池
private ExecutorService executorService;
public ImageLoader(Context context) {
executorService = Executors.newFixedThreadPool(5);
this.context = context;
}
// 最主要的方法
public void DisplayImage(String url, ImageView imageView, boolean isLoadOnlyFromCache) {
imageViews.put(imageView, url);
// 先从内存缓存中查找
Bitmap bitmap = memoryCache.get(url);
if (bitmap != null)
imageView.setImageBitmap(bitmap);
else if (!isLoadOnlyFromCache){
Log.v("image", "1");
// 若没有的话则开启新线程加载图片
queuePhoto(url, imageView);
}
}
private void queuePhoto(String url, ImageView imageView) {
PhotoToLoad p = new PhotoToLoad(url, imageView);
Log.v("image", "222"+url);
executorService.submit(new PhotosLoader(p));
}
private Bitmap getBitmap(String url) {
try {
Bitmap bitmap = null;
File file = new File(getAlbumArt(Integer.parseInt(url)));
bitmap = decodeFile(file);
return bitmap;
} catch (Exception ex) {
Log.e("image", "getBitmap catch Exception...\nmessage = " + ex.getMessage());
return null;
}
}
// decode这个图片并且按比例缩放以减少内存消耗,虚拟机对每张图片的缓存大小也是有限制的
private Bitmap decodeFile(File f) {
try {
// decode image size
BitmapFactory.Options o = new BitmapFactory.Options();
o.inJustDecodeBounds = true;
BitmapFactory.decodeStream(new FileInputStream(f), null, o);
// Find the correct scale value. It should be the power of 2.
final int REQUIRED_SIZE = 100;
int width_tmp = o.outWidth, height_tmp = o.outHeight;
int scale = 1;
while (true) {
if (width_tmp / 2 < REQUIRED_SIZE
|| height_tmp / 2 < REQUIRED_SIZE)
break;
width_tmp /= 2;
height_tmp /= 2;
scale *= 2;
}
// decode with inSampleSize
BitmapFactory.Options o2 = new BitmapFactory.Options();
o2.inSampleSize = scale;
return BitmapFactory.decodeStream(new FileInputStream(f), null, o2);
} catch (FileNotFoundException e) {
}
return null;
}
// Task for the queue
private class PhotoToLoad {
public String url;
public ImageView imageView;
public PhotoToLoad(String u, ImageView i) {
url = u;
imageView = i;
}
}
class PhotosLoader implements Runnable {
PhotoToLoad photoToLoad;
PhotosLoader(PhotoToLoad photoToLoad) {
this.photoToLoad = photoToLoad;
}
@Override
public void run() {
Bitmap bmp = getBitmap(photoToLoad.url);
memoryCache.put(photoToLoad.url, bmp);
if (imageViewReused(photoToLoad))
return;
BitmapDisplayer bd = new BitmapDisplayer(bmp, photoToLoad);
// 更新的操作放在UI线程中
Activity a = (Activity) photoToLoad.imageView.getContext();
a.runOnUiThread(bd);Log.v("image", "4");
}
}
/**
* 防止图片错位
*/
boolean imageViewReused(PhotoToLoad photoToLoad) {
String tag = imageViews.get(photoToLoad.imageView);
if (tag == null || !tag.equals(photoToLoad.url))
return true;
return false;
}
// 用于在UI线程中更新界面
class BitmapDisplayer implements Runnable {
Bitmap bitmap;
PhotoToLoad photoToLoad;
public BitmapDisplayer(Bitmap b, PhotoToLoad p) {
bitmap = b;
photoToLoad = p;
}
public void run() {
if (imageViewReused(photoToLoad))
return;
if (bitmap != null){
photoToLoad.imageView.setImageBitmap(bitmap);
Log.v("image", "5");
}
}
}
public String getAlbumArt(int trackId) {// trackId是音乐的id
String mUriTrack = "content://media/external/audio/media/#";
String[] projection = new String[] { "album_id" };
String selection = "_id = ?";
String[] selectionArgs = new String[] { Integer.toString(trackId) };
Cursor cur = context.getContentResolver().query(Uri.parse(mUriTrack), projection, selection, selectionArgs, null);
int album_id = 0;
if (cur.getCount() > 0 && cur.getColumnCount() > 0) {
cur.moveToNext();
album_id = cur.getInt(0);
}
cur.close();
cur = null;
if (album_id < 0) {
return null;
}
String mUriAlbums = "content://media/external/audio/albums";
projection = new String[] { "album_art" };
cur = context.getContentResolver().query(Uri.parse(mUriAlbums + "/" + Integer.toString(album_id)), projection, null, null, null);
String album_art = null;
if (cur.getCount() > 0 && cur.getColumnCount() > 0) {
cur.moveToNext();
album_art = cur.getString(0);
}
cur.close();
cur = null;
return album_art;
}
public void clearCache() {
memoryCache.clear();
}
}
②Mp3播放Util
public class MusicUtils {
private static List<String> mMusicList = new ArrayList<String>();
private static List<Album> albums = new ArrayList<Album>();
public static ArrayList<String> al_playlist = new ArrayList<String>();
private static List<Mp3> playList = new ArrayList<Mp3>();
private static String[] mCols = new String[]{MediaStore.Audio.Playlists._ID, MediaStore.Audio.Playlists.NAME};
/**
* 清空歌曲列表中的全部歌曲,plid为列表id
*/
public static void clearPlaylist(Context context, long plid) {
Uri uri = MediaStore.Audio.Playlists.Members.getContentUri("external", plid);
context.getContentResolver().delete(uri, null, null);
return;
}
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 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;
}
}
/**
* 得到歌曲列表中的全部歌曲,plid为列表id
*/
public static ArrayList<Mp3> getSongListForPlaylist(Context context, long plid) {
final String[] ccols = new String[]{MediaStore.Audio.Playlists.Members._ID, MediaStore.Audio.Playlists.Members.TITLE, MediaStore.Audio.Playlists.Members.ARTIST,
MediaStore.Audio.Playlists.Members.AUDIO_ID, MediaColumns.DATA};
Cursor cursor = query(context, MediaStore.Audio.Playlists.Members.getContentUri("external", plid), ccols, null, null, MediaStore.Audio.Playlists.Members.DEFAULT_SORT_ORDER);
if (cursor != null) {
ArrayList<Mp3> list = getSongListForCursor(context, cursor);
cursor.close();
return list;
}
return null;
}
public static ArrayList<Mp3> getSongListForCursor(Context context, Cursor cursor) {
if (cursor == null) {
return null;
}
int len = cursor.getCount();
long[] list = new long[len];
cursor.moveToFirst();
int id = -1, title = -1, artist = -1;
int allSongIndex = -1;
int url = -1;
try {
allSongIndex = cursor.getColumnIndexOrThrow(MediaStore.Audio.Playlists.Members.AUDIO_ID);
id = cursor.getColumnIndexOrThrow(MediaStore.Audio.Playlists.Members._ID);
title = cursor.getColumnIndexOrThrow(MediaStore.Audio.Playlists.Members.TITLE);
artist = cursor.getColumnIndexOrThrow(MediaStore.Audio.Playlists.Members.ARTIST);
url = cursor.getColumnIndexOrThrow(MediaColumns.DATA);
} catch (IllegalArgumentException ex) {
id = cursor.getColumnIndexOrThrow(MediaStore.Audio.Media._ID);
}
ArrayList<Mp3> songs = new ArrayList<>();
songs.clear();
for (int i = 0; i < len; i++) {
long song_id = cursor.getLong(id);
long allSongId = cursor.getLong(allSongIndex);
String song_url = cursor.getString(url);
String tilte = cursor.getString(title);
String song_artist = cursor.getString(artist);
Mp3 song = new Mp3();
song.setSqlId(song_id + "");
song.setName(tilte);
song.setSingerName(song_artist);
song.setAllSongIndex(allSongId);
song.setUrl(song_url);
songs.add(song);
cursor.moveToNext();
}
return songs;
}
/**
* 将某一首歌添加到某个歌曲列表中,ids是歌曲id,playlistid是列表id
*/
public static void addToPlaylist(Context context, long[] ids, long playlistid) {
if (ids == null) {
Log.e("MusicBase", "ListSelection null");
} else {
int size = ids.length;
ContentResolver resolver = context.getContentResolver();
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);
}
}
}
private static ContentValues[] sContentValuesCache = null;
private static void makeInsertItems(long[] ids, int offset, int len, int base) {
if (offset + len > ids.length) {
len = ids.length - offset;
}
if (sContentValuesCache == null || sContentValuesCache.length != len) {
sContentValuesCache = new ContentValues[len];
}
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 List<String> getSongsName(Context context) {
Cursor c = query(context, MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, new String[]{MediaStore.Audio.Media._ID, MediaStore.Audio.Media.TITLE, MediaStore.Audio.Media.ARTIST, MediaColumns.DATA},
MediaStore.Audio.Media.IS_MUSIC + "=1", null, null);
try {
if (c == null || c.getCount() == 0) {
return null;
}
List<String> songsNameList = new ArrayList<>();
int columnIndexOrThrow = c.getColumnIndexOrThrow(MediaStore.Audio.Media.TITLE);
int len = c.getCount();
for (int i = 0; i < len; i++) {
c.moveToNext();
String song = c.getString(columnIndexOrThrow);
songsNameList.add(song);
}
return songsNameList;
} finally {
if (c != null) {
c.close();
}
}
}
/**
* 得到媒体库中的全部歌曲
*/
public static ArrayList<Mp3> getAllSongs(Context context) {
Cursor c = query(context, MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, new String[]{MediaStore.Audio.Media._ID, MediaStore.Audio.Media.TITLE, MediaStore.Audio.Media.ARTIST, MediaColumns.DATA},
MediaStore.Audio.Media.IS_MUSIC + "=1", null, null);
try {
if (c == null || c.getCount() == 0) {
return null;
}
int len = c.getCount();
ArrayList<Mp3> list = new ArrayList<Mp3>();
int id = c.getColumnIndexOrThrow(MediaStore.Audio.Media._ID);
int title = c.getColumnIndexOrThrow(MediaStore.Audio.Media.TITLE);
int name = c.getColumnIndexOrThrow(MediaStore.Audio.Media.ARTIST);
int url = c.getColumnIndex(MediaColumns.DATA);
for (int i = 0; i < len; i++) {
Mp3 mp3 = new Mp3();
c.moveToNext();
mp3.setSqlId(c.getLong(id) + "");
mp3.setName(c.getString(title));
mp3.setSingerName(c.getString(name));
mp3.setUrl(c.getString(url));
list.add(mp3);
}
return list;
} finally {
if (c != null) {
c.close();
}
}
}
/**
* 根据歌曲查找歌曲
*/
public static ArrayList<Mp3> getSongByName(Context context, String searchName) {
Cursor c = query(context, MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, new String[]{MediaStore.Audio.Media._ID, MediaStore.Audio.Media.TITLE, MediaStore.Audio.Media.ARTIST, MediaColumns.DATA},
MediaStore.Audio.Media.IS_MUSIC + "=1", null, null);
try {
if (c == null || c.getCount() == 0) {
return null;
}
int len = c.getCount();
ArrayList<Mp3> list = new ArrayList<>();
int id = c.getColumnIndexOrThrow(MediaStore.Audio.Media._ID);
int title = c.getColumnIndexOrThrow(MediaStore.Audio.Media.TITLE);
int name = c.getColumnIndexOrThrow(MediaStore.Audio.Media.ARTIST);
int url = c.getColumnIndex(MediaColumns.DATA);
for (int i = 0; i < len; i++) {
c.moveToNext();
String sName = c.getString(title);
if (sName.equals(searchName)) {
Mp3 mp3 = new Mp3();
mp3.setSqlId(c.getLong(id) + "");
mp3.setName(sName);
mp3.setSingerName(c.getString(name));
mp3.setUrl(c.getString(url));
list.add(mp3);
}
}
return list;
} finally {
if (c != null) {
c.close();
}
}
}
/**
* 得到所有歌手的名字列表
*/
public static List<String> MusicSingerList(Context context) {
mMusicList.clear();
if (mMusicList.size() == 0) {
ContentResolver cr = context.getContentResolver();
if (cr != null) {
// 获取全部歌曲
Cursor cursor = cr.query(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, null, null, null, MediaStore.Audio.Media.DEFAULT_SORT_ORDER);
if (null == cursor) {
return null;
}
if (cursor.moveToFirst()) {
do {
String singer = cursor.getString(cursor.getColumnIndex(AudioColumns.ARTIST));
if ("<unknown>".equals(singer)) {
singer = "unknow artist";
}
String name = cursor.getString(cursor.getColumnIndex(MediaColumns.DISPLAY_NAME));
String sbr = name.substring(name.length() - 3, name.length());
// lac也是一种格式
if (sbr.equals("mp3") || sbr.endsWith("lac")) {
if (!mMusicList.contains(singer)) {
mMusicList.add(singer);
}
}
} while (cursor.moveToNext());
}
cursor.close();
}
}
return mMusicList;
}
/**
* 通过歌手名字,得到该歌手的所有歌曲
*/
public static ArrayList<Mp3> MusicMp3ListbySinger(Context context, String Name) {
ArrayList<Mp3> singerMp3 = new ArrayList<>();
if (singerMp3.size() == 0) {
ContentResolver cr = context.getContentResolver();
if (cr != null) {
// 获取全部歌曲
Cursor cursor = cr.query(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, null, null, null, MediaStore.Audio.Media.DEFAULT_SORT_ORDER);
if (null == cursor) {
return null;
}
if (cursor.moveToFirst()) {
do {
String singer = cursor.getString(cursor.getColumnIndex(AudioColumns.ARTIST));
if ("<unknown>".equals(singer)) {
singer = "unknow artist";
}
if (singer.equals(Name)) {
int id = cursor.getInt(cursor.getColumnIndex(BaseColumns._ID));
int sid = cursor.getColumnIndexOrThrow(MediaStore.Audio.Media._ID);
String title = cursor.getString(cursor.getColumnIndex(MediaColumns.TITLE));
String url = cursor.getString(cursor.getColumnIndex(MediaColumns.DATA));
String name = cursor.getString(cursor.getColumnIndex(MediaColumns.DISPLAY_NAME));
String sbr = name.substring(name.length() - 3, name.length());
int duration = cursor.getInt(cursor.getColumnIndex(AudioColumns.DURATION));
long aLong = cursor.getLong(sid);
// Log.e("--------------", sbr);
if (sbr.equals("mp3") || sbr.endsWith("lac")) {
Mp3 mp3 = new Mp3();
mp3.setDuration(duration);
mp3.setName(title);
mp3.setPictureID(id);
mp3.setSingerName(singer);
mp3.setSqlId(aLong+"");
mp3.setUrl(url);
singerMp3.add(mp3);
}
}
} while (cursor.moveToNext());
}
cursor.close();
}
}
return singerMp3;
}
/**
* 得到所有专辑
*/
public static List<Album> MusicAlbumList(Context context) {
if (albums.size() == 0) {
ContentResolver cr = context.getContentResolver();
if (cr != null) {
// 获取全部歌曲
Cursor cursor = cr.query(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, null, null, null, MediaStore.Audio.Media.DEFAULT_SORT_ORDER);
if (null == cursor) {
return null;
}
if (cursor.moveToFirst()) {
do {
String album = cursor.getString(cursor.getColumnIndex(AudioColumns.ALBUM));
if ("<unknown>".equals(album)) {
album = "unknow album";
}
String singer = cursor.getString(cursor.getColumnIndex(AudioColumns.ARTIST));
if ("<unknown>".equals(singer)) {
singer = "unknow artist";
}
String name = cursor.getString(cursor.getColumnIndex(MediaColumns.DISPLAY_NAME));
int id = cursor.getInt(cursor.getColumnIndex(BaseColumns._ID));
String sbr = name.substring(name.length() - 3, name.length());
if (sbr.equals("mp3") || sbr.endsWith("lac")) {
Album album2 = new Album();
album2.setSingerName(singer);
album2.setName(album);
album2.setPicture(BitmapFactory.decodeFile(getAlbumArt(context, id+"")));
if (!mMusicList.contains(album2.getName())) {
albums.add(album2);
mMusicList.add(album2.getName());
}
}
} while (cursor.moveToNext());
}
cursor.close();
}
}
return albums;
}
/**
* 通过歌曲id,找到其所对应的专辑图片路径
*/
public static String getAlbumArt(Context context, String trackId) {// trackId是音乐的id
String mUriTrack = "content://media/external/audio/media/#";
String[] projection = new String[]{"album_id"};
String selection = "_id = ?";
String[] selectionArgs = new String[]{trackId};
Cursor cur = context.getContentResolver().query(Uri.parse(mUriTrack),
projection, selection, selectionArgs, null);
int album_id = 0;
if (cur.getCount() > 0 && cur.getColumnCount() > 0) {
cur.moveToNext();
album_id = cur.getInt(0);
}
cur.close();
cur = null;
if (album_id < 0) {
return null;
}
String mUriAlbums = "content://media/external/audio/albums";
projection = new String[]{"album_art"};
cur = context.getContentResolver().query(Uri.parse(mUriAlbums + "/" +
Integer.toString(album_id)), projection, null, null, null);
String album_art = null;
if (cur.getCount() > 0 && cur.getColumnCount() > 0) {
cur.moveToNext();
album_art = cur.getString(0);
}
cur.close();
cur = null;
return album_art;
}
/**
* 得到专辑中的所有歌曲
*/
public static List<Mp3> MusicMp3ListbyAlbum(Context context, String Album) {
List<Mp3> albumMp3 = new ArrayList<Mp3>();
if (albumMp3.size() == 0) {
ContentResolver cr = context.getContentResolver();
if (cr != null) {
// 获取全部歌曲
Cursor cursor = cr.query(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, null, null, null, MediaStore.Audio.Media.DEFAULT_SORT_ORDER);
if (null == cursor) {
return null;
}
if (cursor.moveToFirst()) {
do {
String album = cursor.getString(cursor.getColumnIndex(AudioColumns.ALBUM));
if ("<unknown>".equals(album)) {
album = "unknow album";
}
if (album.equals(Album)) {
String title = cursor.getString(cursor.getColumnIndex(MediaColumns.TITLE));
int id = cursor.getInt(cursor.getColumnIndex(BaseColumns._ID));
String url = cursor.getString(cursor.getColumnIndex(MediaColumns.DATA));
String name = cursor.getString(cursor.getColumnIndex(MediaColumns.DISPLAY_NAME));
String sbr = name.substring(name.length() - 3, name.length());
int duration = cursor.getInt(cursor.getColumnIndex(AudioColumns.DURATION));
// Log.e("--------------", sbr);
if (sbr.equals("mp3") || sbr.endsWith("lac")) {
Mp3 mp3 = new Mp3();
mp3.setDuration(duration);
mp3.setName(title);
mp3.setPictureID(id);
mp3.setUrl(url);
albumMp3.add(mp3);
}
}
} while (cursor.moveToNext());
}
cursor.close();
}
}
return albumMp3;
}
/**
* 得到所有歌曲列表的列表名字
*/
public static List<String> PlaylistList(Context context) {
List<String> listSongs = new ArrayList<String>();
if (listSongs.size() == 0) {
ContentResolver cr = context.getContentResolver();
Cursor cursor = cr.query(MediaStore.Audio.Playlists.EXTERNAL_CONTENT_URI, mCols, null, null, MediaStore.Audio.Playlists._ID + " desc");
al_playlist.clear();
int len = cursor.getCount();
int id = cursor.getColumnIndexOrThrow(MediaStore.Audio.Playlists._ID);
int name = cursor.getColumnIndexOrThrow(MediaStore.Audio.Playlists.NAME);
for (int i = 0; i < len; i++) {
cursor.moveToNext();
long id_temp = cursor.getLong(id);
String temp = cursor.getString(name);
al_playlist.add(id_temp + "");
listSongs.add(temp);
}
}
return listSongs;
}
/**
* 通过歌曲列表名找到列表id
*/
public static long getPlayListId(Context context, String listName) {
long listId = -1;
ContentResolver cr = context.getContentResolver();
Cursor cursor = cr.query(MediaStore.Audio.Playlists.EXTERNAL_CONTENT_URI, mCols, null, null, MediaStore.Audio.Playlists._ID + " desc");
al_playlist.clear();
int len = cursor.getCount();
int id = cursor.getColumnIndexOrThrow(MediaStore.Audio.Playlists._ID);
int name = cursor.getColumnIndexOrThrow(MediaStore.Audio.Playlists.NAME);
for (int i = 0; i < len; i++) {
cursor.moveToNext();
long id_temp = cursor.getLong(id);
String temp = cursor.getString(name);
if (listName.equals(temp)) {
listId = id_temp;
}
}
return listId;
}
public static List<Mp3> getPlayList() {
return playList;
}
public static void setPlayList(List<Mp3> playList) {
MusicUtils.playList = playList;
}
public static ArrayList<String> getAl_playlist() {
return al_playlist;
}
public static void setAl_playlist(ArrayList<String> al_playlist) {
MusicUtils.al_playlist = al_playlist;
}
}
③Mp3后台播放Service
public class MusicPlayService extends Service {
private final IBinder mBinder = new LocalBinder();
private Context context;
private MediaPlayer mMediaPlayer = null;
private int currentTime = 0;//歌曲播放进度
private int currentListItme = -1;//当前播放第几首歌
private List<Mp3> songs;//要播放的歌曲集合
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
@Override
public void onCreate() {
super.onCreate();
if (mMediaPlayer==null){
mMediaPlayer = new MediaPlayer();
}
}
/**
*得到当前播放进度
*/
public int getCurent(){
if (mMediaPlayer.isPlaying()){
return mMediaPlayer.getCurrentPosition();
}else {
return currentTime;
}
}
/**
* 跳转到播放的进度
*/
public void movePlay(int progress){
mMediaPlayer.seekTo(progress);
currentTime=progress;
}
/**
* 根据歌曲存储路径播放歌曲
*/
public void playMusic(String path) {
try {
/* 重置MediaPlayer */
mMediaPlayer.reset();
/* 设置要播放的文件的路径 */
mMediaPlayer.setDataSource(path);
mMediaPlayer.prepare();
/* 开始播放 */
mMediaPlayer.start();
mMediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
public void onCompletion(MediaPlayer arg0) {
// 播放完成一首之后进行下一首
nextMusic();
}
});
} catch (IOException e) {
}
}
/**
* 下一曲
*/
public void nextMusic() {
if (++currentListItme>=songs.size()){
currentListItme=0;
}
playMusic(songs.get(currentListItme).getUrl());
}
/**
* 上一曲
*/
public void preMusic(){
if (--currentListItme<0){
currentListItme=songs.size()-1;
}
playMusic(songs.get(currentListItme).getUrl());
}
/**
* 歌曲是否正在播放
*/
public boolean isPlay(){
return mMediaPlayer.isPlaying();
}
/**
* 暂停或开始播放歌曲
*/
public void pausePlay(){
if (mMediaPlayer.isPlaying()){
currentTime=mMediaPlayer.getCurrentPosition();
mMediaPlayer.pause();
}else {
mMediaPlayer.start();
}
}
/**
* 获取歌曲名字
*
*/
public String getSongName(){
return songs.get(currentListItme).getName();
}
/**
* 获取歌手的名字
*/
public String getSingerName(){
return songs.get(currentListItme).getSingerName();
}
/**
* 自定义绑定Service类,通过这里的getService得到Service,之后就可调用Service这里的方法了
*/
public class LocalBinder extends Binder {
public MusicPlayService getService() {
return MusicPlayService.this;
}
}
public void setContext(Context context) {
this.context = context;
}
public MediaPlayer getmMediaPlayer() {
return mMediaPlayer;
}
public void setmMediaPlayer(MediaPlayer mMediaPlayer) {
this.mMediaPlayer = mMediaPlayer;
}
public int getCurrentListItme() {
return currentListItme;
}
public void setCurrentListItme(int currentListItme) {
this.currentListItme = currentListItme;
}
public int getDuration() {
return mMediaPlayer.getDuration();
}
public List<Mp3> getSongs() {
return songs;
}
public void setSongs(List<Mp3> songs) {
this.songs = songs;
}
// 兼容2.0以前版本
@Override
public void onStart(Intent intent, int startId) {
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
return START_STICKY;
}
@Override
public void onDestroy() {
}
}
④Mp3播放activity
/**
* 根据演唱者名字播放其音乐
*/
private String singer="林俊杰";
public void getSingerSongs(String singer) {
List<String> strings = MusicUtils.MusicSingerList(musicContext);
boolean contains = strings.contains(singer);
if (contains){
List<Mp3> mp3s = MusicUtils.MusicMp3ListbySinger(musicContext, singer);
musicView.startSinger(mp3s);
}else {
//TODO 本地没有搜索到提示用户,获取网络搜索
}
}
public void startSinger(List<Mp3> nameSongs) {
mService.setSongs(nameSongs);
mService.setCurrentListItme(0);
mService.playMusic(nameSongs.get(0).getUrl());
}
/**
*根据音乐名字播放音乐
*/
private String songName="";
public void getNameSong(String songName) {
for (Mp3 song : allSongs) {
String name = song.getName();
if (name.contains(songName)){
int playlistId = song.getPlaylistId();
String url = song.getUrl();
String singerName = song.getSingerName();
musicView.startSongName(allSongs, playlistId, url);
musicView.showContent(name,singerName);
}else{
//TODO 本地没有搜索到提示用户,获取网络搜索
}
}
}
public void startSongName(ArrayList<Mp3> allSongs, int playlistId, String url) {
mService.setSongs(allSongs);
mService.setCurrentListItme(playlistId);
mService.playMusic(url);
}