Android-WebRTC-双人视频

省略开启本机摄像头的过程
以下和WebSocket通信的时候，是通过Gson转对象为字符串的方式传输的数据

• 整个过程
  
• layout_rtc.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="@dimen/dp_20"
    >

    <org.webrtc.SurfaceViewRenderer
        android:id="@+id/localView"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        app:layout_constraintHeight_percent="0.5"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <org.webrtc.SurfaceViewRenderer
        android:id="@+id/remoteView"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        app:layout_constraintHeight_percent="0.5"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        />

</androidx.constraintlayout.widget.ConstraintLayout>

• RtcActivity

package com.dream.app.activity;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;

import androidx.annotation.Nullable;

import com.dream.app.adapter.PeerConnectionAdapter;
import com.dream.app.adapter.SdpAdapter;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import org.webrtc.Camera1Enumerator;
import org.webrtc.DefaultVideoDecoderFactory;
import org.webrtc.DefaultVideoEncoderFactory;
import org.webrtc.EglBase;
import org.webrtc.IceCandidate;
import org.webrtc.MediaConstraints;
import org.webrtc.MediaStream;
import org.webrtc.PeerConnection;
import org.webrtc.PeerConnectionFactory;
import org.webrtc.SessionDescription;
import org.webrtc.SurfaceTextureHelper;
import org.webrtc.SurfaceViewRenderer;
import org.webrtc.VideoCapturer;
import org.webrtc.VideoSource;
import org.webrtc.VideoTrack;

import java.lang.reflect.Type;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Collections;
import java.util.Random;

public class RtcActivity extends Activity {

    private static final String TAG = "RtcRemoteActivity";

    private WebSocketClient webSocketClient = null;
    private PeerConnection peerConnection = null;
    private static final Type sessionDescriptionType = new TypeToken<SessionDescription>(){}.getType();
    private static final Type iceCandidateType = new TypeToken<IceCandidate>(){}.getType();
    private VideoTrack videoTrack;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_rtc);

        //  factory static init
        PeerConnectionFactory.initialize(PeerConnectionFactory.InitializationOptions
                .builder(this)
                .createInitializationOptions());
        EglBase.Context eglBaseContext = EglBase.create().getEglBaseContext();
        PeerConnectionFactory.Options options = new PeerConnectionFactory.Options();

        //  create video encoder/decoder
        DefaultVideoEncoderFactory defaultVideoEncoderFactory =
                new DefaultVideoEncoderFactory(eglBaseContext, true, true); // encoder
        DefaultVideoDecoderFactory defaultVideoDecoderFactory =
                new DefaultVideoDecoderFactory(eglBaseContext); // decoder

        //  factory create
        PeerConnectionFactory peerConnectionFactory = PeerConnectionFactory.builder()
                .setOptions(options)
                .setVideoEncoderFactory(defaultVideoEncoderFactory)
                .setVideoDecoderFactory(defaultVideoDecoderFactory)
                .createPeerConnectionFactory();

        // create videoCapturer
        Camera1Enumerator camera1Enumerator = new Camera1Enumerator(false);// false输出到surface
        String[] deviceNames = camera1Enumerator.getDeviceNames();
        VideoCapturer videoCapturer = null;
        for (String deviceName : deviceNames) {
            if (camera1Enumerator.isFrontFacing(deviceName)) {
                VideoCapturer capturer = camera1Enumerator.createCapturer(deviceName, null);
                if (capturer != null) {
                    videoCapturer = capturer;
                    break;
                }
                Log.e(TAG, "onCreate: create capturer fail");
                return;
            }
        }
        if (videoCapturer == null) {
            Log.e(TAG, "onCreate: create capturer fail");
            return;
        }

        //  create videoSource
        VideoSource videoSource = peerConnectionFactory.createVideoSource(videoCapturer.isScreencast());

        //  init videoCapturer
        SurfaceTextureHelper surfaceTextureHelper = SurfaceTextureHelper.create("surfaceTexture", eglBaseContext);
        videoCapturer.initialize(surfaceTextureHelper, this, videoSource.getCapturerObserver());
        videoCapturer.startCapture(480, 640, 30);// width, height, frame

        //  create videoTrack
        videoTrack = peerConnectionFactory.createVideoTrack("videoTrack-1", videoSource);

        //  get show view
        SurfaceViewRenderer localView = findViewById(R.id.localView);
        localView.setMirror(true);// 镜像
        localView.init(eglBaseContext, null);

        //  link track to view so that data show in view
        videoTrack.addSink(localView);

        Activity activity = this;

        // link websocket
        try {
            String uriStr = "ws://host/webrtc/" + Math.abs(new Random().nextInt()) % 100;
            Log.e(TAG, "onCreate: " + uriStr);
            webSocketClient = new WebSocketClient(new URI(uriStr)) {
                @Override
                public void onOpen(ServerHandshake handshakedata) {
                    //  create peerConnection
                    peerConnection = peerConnectionFactory.createPeerConnection(Collections.singletonList(PeerConnection.IceServer
                            .builder("turn:host:3478")
                            .setUsername("admin")
                            .setPassword("123456")
                            .createIceServer()), new PeerConnectionAdapter() {

                        @Override
                        public void onIceGatheringChange(PeerConnection.IceGatheringState iceGatheringState) {
                            super.onIceGatheringChange(iceGatheringState);
                            Log.e(TAG, "onIceGatheringChange: " + iceGatheringState);
                        }

                        @Override
                        public void onIceCandidate(IceCandidate iceCandidate) {
                            super.onIceCandidate(iceCandidate);
                            //TODO send to remote the local iceCandidate
                            Log.e(TAG, "onIceCandidate: ICE CANDIDATE");
                            webSocketClient.send(new Gson().toJson(iceCandidate, iceCandidateType));
                        }

                        @Override
                        public void onAddStream(MediaStream mediaStream) { // turn deal with
                            super.onAddStream(mediaStream);
                            Log.e(TAG, "onAddStream: ICE STREAM");
                            //  get remote videoTrack
                            VideoTrack remoteVideoTrack = mediaStream.videoTracks.get(0);
                            runOnUiThread(() -> {
                                SurfaceViewRenderer remoteView = findViewById(R.id.remoteView);
                                remoteView.setMirror(false);
                                remoteView.init(eglBaseContext, null);
                                //  link track to view so that data show in view
                                remoteVideoTrack.addSink(remoteView);
                            });
                        }
                    });

                    if (peerConnection == null) {
                        Log.e(TAG, "onCreate: peerConnection fail");
                        webSocketClient.close();
                        activity.finish();
                    }

                    //  create stream
                    MediaStream stream = peerConnectionFactory.createLocalMediaStream("stream");
                    stream.addTrack(videoTrack);
                    peerConnection.addStream(stream);
                }

                @Override
                public void onMessage(String message) {
                    Log.e(TAG, "onMessage: " + message);

                    /**
                     * SDP change
                     */
                    if ("offer".equals(message)) {
                        // peerConnection offer
                        peerConnection.createOffer(new SdpAdapter("offer") {
                            @Override
                            public void onCreateSuccess(SessionDescription sessionDescription) {
                                super.onCreateSuccess(sessionDescription);
                                peerConnection.setLocalDescription(new SdpAdapter("local set local sd"), sessionDescription);

                                //TODO send sessionDescription to remote
                                webSocketClient.send("offer-" + new Gson().toJson(sessionDescription, sessionDescriptionType));
                            }
                        }, new MediaConstraints());
                        return;
                    }
                    if (message.startsWith("answer-")) {

                        peerConnection.setRemoteDescription(new SdpAdapter()
                                , new Gson().fromJson(message.substring("answer-".length()), sessionDescriptionType));
                        peerConnection.createAnswer(new SdpAdapter() {
                            @Override
                            public void onCreateSuccess(SessionDescription sessionDescription) {
                                super.onCreateSuccess(sessionDescription);

                                Log.e(TAG, "onCreateSuccess: createAnswer");

                                peerConnection.setLocalDescription(new SdpAdapter(), sessionDescription);
                                // send local sd to call
                                webSocketClient.send("answer-offer-" + new Gson().toJson(sessionDescription, sessionDescriptionType));
                            }

                            @Override
                            public void onCreateFailure(String s) {
                                super.onCreateFailure(s);
                                Log.e(TAG, "onCreateFailure: fail " + s);
                            }

                        }, new MediaConstraints());
                        return;
                    }
                    if (message.startsWith("offer-receiver-")) {
                        peerConnection.setRemoteDescription(new SdpAdapter()
                                , new Gson().fromJson(message.substring("offer-receiver-".length()), sessionDescriptionType));
                        return;
                    }
                    // ------------------------ sdp change -----------------------------------

                    /**
                     * ICE change
                     */
                    // get remote IceCandidate
                    IceCandidate remoteIceCandidate = new Gson().fromJson(message, iceCandidateType);
                    peerConnection.addIceCandidate(remoteIceCandidate);
                    // ------------------------ ice change -----------------------------------
                }

                @Override
                public void onClose(int code, String reason, boolean remote) {

                }

                @Override
                public void onError(Exception ex) {
                    ex.printStackTrace();
                }
            };
        } catch (URISyntaxException e) {
            Log.e(TAG, "onCreate: ", e);
            return;
        }
        webSocketClient.connect();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (webSocketClient.isOpen()) {
            webSocketClient.close();
            webSocketClient = null;
        }
        if (peerConnection != null) {
            peerConnection.dispose();
            peerConnection = null;
        }
        if (videoTrack != null) {
            videoTrack.dispose();
            videoTrack = null;
        }
    }
}