Android   发布时间:2022-04-28  发布网站:大佬教程  code.js-code.com
大佬教程收集整理的这篇文章主要介绍了DataChannel.state()始终返回CONNECTING webRTC Android大佬教程大佬觉得挺不错的,现在分享给大家,也给大家做个参考。
我有一个 Android应用程序作为运行在Node.js服务器上的WebRTC服务器的客户端运行.
该应用程序的当前状态是我可以进行视频通话,但无法在DataChAnnel上发送消息.

这是我的Android应用程序的完整代码.

Home.java

public class Home extends Activity {

    public List<PeerConnection.IceServer> iceServers;
    private GLSurfaceView videoView;
    public static SocketIO socket;
    ArrayList<String> userIDs = new ArrayList<>();
    private static final String FIELD_TRIAL_VP9 = "WebRTC-SupportVP9/Enabled/";
    String RoomId = "";
    String sreverURL = "http://xx.xx.xx.xx:xxxx/";
    private EditText roomid;
    private VideoRenderer.CallBACks remote_view;
    private VideoRenderer.CallBACks local_view;
    protected PeerConnectionFactory factory;
    PeerConnectionFactory.options options = null;
    Events pc_events;

    @Override
    protected void onCreate(Bundle savedInstanceStatE) {
        super.onCreate(savedInstanceStatE);
        setContentView(R.layout.activity_homE);
        videoView = (GLSurfaceView) findViewById(R.id.glview_call_remotE);
        VideoRendererGui.setView(videoView,new Runnable() {
            @Override
            public void run() {
                createPeerConnectionFactory();
            }
        });

        remote_view = VideoRendererGui.create(0,100,ScalingType.SCALE_ASPECT_FIT,falsE);
        local_view = VideoRendererGui.create(0,ScalingType.SCALE_ASPECT_FILL,truE);
        iceServers = new ArrayList<>();
        IceServer icc = new IceServer("stun:stun.l.google.com:19302","","");
        iceServers.add(icc);
        roomid = (EditText) findViewById(R.id.roomId);
        Random rand = new Random();
        roomid.setText("" + rand.nexTint(9999));
        pc_events = new peerEventHandler();
    }

    private void createPeerConnectionFactory() {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                PeerConnectionFactory.initializeFieldTrials(FIELD_TRIAL_VP9);
                PeerConnectionFactory.initializeAndroidGlobals(Home.this,true,VideoRendererGui.getEGLContext());
                try {
                    factory = new PeerConnectionFactory();
                } catch (Exception E) {
                    e.printStackTrace();
                }
            }
        });
    }

    public void ondail(View view) {

        try {

            try {
                SocketIO.setDefaultSSLSocketFactory(SSLContext.getDefault());
            } catch (NoSuchAlgorithmException e1) {
                e1.printStackTrace();
            }

            socket = new SocketIO();

            socket.connect(sreverURL,new IOCallBACk() {

                @Override
                public void onmessage(JSONObject json,IOAckNowledge ack) {
                }
                @Override
                public void onmessage(String data,IOAckNowledge ack) {
                }
                @Override
                public void onError(SocketIOException socketIOException) {
                    socketIOException.printStackTrace();
                }
                @Override
                public void onDisconnect() {
                }
                @Override
                public void onConnect() {
                    showToast("Connected to " + sreverURL);
                }
                @Override
                public void on(final String event,IOAckNowledge ack,final Object... args) {

                    Log.e("Socked.on",event + "," + args);
                    switch (getEvent(event)) {

                        case LOG :
                            break;
                        case messaGE :
                            if (args instanceof Object[]) {
                                pc_events.setmessage(args[0].toString());
                            } else {
                                pc_events.setmessage(args.toString());
                            }
                            break;
                        case CREATED :
                            runOnUiThread(new Runnable() {
                                public void run() {
                                    showToast("Room Created " + args[0]);
                                }
                            });
                            break;
                        case BroaDCAST :
                            break;
                        case JOIN :
                            break;
                        case EMIT :
                            Log.e("Socked.onEMIT",args.toString());
                            startCall();
                            pc_events.createOffer();
                            break;

                        case ERROR :
                            Log.e("Socked.onERROR",args.toString());
                            break;

                        default :

                            break;
                    }
                }
            });

            try {
                RoomId = roomid.getText().toString();
            } catch (Exception E) {
            }

            socket.emit("create or join",RoomId);

        } catch (MalformedURLException E) {

            e.printStackTrace();
        }

    }

    public void oncancel(View view) {

    }

    public SocketEvent getEvent(String eventString) {

        SocketEvent eventType;

        try {

            if (eventString.contains("log")) {
                eventType = SocketEvent.LOG;
            } else if (eventString.contains("created")) {
                eventType = SocketEvent.CREATED;
            } else if (eventString.contains("emit():")) {
                eventType = SocketEvent.EMIT;
            }

            else if (eventString.contains("broadcast():")) {
                eventType = SocketEvent.broaDCAST;
            } else if (eventString.contains("message")) {
                eventType = SocketEvent.messaGE;
            } else if (eventString.toLowerCase().subString(0,20).contains("join")) {
                eventType = SocketEvent.JOIN;
            } else {
                eventType = SocketEvent.ERROR;
            }

        } catch (Exception E) {
            eventType = SocketEvent.ERROR;
        }

        return eventType;

    }

    public static interface Events {

        public void peerConnectionEvent(VideoRenderer.CallBACks localRender,VideoRenderer.CallBACks remoteRender);

        public void setFactory(PeerConnectionFactory factory);

        public void setmessage(String messagE);
        public void createOffer();

        public void sendmessage(String msg);
    }

    private void startCall() {

        pc_events.setFactory(factory);

        pc_events.peerConnectionEvent(remote_view,local_view);

    }

    public void showToast(final String messagE) {

        runOnUiThread(new Runnable() {
            public void run() {
                Toast.makeText(Home.this,message,Toast.LENGTH_SHORT).show();
            }
        });
    }

    public void makeOffer(View v) {
        pc_events.sendmessage("Hello");
    }

}

peerEventHandler.java

public class peerEventHandler implements Events {

    private PeerConnection peerConnection;
    private PeerConnectionFactory factory;
    PCObserver pcObserver = new PCObserver();
    public LooperExecutor executor;

    private MediaStream mediaStream;

    private Videosource videosource;
    private DcObserver dc_observer;
    public static final String VIDEO_TRACK_ID = "ARDAMSv0";
    public static final String AUdio_TRACK_ID = "ARDAMSa0";

    private VideoCapturerAndroid videoCapturer;
    private VideoTrack localVideoTrack;
    private VideoTrack remoteVideoTrack;
    public Boolean preferIsac = false;
    public Boolean videoCALLENabled = true;
    public Boolean preferH264 = false;

    private SessionDescription localSdp;

    private final SDPObserver sdpObserver = new SDPObserver();

    public Boolean isInitiator = false;
    private MediaConsTraints sdpMediaConsTraints;

    private VideoRenderer.CallBACks remote_view;
    private VideoRenderer.CallBACks local_view;
    private DataChAnnel dataChAnnel;

    @Override
    public void peerConnectionEvent(CallBACks remoteRender,CallBACks localRender) {

        this.remote_view = remoteRender;
        this.local_view = localRender;
        creatPeerConnection();

    }

    public void creatPeerConnection() {

        executor = new LooperExecutor();
        executor.requestStart();

        MediaConsTraints pcConsTraints = new MediaConsTraints();
        MediaConsTraints videoConsTraints = new MediaConsTraints();
        MediaConsTraints audioConsTraints = new MediaConsTraints();
        sdpMediaConsTraints = new MediaConsTraints();

        creatPcConsTrains(pcConsTraints);
        creatvideoConsTraints(videoConsTraints);
        creatsdpMediaConsTraints(sdpMediaConsTraints);

        List<PeerConnection.IceServer> iceServers = new ArrayList<PeerConnection.IceServer>();

        IceServer iceServer = new IceServer("stun:stun.l.google.com:19302","");

        iceServers.add(iceServer);

        PeerConnection.RTCConfiguration rtcConfig = new PeerConnection.RTCConfiguration(iceServers);

        rtcConfig.tcpCandidatePolicy = PeerConnection.TcpCandidatePolicy.DISABLED;
        rtcConfig.bundlePolicy = PeerConnection.bundlePolicy.bALANCED;
        rtcConfig.rtcpMuxPolicy = PeerConnection.RtcpMuxPolicy.NEGOTIATE;

        peerConnection = factory.createPeerConnection(rtcConfig,pcConsTraints,pcObserver);

        Logging.enableTracing("logcat:",EnumSet.of(Logging.TraceLevel.TRACE_DEFAULT),Logging.Severity.LS_WARNING);

        mediaStream = factory.createLocalMediaStream("ARDAMS");

        String cameradeviceName = CameraEnumerationAndroid.getdeviceName(0);
        String frontCameradeviceName = CameraEnumerationAndroid.getNameOfFrontFacingDevice();

        cameradeviceName = frontCameradeviceName;

        videoCapturer = VideoCapturerAndroid.create(cameradeviceName,null);

        videosource = factory.createVideosource(videoCapturer,videoConsTraints);

        localVideoTrack = factory.createVideoTrack(VIDEO_TRACK_ID,videosourcE);
        localVideoTrack.setEnabled(true);
        localVideoTrack.addRenderer(new VideoRenderer(local_view));
        mediaStream.addTrack(factory.createAudioTrack(AUdio_TRACK_ID,factory.createAudiosource(audioConsTraints)));
        mediaStream.addTrack(localVideoTrack);
        peerConnection.addStream(mediaStream);

        dataChAnnel = peerConnection.createDataChAnnel("sendDataChAnnel",new DataChAnnel.Init());
        dc_observer = new DcObserver();
        dataChAnnel.registerObserver(dc_observer);

    }

    @Override
    public void createOffer() {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                if (peerConnection != null) {
                    isInitiator = true;
                    peerConnection.createOffer(sdpObserver,sdpMediaConsTraints);
                }
            }
        });

    }

    public void createAnswer() {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                if (peerConnection != null) {
                    isInitiator = false;
                    peerConnection.createAnswer(sdpObserver,sdpMediaConsTraints);
                }
            }
        });
    }

    private class PCObserver implements PeerConnection.observer {

        @Override
        public void onAddStream(final MediaStream stream) {

            Log.e("onAddStream","onAddStream");
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    if (peerConnection == null) {
                        return;
                    }
                    if (stream.audioTracks.size() > 1 || stream.videoTracks.size() > 1) {
                        // /reportError("Weird-looking stream: " + stream);
                        return;
                    }
                    if (stream.videoTracks.size() == 1) {
                        remoteVideoTrack = stream.videoTracks.get(0);
                        remoteVideoTrack.setEnabled(true);
                        remoteVideoTrack.addRenderer(new VideoRenderer(remote_view));
                        VideoRendererGui.update(local_view,75,70,60,truE);
                        VideoRendererGui.update(remote_view,200,falsE);
                    }
                }
            });



        }

        @Override
        public void onDataChAnnel(final DataChAnnel dC) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    dataChAnnel = dc;
                    String chAnnelName = dataChAnnel.label();
                    dataChAnnel.registerObserver(new DcObserver());
                }
            });
        }

        @Override
        public void onIceCandidate(IceCandidate candidatE) {

            SocketIO socket = Home.socket;

            JSONObject json = new JSONObject();
            try {

                json.putOpt("type","candidate");
                json.putOpt("label",candidate.sdpMLineIndeX);
                json.putOpt("id",candidate.sdpMid);
                json.putOpt("candidate",candidate.sdp);

            } catch (JSONException E) {
                e.printStackTrace();
            }

            socket.emit("message",json);
        }

        @Override
        public void onIceConnectionChange(IceConnectionState arg0) {
        }

        @Override
        public void onIceConnectionReceivingChange(Boolean arg0) {
        }

        @Override
        public void onIceGatheringChange(IceGatheringState arg0) {
        }

        @Override
        public void onRemoveStream(MediaStream arg0) {
        }

        @Override
        public void onRenegotiationNeeded() {
        }

        @Override
        public void onSignalingChange(SignalingState arg0) {
        }

    }

    public void creatPcConsTrains(MediaConsTraints pcConsTraints) {
        pcConsTraints.optional.add(new KeyValuePair("DtlsSrtpKeyAgreement","true"));
        pcConsTraints.optional.add(new KeyValuePair("RtPDAtaChAnnels","true"));
        pcConsTraints.optional.add(new KeyValuePair("internalSctPDAtaChAnnels","true"));
    }
    public void creatvideoConsTraints(MediaConsTraints videoConsTraints) {

        String MAX_VIDEO_WIDTH_CONSTraiNT = "maxWidth";
        String MIN_VIDEO_WIDTH_CONSTraiNT = "minWidth";
        String MAX_VIDEO_HEIGHT_CONSTraiNT = "maxHeight";
        String MIN_VIDEO_HEIGHT_CONSTraiNT = "minHeight";
        String MAX_VIDEO_FPS_CONSTraiNT = "maxFrameRate";
        String MIN_VIDEO_FPS_CONSTraiNT = "minFrameRate";

        int videoWidth = 0;
        int videoHeight = 0;

        if ((videoWidth == 0 || videoHeight == 0) && true && MediaCodecVideoEncoder.isVp8HwSupported()) {
            videoWidth = 1280;
            videoHeight = 1280;
        }

        if (videoWidth > 0 && videoHeight > 0) {
            videoWidth = Math.min(videoWidth,1280);
            videoHeight = Math.min(videoHeight,1280);
            videoConsTraints.mandatory.add(new KeyValuePair(MIN_VIDEO_WIDTH_CONSTraiNT,Integer.toString(videoWidth)));
            videoConsTraints.mandatory.add(new KeyValuePair(MAX_VIDEO_WIDTH_CONSTraiNT,Integer.toString(videoWidth)));
            videoConsTraints.mandatory.add(new KeyValuePair(MIN_VIDEO_HEIGHT_CONSTraiNT,Integer.toString(videoHeight)));
            videoConsTraints.mandatory.add(new KeyValuePair(MAX_VIDEO_HEIGHT_CONSTraiNT,Integer.toString(videoHeight)));
        }

        int videoFps = 30;

        videoConsTraints.mandatory.add(new KeyValuePair(MIN_VIDEO_FPS_CONSTraiNT,Integer.toString(videoFps)));
        videoConsTraints.mandatory.add(new KeyValuePair(MAX_VIDEO_FPS_CONSTraiNT,Integer.toString(videoFps)));

    }
    public void creataudioConsTraints(MediaConsTraints pcConsTraints) {
        pcConsTraints.optional.add(new KeyValuePair("DtlsSrtpKeyAgreement","true"));
    }
    public void creatsdpMediaConsTraints(MediaConsTraints sdpMediaConsTraints) {

        sdpMediaConsTraints.mandatory.add(new KeyValuePair("OfferToReceiveAudio","true"));

        sdpMediaConsTraints.mandatory.add(new KeyValuePair("OfferToReceiveVideo","true"));

    }

    private class SDPObserver implements SdpObserver {

        @Override
        public void onCreateFailure(String arg0) {
            System.out.print(arg0);
        }

        @Override
        public void onCreatesuccess(SessionDescription origSdp) {
            if (localSdp != null) {
                return;
            }
            localSdp = origSdp;
            setLocalDescription(origSdp);
        }

        @Override
        public void onSetFailure(String arg0) {
        }

        @Override
        public void onSetsuccess() {

            executor.execute(new Runnable() {
                @Override
                public void run() {
                    if (peerConnection == null) {
                        return;
                    }
                    if (isInitiator) {
                        if (peerConnection != null) {
                            JSONObject json = new JSONObject();
                            try {
                                json.putOpt("type",localSdp.type.toString().toLowerCase());
                                json.putOpt("sdp",localSdp.description);
                            } catch (JSONException E) {
                                e.printStackTrace();
                            }
                            Home.socket.emit("message",json);
                        }
                    } else {
                        // createAnswer();
                    }
                }
            });

        }

    }
    public void addRemoteIceCandidate(final IceCandidate candidatE) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                peerConnection.adDiceCandidate(candidatE);
            }
        });
    }

    public void setLocalDescription(final SessionDescription sdp) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                if (peerConnection == null) {
                    return;
                }
                peerConnection.setLocalDescription(sdpObserver,sdp);
            }
        });
    }

    public void setRemoteDescription(final SessionDescription sdp) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                if (peerConnection == null) {
                    return;
                }

                peerConnection.setRemoteDescription(sdpObserver,sdp);
            }
        });
    }

    @Override
    public void setFactory(PeerConnectionFactory factory) {
        this.factory = factory;
    }

    public void onWebSocketmessage(final String msg) {

        try {
            Log.e("onWebSocketmessage",msg);
            JSONObject json = new JSONObject(msg);
            json = new JSONObject(msg);
            String type = json.optString("type");
            if (type.equals("candidate")) {
                IceCandidate candidate = new IceCandidate(json.getString("id"),json.geTint("label"),json.getString("candidate"));
                addRemoteIceCandidate(candidatE);
            } else if (type.equals("answer")) {
                isInitiator = false;
                SessionDescription sdp = new SessionDescription(SessionDescription.Type.fromCanonicalForm(typE),json.getString("sdp"));
                setRemoteDescription(sdp);
            } else if (type.equals("offer")) {
                SessionDescription sdp = new SessionDescription(SessionDescription.Type.fromCanonicalForm(typE),json.getString("sdp"));
                setRemoteDescription(sdp);
            } else if (type.equals("bye")) {
            } else {
            }

        } catch (JSONException E) {

        }
    }

    @Override
    public void setmessage(String messagE) {
        if (message.toString().contains("got user media") || message.toString().contains("bye")) {

        } else
            onWebSocketmessage(messagE);

    }

    private class DcObserver implements DataChAnnel.observer {

        @Override
        public void onmessage(DataChAnnel.buffer buffer) {

            ByteBuffer data = buffer.data;
            byte[] bytes = new byte[data.remaining()];
            data.get(bytes);
            String command = new String(bytes);

            Log.e("onmessage ",command);

        }

        @Override
        public void onStateChange() {
            Log.e("onStateChange ","onStateChange");
        }

        @Override
        public void onBufferedamountChange(long arg0) {
            Log.e("onmessage ","" + arg0);

        }
    }

    @Override
    public void sendmessage(String msg) {
        ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
        Boolean sent = dataChAnnel.send(new DataChAnnel.buffer(buffer,falsE));
        if (sent) {
            Log.e("message sent","" + sent);
        }
    }
}

欢迎任何意见和建议;)

解决方法

WebRTC数据通道现在通过SCTP工作,因此您可以删除RtPDAtaChAnnels约束.

大佬总结

以上是大佬教程为你收集整理的DataChannel.state()始终返回CONNECTING webRTC Android全部内容,希望文章能够帮你解决DataChannel.state()始终返回CONNECTING webRTC Android所遇到的程序开发问题。

如果觉得大佬教程网站内容还不错,欢迎将大佬教程推荐给程序员好友。

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ:384754419,请注明来意。