exoplayer和mediaplayer的封装

最新推荐文章于 2024-06-11 10:45:20 发布

u010548935

最新推荐文章于 2024-06-11 10:45:20 发布

阅读量1.1k

点赞数

分类专栏： #android 文章标签： android

本文链接：https://blog.csdn.net/u010548935/article/details/104348872

版权

#android 专栏收录该内容

1 篇文章

订阅专栏

为解决MediaPlayer在播放特定音频流时出现的错误，本文介绍了一种在不改变现有接口的情况下，封装MediaPlayer和ExoPlayer的方法。通过创建统一的播放器接口，实现了对两种播放器的无缝切换，有效提升了音频流播放的稳定性和兼容性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

问题：开发播放器的过程中发现，在mediaplayer对喜马拉雅的hls直播音频流进行播放的过程中，发生MediaPlayer:Error(1,-1007)错误，尝试播放网上找的直播流"http://content.mobile-tv.sky.com/content/ssna/live/ssnraudio.m3u8"不放生此问题

对此在不改变项目已有接口的情况下将MediaPlayer 和 ExoPlayer进行封装

代码如下

public class MediaPlayerImp {
    private UaiMediaListener listener;

    private Context context;

    private boolean isExoPLayer = false;

    private Object mMediaPlayer;

    private Object exoPlayerListener;

    public interface UaiMediaListener {
        void onPrepared();

        void onCompletion();

        void onSeekComplete();

        void onError();
    }

    public MediaPlayerImp(Context context) {
        this.context = context;
        mMediaPlayer = createMediaPlayer(context);
    }

    public MediaPlayerImp(Context context, boolean isNeedExoPLayer){
        this(context);
        this.isExoPLayer = isNeedExoPLayer;
    }

    public void reset() {
        if (isExoPLayer) {
            //no reset do nothing
        } else {
            ((MediaPlayer) mMediaPlayer).reset();
        }
    }

    public boolean isPlaying() {
        if (isExoPLayer) {
            return ((ExoPlayer) mMediaPlayer).getPlayWhenReady();
        } else {
            return ((MediaPlayer) mMediaPlayer).isPlaying();
        }
    }

    public void start() {
        if (isExoPLayer) {
            ((ExoPlayer) mMediaPlayer).setPlayWhenReady(true);
        } else {
            ((MediaPlayer) mMediaPlayer).start();
        }
    }

    public void pause() {
        if (isExoPLayer) {
            ((ExoPlayer) mMediaPlayer).setPlayWhenReady(false);
        } else {
            ((MediaPlayer) mMediaPlayer).pause();
        }
    }

    public void stop() {
        if (isExoPLayer) {
            ((ExoPlayer) mMediaPlayer).setPlayWhenReady(false);
            ((ExoPlayer) mMediaPlayer).stop();
        } else {
            ((MediaPlayer) mMediaPlayer).stop();
        }
    }

    public void release() {
        if (isExoPLayer) {
            ((ExoPlayer) mMediaPlayer).removeListener((Player.EventListener) exoPlayerListener);
            ((ExoPlayer) mMediaPlayer).release();
        } else {
            ((MediaPlayer) mMediaPlayer).release();
        }
    }

    public void seekTo(int msec) {
        if (isExoPLayer) {
            ((ExoPlayer) mMediaPlayer).seekTo(msec);
        } else {
            ((MediaPlayer) mMediaPlayer).seekTo(msec);
        }
    }

    public void playAsync(String strUri) {
        if (isExoPLayer) {
            DataSource.Factory dataSourceFactory = new DefaultDataSourceFactory(context, "MediaPlayerImp");
            if (strUri.endsWith("m3u8")) {
                MediaSource hlsMediaSource = new HlsMediaSource.Factory(dataSourceFactory).createMediaSource(Uri.parse(strUri));
                ((ExoPlayer) mMediaPlayer).prepare(hlsMediaSource, true, true);
            } else {
                MediaSource extraMediaSource = new ExtractorMediaSource.Factory(dataSourceFactory).createMediaSource(Uri.parse(strUri));
                ((ExoPlayer) mMediaPlayer).prepare(extraMediaSource);
            }
        } else {
            try {
                ((MediaPlayer) mMediaPlayer).setDataSource(strUri);
                ((MediaPlayer) mMediaPlayer).prepareAsync();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public long getDuration() {
        if (isExoPLayer) {
            return ((ExoPlayer) mMediaPlayer).getDuration();
        } else {
            return ((MediaPlayer) mMediaPlayer).getDuration();
        }
    }

    public long getCurrentPosition() {
        if (isExoPLayer) {
            return ((ExoPlayer) mMediaPlayer).getCurrentPosition();
        } else {
            return ((MediaPlayer) mMediaPlayer).getCurrentPosition();
        }
    }

    public void setUaiMediaListener(@NonNull UaiMediaListener listener) {
        this.listener = listener;
    }

    private Object createMediaPlayer(Context context) {
        if (isExoPLayer) {
            // Create the player
            ExoPlayer exoPlayer = ExoPlayerFactory.newSimpleInstance(new DefaultRenderersFactory(context),
                    new DefaultTrackSelector(), new DefaultLoadControl());
            exoPlayerListener = new Player.DefaultEventListener() {

                @Override
                public void onPlayerStateChanged(boolean playWhenReady, int playbackState) {
                    if (playbackState == Player.STATE_READY) {
                        listener.onPrepared();
                    }
                    if (playbackState == Player.STATE_ENDED) {
                        listener.onCompletion();
                    }
                }

                @Override
                public void onPlayerError(ExoPlaybackException error) {
                    listener.onError();
                }

                @Override
                public void onSeekProcessed() {
                    listener.onSeekComplete();
                }
            };
            exoPlayer.addListener((Player.EventListener) exoPlayerListener);
            return exoPlayer;
        } else {
            MediaPlayer mediaPlayer = new MediaPlayer();
            mediaPlayer.setOnPreparedListener((mp) -> {
                listener.onPrepared();

            });
            mediaPlayer.setOnErrorListener((mp, what, extra) -> {
                listener.onError();
                return true;
            });
            mediaPlayer.setOnCompletionListener((mp) -> {
                listener.onCompletion();

            });
            mediaPlayer.setOnSeekCompleteListener((mp) -> {
                listener.onSeekComplete();
            });
            return mediaPlayer;
        }
    }


}