MediaPlayer之构建MediaPlayer管理类（帮助类）--单例模式

引言：
我前些天，遇到了一个问题，我想实现在任何一个界面对我当前播放器播放音乐进行控制，比如当我播放视频，我想在此界面停止音乐播放。听了慕课上一个大佬讲的例子，我才明白，我们构建一个MediaPlayHelper类，使用单例模式，即可完成这项工作。

package com.example.test2.entities;

import android.content.Context;
import android.content.res.AssetFileDescriptor;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.net.Uri;

import java.io.IOException;

public class MediaHelper {
    private static MediaHelper instance;
    private Context mContext;
    private MediaPlayer mMediaPlayer;
    private OnMediaHelperPrepareListener mOnMediaHelperPrepareListener;
    private OnMediaHelperCompletionListener mOnMediaHelperCompletionListener;
    private OnMediaHelperPauseListener mOnMediaHelperPauseListener;
    private OnInitMusicListener mOnInitMusicListener;
    private int mResID=-5;

    public void setmOnInitMusicListener(OnInitMusicListener mOnInitMusicListener) {
        this.mOnInitMusicListener = mOnInitMusicListener;
    }

    public void setmOnMediaHelperPauseListener(OnMediaHelperPauseListener mOnMediaHelperPauseListener) {
        this.mOnMediaHelperPauseListener = mOnMediaHelperPauseListener;
    }

    public void setmOnMediaHelperPrepareListener(OnMediaHelperPrepareListener mOnMediaHelperPrepareListener) {
        this.mOnMediaHelperPrepareListener = mOnMediaHelperPrepareListener;
    }

    public void setmOnMediaHelperCompletionListener(OnMediaHelperCompletionListener mOnMediaHelperCompletionListener) {
        this.mOnMediaHelperCompletionListener = mOnMediaHelperCompletionListener;
    }

    public static MediaHelper getInstance(Context context) {
        if(instance==null){
            synchronized (MediaHelper.class){
                if(instance==null){
                    instance=new MediaHelper(context);
                }
            }
        }
        return instance;
    }

    private MediaHelper(Context context){
        mContext=context;
        mMediaPlayer=new MediaPlayer();
    }

    /**
     * 当播放本地uri中音时调用
     * @param path
     */
    public void setPath(String path){
        if(mMediaPlayer.isPlaying()){
            mMediaPlayer.reset();
        }
        try {
            mMediaPlayer.setDataSource(mContext, Uri.parse(path));
        } catch (IOException e) {
            e.printStackTrace();
        }
        mMediaPlayer.prepareAsync();
        mMediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
            @Override
            public void onPrepared(MediaPlayer mp) {
                if(mOnMediaHelperPrepareListener !=null){
                    mOnMediaHelperPrepareListener.onPrepared(mp);
                }
            }
        });
        mMediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
            @Override
            public void onCompletion(MediaPlayer mp) {
                if(mOnMediaHelperPrepareListener !=null){
                    mOnMediaHelperCompletionListener.onCompletion(mp);
                }
            }
        });
    }

    /**
     * 当调用raw下的文件时使用
     * @param resid
     */
    public void setRawFile(int resid){
        if(resid==mResID&&mResID!=-5){
            //相同音乐id或者且不是第一次播放，就直接返回
            return;
        }
        mOnInitMusicListener.initMode();
        mResID=resid;
        final AssetFileDescriptor afd = mContext.getResources().openRawResourceFd(resid);
        try {
            mMediaPlayer.reset();
            mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
            mMediaPlayer.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
            mMediaPlayer.prepareAsync();
        } catch (IOException e) {
            e.printStackTrace();
        }
        mMediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
            @Override
            public void onPrepared(MediaPlayer mp) {
                if(mOnMediaHelperPrepareListener !=null){
                    mOnMediaHelperPrepareListener.onPrepared(mp);
                    try {
                        afd.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        mMediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
            @Override
            public void onCompletion(MediaPlayer mp) {
                if(mOnMediaHelperPrepareListener !=null){
                    mOnMediaHelperCompletionListener.onCompletion(mp);
                }
            }
        });
    }

    public void start(){
        if(mMediaPlayer.isPlaying()){
            return;
        }
        mMediaPlayer.start();
    }

    public void pause(){
        if(!mMediaPlayer.isPlaying()){
            return;
        }
        mMediaPlayer.pause();
        mOnMediaHelperPauseListener.showPauseImg();
    }

    public boolean isPlaying(){
        if(mMediaPlayer!=null&&mMediaPlayer.isPlaying()){
            return true;
        }
        return false;
    }

    public int getCurrentPosition(){
        return mMediaPlayer.getCurrentPosition();
    }

    public int getDuration(){
        return mMediaPlayer.getDuration();
    }

    public void seekTo(int progress){
        mMediaPlayer.seekTo(progress);
    }

    public interface OnMediaHelperCompletionListener{
        void onCompletion(MediaPlayer mp);
    }

    public interface OnMediaHelperPrepareListener {
        void onPrepared(MediaPlayer mp);
    }

    public interface OnMediaHelperPauseListener {
        void showPauseImg();
    }

    public interface OnInitMusicListener{
        void initMode();
    }

}

接口说明：
我定义了4个接口，并在类中创建了他们的成员变量，在相应的地方实现对他们方法的调用。这使得我单例模式下的唯一instance持有这4个接口，并可以调用他们的set方法。这样一来，就实现了接口外放，在外部，set接口，实现方法的重写，编写相关交互代码。
问题解决：
比如，这样一来，我只需要在视频界面getInstance()，就能调用pause方法和start方法来控制音乐播放。