ijkplayer

1月18日，北京，聊聊2025如何加入技术开发？

public class IJKPlayer implements IPlayback, IMediaPlayer.OnCompletionListener, IMediaPlayer.OnErrorListener{
    private static final String TAG = "IJKPlayer";

    private static volatile IJKPlayer sInstance;

    private IjkMediaPlayer mIjkMediaPlayer;

    private PlayList mPlayList;

    // Default size 2: for service and UI
    private List<Callback> mCallbacks = new ArrayList<>(2);


    // AudioPlayer status
    private boolean isPaused;
    private boolean isPlaying;

    private IJKPlayer() {
        mIjkMediaPlayer = new IjkMediaPlayer();
        mPlayList = new PlayList();
        mIjkMediaPlayer.setOnCompletionListener(this);
        mIjkMediaPlayer.setOnErrorListener(this);
    }

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


    @Override
    public void changePlayerSpeed(float speed) {
        mIjkMediaPlayer.setSpeed(speed);
        mIjkMediaPlayer.start();
    }

    @Override
    public void prepareDataSource(Song mSong) {
        if(ObjectUtils.isEmpty(mSong)) {
            return;
        }
        List<Song> songs = mPlayList.getSongs();
        songs.add(0, mSong);
        try {
            LogUtils.e("start time", System.currentTimeMillis());
            mIjkMediaPlayer.stop();
            mIjkMediaPlayer.reset();
            mIjkMediaPlayer.setDataSource(mSong.getPath());
            mIjkMediaPlayer.prepareAsync();
            LogUtils.e("end time", System.currentTimeMillis());
        } catch (IOException e) {
            LogUtils.e(TAG, "play: ", e);
        }
    }

    @Override
    public boolean play() {
        boolean result = true;
        boolean flag = true;
        isPlaying = true;
        if (isPaused) {
            mIjkMediaPlayer.start();
        } else {
            Song song = mPlayList.getSongs().get(0);
            try {
                mIjkMediaPlayer.reset();
                mIjkMediaPlayer.setDataSource(song.getPath());
                mIjkMediaPlayer.prepareAsync();
                mIjkMediaPlayer.start();
            } catch (IOException e) {
                LogUtils.e(TAG, "play: ", e);
                flag = false;
                result = false;
            }
        }
        notifyPlayStatusChanged(flag);
        return result;
    }

    @Override
    public boolean play(Song song) {
        if (song == null) return false;

        isPaused = false;
        mPlayList.getSongs().clear();
        mPlayList.getSongs().add(song);
        return play();
    }

    @Override
    public boolean pause() {
        if (isPlaying) {
            mIjkMediaPlayer.pause();
            isPaused = true;
            isPlaying = false;
            notifyPlayStatusChanged(false);
            return true;
        }
        return false;
    }

    @Override
    public boolean isPlaying() {
        return isPlaying;
    }

    @Override
    public long getProgress() {
        return mIjkMediaPlayer.getCurrentPosition();
    }

    @Override
    public Song getPlayingSong() {
        return mPlayList.getSongs().get(0);
    }

    @Override
    public boolean seekTo(int progress) {
        if (mPlayList.getSongs().isEmpty()) return false;

        Song currentSong = getPlayingSong();
        if (currentSong != null) {
            if (currentSong.getDuration() <= progress) {
                onCompletion(mIjkMediaPlayer);
            } else {
                mIjkMediaPlayer.seekTo(progress);
            }
            return true;
        }
        return false;
    }

    @Override
    public void registerCallback(Callback callback) {
        mCallbacks.add(callback);
    }

    @Override
    public void unregisterCallback(Callback callback) {
        mCallbacks.remove(callback);
    }

    @Override
    public void removeCallbacks() {
        mCallbacks.clear();
    }

    @Override
    public void releasePlayer() {
        mPlayList = null;
        mIjkMediaPlayer.stop();
        mIjkMediaPlayer.reset();
        mIjkMediaPlayer.release();
        mIjkMediaPlayer = null;
        sInstance = null;
        isPlaying = false;
    }

    @Override
    public void onCompletion(IMediaPlayer mp) {
        LogUtils.i("IJKPlayer 播放完成 ".concat(mp.toString()));
        // There is only one limited play mode which is list, player should be stopped when hitting the list end
        if (mPlayList.getPlayMode() == PlayMode.LIST && mPlayList.getPlayingIndex() == mPlayList.getNumOfSongs() - 1) {
            // In the end of the list
            // Do nothing, just deliver the callback
        } else if (mPlayList.getPlayMode() == PlayMode.SINGLE) {
//            play();
        } else {
            boolean hasNext = mPlayList.hasNext(true);
            if (hasNext) {
//                play();
            }
        }
    }

    private void notifyPlayStatusChanged(boolean isPlaying) {
        for (Callback callback : mCallbacks) {
            callback.onPlayStatusChanged(isPlaying);
        }
    }

    @Override
    public boolean onError(IMediaPlayer mp, int what, int extra) {
        LogUtils.e("IJKPlayer 播放错误 what is ".concat(String.valueOf(what)).concat(" extra is").concat(String.valueOf(extra)));
        return false;
    }
}

    //ijkplayer引入开始
    // required, enough for most devices.
    implementation 'tv.danmaku.ijk.media:ijkplayer-java:0.8.8'
    implementation 'tv.danmaku.ijk.media:ijkplayer-armv7a:0.8.8'
    // Other ABIs: optional
    implementation 'tv.danmaku.ijk.media:ijkplayer-armv5:0.8.8'
    implementation 'tv.danmaku.ijk.media:ijkplayer-arm64:0.8.8'
    implementation 'tv.danmaku.ijk.media:ijkplayer-x86:0.8.8'
    implementation 'tv.danmaku.ijk.media:ijkplayer-x86_64:0.8.8'

    //ExoPlayer as IMediaPlayer: optional, experimental
    implementation 'tv.danmaku.ijk.media:ijkplayer-exo:0.8.8'
    //ijkplayer引入结束