Android 通过rtsp在VideoView中无延迟地进行流式传输

您好，我在android上遇到流视频延迟问题。 我有一个大约8秒的延迟，这是非常烦人的。计算机上没有延迟。 这是通过wifi-->rtsp从类似gopro的摄像头发送的流

我发现这个话题太。。。 我和阿克什瓦·贾哈有同样的问题。不幸的是，我不懂Java。有人能帮我根据阿克什瓦·贾哈给的修改设计吗

package com.teststream.robotclient;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.UnknownHostException;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.net.Uri;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.util.Pair;
import android.widget.VideoView;

import com.jmedeisis.bugstick.Joystick;
import com.jmedeisis.bugstick.JoystickListener;

public class MainActivity extends Activity {

    private String host;
    private int port;
    private DatagramSocket socket;
    private VideoView videoView;

    private static final String TAG = "MainActivity";

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

        WifiManager wifiManager = (WifiManager) getApplicationContext().getSystemService(WIFI_SERVICE);
        WifiInfo info = wifiManager.getConnectionInfo();
        String ssid = info.getSSID();
        String desiredSsid = getString(R.string.ssid);
        Log.i(TAG, desiredSsid);

        if(!ssid.equals(desiredSsid) && !desiredSsid.equals("*")) {
            exitDialog("Wrong SSID", "The SSID of the WIFI network is wrong. Desired SSID: " + desiredSsid);
        }

        host = getString(R.string.host);
        port = Integer.parseInt(getString(R.string.port));

        //new CheckConnectivity().execute();

        videoView = findViewById(R.id.videoView);
        Uri videoUri = Uri.parse(getString(R.string.video_uri));
        videoView.setVideoURI(videoUri);
        videoView.start();

        Joystick left = findViewById(R.id.joystick_left);
        Joystick right = findViewById(R.id.joystick_right);

        left.setJoystickListener(new JoystickListener() {
            @Override
            public void onDown() {
                log("down");
            }

            @Override
            public void onDrag(float degrees, float offset) {
                log("deg: " + degrees + ", off: " + offset);
                float upValue = (float) Math.sin(Math.toRadians(degrees)) * offset;
                log("" + upValue);

                int intValue = normalisedFloatToByte(upValue);
                new UpdateServo().execute(Pair.create(0xff, intValue));
            }

            @Override
            public void onUp() {
                log("up");
            }
        });

        right.setJoystickListener(new JoystickListener() {
            @Override
            public void onDown() {
                log("down");
            }

            @Override
            public void onDrag(float degrees, float offset) {
                log("deg: " + degrees + ", off: " + offset);
                float upValue = (float) Math.sin(Math.toRadians(degrees)) * offset;
                log("" + upValue);

                int intValue = normalisedFloatToByte(upValue);
                new UpdateServo().execute(Pair.create(0xfe, intValue));
            }

            @Override
            public void onUp() {
                log("up");
            }
        });
    }

    private int normalisedFloatToByte(float value) {
        if(value < -1.0 || value > 1.0) {
            return 0;
        }
        return 127 + Math.round(value * 127);
    }

    private void log(String text) {
        Log.d(TAG, text);
    }

    private void exitDialog(String title, String text) {
        new AlertDialog.Builder(MainActivity.this)
                .setTitle(title)
                .setMessage(text)
                .setNeutralButton("OK", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        finish();
                    }
                })
                .show();
    }

    class CheckConnectivity extends AsyncTask<Void, Void, Boolean> {
        protected Boolean doInBackground(Void ...params) {
            try {
                if(!InetAddress.getByName(host).isReachable(2000)) {
                    return false;
                }
            } catch (UnknownHostException e) {
                return false;
            } catch (IOException e) {
                return false;
            }
            return true;
        }

        protected void onPostExecute(Boolean result) {
            if(result == false) {
                exitDialog("Can't connect", "Can't connect with host " + host);
            }
        }
    }

    class UpdateServo extends AsyncTask<Pair<Integer, Integer>, Void, Void> {
        protected Void doInBackground(Pair<Integer, Integer>... requests) {
            byte[] payload = {
                    requests[0].first.byteValue(),
                    requests[0].second.byteValue()
            };

            try {
                InetAddress addr = InetAddress.getByName(host);

                DatagramPacket sendPacket = new DatagramPacket(payload, 0, payload.length, addr, port);
                if (socket != null) {
                    socket.disconnect();
                    socket.close();
                }
                socket = new DatagramSocket(port);
                socket.send(sendPacket);
            } catch (UnknownHostException e) {
                Log.e(TAG, "getByName failed");
            } catch (IOException e) {
                Log.e(TAG, "send failed");
            }
            return null;
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
    }
}

package com.teststream.robotclient；
导入java.io.IOException；
导入java.net.DatagramPacket；
导入java.net.DatagramSocket；
导入java.net.InetAddress；
导入java.net.UnknownHostException；
导入android.app.Activity；
导入android.app.AlertDialog；
导入android.content.DialogInterface；
导入android.net.Uri；
导入android.net.wifi.WifiInfo；
导入android.net.wifi.WifiManager；
导入android.os.AsyncTask；
导入android.os.Bundle；
导入android.util.Log；
导入android.util.Pair；
导入android.widget.VideoView；
导入com.jmedeisis.bugstick.mogage；
导入com.jmedeisis.bugstick.JoystickListener；
公共类MainActivity扩展了活动{
私有字符串主机；
专用int端口；
专用DatagramSocket套接字；
私人视频视图；
私有静态最终字符串TAG=“MainActivity”；
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
WifiManager WifiManager=（WifiManager）getApplicationContext（）.getSystemService（WIFI_服务）；
WifiInfo=wifiManager.getConnectionInfo（）；
字符串ssid=info.getSSID（）；
String desiredSsid=getString（R.String.ssid）；
Log.i（标签，所需SSID）；
如果（！ssid.equals（desiredSsid）&&！desiredSsid.equals（“*”）{
exitDialog（“错误的SSID”，“WIFI网络的SSID错误。需要的SSID:”+desiredSsid）；
}
host=getString（R.string.host）；
port=Integer.parseInt（getString（R.string.port））；
//新建CheckConnectivity（）.execute（）；
videoView=findviewbyd（R.id.videoView）；
urivideouri=Uri.parse（getString（R.string.video_Uri））；
setVideoURI（videoUri）；
videoView.start（）；
左操纵杆=findViewById（右id左操纵杆）；
右操纵杆=findViewById（右操纵杆）；
left.setJoystickListener（新的JoystickListener（）{
@凌驾
公屋{
记录（“下降”）；
}
@凌驾
公共空间偏移量（浮动度数、浮动偏移量）{
日志（“度：+度+”，关：+偏移）；
float upValue=（float）Math.sin（Math.toRadians（度））*偏移量；
对数（“+upValue”）；
int intValue=正常的ISEDFLOATTOBYTE（upValue）；
new UpdateServo（）.execute（Pair.create（0xff，intValue））；
}
@凌驾
公共图书馆（onUp）{
记录（“向上”）；
}
});
右。setJoystickListener（新的JoystickListener（）{
@凌驾
公屋{
记录（“下降”）；
}
@凌驾
公共空间偏移量（浮动度数、浮动偏移量）{
日志（“度：+度+”，关：+偏移）；
float upValue=（float）Math.sin（Math.toRadians（度））*偏移量；
对数（“+upValue”）；
int intValue=正常的ISEDFLOATTOBYTE（upValue）；
new UpdateServo（）.execute（Pair.create（0xfe，intValue））；
}
@凌驾
公共图书馆（onUp）{
记录（“向上”）；
}
});
}
私有int normalisedFloatToByte（浮点值）{
如果（值<-1.0 | |值>1.0）{
返回0；
}
返回127+数学舍入（值*127）；
}
专用作废日志（字符串文本）{
Log.d（标签、文本）；
}
私有void exitDialog（字符串标题、字符串文本）{
新建AlertDialog.Builder（MainActivity.this）
.setTitle（标题）
.setMessage（文本）
.setNeutralButton（“确定”，新的DialogInterface.OnClickListener（）{
@凌驾
公共void onClick（DialogInterface，inti）{
完成（）；
}
})
.show（）；
}
类CheckConnectivity扩展了异步任务{
受保护的布尔doInBackground（Void…params）{
试一试{
如果（！InetAddress.getByName（主机）.isRecable（2000））{
返回false；
}
}捕获（未知后异常e）{
返回false；
}捕获（IOE异常）{
返回false；
}
返回true；
}
受保护的void onPostExecute（布尔结果）{
如果（结果==false）{
exitDialog（“无法连接”，“无法连接主机”+主机）；
}
}
}
类UpdateServo扩展了AsyncTask{
受保护的Void doInBackground（成对…请求）{
字节[]有效负载={
请求[0]。第一个。字节值（），
请求[0]。秒。字节值（）
};
试一试{
InetAddress addr=InetAddress.getByName（主机）；
DatagramPacket sendPacket=新的DatagramPacket（有效载荷，0，有效载荷.length，地址，端口）；
if（套接字！=null）{
socket.disconnect（）；
socket.close（）；
}
套接字=新的DatagramSocket（端口）；
socket.send（sendPacket）；
}捕获（未知后异常e）{
Log.e（标记“getByName失败”）；
}捕获（IOE异常）{
Log.e（标记“发送失败”）；
}
返回null；
}
}
@奥夫