webrtc 工具类

直接上代码；webrtc 工具类

package com.example.mqttdome;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.media.projection.MediaProjection;
import android.media.projection.MediaProjectionManager;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.WindowManager;
import android.widget.Toast;

import org.webrtc.AudioSource;
import org.webrtc.AudioTrack;
import org.webrtc.Camera1Enumerator;
import org.webrtc.Camera2Enumerator;
import org.webrtc.CameraVideoCapturer;
import org.webrtc.DataChannel;
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.RtpReceiver;
import org.webrtc.ScreenCapturerAndroid;
import org.webrtc.SessionDescription;
import org.webrtc.SurfaceTextureHelper;
import org.webrtc.VideoCapturer;
import org.webrtc.VideoDecoderFactory;
import org.webrtc.VideoEncoderFactory;
import org.webrtc.VideoSource;
import org.webrtc.VideoTrack;

import java.util.ArrayList;

public class WebRTCUtils {
    private static final String TAG = "webrtc_utils";
    private final PeerConnectionFactory factory;
    private final PeerConnection peer;
    private final EglBase.Context eglBaseContext;
    private final SurfaceTextureHelper surfaceTextureHelper;
    private final VideoCapturer camera;
    private final AudioTrack audioTrack;
    private VideoTrack videoTrack;

    private OnWebRtcListener webRtcListener;

    public EglBase.Context getEglBaseContext() {
        return eglBaseContext;
    }

    public void setWebRtcListener(OnWebRtcListener webRtcListener) {
        this.webRtcListener = webRtcListener;
    }

    public VideoTrack getVideoTrack() {
        return videoTrack;
    }

    public WebRTCUtils(Context context, Intent data) {

        eglBaseContext = EglBase.create().getEglBaseContext();

        surfaceTextureHelper = SurfaceTextureHelper.create("SurfaceTextureHelper_jason", eglBaseContext);

        PeerConnectionFactory.Options options = new PeerConnectionFactory.Options();

        VideoEncoderFactory enc = new DefaultVideoEncoderFactory(eglBaseContext, true, false);
        VideoDecoderFactory dec = new DefaultVideoDecoderFactory(eglBaseContext);

        PeerConnectionFactory.initialize(PeerConnectionFactory.InitializationOptions
                .builder(context)
                .createInitializationOptions());

        factory = PeerConnectionFactory.builder()
                .setOptions(options)
                .setVideoDecoderFactory(dec)
                .setVideoEncoderFactory(enc)
                .createPeerConnectionFactory();


        ArrayList<PeerConnection.IceServer> iceServers = new ArrayList<>();
        iceServers.add(PeerConnection.IceServer.builder("stun:stun3.l.google.com:19302").createIceServer());


        peer = factory.createPeerConnection(iceServers, new PeerObserver() {
            @Override
            public void onIceCandidate(IceCandidate iceCandidate) {
                super.onIceCandidate(iceCandidate);
                webRtcListener.onIceCandidate(iceCandidate);
            }

            @Override
            public void onAddStream(MediaStream mediaStream) {
                super.onAddStream(mediaStream);
                webRtcListener.onAddStream(mediaStream);
            }
        });


        AudioSource audioSource = factory.createAudioSource(new MediaConstraints());
        audioTrack = factory.createAudioTrack("jason_audio_track", audioSource);

        camera = createCameraDevices(true, context);
        if (camera != null) {
            VideoSource videoSource = factory.createVideoSource(camera.isScreencast());
            camera.initialize(surfaceTextureHelper, context, videoSource.getCapturerObserver());
            videoTrack = factory.createVideoTrack("VideoTrack_jason", videoSource);
        }

        MediaStream stream = factory.createLocalMediaStream("jason_stream");
        stream.addTrack(audioTrack);
        if (videoTrack != null)
            stream.addTrack(videoTrack);

        if (peer != null)
            peer.addStream(stream);

        // start capture
        if (camera != null)
            camera.startCapture(640, 360, 25);

        Log.i(TAG, "WebRTCUtils: camera:" + camera);
    }

    public void createOffer() {
        if (peer == null)
            return;
        peer.createOffer(new SdpObserver() {
            @Override
            public void onCreateSuccess(SessionDescription sessionDescription) {
                super.onCreateSuccess(sessionDescription);
                peer.setLocalDescription(new SdpObserver(), sessionDescription);
                // send sdp
                String description = sessionDescription.description;
                webRtcListener.onSdpSendRemoteOffer(description);
                Log.i(TAG, "onCreateSuccess: sdp:" + description);
            }
        }, new MediaConstraints());
    }

    public void receiveOffer(String sdp) {
        if (peer == null)
            return;
        peer.setRemoteDescription(new SdpObserver(), new SessionDescription(SessionDescription.Type.OFFER, sdp));
        peer.createAnswer(new SdpObserver() {
            @Override
            public void onCreateSuccess(SessionDescription sessionDescription) {
                super.onCreateSuccess(sessionDescription);
                peer.setLocalDescription(new SdpObserver(), sessionDescription);
                // send back sdp
                String description = sessionDescription.description;
                webRtcListener.onSdpSendRemoteAnswer(description);
                Log.i(TAG, "onCreateSuccess: sdp back:" + description);
            }
        }, new MediaConstraints());
    }

    public void saveAnswer(String sdp) {
        if (peer == null)
            return;
        Log.i(TAG, "saveAnswer: " + sdp);
        peer.setRemoteDescription(new SdpObserver(), new SessionDescription(SessionDescription.Type.ANSWER, sdp));
    }

    public void saveCandidate(int lineIndex, String mid, String candidate) {
        if (peer == null)
            return;
        Log.i(TAG, "saveCandidate: " + candidate);
        peer.addIceCandidate(new IceCandidate(
                mid,
                lineIndex,
                candidate
        ));
    }

    public void release() {
        try {
            if (camera != null)
                camera.stopCapture();
        } catch (Exception e) {
            Log.i(TAG, "release: error:" + e.getMessage());
        }
        if (audioTrack!=null)
            audioTrack.setEnabled(false);
        if (videoTrack!=null)
            videoTrack.setEnabled(false);

        if (peer!=null){
            peer.close();
            peer.dispose();
        }

        factory.dispose();

        surfaceTextureHelper.dispose();
    }


    // -----------------------------------------------------------------------------------------工具类

    public interface OnWebRtcListener {
        void onIceCandidate(IceCandidate iceCandidate);

        void onAddStream(MediaStream mediaStream);

        void onSdpSendRemoteOffer(String sdp);

        void onSdpSendRemoteAnswer(String sdp);
    }

    private static class PeerObserver implements PeerConnection.Observer {


        @Override
        public void onSignalingChange(PeerConnection.SignalingState signalingState) {

        }

        @Override
        public void onIceConnectionChange(PeerConnection.IceConnectionState iceConnectionState) {

        }

        @Override
        public void onIceConnectionReceivingChange(boolean b) {

        }

        @Override
        public void onIceGatheringChange(PeerConnection.IceGatheringState iceGatheringState) {

        }

        @Override
        public void onIceCandidate(IceCandidate iceCandidate) {

        }

        @Override
        public void onIceCandidatesRemoved(IceCandidate[] iceCandidates) {

        }

        @Override
        public void onAddStream(MediaStream mediaStream) {

        }

        @Override
        public void onRemoveStream(MediaStream mediaStream) {

        }

        @Override
        public void onDataChannel(DataChannel dataChannel) {

        }

        @Override
        public void onRenegotiationNeeded() {

        }

        @Override
        public void onAddTrack(RtpReceiver rtpReceiver, MediaStream[] mediaStreams) {

        }
    }

    private static class SdpObserver implements org.webrtc.SdpObserver {

        @Override
        public void onCreateSuccess(SessionDescription sessionDescription) {

        }

        @Override
        public void onSetSuccess() {

        }

        @Override
        public void onCreateFailure(String s) {

        }

        @Override
        public void onSetFailure(String s) {

        }
    }


    public static void startCaptor(Activity activity) {
        MediaProjectionManager manager = (MediaProjectionManager) activity.getSystemService(Context.MEDIA_PROJECTION_SERVICE);
        if (manager == null) {
            Log.i(TAG, "startCaptor: manager is null");
            return;
        }
        Intent intent = manager.createScreenCaptureIntent();
        activity.startActivityForResult(intent, 119);
    }


    public static VideoCapturer createCameraDevices(boolean isFront, Context context) {

        Camera2Enumerator camera2Enumerator = new Camera2Enumerator(context);
        String[] deviceNames1 = camera2Enumerator.getDeviceNames();
        for (String item : deviceNames1) {
            if (isFront ? camera2Enumerator.isFrontFacing(item) : camera2Enumerator.isBackFacing(item)) {
                CameraVideoCapturer cameraVideoCapturer = camera2Enumerator.createCapturer(item, null);
                if (cameraVideoCapturer != null){
                    Log.i(TAG, "createCameraDevices: use camera 2 ");
                    Toast.makeText(context, "camera 2", Toast.LENGTH_LONG).show();
                    return cameraVideoCapturer;
                }
            }
        }

        Camera1Enumerator enumerator = new Camera1Enumerator(false);
        final String[] deviceNames = enumerator.getDeviceNames();

        // First, try to find front facing camera
        for (String deviceName : deviceNames) {
            if (isFront ? enumerator.isFrontFacing(deviceName) : enumerator.isBackFacing(deviceName)) {
                VideoCapturer videoCapturer = enumerator.createCapturer(deviceName, null);
                if (videoCapturer != null) {
                    Log.i(TAG, "createCameraDevices: use camera 1 ");
                    Toast.makeText(context, "camera 1", Toast.LENGTH_LONG).show();
                    return videoCapturer;
                }
            }
        }



        return null;
    }


}