即使使用OGG格式，Android MediaPlayer循环也存在漏洞

在Android 4.x中，我的音频循环应用程序在声音循环中有0.2到0.5秒的间隔

我使用MediaPlayer是因为我的声音可能相当大（在某些情况下，每个声音为2-3mb），并且它可以同时运行多个实例

我对此做了很多研究，我发现Android 4.x有一个bug。。。然而，我已经尝试了许多变通方法，但似乎都无法奏效

• 使用Audacity将所有WAV转换为OGG（质量级别2到10，无所谓）
• 已尝试setNextMediaPlayer（）
• 尝试在停止并重复时使用seekTo（0）
• 尝试了有自己缺陷的soundPool

下面是我正在使用的代码示例：

public class SoundPlayer implements OnCompletionListener {
    private MediaPlayer mp = null;

    public void initPlayer() {
        if(mp == null) {
            mp = new MediaPlayer();
        }
    }

    public void prepare(Context context, int resource) {
    initPlayer();
    try{
        mp.reset();
        Uri uri = Uri.parse("android.resource://com.myapp.app/"+resource);
        mp.setDataSource(context,uri);
        mp.prepare();
        isPrepared = true;
        mp.setOnCompletionListener(this);
    } catch(Exception e) {
        e.printStackTrace();
    }
    }


.......... etc (Uses typical MediaPlayer methods such as stop(), start(), setLooping(true)


}

---

我没有使用任何特别的东西，所以我只是想知道是否有人知道Android上的循环漏洞的解决方法。

好的，老帖子，但这个解决方案是有效的。这是一种黑客行为。如果有人找到了这个答案，那会有帮助的

我只使用了三台媒体播放器<代码>mp1，

mp2

，

mp3

mp1

开始播放，我将

mp2

设置为其

setNextMediaPlayer

。当

mp1

结束时，我将

mp3

设置为

mp2的
setNextMediaPlayer
。当
mp2
结束时，我将
mp1
设置为
mp3
setNextMediaPlayer
。下面是播放暂停、停止、设置音量的完整代码。只需创建一个对象
BZMediaPlayer
，通过提供
uri
或资源id来启动它

import android.content.Context;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnCompletionListener;
import android.net.Uri;
import android.util.Log;

public class BZMediaPlayer {


    private Context context;
    private Uri uri;
    private int resourceId;

    // which file is getting played
    public static final int URI_PLAYING = 1;
    public static final int RESOURCE_PLAYING = 2;
    private int filePlaying;

    // states of the media player
    public static final int STATE_PLAYING = 1;
    public static final int STATE_PAUSED = 2;
    public static final int STATE_STOP = 3;

    // current state
    private int state = STATE_STOP;

    // current mediaPlayer which is playing
    private int mediaPlayerIndex = -1;

    // 3 media players
    private MediaPlayer mp[] = new MediaPlayer[3];

    // current volume
    private float vol;


    public BZMediaPlayer(Context context) {
        this.context = context;
    }

    /**
     * plays the provided uri
     * @param uri
     */
    public void play(Uri uri) {
        this.uri = uri;
        // current playing file
        filePlaying = URI_PLAYING;
        // stop any playing session
        stop();

        // initialize and set listener to three mediaplayers
        for (int i = 0; i < mp.length; i++) {
            mp[i] = MediaPlayer.create(context, uri);
            mp[i].setOnCompletionListener(completionListener);
        }

        // set nextMediaPlayers
        mp[0].setNextMediaPlayer(mp[1]);
        mp[1].setNextMediaPlayer(mp[2]);

        // start the first MediaPlayer
        mp[0].start();
        // set mediaplayer inex
        mediaPlayerIndex = 0;
        // set state
        state = STATE_PLAYING;
    }

    /**
     * play file from resource
     * @param resourceId
     */
    public void play(int resourceId) {
        this.resourceId = resourceId;
        filePlaying = RESOURCE_PLAYING;
        stop();
        for (int i = 0; i < mp.length; i++) {
            mp[i] = MediaPlayer.create(context, resourceId);
            mp[i].setOnCompletionListener(completionListener);
        }

        mp[0].setNextMediaPlayer(mp[1]);
        mp[1].setNextMediaPlayer(mp[2]);

        mp[0].start();
        mediaPlayerIndex = 0;
        state = STATE_PLAYING;
    }

    /**
     * play if the mediaplayer is pause
     */
    public void play() {
        if (state == STATE_PAUSED) {
            mp[mediaPlayerIndex].start();
            Log.d("BZMediaPlayer", "playing");
            state = STATE_PLAYING;
        }
    }

    /**
     * pause current playing session
     */
    public void pause() {
        if (state == STATE_PLAYING) {
            mp[mediaPlayerIndex].pause();
            Log.d("BZMediaPlayer", "pausing");
            state = STATE_PAUSED;
        }
    }

    /**
     * get current state
     * @return
     */
    public int getState() {
        return state;
    }

    /**
     * stop every mediaplayer
     */
    public void stop() {
        for(int i = 0 ; i < mp.length ; i++) {
            if (mp[i] != null) { 
                mp[i].stop();

                if(mp[i].isPlaying()) {
                    mp[i].release();
                }
            }   
        }
        state = STATE_STOP;
    }

    /**
     * set vol for every mediaplayer
     * @param vol
     */
    public void setVol(float vol) {
        this.vol = vol;
        for(int i = 0 ; i < mp.length ; i++) {
            if (mp[i] != null && mp[i].isPlaying()) {
                mp[i].setVolume(vol, vol);
            }   
        }
    }

    /**
     * internal listener which handles looping thing
     */
    private MediaPlayer.OnCompletionListener completionListener = new OnCompletionListener() {

        @Override
        public void onCompletion(MediaPlayer curmp) {
            int mpEnds = 0;
            int mpPlaying = 0;
            int mpNext = 0;
            if(curmp == mp[0]) {
                mpEnds = 0;
                mpPlaying = 1;
                mpNext = 2;
            }
            else if(curmp == mp[1]) {
                mpEnds = 1;
                mpPlaying = 2;
                mpNext = 0;  // corrected, else index out of range
            }
            else if(curmp == mp[2]) {
                mpEnds = 2;
                mpPlaying = 0; // corrected, else index out of range
                mpNext = 1; // corrected, else index out of range
            }

            // as we have set mp2 mp1's next, so index will be 1
            mediaPlayerIndex = mpPlaying;
            Log.d("BZMediaPlayer", "Media Player " + mpEnds);
            try {
                // mp3 is already playing release it
                if (mp[mpNext] != null) {
                    mp[mpNext].release();
                }
                // if we are playing uri
                if (filePlaying == URI_PLAYING) {
                    mp[mpNext] = MediaPlayer.create(context, uri);
                } else {
                    mp[mpNext] = MediaPlayer.create(context, resourceId);
                }
                // at listener to mp3
                mp[mpNext].setOnCompletionListener(this);
                // set vol
                mp[mpNext].setVolume(vol, vol);
                // set nextMediaPlayer
                mp[mpPlaying].setNextMediaPlayer(mp[mpNext]);
                // set nextMediaPlayer vol
                mp[mpPlaying].setVolume(vol, vol);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    };

}

导入android.content.Context；
导入android.media.MediaPlayer；
导入android.media.MediaPlayer.OnCompletionListener；
导入android.net.Uri；
导入android.util.Log；
公共类BZMediaPlayer{
私人语境；
私有Uri；
私有资源ID；
//正在播放哪个文件
公共静态最终int URI_PLAYING=1；
公共静态最终int资源_PLAYING=2；
私人娱乐；
//媒体播放器的状态
公共静态最终整数状态_PLAYING=1；
公共静态最终整数状态_=2；
公共静态最终int状态_停止=3；
//现状
private int state=state\u STOP；
//正在播放的当前媒体播放器
私有int mediaPlayerIndex=-1；
//3个媒体播放器
私有媒体播放器mp[]=新媒体播放器[3]；
//当前卷
私人浮动卷；
公共BZMediaPlayer（上下文）{
this.context=上下文；
}
/**
*播放提供的uri
*@param-uri
*/
公共无效播放（Uri）{
this.uri=uri；
//当前播放文件
filePlaying=URI\u PLAYING；
//停止任何游戏会话
停止（）；
//初始化并将侦听器设置为三个MediaPlayer
对于（int i=0；i