创建PeerConnection的操作都封装在PeerConnectionClient中，而且创建PeerConnection的操作必须是单线程的，而PeerConnection是由PeerConnectionFactory完成的。

1、创建PeerConnectionFactory

我们前面说过PeerConnectionFactory一个用来生成PeerConnection的工厂类，同时负责初始化全局和底层交互。

/**
 * 创建PeerConnectionFactory的方法
 * @param context
 * @param localRender   本地视频
 * @param renderEGLContext    
 * @param peerConnectionParameters
 */
public void createPeerConnectionFactory(
        final Context context,
        final VideoRenderer.Callbacks localRender,
        final EglBase.Context renderEGLContext,
        final PeerConnectionParameters peerConnectionParameters) {
    this.peerConnectionParameters = peerConnectionParameters;
    this.localRender = localRender;
    videoCallEnabled = peerConnectionParameters.videoCallEnabled;
    if(localRender==null)
        videoCallEnabled = false;
    // Reset variables to initial states.
    factory = null;
    preferIsac = false;
    videoCapturerStopped = false;
    isError = false;
    mediaStream = null;
    videoCapturer = null;
    renderVideo = true;
    localVideoTrack = null;
    enableAudio = true;
    localAudioTrack = null;
    this.videoWidth = peerConnectionParameters.videoWidth;
    this.videoHeight = peerConnectionParameters.videoHeight;
    this.videoFps = peerConnectionParameters.videoFps;
    statsTimer = new Timer();
        //用于保存对端的IceCandidate
    queuedRemoteCandidates = new ConcurrentHashMap<String,LinkedList<IceCandidate>>();
    if(isRTCClosed) return;

    executor.execute(new Runnable() {
        @Override
        public void run() {
            if(isRTCClosed) return;
            try {
                                //创建媒体约束，创建PeerConnection时用
                createMediaConstraintsInternal();
                createPeerConnectionFactoryInternal(context, renderEGLContext);
            }
            catch (Exception e){
                reportError("Failed to create peer connection: " + e.getMessage());
                return;
            }
        }
    });
}

主要是根据PeerConnectionParameters中的参数创建媒体约束

/**
 * 创建媒体约束
 */
private void createMediaConstraintsInternal() {
    // Create peer connection constraints.
    pcConstraints = new MediaConstraints();
    //是否允许呼叫自己
    if (peerConnectionParameters.loopback) {
        pcConstraints.optional.add(
                new MediaConstraints.KeyValuePair(DTLS_SRTP_KEY_AGREEMENT_CONSTRAINT, "false"));
    } else {
        pcConstraints.optional.add(
                new MediaConstraints.KeyValuePair(DTLS_SRTP_KEY_AGREEMENT_CONSTRAINT, "true"));
    }
    pcConstraints.optional.add(new MediaConstraints.KeyValuePair(
            "RtpDataChannels", "true"));
    if (videoCallEnabled) {
        videoWidth = peerConnectionParameters.videoWidth;
        videoHeight = peerConnectionParameters.videoHeight;
        videoFps = peerConnectionParameters.videoFps;

        if (videoWidth == 0 || videoHeight == 0) {
            videoWidth = HD_VIDEO_WIDTH;
            videoHeight = HD_VIDEO_HEIGHT;
        }

        if (videoFps == 0) {
            videoFps = 30;
        }
        Logging.d(TAG, "Capturing format: " + videoWidth + "x" + videoHeight + "@" + videoFps);
    }

    audioConstraints = new MediaConstraints();

    if (peerConnectionParameters.noAudioProcessing) {
        Log.d(TAG, "Disabling audio processing");
        audioConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
                AUDIO_ECHO_CANCELLATION_CONSTRAINT, "false"));
        audioConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
                AUDIO_AUTO_GAIN_CONTROL_CONSTRAINT, "false"));
        audioConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
                AUDIO_HIGH_PASS_FILTER_CONSTRAINT, "false"));
        audioConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
                AUDIO_NOISE_SUPPRESSION_CONSTRAINT, "false"));
    }
    // Create SDP constraints.
    sdpMediaConstraints = new MediaConstraints();
    sdpMediaConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
            "OfferToReceiveAudio", "true"));
    if (videoCallEnabled || peerConnectionParameters.loopback) {
        sdpMediaConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
                "OfferToReceiveVideo", "true"));
    } else {
        sdpMediaConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
                "OfferToReceiveVideo", "false"));
    }
}

创建PeerConnectionFactory实例和MediaStream实例

/**
 * createPeerConnectionFactory
 * @param context
 * @param renderEGLContext
 */
private void createPeerConnectionFactoryInternal(Context context, final EglBase.Context renderEGLContext) {
    PeerConnectionFactory.initializeInternalTracer();
    if (peerConnectionParameters.tracing) {
        PeerConnectionFactory.startInternalTracingCapture(
                Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator
                        + "webrtc-trace.txt");
    }
    Log.d(TAG, "Create peer connection factory. Use video: " +
            peerConnectionParameters.videoCallEnabled);

    isError = false;

    String fieldTrials = "";
    if (peerConnectionParameters.videoFlexfecEnabled) {
        fieldTrials += VIDEO_FLEXFEC_FIELDTRIAL;
        Log.d(TAG, "Enable FlexFEC field trial.");
    }
    fieldTrials += VIDEO_VP8_INTEL_HW_ENCODER_FIELDTRIAL;
    preferredVideoCodec = VIDEO_CODEC_VP8;
    if (videoCallEnabled && peerConnectionParameters.videoCodec != null) {
        switch (peerConnectionParameters.videoCodec) {
            case VIDEO_CODEC_VP8:
                preferredVideoCodec = VIDEO_CODEC_VP8;
                break;
            case VIDEO_CODEC_VP9:
                preferredVideoCodec = VIDEO_CODEC_VP9;
                break;
            case VIDEO_CODEC_H264_BASELINE:
                preferredVideoCodec = VIDEO_CODEC_H264;
                break;
            case VIDEO_CODEC_H264_HIGH:
                // TODO(magjed): Strip High from SDP when selecting Baseline instead of using field trial.
                fieldTrials += VIDEO_H264_HIGH_PROFILE_FIELDTRIAL;
                preferredVideoCodec = VIDEO_CODEC_H264;
                break;
            default:
                preferredVideoCodec = VIDEO_CODEC_VP8;
        }
    }
    // Initialize field trials.
    Log.d(TAG, "Preferred video codec: " + preferredVideoCodec);
    PeerConnectionFactory.initializeFieldTrials(fieldTrials);

    preferIsac = false;
    if (peerConnectionParameters.audioCodec != null
            && peerConnectionParameters.audioCodec.equals(AUDIO_CODEC_ISAC)) {
        preferIsac = true;
    }
    if (!peerConnectionParameters.useOpenSLES) {
        Log.d(TAG, "Disable OpenSL ES audio even if device supports it");
        WebRtcAudioManager.setBlacklistDeviceForOpenSLESUsage(true /* enable */);
    } else {
        Log.d(TAG, "Allow OpenSL ES audio if device supports it");
        WebRtcAudioManager.setBlacklistDeviceForOpenSLESUsage(false);
    }

    if (peerConnectionParameters.disableBuiltInAEC) {
        Log.d(TAG, "Disable built-in AEC even if device supports it");
        WebRtcAudioUtils.setWebRtcBasedAcousticEchoCanceler(true);
    } else {
        Log.d(TAG, "Enable built-in AEC if device supports it");
        WebRtcAudioUtils.setWebRtcBasedAcousticEchoCanceler(false);
    }

    if (peerConnectionParameters.disableBuiltInAGC) {
        Log.d(TAG, "Disable built-in AGC even if device supports it");
        WebRtcAudioUtils.setWebRtcBasedAutomaticGainControl(true);
    } else {
        Log.d(TAG, "Enable built-in AGC if device supports it");
        WebRtcAudioUtils.setWebRtcBasedAutomaticGainControl(false);
    }

    if (peerConnectionParameters.disableBuiltInNS) {
        Log.d(TAG, "Disable built-in NS even if device supports it");
        WebRtcAudioUtils.setWebRtcBasedNoiseSuppressor(true);
    } else {
        Log.d(TAG, "Enable built-in NS if device supports it");
        WebRtcAudioUtils.setWebRtcBasedNoiseSuppressor(false);
    }

    WebRtcAudioRecord.setErrorCallback(new WebRtcAudioRecord.WebRtcAudioRecordErrorCallback() {
        @Override
        public void onWebRtcAudioRecordInitError(String errorMessage) {
            Log.e(TAG, "onWebRtcAudioRecordInitError: " + errorMessage);
            reportError(errorMessage);
        }

        @Override
        public void onWebRtcAudioRecordStartError(
                WebRtcAudioRecord.AudioRecordStartErrorCode errorCode, String errorMessage) {
            Log.e(TAG, "onWebRtcAudioRecordStartError: " + errorCode + ". " + errorMessage);
            reportError(errorMessage);
        }

        @Override
        public void onWebRtcAudioRecordError(String errorMessage) {
            Log.e(TAG, "onWebRtcAudioRecordError: " + errorMessage);
            reportError(errorMessage);
        }
    });

    WebRtcAudioTrack.setErrorCallback(new WebRtcAudioTrack.WebRtcAudioTrackErrorCallback() {
        @Override
        public void onWebRtcAudioTrackInitError(String errorMessage) {
            reportError(errorMessage);
        }

        @Override
        public void onWebRtcAudioTrackStartError(String errorMessage) {
            reportError(errorMessage);
        }

        @Override
        public void onWebRtcAudioTrackError(String errorMessage) {
            reportError(errorMessage);
        }
    });
    PeerConnectionFactory.initializeAndroidGlobals(context, peerConnectionParameters.videoCodecHwAcceleration);
    if (options != null) {
        Log.d(TAG, "Factory networkIgnoreMask option: " + options.networkIgnoreMask);
    }
    //创建PeerConnectionFactory
    factory = new PeerConnectionFactory(options);
    Log.d(TAG, "Peer connection factory created.");

    //创建本地媒体流
    mediaStream = factory.createLocalMediaStream("ARDAMS");
    if (videoCallEnabled) {
        //创建videoCapturer 
        videoCapturer = createVideoCapturer();
        if (videoCapturer == null) {
            Log.e(TAG,"Failed to open camera");
        }
        else {
            //创建视频轨道并添加到媒体流中
            mediaStream.addTrack(createVideoTrack(videoCapturer));
        }
    }
    //创建音频轨道并添加到媒体流中
    //如果videoCallEnabled == true的话，此时的mediaStream中有两条轨道
    mediaStream.addTrack(createAudioTrack());
    if (videoCallEnabled) {
        Log.d(TAG, "EGLContext: " + renderEGLContext);
                //视频硬件加速时需要用到renderEGLContext
        factory.setVideoHwAccelerationOptions(renderEGLContext, renderEGLContext);
    }
}

2、创建PeerConnection

在前面的步骤中已经创建了PeerConnectionFactory的实例，

/**
 * 
 * @param peerName    对方
 * @param remoteRender    远端的视频流
 * @param iceServers    IceServer
 * @param isCallout    呼叫还是接听
 * @param iceTransportsType
 * @param events    创建PeerConnection的回调
 */
public void createPeerConnection(
        final String peerName,
        final VideoRenderer.Callbacks remoteRender,
        final List<PeerConnection.IceServer> iceServers,
        final boolean isCallout,
        final PeerConnection.IceTransportsType iceTransportsType,
        final PeerConnectionEvents events) {
    Log.e(TAG,"createPeerConnection...");
    this.peerName = peerName;
    this.isCallout = isCallout;
    //this.executor = Executors.newSingleThreadScheduledExecutor();
    this.remoteRender = remoteRender;
    isError = false;
    this.events = events;
    if (peerConnectionParameters == null) {
        Log.e(TAG, "Creating peer connection without initializing factory.");
        return;
    }
    executor.execute(new Runnable() {
        @Override
        public void run() {
            createPeerConnectionInternal(mediaStream, iceServers, iceTransportsType);
            peerConnections.put(peerName,peerConnection);
        }
    });
}

创建PeerConnection并添加本地媒体流，创建PeerConnection需要3个参数：RTCConfiguration rtcConfig, MediaConstraints constraints, Observer observer。
constraints在创建factory实例时已经创建完成，rtcConfig在方法中完成，observer需要实现。

/**
 * 
 * @param localmediaStream    本地视频流
 * @param iceServers      IceServer
 * @param iceTransportsType    转发还是P2P
 */
private void createPeerConnectionInternal(MediaStream localmediaStream, List<PeerConnection.IceServer> iceServers, PeerConnection.IceTransportsType iceTransportsType) {

    PeerConnection.RTCConfiguration rtcConfig =
            new PeerConnection.RTCConfiguration(iceServers);
    rtcConfig.tcpCandidatePolicy = PeerConnection.TcpCandidatePolicy.DISABLED;

    if(PreferenceUtil.getInstance().getString("BundlePolicy","0").equals("0")){
        rtcConfig.bundlePolicy = PeerConnection.BundlePolicy.BALANCED;
    }else if(PreferenceUtil.getInstance().getString("BundlePolicy","0").equals("1")) {
        rtcConfig.bundlePolicy = PeerConnection.BundlePolicy.MAXBUNDLE;
    }else if(PreferenceUtil.getInstance().getString("BundlePolicy","0").equals("2")){
        rtcConfig.bundlePolicy = PeerConnection.BundlePolicy.MAXCOMPAT;
    }
    if(PreferenceUtil.getInstance().getString("RtcpMuxPolicy","0").equals("0")){
        rtcConfig.rtcpMuxPolicy = PeerConnection.RtcpMuxPolicy.NEGOTIATE;
    }else if(PreferenceUtil.getInstance().getString("RtcpMuxPolicy","0").equals("1")){
        rtcConfig.rtcpMuxPolicy = PeerConnection.RtcpMuxPolicy.REQUIRE;
    }

    rtcConfig.continualGatheringPolicy = PeerConnection.ContinualGatheringPolicy.GATHER_CONTINUALLY;
    rtcConfig.iceTransportsType = iceTransportsType;

    rtcConfig.keyType = PeerConnection.KeyType.ECDSA;

    Log.d(TAG, "createPeerConnection begin .");

    //创建peerConnection实例
    peerConnection = factory.createPeerConnection(rtcConfig, pcConstraints, pcObserver);

    Log.d(TAG, "createPeerConnection finish .");
    if (dataChannelEnabled) {
        DataChannel.Init init = new DataChannel.Init();
        init.ordered = true;
        init.negotiated = false;
        init.maxRetransmits = -1;
        init.maxRetransmitTimeMs = -1;
        init.id = -1;
        init.protocol = "";
        dataChannel = peerConnection.createDataChannel("ApprtcDemo data", init);
    }

    Logging.enableTracing("logcat:", EnumSet.of(Logging.TraceLevel.TRACE_DEFAULT));
    Logging.enableLogToDebugOutput(Logging.Severity.LS_ERROR);
    mediaStream = localmediaStream;
    peerConnection.addStream(mediaStream);//将本地视频流添加到peerConnection

    Log.d(TAG, "Peer connection created.");
}

3、实现PeerConnection.Observer

作为PeerConnectionClient的内部类，创建PeerConnection过程中的回调

private class PCObserver implements PeerConnection.Observer{

    @Override
    public void onSignalingChange(PeerConnection.SignalingState signalingState) {
        Log.d(TAG,"SignalingState: " + signalingState);
    }

    @Override
    public void onIceConnectionChange(final PeerConnection.IceConnectionState iceConnectionState) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG,"IceConnectionState: " + iceConnectionState);
                if (iceConnectionState == PeerConnection.IceConnectionState.CONNECTED) {
                    events.onIceConnected();
                } else if (iceConnectionState == PeerConnection.IceConnectionState.DISCONNECTED) {
                    events.onIceDisconnected();
                } else if (iceConnectionState == PeerConnection.IceConnectionState.FAILED) {
                }
            }
        });
    }

    @Override
    public void onIceConnectionReceivingChange(final boolean b) {
        Log.d(TAG,"IceConnectionReceiving changed to " + b);
    }

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

    @Override
    public void onIceCandidate(final IceCandidate iceCandidate) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG,"onIceCandidate: ");
                events.onIceCandidate(iceCandidate);
            }
        });
    }

    @Override
    public void onIceCandidatesRemoved(final IceCandidate[] iceCandidates) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG,"onIceCandidatesRemoved: ");
                events.onIceCandidatesRemoved(iceCandidates);
            }
        });
    }

    @Override
    public void onAddStream(final MediaStream mediaStream) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG,"onAddStream " + peerConnection);
                if (peerConnection == null || isError) {
                    return;
                }
                if (mediaStream.audioTracks.size() > 1 || mediaStream.videoTracks.size() > 1) {
                    Log.d(TAG,"Weird-looking stream: " + mediaStream);
                    return;
                }
                if(mediaStream.audioTracks.size() == 1){
                    remoteAudioTrack = mediaStream.audioTracks.get(0);
                }
                if (mediaStream.videoTracks.size() == 1) {
                    remoteVideoTrack = mediaStream.videoTracks.get(0);
                    remoteVideoTrack.setEnabled(true);
                    remoteVideoTrack.addRenderer(new VideoRenderer(remoteRender));
                }
            }
        });
    }

    @Override
    public void onRemoveStream(final MediaStream mediaStream) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG,"onRemoveStream");
                remoteAudioTrack = null;
                remoteVideoTrack = null;
            }
        });
    }

    @Override
    public void onDataChannel(final DataChannel dataChannel) {
        Log.d(TAG,"dc rev!");
    }

    @Override
    public void onRenegotiationNeeded() {
        Log.d(TAG,"onRenegotiationNeeded!");
    }

    @Override
    public void onAddTrack(final RtpReceiver rtpReceiver, final MediaStream[] mediaStreams) {
        Log.d(TAG,"onAddTrack!");
    }
}

4、总结

  至此已经创建了PeerConnection对象，将音视频数据封装成MediaStream添加到PeerConnection中。创建PeerConnection对象之后就可以调用PeerConnection的几个方法了，但是还需要包装一下，以后再说！