Android开发Mp3播放器工具类

最新推荐文章于 2024-03-30 12:26:01 发布

WhatYouSeeMe

最新推荐文章于 2024-03-30 12:26:01 发布

阅读量905

点赞数

分类专栏： android 文章标签： android mp3 音乐 android开发

本文链接：https://blog.csdn.net/wangjiangjun0815/article/details/56480113

版权

android 专栏收录该内容

35 篇文章 0 订阅

订阅专栏

最近项目在用到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);
    }

WhatYouSeeMe

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Android开发Mp3播放器工具类

最近项目在用到Mp3播放器直接播放音乐,于是整理一个播放器工具类,记录下.以便日后使用.①首先把使用到的MP3内容封装成的类列出来/** * map3内容 */public class Mp3 { public int id; public int playlistId;//列表id public String albumName;//专辑名字 public
复制链接

扫一扫