Android MediaPlayer 实现读秒播放音频

1、首先介绍一下属性：

setUsage : 设置用途
USAGE_MEDIA：表示音频的用途是多媒体。
USAGE_VOICE_COMMUNICATION：表示音频的用途是语音通信。
USAGE_NOTIFICATION：表示音频的用途是通知。
USAGE_ALARM：表示音频的用途是闹钟。
USAGE_ASSISTANCE_ACCESSIBILITY：表示音频的用途是辅助功能和无障碍功能。

setContentType: 设置描述音频信号(如语音或音乐)的内容类型的属性。
CONTENT_TYPE_MUSIC：表示音频的内容类型是音乐。
CONTENT_TYPE_SPEECH：表示音频的内容类型是语音。
CONTENT_TYPE_MOVIE：表示音频的内容类型是电影。
CONTENT_TYPE_SONIFICATION：表示音频的内容类型是提示音或系统声音。

setFlags(int flags)：设置音频的标志

//设置初始化
 mMediaPlayer = new MediaPlayer();
        //设置音乐播放
  mMediaPlayer.setAudioAttributes(new AudioAttributes.Builder()
                .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
                .setUsage(AudioAttributes.USAGE_MEDIA)
                .build()
);

2、详细代码：

public class AudioPlayerManager {

    private static volatile AudioPlayerManager inStance = null;
    private MediaPlayer mMediaPlayer;
    private String mAudioPlayerPath;
    private AudioPlayerListener playerListener;
    private boolean isPlaying = false;
    private int audioPlayingDuration;

    public static AudioPlayerManager getInstance() {
        if (inStance == null) {
            synchronized (AudioPlayerManager.class) {
                if (inStance == null) {
                    inStance = new AudioPlayerManager();
                }
            }
        }
        return inStance;
    }

    private AudioPlayerManager() {
        init();
    }

    private void init() {
        mMediaPlayer = new MediaPlayer();
        //设置音乐播放
        mMediaPlayer.setAudioAttributes(new AudioAttributes.Builder()
                .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
                .setUsage(AudioAttributes.USAGE_MEDIA)
                .build()
        );
        //网络流媒体的缓冲监听
//        mMediaPlayer.setOnBufferingUpdateListener(new MediaPlayer.OnBufferingUpdateListener() {
//            @Override
//            public void onBufferingUpdate(MediaPlayer mp, int percent) {
//
//            }
//        });
        //网络流媒体播放结束监听
        mMediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
            @Override
            public void onCompletion(MediaPlayer mp) {
                stopTimer();
                if (playerListener != null) {
                    playerListener.onAudioPlayerCompletion();
                }

            }
        });
        //设置错误信息监听
        mMediaPlayer.setOnErrorListener(new MediaPlayer.OnErrorListener() {
            @Override
            public boolean onError(MediaPlayer mp, int what, int extra) {
                return false;
            }
        });
        //音频源准备好后调用
        mMediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
            @Override
            public void onPrepared(MediaPlayer mp) {
                if (audioPlayingDuration <= 0) {
                    start();
                } else {
                    mMediaPlayer.seekTo(audioPlayingDuration * 1000);
                }

            }
        });
        //Seek操作完成后调用
        mMediaPlayer.setOnSeekCompleteListener(new MediaPlayer.OnSeekCompleteListener() {
            @Override
            public void onSeekComplete(MediaPlayer mp) {
                start();
            }
        });

//        mMediaPlayer.setOnTimedTextListener(new MediaPlayer.OnTimedTextListener() {
//            @Override
//            public void onTimedText(MediaPlayer mp, TimedText text) {
//            }
//        });
//
//        mMediaPlayer.setOnInfoListener(new MediaPlayer.OnInfoListener() {
//            @Override
//            public boolean onInfo(MediaPlayer mp, int what, int extra) {
//                return false;
//            }
//        });
        initTimerListener();
    }

    /**
     * 初始化 定时器 监听
     */
    private void initTimerListener() {
        HandlerManager.getInstance().addListener(new HandlerListener() {
            @Override
            public void disposeHandleMessage(int handlerWhat, long currentTimeMillis, HandlerBean handlerBean) {
                if (playerListener != null && isPlaying) {
                    playerListener.onAudioPlayerProgress(mMediaPlayer.getCurrentPosition() / 1000, mMediaPlayer.getDuration() / 1000, isPlaying);

                    HandlerManager.getInstance().sendMessageLocalityDelayed(BaseConstantValue.AUDIO_START_TIME_WHAT, BaseConstantValue.AUDIO_START_TIME_WHAT, 1);
                }

            }
        }, BaseConstantValue.AUDIO_START_TIME_WHAT);

    }

    private void stopTimer() {
        isPlaying = false;
        //移除handler 读秒
        HandlerManager.getInstance().removeMessages(BaseConstantValue.AUDIO_START_TIME_WHAT);
    }

    /**
     * 播放
     */
    private void start() {
        isPlaying = true;
        if (!mMediaPlayer.isPlaying()) {
            //异步准备
            mMediaPlayer.start();
        }
        //通过handler 发送延迟1秒，实现读秒功能
        HandlerManager.getInstance().sendMessageLocalityDelayed(BaseConstantValue.AUDIO_START_TIME_WHAT, BaseConstantValue.AUDIO_START_TIME_WHAT, 1);
    }

    /**
     * 资源准备
     *
     * @param path
     * @throws IOException
     */
    private void prepareAsync(String path) throws IOException {
        stopTimer();
        mMediaPlayer.stop();
        mMediaPlayer.reset();
        mMediaPlayer.setDataSource(path);
        //异步准备
        mMediaPlayer.prepareAsync();
    }

    /**
     * 初始化资源数据，并准备数据
     * @param path
     * @param audioPlayingDuration
     * @param audioPlayerListener
     */
    public synchronized void start(String path, int audioPlayingDuration, AudioPlayerListener audioPlayerListener) {
        try {
            this.audioPlayingDuration = audioPlayingDuration;
            //判断当前监听是否存在
            if (playerListener != null) {
                int currentPosition = -1;
                //判断当前是否在播放，如果在，则获取播放进度，并暂停播放
                if (mMediaPlayer.isPlaying()) {
                    currentPosition = mMediaPlayer.getCurrentPosition() / 1000;
                }
                playerListener.onAudioPlayerPause(currentPosition);
            }
            //设置新的播放进度监听
            setListener(audioPlayerListener);
            //判断是否为同一个播放源
            if (isIdenticalSource(path)) {
                start();
            } else {
                prepareAsync(path);
            }
            this.mAudioPlayerPath = path;
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 暂停播放
     *
     * @return
     */
    public void pause() {
        stopTimer();
        if (mMediaPlayer != null && mMediaPlayer.isPlaying()) {
            mMediaPlayer.pause();
        }
        playerListener = null;
    }

    /**
     * 停止播放，释放资源，可以用于：界面关闭，切换界面
     */
    public void stop() {
        stopTimer();
        if (mMediaPlayer != null && mMediaPlayer.isPlaying()) {
            mMediaPlayer.pause();
            if (playerListener != null) {
                playerListener.onAudioPlayerPause(mMediaPlayer.getCurrentPosition() / 1000);
            }
        }
        mAudioPlayerPath = "";

        playerListener = null;

    }

    /**
     * 当前文件是否是 MediaPlayer 播放状态
     *
     * @param audioPlayerPath 当前文件
     * @return -1:标识不是当前播放文件  其他值：播放状态
     */
    public int isPlaying(String audioPlayerPath) {
        if (isIdenticalSource(audioPlayerPath) && mMediaPlayer.isPlaying()) {
            return mMediaPlayer.getCurrentPosition() / 1000;
        }
        return -1;
    }

    /**
     * 判断是否为同一个音频源
     *
     * @param audioPlayerPath
     * @return
     */
    private boolean isIdenticalSource(String audioPlayerPath) {
        return TextUtils.equals(mAudioPlayerPath, audioPlayerPath);
    }


    /**
     * 设置播放读秒回调监听
     *
     * @param audioPlayerListener
     */
    public void setListener(AudioPlayerListener audioPlayerListener) {
        playerListener = audioPlayerListener;

    }

3、播放状态或者进度

public interface AudioPlayerListener {


    /**
     * 语音播放中回调进度
     *
     * @param playingPosition
     * @param duration
     * @param isPlaying
     */
    void onAudioPlayerProgress(int playingPosition, int duration, boolean isPlaying);

    /**
     * 暂停播放
     *
     * @param playingPosition -1：表示未播放 其他值，表示已播放多少
     */
    void onAudioPlayerPause(int playingPosition);

    /**
     * 语音播放结束
     */
    void onAudioPlayerCompletion();
}

4、示例：

1、获取 int playingState = AudioPlayerManager.getInstance().isPlaying(audioUrl);
2、判断 playingState 状态
   ①、playingState > 0 表示当前音频播放，只需要设置播放进度监听AudioPlayerManager.getInstance().setListener(new AudioPlayerListener() {});
   ②、 反之不需要处理逻辑，如果本地数据有做状态记录，需要设置本地状态
3、设置语音点击事件(如播放、暂停等).