Android练习项目 Mp3播放器实现（二）

在经过几天的折腾之后，迎来了Mp3播放器的第二篇博客，这篇文章主要将如何实现播放器的播放，下一首，上一首，顺序播放，循环播放，随机播放，单曲循环等操作。
其实操作的过程中主要是通过参数的传递来实现功能的。
在activity里面互相传参有很多中方法，但对于activity和service进行交互有些方法并不适合，通过对Broadcast和BroadcastReceiver等操作，来控制播放的实现。
我们先设定好广播，然后通过发送信号来进行传递数据。
主要在activity里面动态注册广播，通过传递播放的顺序选择，Mp3的url，Mp3播放的位置到service里面，service里面接受传来的广播，获得参数，在进行对应的操作。
还有一个要解决的问题就是，如何通过service将播放的时间和歌曲信息反馈到activity里面，然后更新标题，时间，所以就是参数在service和activity之间进行传递，在程序中通过handle来处理程序的更新数据，通过handle来和activity交互，但由于没有开启线程，所以十分耗时的操作可能不适合，在下一个版本可能需要着手解决这个问题。
所以对于广播的处理就显得比较重要了。

先将作出的效果粘贴出来，目前还没有歌词等处理。

对于里面流程的处理十分重要，需要不断的调试，这是最为花费功夫的。
activity_main.xml布局文件

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:orientation="vertical">
<ListView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:id="@+id/listviewmusic">
</ListView>
</LinearLayout>

主要功能通过展示listview来显示内容。
自定义子部局：
listmusic.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:layout_width="match_parent"
              android:layout_height="60dp"
              android:orientation="vertical">

    <TextView
        android:layout_width="70dp"
        android:layout_height="wrap_content"
        android:textAppearance="?android:attr/textAppearanceSmall"
        android:text="Small Text"
        android:id="@+id/MusicID"
        android:gravity="center"
        android:layout_alignParentLeft="true"
        android:layout_alignParentStart="true"
        android:layout_alignParentBottom="true"
        android:layout_alignParentTop="true"/>

    <TextView
        android:layout_width="200dp"
        android:layout_height="wrap_content"
        android:textAppearance="?android:attr/textAppearanceSmall"
        android:text="Small Text"
        android:id="@+id/Musictitle"
        android:textStyle="bold"
        android:layout_alignParentTop="true"
        android:layout_toRightOf="@+id/MusicID"
        android:layout_toEndOf="@+id/MusicID"
        android:layout_marginLeft="20dp"
        android:layout_marginTop="10dp"
        android:textSize="15dp"
        android:singleLine="true"
        android:ellipsize="end"/>

    <TextView
        android:layout_width="220dp"
        android:layout_height="wrap_content"
        android:textAppearance="?android:attr/textAppearanceSmall"
        android:text="Small Text"
        android:id="@+id/MusicArtist"
        android:textColor="#878383"
        android:layout_toRightOf="@+id/MusicID"
        android:layout_toEndOf="@+id/MusicID"
        android:layout_marginLeft="20dp"
        android:layout_below="@+id/Musictitle"
        android:layout_marginTop="7dp"
        android:textSize="12dp"
        android:ellipsize="end"
        android:singleLine="true"/>

    <ImageView
        android:layout_width="25dp"
        android:layout_height="25dp"
        android:id="@+id/MusicIcon"
        android:layout_centerVertical="true"
        android:layout_alignParentRight="true"
        android:layout_alignParentEnd="true"
        android:layout_marginRight="30dp"
        />

</RelativeLayout>

MainActivity.java
主要获取mp3文件，对于里面出现的Mp3infos这个类，参考我上篇文章，这篇文章没有修改。

package com.flashmusic;

import android.app.Activity;
import android.app.ActivityManager;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.os.Bundle;
import android.provider.MediaStore;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ListView;
import android.widget.SimpleAdapter;

import com.flashmusic.tool.Mp3Info;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;


public class MainActivity extends Activity implements AdapterView.OnItemClickListener {

        //Music的listview控件
        private ListView MusicList;

        // 存储数据的数组列表
        ArrayList<HashMap<String, Object>> MusiclistData = new ArrayList<HashMap<String, Object>>();

        // 适配器
        private SimpleAdapter MusicListAdapter;

        //存放mp3信息
        static  List<Mp3Info> mp3Infos;
        @Override
        public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.activity_main);

                MusicList = (ListView) findViewById(R.id.listviewmusic);

                mp3Infos = getMp3Infos();
                GetData(mp3Infos);

                MusicListAdapter = new SimpleAdapter(
                        this,
                        MusiclistData,
                        R.layout.listmusic,
                        new String[]{"ID", "Title", "Artist", "Icon"},
                        new int[]{R.id.MusicID, R.id.Musictitle, R.id.MusicArtist, R.id.MusicIcon}
                );
                //赋予数据
                MusicList.setAdapter(MusicListAdapter);

                MusicList.setOnItemClickListener(MusiclistListen);
        }

        AdapterView.OnItemClickListener MusiclistListen = new AdapterView.OnItemClickListener() {
                @Override
                public void onItemClick(AdapterView<?> adapterView, View view, int i, long l) {
//                         //Toast.makeText(MainActivity.this, String.valueOf(l), Toast.LENGTH_SHORT).show();
//
//                        //判断当前服务是否已经开启
//                        if(isServiceRunning(getBaseContext(),"com.flashmusic.MusicService")){
//                                stopService(new Intent(MainActivity.this, MusicService.class));
//                        }
//                        Intent intent   = new Intent();
//                        intent.putExtra("url", mp3Infos.get(i).getUrl());
//                        intent.putExtra("position",String.valueOf(i));
//                        intent.setClass(MainActivity.this, MusicService.class);
//                        //启动服务
//                        startService(intent);

                        Intent musicintent      = new Intent(MainActivity.this, MusicActivity.class);
                        //当前播放的位置
                        musicintent.putExtra("position", String.valueOf(i));
                        MusicActivity.mp3Infos = mp3Infos;
                   //     MusicActivity.musicserviceintent = intent;
                        //启动音乐播放界面
                        startActivity(musicintent);
                }
        };

        //判断服务是否存在
        public static boolean isServiceRunning(Context mContext,String className) {
                boolean isRunning = false;
                ActivityManager activityManager = (ActivityManager)
                        mContext.getSystemService(Context.ACTIVITY_SERVICE);
                List<ActivityManager.RunningServiceInfo> serviceList= activityManager.getRunningServices(50);
                if (!(serviceList.size()>0)) {
                        return false;
                }
                for (int i=0; i<serviceList.size(); i++) {
                        String a =serviceList.get(i).service.getClassName();
                        if (serviceList.get(i).service.getClassName().equals(className) == true) {
                                isRunning = true;
                                break;
                        }
                }
                return isRunning;
        }
        public void GetData(List<Mp3Info> mp3Infos) {
                for (int i = 0; i < mp3Infos.size(); i++) {
                        HashMap<String, Object> map = new HashMap<String, Object>();
                        map.put("ID",mp3Infos.get(i).getID());
                        map.put("Title", mp3Infos.get(i).getTitle());
                        map.put("Artist", mp3Infos.get(i).getArtist());
                        map.put("Icon", R.drawable.musicicon);
                        MusiclistData.add(map);
                }
        }

        public List<Mp3Info> getMp3Infos() {
                Cursor cursor = getContentResolver().query(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, null, null, null,
                        MediaStore.Audio.Media.DEFAULT_SORT_ORDER);
                int ID = 0;
                List<Mp3Info> mp3Infos = new ArrayList<Mp3Info>();
                for (int i = 0; i < cursor.getCount(); i++) {
                        Mp3Info mp3Info = new Mp3Info();
                        cursor.moveToNext();
                        long id = cursor.getLong(cursor.getColumnIndex(MediaStore.Audio.Media._ID));   //音乐id,音乐ID不是播放的顺序
                        String title = cursor.getString((cursor.getColumnIndex(MediaStore.Audio.Media.TITLE)));//音乐标题
                        String artist = cursor.getString(cursor.getColumnIndex(MediaStore.Audio.Media.ARTIST));//艺术家
                        long duration = cursor.getLong(cursor.getColumnIndex(MediaStore.Audio.Media.DURATION));//时长
                        long size = cursor.getLong(cursor.getColumnIndex(MediaStore.Audio.Media.SIZE));  //文件大小
                        String url = cursor.getString(cursor.getColumnIndex(MediaStore.Audio.Media.DATA));              //文件路径
                        int isMusic = cursor.getInt(cursor.getColumnIndex(MediaStore.Audio.Media.IS_MUSIC));//是否为音乐
                        if (isMusic != 0) {
                                //只把音乐添加到集合当中
                                ID++;
                                mp3Info.setID(ID);
                                mp3Info.setTitle(title);
                                mp3Info.setArtist(artist);
                                mp3Info.setDuration(duration);
                                mp3Info.setSize(size);
                                mp3Info.setUrl(url);
                                mp3Infos.add(mp3Info);
                        }
                }
                return mp3Infos;
        }


        @Override
        public void onItemClick(AdapterView<?> adapterView, View view, int i, long l) {
        }
}

musicplay.xml，播放界面的布局

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
                android:layout_width="fill_parent"
                android:layout_height="fill_parent"
                android:focusable="false"
                android:orientation="horizontal"
                android:background="@drawable/background">


    <TextView
        android:id="@+id/musictitle"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:layout_centerHorizontal="true"
        android:textColor="#ffffff"
        android:textSize="20dp"
        android:textStyle="bold"
        android:layout_marginTop="15dp"/>

    <TextView
        android:id="@+id/musicartist"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/musictitle"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="5dp"
        android:textColor="#c6bbbb"/>

    <LinearLayout
        android:id="@+id/linearLayout"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true"
        android:layout_alignParentLeft="true"
        android:layout_alignParentStart="true"
        android:layout_marginBottom="10dp">

        <ImageView
            android:id="@+id/musicplaymode"
            android:layout_width="40dp"
            android:layout_height="40dp"
            android:layout_margin="10dp"
            android:layout_weight="1"
            android:src="@drawable/orderplay"/>

        <ImageView
            android:id="@+id/musicprevious"
            android:layout_width="40dp"
            android:layout_height="40dp"
            android:layout_margin="10dp"
            android:layout_weight="1"
            android:src="@drawable/musicprevious"/>

        <ImageView
            android:id="@+id/musicplay"
            android:layout_width="40dp"
            android:layout_height="40dp"
            android:layout_margin="10dp"
            android:layout_weight="1"
            android:src="@drawable/musicpause"/>

        <ImageView
            android:id="@+id/musicnext"
            android:layout_width="40dp"
            android:layout_height="40dp"
            android:layout_margin="10dp"
            android:layout_weight="1"
            android:src="@drawable/musicnext"/>

        <ImageView
            android:id="@+id/musicplaymenu"
            android:layout_width="40dp"
            android:layout_height="40dp"
            android:layout_margin="10dp"
            android:layout_weight="1"
            android:src="@drawable/menuplay"/>
    </LinearLayout>

    <LinearLayout
        android:layout_width="fill_parent"
        android:layout_height="60dp"
        android:layout_above="@+id/linearLayout"
        android:layout_alignParentLeft="true"
        android:layout_alignParentStart="true"
        android:gravity="center_vertical"
        android:orientation="horizontal">

        <TextView
            android:id="@+id/playcurrenttime"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignBottom="@+id/MusicProgress"
            android:layout_alignParentLeft="true"
            android:layout_alignParentStart="true"
            android:text="00:00"
            android:textAppearance="?android:attr/textAppearanceSmall"/>

        <SeekBar
            android:id="@+id/MusicProgress"
            android:layout_width="184dp"
            android:layout_height="wrap_content"
            android:layout_above="@+id/linearLayout"
            android:layout_toRightOf="@+id/playcurrenttime"
            android:layout_weight="0.16"
            android:indeterminate="false"
            android:max="100"/>

        <TextView
            android:id="@+id/playtime"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="00:00"
            android:textAppearance="?android:attr/textAppearanceSmall"/>

    </LinearLayout>

</RelativeLayout>

接下来就是MusicActivity.java
这里面有个东西我觉得非常好，就是用了static变量，来共享mp3infos文件信息，通过MainActivity函数来赋值进来，相当于不再需要另一块内存来存储数据了，service也是这样实现的，这样每次我们只需要将位置position传进去就能够解决问题了。

package com.flashmusic;

import com.flashmusic.tool.PlayerMSG;

import android.annotation.TargetApi;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.ServiceConnection;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.view.Menu;
import android.view.View;
import android.widget.ImageView;
import android.widget.SeekBar;
import android.widget.TextView;
import android.widget.ThemedSpinnerAdapter;
import android.widget.Toast;

import com.flashmusic.tool.Mp3Info;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Random;
import java.util.TimeZone;


public class MusicActivity extends Activity implements View.OnClickListener {

    //mp3需要播放的数据
    static List<Mp3Info> mp3Infos;
    static Intent musicserviceintent;

    //播放按钮
    private ImageView MusicPlay;
    //下一首
    private ImageView MusicNext;
    //上一首
    private ImageView MusicPrevious;
    //播放方式选择
    private ImageView MusicMOde;
    //播放菜单
    private ImageView MusicMenu;
    //显示总时间
    private TextView MusicTime;
    //显示当前时间
    private TextView MusicCurrentTime;
    //显示歌曲名
    private TextView MusicTitle;
    //显示歌曲艺术家
    private TextView MusicArtist;
    //进度条
    SeekBar seekBar;
    //广播
    MusicPlayerReceiver musicPlayerReceiver;


    private final int isorderplay = 0;//顺序播放
    private final int islistloop = 1;//表示列表循环
    private final int isrepeatone = 2;//单曲循环
    private final int israndomplay = 3;//随机

    public static final String UPDATE_ACTION = "com.flashmusic.action.UPDATE_ACTION";  //更新动作
    public static final String CTL_ACTION = "com.flashmusic.action.CTL_ACTION";        //控制动作
    public static final String MUSIC_CURRENT = "com.flashmusic.action.MUSIC_CURRENT";  //音乐当前时间改变动作
    public static final String MUSIC_DURATION = "com.flashmusic.action.MUSIC_DURATION";//音乐播放长度改变动作
    public static final String MUSIC_PLAYING = "com.flashmusic.action.MUSIC_PLAYING";  //音乐正在播放动作
    public static final String REPEAT_ACTION = "com.flashmusic.action.REPEAT_ACTION";  //音乐重复播放动作
    public static final String SHUFFLE_ACTION = "com.flashmusic.action.RANDOM_ACTION";//音乐随机播放动作
    public static final String PLAY_STATUE = "com.flashmusic.action.PLAY_STATUE";      //更新播放状态

    //是否绑定了对应的service
    Boolean mBound = false;
    //播放方式表识0表示顺序播放，1表示列表循环，2表示单曲循环，3表示随机，初始为顺序播放
    int playmodeflag = 0;
    //歌曲播放的位置,就能够获取位置
    int position;
    int currentTime;
    int duration;//总时间

    //记录鼠标点击了几次，播放和暂停状态
    boolean playorpauseflag = false;
    //播放服务
    MusicService mService;
    // 正在播放
    private boolean isPlaying;
    // 暂停
    private boolean isPause;

    //多线程，后台更新UI
    Thread myThread;

    //控制后台线程退出
    boolean playStatus = true;


    //转换毫秒数为时间模式，一般都是分钟数，音乐文件
    public static String formatDuring(long mss) {
        long days = mss / (1000 * 60 * 60 * 24);
        long hours = (mss % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60);
        long minutes = (mss % (1000 * 60 * 60)) / (1000 * 60);
        long seconds = (mss % (1000 * 60)) / 1000;
        return String.format("%02d", minutes) + ":" + String.format("%02d", seconds);
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.musicplay);

        //初始化控件
        InitView();

        //获得传过来的值
        Intent intent = getIntent();
        position = Integer.parseInt(intent.getStringExtra("position"));

        MusicArtist.setText(mp3Infos.get(position).getArtist());
        MusicTitle.setText(mp3Infos.get(position).getTitle());

        //注册广播
        musicPlayerReceiver = new MusicPlayerReceiver();
        IntentFilter filter = new IntentFilter();
        filter.addAction(UPDATE_ACTION);
        filter.addAction(MUSIC_CURRENT);
        filter.addAction(MUSIC_DURATION);
        filter.addAction(PLAY_STATUE);

        registerReceiver(musicPlayerReceiver, filter);


        //设置响应事件
        MusicNext.setOnClickListener(this);
        MusicPrevious.setOnClickListener(this);
        MusicMenu.setOnClickListener(this);
        MusicMOde.setOnClickListener(this);
        MusicPlay.setOnClickListener(this);
        seekBar.setOnSeekBarChangeListener(seekBarChangeListener);
        PlayMusic();
    }

    //初始化控件
    void InitView() {
        MusicPlay = (ImageView) findViewById(R.id.musicplay);
        MusicNext = (ImageView) findViewById(R.id.musicnext);
        MusicPrevious = (ImageView) findViewById(R.id.musicprevious);
        MusicMenu = (ImageView) findViewById(R.id.musicplaymenu);
        MusicMOde = (ImageView) findViewById(R.id.musicplaymode);
        MusicTime = (TextView) findViewById(R.id.playtime);
        MusicCurrentTime = (TextView) findViewById(R.id.playcurrenttime);
        MusicTitle = (TextView) findViewById(R.id.musictitle);
        MusicArtist = (TextView) findViewById(R.id.musicartist);
        seekBar = (SeekBar) findViewById(R.id.MusicProgress);

    }

    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    @Override
    public void onClick(View v) {
        Intent intent = new Intent();
        switch (v.getId()) {
            case R.id.musicplay:
                if (isPlaying) {
                    MusicPlay.setImageDrawable(getResources().getDrawable(R.drawable.musicpause, null));
                    intent.setClass(MusicActivity.this, MusicService.class);
                    intent.putExtra("MSG", PlayerMSG.MSG.PAUSE_MSG);
                    startService(intent);
                    isPlaying = false;

                } else {
                    MusicPlay.setImageDrawable(getResources().getDrawable(R.drawable.musicplay, null));
                    intent.setClass(MusicActivity.this, MusicService.class);
                    intent.putExtra("MSG", PlayerMSG.MSG.CONTINUE_MSG);
                    startService(intent);
                    isPlaying = true;
                }
                break;
            case R.id.musicplaymode:
                setPlayMOde();
                break;
            case R.id.musicnext:
                PlayNextMusic();
                break;
            case R.id.musicprevious:
                PlayPreviousMusic();
                break;
            case R.id.musicplaymenu:
                break;
            default:
                break;
        }
    }

    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    void setPlayMOde() {
        playmodeflag++;
        Intent intent = new Intent(CTL_ACTION);
        intent.putExtra("control", playmodeflag);
        sendBroadcast(intent);
        switch (playmodeflag) {
            case isorderplay:
                MusicMOde.setImageDrawable(getResources().getDrawable(R.drawable.orderplay, null));
                break;
            case islistloop:
                MusicMOde.setImageDrawable(getResources().getDrawable(R.drawable.repeatplay, null));
                break;
            case isrepeatone:
                MusicMOde.setImageDrawable(getResources().getDrawable(R.drawable.repeatoneplay, null));
                break;
            case israndomplay:
                MusicMOde.setImageDrawable(getResources().getDrawable(R.drawable.randomplay, null));
                playmodeflag = -1;
                break;
            default:
                break;
        }

    }

    SeekBar.OnSeekBarChangeListener seekBarChangeListener = new SeekBar.OnSeekBarChangeListener() {

        //停止拖动事件
        @Override
        public void onStopTrackingTouch(SeekBar seekBar) {
            //手动调节进度
            // TODO Auto-generated method stub
            //seekbar的拖动位置
            int progress = seekBar.getProgress();

            ChangeProgress(progress);
            //调用service调节播放进度
            //      mService.setProgress(max, dest);
        }

        //数值改变事件
        @Override
        public void onProgressChanged(SeekBar arg0, int arg1, boolean arg2) {
            // TODO Auto-generated method stub
        }

        //开始拖动事件
        @Override
        public void onStartTrackingTouch(SeekBar arg0) {
            // TODO Auto-generated method stub
        }
    };

    public void ChangeProgress(int progress) {
        Intent intent = new Intent();
        intent.setClass(MusicActivity.this, MusicService.class);
        intent.putExtra("url", mp3Infos.get(position).getUrl());
        intent.putExtra("position", position);
        intent.putExtra("MSG", PlayerMSG.MSG.PROGRESS_CHANGE);
        intent.putExtra("progress", progress);
        startService(intent);
    }

    //播放音乐
    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    public void PlayMusic() {
        isPlaying = true;

        MusicPlay.setImageDrawable(getResources().getDrawable(R.drawable.musicplay, null));
        // 开始播放的时候为顺序播放
        Intent intent = new Intent();
        intent.setClass(MusicActivity.this, MusicService.class);
        intent.putExtra("url", mp3Infos.get(position).getUrl());
        intent.putExtra("position", position);
        intent.putExtra("MSG", PlayerMSG.MSG.PLAY_MSG);
        MusicService.mp3Infos = mp3Infos;
        startService(intent);
    }

    //播放上一首音乐
    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    public void PlayPreviousMusic() {
        position = position - 1;
        //   MusicPlay.setImageDrawable(getResources().getDrawable(R.drawable.musicpause,null));

        if (position < 0) {
            position = mp3Infos.size() - 1;
        }
        Mp3Info mp3Info = mp3Infos.get(position);
        MusicTitle.setText(mp3Info.getTitle());
        MusicArtist.setText(mp3Info.getArtist());
        Intent intent = new Intent();
        intent.setClass(MusicActivity.this, MusicService.class);
        intent.putExtra("url", mp3Info.getUrl());
        intent.putExtra("position", position);
        intent.putExtra("MSG", PlayerMSG.MSG.PRIVIOUS_MSG);
        startService(intent);
        isPlaying = true;

        MusicPlay.setImageDrawable(getResources().getDrawable(R.drawable.musicplay, null));
    }

    //播放下一首音乐
    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    public void PlayNextMusic() {
        //判断是否是随机播放，因为随机播放设置后，playmodeflag变为-1了
        if (playmodeflag == -1) {
            Random random = new Random();
            position = random.nextInt(mp3Infos.size());
        } else
            position = position + 1;
        if (position >= mp3Infos.size())
            position = 0;

        Mp3Info mp3Info = mp3Infos.get(position);
        MusicTitle.setText(mp3Info.getTitle());
        MusicArtist.setText(mp3Info.getArtist());
        Intent intent = new Intent();
        intent.setClass(MusicActivity.this, MusicService.class);
        intent.putExtra("url", mp3Info.getUrl());
        intent.putExtra("position", position);
        intent.putExtra("MSG", PlayerMSG.MSG.NEXT_MSG);
        startService(intent);
        MusicPlay.setImageDrawable(getResources().getDrawable(R.drawable.musicplay, null));
        isPlaying = true;

    }


    public class MusicPlayerReceiver extends BroadcastReceiver {
        @TargetApi(Build.VERSION_CODES.LOLLIPOP)
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            //当前时间更新
            if (action.equals(MUSIC_CURRENT)) {
                currentTime = intent.getIntExtra("currentTime", -1);
                seekBar.setProgress(currentTime);
                MusicCurrentTime.setText(formatDuring(currentTime));


            } else if (action.equals(MUSIC_DURATION)) {
                //总时间更新
                duration = intent.getIntExtra("duration", -1);
                seekBar.setMax(duration);
                MusicTime.setText(formatDuring(duration));

            } else if (action.equals(UPDATE_ACTION)) {
                position = intent.getIntExtra("position", -1);
                String url = mp3Infos.get(position).getUrl();

                MusicTitle.setText(mp3Infos.get(position).getTitle());
                MusicArtist.setText(mp3Infos.get(position).getArtist());
                MusicTime.setText(formatDuring(mp3Infos.get(position).getDuration()));

            } else if (action.equals(PLAY_STATUE)) {
                boolean playstatue = intent.getBooleanExtra("playstatue", true);
                if (playstatue) {
                    MusicPlay.setImageDrawable(getResources().getDrawable(R.drawable.musicplay, null));
                    isPlaying = true;
                } else {
                    MusicPlay.setImageDrawable(getResources().getDrawable(R.drawable.musicpause, null));
                    isPlaying = false;
                }
            }

        }
    }

    public void onDestroy() {
        //销毁activity时，要记得销毁线程
        playStatus = false;
        super.onDestroy();
    }
}

这里面有许多细节，处理的过程就是不断调试。

最为重要的就是写service了，这个里面主要涉及到MP3的播放，暂停，切换，上一首，进行操作的主要是接受MusicActivity里面传过来的广播，然后进行判断，然后处理对应的函数。说的就是这么简单，但处理起来，并不是很好解决。
MusicService.java

package com.flashmusic;

import com.flashmusic.tool.PlayerMSG;
import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.os.Binder;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.util.Log;
import android.widget.Toast;


import com.flashmusic.tool.Mp3Info;

import java.util.ArrayList;
import java.util.List;

public class MusicService extends Service {

    // mp3的绝对路径
    private String path;
    //当前播放位置
    private int position;
    //当前播放进度
    private int currentTime;

    private int msg;                //播放信息

    private boolean isPause;

    static List<Mp3Info> mp3Infos;    //存放Mp3Info对象的集合

    private int duration;            //播放长度

    int palyflag = 0;


    //服务要发送的一些Action
    public static final String UPDATE_ACTION = "com.flashmusic.action.UPDATE_ACTION";  //更新音乐播放曲目
    public static final String CTL_ACTION = "com.flashmusic.action.CTL_ACTION";        //控制播放模式
    public static final String MUSIC_CURRENT = "com.flashmusic.action.MUSIC_CURRENT";  //当前音乐播放时间更新
    public static final String MUSIC_DURATION = "com.flashmusic.action.MUSIC_DURATION";//播放音乐长度更新
    public static final String PLAY_STATUE = "com.flashmusic.action.PLAY_STATUE";      //更新播放状态

    //播放音乐的媒体类
    MediaPlayer mediaPlayer;
    //广播接收器，接收来自MusicActivity的广播
    private MusicReceiver musicReceiver;


    IBinder musicBinder = new MyBinder();

    //handler用来接收消息，来发送广播更新播放时间
    private Handler mHandler = new Handler() {
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    if (mediaPlayer != null) {
                        currentTime = mediaPlayer.getCurrentPosition();
                        Intent intent = new Intent();
                        intent.setAction(MUSIC_CURRENT);
                        intent.putExtra("currentTime", currentTime);
                        sendBroadcast(intent); // 给PlayerActivity发送广播
                        mHandler.sendEmptyMessageDelayed(1, 1000);
                    }
                    break;
                default:
                    break;
            }
        }

        ;
    };

    class MyBinder extends Binder {
        public Service getService() {
            return MusicService.this;
        }
    }


    @Override
    public void onCreate() {
        super.onCreate();

        mediaPlayer = new MediaPlayer();

        /**
         * 设置音乐播放完成时的监听器
         */
        mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {

            @Override
            public void onCompletion(MediaPlayer mp) {
                Intent intent = new Intent(PLAY_STATUE);
                // 发送播放完毕的信号，更新播放状态
                intent.putExtra("playstatue", false);
                sendBroadcast(intent);


                //       Toast.makeText(getApplicationContext(),"服务完成了",Toast.LENGTH_SHORT).show();
                if (palyflag == 2) {
                    Intent loopintent = new Intent(PLAY_STATUE);
                    // 发送播放完毕的信号，更新播放状态
                    intent.putExtra("playstatue", true);
                    sendBroadcast(loopintent);
                    // 单曲循环
                    mediaPlayer.start();

                } else if (palyflag == 1) {
                    // 列表循环
                    position++;
                    if (position > mp3Infos.size() - 1) {
                        //变为第一首的位置继续播放
                        position = 0;
                    }
                    Intent sendIntent = new Intent(UPDATE_ACTION);
                    sendIntent.putExtra("position", position);
                    // 发送广播，将被Activity组件中的BroadcastReceiver接收到
                    sendBroadcast(sendIntent);
                    path = mp3Infos.get(position).getUrl();
                    play(0);
                } else if (palyflag == 0) { // 顺序播放
                    position++;    //下一首位置
                    if (position <= mp3Infos.size() - 1) {
                        Intent sendIntent = new Intent(UPDATE_ACTION);
                        sendIntent.putExtra("position", position);
                        // 发送广播，将被Activity组件中的BroadcastReceiver接收到
                        sendBroadcast(sendIntent);
                        path = mp3Infos.get(position).getUrl();
                        play(0);
                    } else {
                        mediaPlayer.seekTo(0);
                        position = 0;
                        Intent sendIntent = new Intent(UPDATE_ACTION);
                        sendIntent.putExtra("position", position);
                        // 发送广播，将被Activity组件中的BroadcastReceiver接收到
                        sendBroadcast(sendIntent);
                    }
                } else if (palyflag == 3) {    //随机播放
                    position = getRandomIndex(mp3Infos.size() - 1);
                    Intent sendIntent = new Intent(UPDATE_ACTION);
                    sendIntent.putExtra("position", position);
                    // 发送广播，将被Activity组件中的BroadcastReceiver接收到
                    sendBroadcast(sendIntent);
                    path = mp3Infos.get(position).getUrl();
                    play(0);
                }
            }
        });

        musicReceiver = new MusicReceiver();
        IntentFilter filter = new IntentFilter();
        filter.addAction(CTL_ACTION);
        //     filter.addAction(SHOW_LRC);
        registerReceiver(musicReceiver, filter);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {

        path = intent.getStringExtra("url");        //歌曲路径
        position = intent.getIntExtra("position", -1);    //当前播放歌曲的在mp3Infos的位置
        msg = intent.getIntExtra("MSG", 0);            //播放信息
        if (msg == PlayerMSG.MSG.PLAY_MSG) {    //直接播放音乐
            play(0);
        } else if (msg == PlayerMSG.MSG.PAUSE_MSG) {    //暂停
            pause();
        } else if (msg == PlayerMSG.MSG.STOP_MSG) {        //停止
            stop();
        } else if (msg == PlayerMSG.MSG.CONTINUE_MSG) {    //继续播放
            resume();
        } else if (msg == PlayerMSG.MSG.PRIVIOUS_MSG) {    //上一首
            previous();
        } else if (msg == PlayerMSG.MSG.NEXT_MSG) {        //下一首
            next();
        } else if (msg == PlayerMSG.MSG.PROGRESS_CHANGE) {    //进度更新
            currentTime = intent.getIntExtra("progress", -1);
            play(currentTime);
        } else if (msg == PlayerMSG.MSG.PLAYING_MSG) {
            mHandler.sendEmptyMessage(1);
        }
        return super.onStartCommand(intent, flags, startId);
    }

    private void play(int currentTime) {
        try {

            mediaPlayer.reset();// 把各项参数恢复到初始状态
            mediaPlayer.setDataSource(path);
            mediaPlayer.prepare(); // 进行缓冲
            mediaPlayer.setOnPreparedListener(new PreparedListener(currentTime));// 注册一个监听器
            //更新播放状态
            Intent intent = new Intent(PLAY_STATUE);
            // 发送播放完毕的信号，更新播放状态
            intent.putExtra("playstatue", true);
            sendBroadcast(intent);
            mHandler.sendEmptyMessage(1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    //继续播放
    private void resume() {
        if (isPause) {
            mediaPlayer.start();
            isPause = false;
        }
    }

    /**
     * 上一首
     */
    private void previous() {
        Intent sendIntent = new Intent(UPDATE_ACTION);
        sendIntent.putExtra("position", position);
        // 发送广播，将被Activity组件中的BroadcastReceiver接收到
        sendBroadcast(sendIntent);
        play(0);
    }

    /**
     * 下一首
     */
    private void next() {
        Intent sendIntent = new Intent(UPDATE_ACTION);
        sendIntent.putExtra("position", position);
        // 发送广播，将被Activity组件中的BroadcastReceiver接收到
        sendBroadcast(sendIntent);
        play(0);
    }

    private void pause() {
        if (mediaPlayer != null && mediaPlayer.isPlaying()) {
            mediaPlayer.pause();
            isPause = true;
        }
    }

    private void stop() {
        if (mediaPlayer != null) {
            mediaPlayer.stop();
            try {
                mediaPlayer.prepare(); // 在调用stop后如果需要再次通过start进行播放,需要之前调用prepare函数
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 实现一个OnPrepareLister接口,当音乐准备好的时候开始播放
     */
    private final class PreparedListener implements MediaPlayer.OnPreparedListener {
        private int currentTime;

        public PreparedListener(int currentTime) {
            this.currentTime = currentTime;
        }

        @Override
        public void onPrepared(MediaPlayer mp) {
            mediaPlayer.start(); // 开始播放
            if (currentTime > 0) { // 如果音乐不是从头播放
                mediaPlayer.seekTo(currentTime);
            }
            Intent intent = new Intent();
            intent.setAction(MUSIC_DURATION);
            duration = mediaPlayer.getDuration();
            intent.putExtra("duration", duration);    //通过Intent来传递歌曲的总长度
            sendBroadcast(intent);
        }
    }

    protected int getRandomIndex(int end) {
        int index = (int) (Math.random() * end);
        return index;
    }


    public class MusicReceiver extends BroadcastReceiver {

        @Override
        public void onReceive(Context context, Intent intent) {
            int control = intent.getIntExtra("control", -1);
            switch (control) {
                case 0:
                    palyflag = 0; // 顺序播放
                    break;
                case 1:
                    palyflag = 1;    //列表循环
                    break;
                case 2:
                    palyflag = 2;    //单曲循环
                    break;
                case 3:
                    palyflag = 3;  //随机
                    break;
                default:
                    break;
//            if(action.equals(SHOW_LRC)){
//                current = intent.getIntExtra("listPosition", -1);
//                initLrc();
            }
        }
    }


    @Override
    public IBinder onBind(Intent arg0) {
        // TODO Auto-generated method stub
        //当绑定后，返回一个musicBinder
        return musicBinder;
    }

    @Override
    public void onDestroy() {
        if (mediaPlayer != null) {
            mediaPlayer.stop();
            mediaPlayer.release();
            mediaPlayer = null;
        }

    }
}

这些函数里面有个标识，其实有时候，我们并不想通过new一个类来处理信息，这个就是个很好的表示来解决问题。
PlayerMSG.java

package com.flashmusic.tool;

/**
 * Created by zhouchenglin on 2016/4/18.
 */
public class PlayerMSG {
    public class MSG{
        public static final int PLAY_MSG = 1;       //播放
        public static final int PAUSE_MSG = 2;      //暂停
        public static final int STOP_MSG = 3;       //停止
        public static final int CONTINUE_MSG = 4;   //继续
        public static final int PRIVIOUS_MSG = 5;   //上一首
        public static final int NEXT_MSG = 6;       //下一首
        public static final int PROGRESS_CHANGE = 7;//进度改变
        public static final int PLAYING_MSG = 8;    //正在播放
    }
}

主要的内容就这么多，现在还未完成歌词显示，还有需要解决地问题，就是需要在子线程里面更新UI,这个需要重新考虑。
这篇博客，改变了上一篇博客里面的设计思路，让我掌握了广播的使用。

参考这篇文章，我就是参考大神之后修改的，站在巨人的肩膀上看世界

源码下载