Java Android上的点对点音频呼叫：语音中断和延迟（接收数据包的延迟）增加_Java_Android

Java Android上的点对点音频呼叫：语音中断和延迟（接收数据包的延迟）增加

java android

Java Android上的点对点音频呼叫：语音中断和延迟（接收数据包的延迟）增加,java,android,Java,Android,我正在尝试在android上建立点对点音频呼叫。我使用安卓手机和平板电脑进行通信，但在收到大约40个数据包后，手机几乎停止接收数据包，然后突然收到一些数据包并播放它们，以此类推，但等待时间增加了。类似地，平板电脑最初接收数据包并播放数据包，但延迟增加，而且语音在一段时间后开始中断，就好像一些数据包丢失了一样。知道是什么导致了这个问题吗这是应用程序的代码…我只是在RecordAudio类中提供发送方和接收方的ip地址，同时在两台设备上运行它 public class AudioRPActivit

我正在尝试在android上建立点对点音频呼叫。我使用安卓手机和平板电脑进行通信，但在收到大约40个数据包后，手机几乎停止接收数据包，然后突然收到一些数据包并播放它们，以此类推，但等待时间增加了。类似地，平板电脑最初接收数据包并播放数据包，但延迟增加，而且语音在一段时间后开始中断，就好像一些数据包丢失了一样。知道是什么导致了这个问题吗

这是应用程序的代码…我只是在RecordAudio类中提供发送方和接收方的ip地址，同时在两台设备上运行它

public class AudioRPActivity extends Activity implements OnClickListener {

    DatagramSocket socketS,socketR;
    DatagramPacket recvP,sendP;
    RecordAudio rt;
    PlayAudio pt;

    Button sr,stop,sp;
    TextView tv,tv1;
    File rf;

    boolean isRecording = false;
    boolean isPlaying = false;

    int frequency = 44100;
    int channelConfiguration = AudioFormat.CHANNEL_CONFIGURATION_MONO;
    int audioEncoding = AudioFormat.ENCODING_PCM_16BIT;

    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        tv = (TextView)findViewById(R.id.text1);
        tv1 = (TextView)findViewById(R.id.text2);

        sr = (Button)findViewById(R.id.sr);
        sp = (Button)findViewById(R.id.sp);
        stop = (Button)findViewById(R.id.stop);

        sr.setOnClickListener(this);
        sp.setOnClickListener(this);
        stop.setOnClickListener(this);

        stop.setEnabled(false);

        try
        {
        socketS=new DatagramSocket();
        socketR=new DatagramSocket(6000);
        }
        catch(SocketException se)
        {
            tv.setText(se.toString());
            finish();
        }
    }

    public void onClick(View v) {

        if(v == sr)
            record();
        else if(v == sp)
            play();
        else if(v == stop)
            stopPlaying();
    }

    public void play()
    {
        stop.setEnabled(true);
        sp.setEnabled(false);
        pt = new PlayAudio();
        pt.execute();
    }

    public void stopPlaying()
    {
        isRecording=false;
        isPlaying = false;
        stop.setEnabled(false);
    }

    public void record()
    {
        stop.setEnabled(true);
        sr.setEnabled(false);
        rt = new RecordAudio();
        rt.execute();
    }



    private class PlayAudio extends AsyncTask<Void,String,Void>
    {

        @Override
        protected Void doInBackground(Void... arg0)
        {
            isPlaying = true;
            int bufferSize = AudioTrack.getMinBufferSize(frequency, channelConfiguration, audioEncoding);

            byte[] audiodata = new byte[bufferSize];

            try
            {
                AudioTrack audioTrack = new AudioTrack(AudioManager.STREAM_MUSIC,frequency,channelConfiguration,
                                                        audioEncoding,4*bufferSize,AudioTrack.MODE_STREAM);
                audioTrack.setPlaybackRate(frequency);
                audioTrack.play();

                while(isPlaying)
                {
                    recvP=new DatagramPacket(audiodata,audiodata.length);
                    socketR.receive(recvP);
                    audioTrack.write(recvP.getData(), 0, recvP.getLength());
                }
                audioTrack.stop();
                audioTrack.release();
            }
            catch(Throwable t)
            {
                Log.e("Audio Track","Playback Failed");
            }
            return null;
        }
        protected void onProgressUpdate(String... progress)
        {
            tv1.setText(progress[0].toString());
        }

        protected void onPostExecute(Void result)
        {
            sr.setEnabled(true);
            sp.setEnabled(true);
        }

    }

    private class RecordAudio extends AsyncTask<Void,String,Void>
    {

        @Override
        protected Void doInBackground(Void... arg0)
        {
            isRecording = true;

            try
            {
                int bufferSize = AudioTrack.getMinBufferSize(frequency, channelConfiguration, audioEncoding);

                AudioRecord audioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC,frequency,channelConfiguration
                                                            ,audioEncoding,4*bufferSize);   
                byte[] buffer = new byte[bufferSize];
                audioRecord.startRecording();
                int r=0;
                while(isRecording)
                {
                    int brr = audioRecord.read(buffer,0,bufferSize);

                    sendP=new DatagramPacket(buffer,brr,InetAddress.getByName("sender's/receiver's ip"),6000);
                    socketS.send(sendP);
                    publishProgress(String.valueOf(r));

                    r++;
                }

                audioRecord.stop();
                audioRecord.release();

            }
            catch(Throwable t)
            {
                Log.e("AudioRecord","Recording Failed....");
            }


            return null;
        }

        protected void onProgressUpdate(String... progress)
        {
            tv.setText(progress[0].toString());
        }

        protected void onPostExecute(Void result)
        {
            sr.setEnabled(true);
            sp.setEnabled(true);
        }
    }
}

公共类AudioRPActivity扩展活动实现OnClickListener{
DatagramSocket套接字，socketR；
数据包记录，sendP；
录音音频rt；
播放音频pt；
按钮sr，停止，sp；
TextView电视，tv1；
文件射频；
布尔值isRecording=false；
布尔isplay=false；
int频率=44100；
int channelConfiguration=AudioFormat.CHANNEL\u CONFIGURATION\u MONO；
int audioEncoding=AudioFormat.ENCODING_PCM_16位；
@凌驾
创建时的公共void（Bundle savedInstanceState）
{
super.onCreate（savedInstanceState）；
setContentView（R.layout.main）；
tv=（TextView）findViewById（R.id.text1）；
tv1=（TextView）findViewById（R.id.text2）；
sr=（按钮）findviewbyd（R.id.sr）；
sp=（按钮）findViewById（R.id.sp）；
停止=（按钮）findViewById（R.id.stop）；
高级setOnClickListener（本）；
sp.setOnClickListener（此）；
stop.setOnClickListener（this）；
stop.setEnabled（false）；
尝试
{
套接字=新的DatagramSocket（）；
socketR=新的DatagramSocket（6000）；
}
捕获（SocketException se）
{
tv.setText（se.toString（））；
完成（）；
}
}
公共void onClick（视图v）{
if（v==sr）
记录（）；
否则，如果（v==sp）
play（）；
否则如果（v==停止）
停止铺设（）；
}
公共游戏
{
stop.setEnabled（true）；
sp.setEnabled（假）；
pt=新播放音频（）；
pt.execute（）；
}
公众假期
{
isRecording=false；
isplay=false；
stop.setEnabled（false）；
}
公开作废记录（）
{
stop.setEnabled（true）；
sr.setEnabled（false）；
rt=新录制音频（）；
rt.execute（）；
}
私有类PlayAudio扩展异步任务
{
@凌驾
受保护的Void doInBackground（Void…arg0）
{
isplay=true；
int bufferSize=AudioTrack.getMinBufferSize（频率、频道配置、音频编码）；
字节[]音频数据=新字节[bufferSize]；
尝试
{
AudioTrack AudioTrack=新的AudioTrack（AudioManager.STREAM_音乐、频率、频道配置、，
音频编码，4*bufferSize，AudioTrack.MODE_流）；
audioTrack.设置播放速率（频率）；
音轨播放（）；
while（isplay）
{
recvP=新数据包（audiodata，audiodata.length）；
插座接收（recvP）；
write（recvP.getData（），0，recvP.getLength（））；
}
audioTrack.stop（）；
audioTrack.release（）；
}
捕获（可丢弃的t）
{
Log.e（“音轨”，“播放失败”）；
}
返回null；
}
受保护的void onProgressUpdate（字符串…进度）
{
tv1.setText（进度[0].toString（））；
}
受保护的void onPostExecute（void结果）
{
sr.setEnabled（真）；
sp.setEnabled（真）；
}
}
私有类RecordAudio扩展异步任务
{
@凌驾
受保护的Void doInBackground（Void…arg0）
{
isRecording=true；
尝试
{
int bufferSize=AudioTrack.getMinBufferSize（频率、频道配置、音频编码）；
AudioRecord AudioRecord=新的录音（MediaRecorder.AudioSource.MIC、频率、频道配置
，音频编码，4*bufferSize）；
字节[]缓冲区=新字节[bufferSize]；
录音。开始录制（）；
int r=0；
while（isRecording）
{
int brr=audioRecord.read（缓冲区，0，缓冲区大小）；
sendP=新的数据包（缓冲区、brr、InetAddress.getByName（“发送方/接收方的ip”），6000）；
socketS.send（sendP）；
出版进度（String.valueOf（r））；
r++；
}
录音。停止（）；
audioRecord.release（）；
}
捕获（可丢弃的t）
{
Log.e（“录音”，“录音失败…”）；
}
返回null；
}
受保护的void onProgressUpdate（字符串…进度）
{
tv.setText（进度[0].toString（））；
}
受保护的void onPostExecute（void结果）
{
sr.setEnabled（真）；
sp.setEnabled（真）；
}
}
}

在网络上发送语音时，如果频率不是8000，我会遇到麻烦。44100听起来很可怕。那可能只是我的情况

另一个困难是，使用UDP很难说数据包到达的顺序。我看到了一个将它们按正确顺序排列的实现，但我现在找不到它。