mirror of https://github.com/OpenVidu/openvidu.git
601 lines
26 KiB
TypeScript
601 lines
26 KiB
TypeScript
/*
|
|
* (C) Copyright 2017-2022 OpenVidu (https://openvidu.io)
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
*/
|
|
|
|
import freeice = require('freeice');
|
|
import { v4 as uuidv4 } from 'uuid';
|
|
import { TypeOfVideo } from '../Enums/TypeOfVideo';
|
|
import { ExceptionEventName } from '../Events/ExceptionEvent';
|
|
import { OpenViduLogger } from '../Logger/OpenViduLogger';
|
|
import { PlatformUtils } from '../Utils/Platform';
|
|
|
|
/**
|
|
* @hidden
|
|
*/
|
|
const logger: OpenViduLogger = OpenViduLogger.getInstance();
|
|
/**
|
|
* @hidden
|
|
*/
|
|
let platform: PlatformUtils;
|
|
|
|
export interface WebRtcPeerConfiguration {
|
|
mediaConstraints: {
|
|
audio: boolean;
|
|
video: boolean;
|
|
};
|
|
simulcast: boolean;
|
|
mediaServer: string;
|
|
onIceCandidate: (event: RTCIceCandidate) => void;
|
|
onIceConnectionStateException: (exceptionName: ExceptionEventName, message: string, data?: any) => void;
|
|
iceServers?: RTCIceServer[];
|
|
rtcConfiguration?: RTCConfiguration;
|
|
mediaStream?: MediaStream | null;
|
|
mode?: 'sendonly' | 'recvonly' | 'sendrecv';
|
|
id?: string;
|
|
typeOfVideo: TypeOfVideo | undefined;
|
|
}
|
|
|
|
export class WebRtcPeer {
|
|
pc: RTCPeerConnection;
|
|
remoteCandidatesQueue: RTCIceCandidate[] = [];
|
|
localCandidatesQueue: RTCIceCandidate[] = [];
|
|
|
|
// Same as WebRtcPeerConfiguration but without optional fields.
|
|
protected configuration: Required<WebRtcPeerConfiguration>;
|
|
|
|
private iceCandidateList: RTCIceCandidate[] = [];
|
|
|
|
constructor(configuration: WebRtcPeerConfiguration) {
|
|
platform = PlatformUtils.getInstance();
|
|
|
|
this.configuration = {
|
|
...configuration,
|
|
iceServers: !!configuration.iceServers && configuration.iceServers.length > 0 ? configuration.iceServers : freeice(),
|
|
rtcConfiguration: configuration.rtcConfiguration !== undefined ? configuration.rtcConfiguration : {},
|
|
mediaStream: configuration.mediaStream !== undefined ? configuration.mediaStream : null,
|
|
mode: !!configuration.mode ? configuration.mode : 'sendrecv',
|
|
id: !!configuration.id ? configuration.id : this.generateUniqueId()
|
|
};
|
|
// prettier-ignore
|
|
logger.debug(`[WebRtcPeer] configuration:\n${JSON.stringify(this.configuration, null, 2)}`);
|
|
|
|
let rtcConfiguration: RTCConfiguration = this.configuration.rtcConfiguration
|
|
? this.configuration.rtcConfiguration
|
|
: { iceServers: this.configuration.iceServers };
|
|
if (!rtcConfiguration.iceServers && this.configuration.iceServers) {
|
|
rtcConfiguration.iceServers = this.configuration.iceServers;
|
|
}
|
|
this.pc = new RTCPeerConnection(rtcConfiguration);
|
|
|
|
this.pc.addEventListener('icecandidate', (event: RTCPeerConnectionIceEvent) => {
|
|
if (event.candidate !== null) {
|
|
// `RTCPeerConnectionIceEvent.candidate` is supposed to be an RTCIceCandidate:
|
|
// https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnectioniceevent-candidate
|
|
//
|
|
// But in practice, it is actually an RTCIceCandidateInit that can be used to
|
|
// obtain a proper candidate, using the RTCIceCandidate constructor:
|
|
// https://w3c.github.io/webrtc-pc/#dom-rtcicecandidate-constructor
|
|
const candidateInit: RTCIceCandidateInit = event.candidate as RTCIceCandidateInit;
|
|
const iceCandidate = new RTCIceCandidate(candidateInit);
|
|
|
|
this.configuration.onIceCandidate(iceCandidate);
|
|
if (iceCandidate.candidate !== '') {
|
|
this.localCandidatesQueue.push(iceCandidate);
|
|
}
|
|
}
|
|
});
|
|
|
|
this.pc.addEventListener('signalingstatechange', async () => {
|
|
if (this.pc.signalingState === 'stable') {
|
|
// SDP Offer/Answer finished. Add stored remote candidates.
|
|
while (this.iceCandidateList.length > 0) {
|
|
let candidate = this.iceCandidateList.shift();
|
|
try {
|
|
await this.pc.addIceCandidate(<RTCIceCandidate>candidate);
|
|
} catch (error) {
|
|
logger.error('Error when calling RTCPeerConnection#addIceCandidate for RTCPeerConnection ' + this.getId(), error);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
getId(): string {
|
|
return this.configuration.id;
|
|
}
|
|
|
|
/**
|
|
* This method frees the resources used by WebRtcPeer
|
|
*/
|
|
dispose() {
|
|
logger.debug('Disposing WebRtcPeer');
|
|
if (this.pc) {
|
|
if (this.pc.signalingState === 'closed') {
|
|
return;
|
|
}
|
|
this.pc.close();
|
|
this.remoteCandidatesQueue = [];
|
|
this.localCandidatesQueue = [];
|
|
}
|
|
}
|
|
|
|
// DEPRECATED LEGACY METHOD: Old WebRTC versions don't implement
|
|
// Transceivers, and instead depend on the deprecated
|
|
// "offerToReceiveAudio" and "offerToReceiveVideo".
|
|
private createOfferLegacy(): Promise<RTCSessionDescriptionInit> {
|
|
if (!!this.configuration.mediaStream) {
|
|
this.deprecatedPeerConnectionTrackApi();
|
|
}
|
|
|
|
const hasAudio = this.configuration.mediaConstraints.audio;
|
|
const hasVideo = this.configuration.mediaConstraints.video;
|
|
|
|
const options: RTCOfferOptions = {
|
|
offerToReceiveAudio: this.configuration.mode !== 'sendonly' && hasAudio,
|
|
offerToReceiveVideo: this.configuration.mode !== 'sendonly' && hasVideo
|
|
};
|
|
|
|
logger.debug('[createOfferLegacy] RTCPeerConnection.createOffer() options:', JSON.stringify(options));
|
|
|
|
return this.pc.createOffer(options);
|
|
}
|
|
|
|
/**
|
|
* Creates an SDP offer from the local RTCPeerConnection to send to the other peer.
|
|
* Only if the negotiation was initiated by this peer.
|
|
*/
|
|
async createOffer(): Promise<RTCSessionDescriptionInit> {
|
|
// TODO: Delete this conditional when all supported browsers are
|
|
// modern enough to implement the Transceiver methods.
|
|
if (!('addTransceiver' in this.pc)) {
|
|
logger.warn(
|
|
'[createOffer] Method RTCPeerConnection.addTransceiver() is NOT available; using LEGACY offerToReceive{Audio,Video}'
|
|
);
|
|
return this.createOfferLegacy();
|
|
} else {
|
|
logger.debug('[createOffer] Method RTCPeerConnection.addTransceiver() is available; using it');
|
|
}
|
|
|
|
// Spec doc: https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-addtransceiver
|
|
|
|
if (this.configuration.mode !== 'recvonly') {
|
|
// To send media, assume that all desired media tracks have been
|
|
// already added by higher level code to our MediaStream.
|
|
|
|
if (!this.configuration.mediaStream) {
|
|
throw new Error(
|
|
`[WebRtcPeer.createOffer] Direction is '${this.configuration.mode}', but no stream was configured to be sent`
|
|
);
|
|
}
|
|
|
|
for (const track of this.configuration.mediaStream.getTracks()) {
|
|
const tcInit: RTCRtpTransceiverInit = {
|
|
direction: this.configuration.mode,
|
|
streams: [this.configuration.mediaStream]
|
|
};
|
|
|
|
if (track.kind === 'video' && this.configuration.simulcast) {
|
|
// Check if the requested size is enough to ask for 3 layers.
|
|
const trackSettings = track.getSettings();
|
|
const trackConsts = track.getConstraints();
|
|
|
|
const trackWidth: number =
|
|
trackSettings.width ?? (trackConsts.width as ConstrainULongRange).ideal ?? (trackConsts.width as number) ?? 0;
|
|
const trackHeight: number =
|
|
trackSettings.height ?? (trackConsts.height as ConstrainULongRange).ideal ?? (trackConsts.height as number) ?? 0;
|
|
logger.info(`[createOffer] Video track dimensions: ${trackWidth}x${trackHeight}`);
|
|
|
|
const trackPixels = trackWidth * trackHeight;
|
|
let maxLayers = 0;
|
|
if (trackPixels >= 960 * 540) {
|
|
maxLayers = 3;
|
|
} else if (trackPixels >= 480 * 270) {
|
|
maxLayers = 2;
|
|
} else {
|
|
maxLayers = 1;
|
|
}
|
|
|
|
tcInit.sendEncodings = [];
|
|
for (let l = 0; l < maxLayers; l++) {
|
|
const layerDiv = 2 ** (maxLayers - l - 1);
|
|
|
|
const encoding: RTCRtpEncodingParameters = {
|
|
rid: 'rdiv' + layerDiv.toString(),
|
|
|
|
// @ts-ignore -- Property missing from DOM types.
|
|
scalabilityMode: 'L1T1'
|
|
};
|
|
|
|
if (['detail', 'text'].includes(track.contentHint)) {
|
|
// Prioritize best resolution, for maximum picture detail.
|
|
encoding.scaleResolutionDownBy = 1.0;
|
|
|
|
// @ts-ignore -- Property missing from DOM types.
|
|
encoding.maxFramerate = Math.floor(30 / layerDiv);
|
|
} else {
|
|
encoding.scaleResolutionDownBy = layerDiv;
|
|
}
|
|
|
|
tcInit.sendEncodings.push(encoding);
|
|
}
|
|
}
|
|
|
|
const tc = this.pc.addTransceiver(track, tcInit);
|
|
|
|
if (track.kind === 'video') {
|
|
let sendParams = tc.sender.getParameters();
|
|
let needSetParams = false;
|
|
|
|
if (!sendParams.degradationPreference?.length) {
|
|
// degradationPreference for video: "balanced", "maintain-framerate", "maintain-resolution".
|
|
// https://www.w3.org/TR/2018/CR-webrtc-20180927/#dom-rtcdegradationpreference
|
|
if (['detail', 'text'].includes(track.contentHint)) {
|
|
sendParams.degradationPreference = 'maintain-resolution';
|
|
} else {
|
|
sendParams.degradationPreference = 'balanced';
|
|
}
|
|
|
|
logger.info(`[createOffer] Video sender Degradation Preference set: ${sendParams.degradationPreference}`);
|
|
|
|
// FIXME: Firefox implements degradationPreference on each individual encoding!
|
|
// (set it on every element of the sendParams.encodings array)
|
|
|
|
needSetParams = true;
|
|
}
|
|
|
|
// FIXME: Check that the simulcast encodings were applied.
|
|
// Firefox doesn't implement `RTCRtpTransceiverInit.sendEncodings`
|
|
// so the only way to enable simulcast is with `RTCRtpSender.setParameters()`.
|
|
//
|
|
// This next block can be deleted when Firefox fixes bug #1396918:
|
|
// https://bugzilla.mozilla.org/show_bug.cgi?id=1396918
|
|
//
|
|
// NOTE: This is done in a way that is compatible with all browsers, to save on
|
|
// browser-conditional code. The idea comes from WebRTC Adapter.js:
|
|
// * https://github.com/webrtcHacks/adapter/issues/998
|
|
// * https://github.com/webrtcHacks/adapter/blob/v7.7.0/src/js/firefox/firefox_shim.js#L231-L255
|
|
if (this.configuration.simulcast) {
|
|
if (sendParams.encodings?.length !== tcInit.sendEncodings!.length) {
|
|
sendParams.encodings = tcInit.sendEncodings!;
|
|
|
|
needSetParams = true;
|
|
}
|
|
}
|
|
|
|
if (needSetParams) {
|
|
logger.debug(`[createOffer] Setting new RTCRtpSendParameters to video sender`);
|
|
try {
|
|
await tc.sender.setParameters(sendParams);
|
|
} catch (error) {
|
|
let message = `[WebRtcPeer.createOffer] Cannot set RTCRtpSendParameters to video sender`;
|
|
if (error instanceof Error) {
|
|
message += `: ${error.message}`;
|
|
}
|
|
throw new Error(message);
|
|
}
|
|
}
|
|
}
|
|
|
|
// DEBUG: Uncomment for details.
|
|
// if (track.kind === "video" && this.configuration.simulcast) {
|
|
// // Print browser capabilities.
|
|
// // prettier-ignore
|
|
// logger.debug(`[createOffer] Transceiver send capabilities (static):\n${JSON.stringify(RTCRtpSender.getCapabilities?.("video"), null, 2)}`);
|
|
// // prettier-ignore
|
|
// logger.debug(`[createOffer] Transceiver recv capabilities (static):\n${JSON.stringify(RTCRtpReceiver.getCapabilities?.("video"), null, 2)}`);
|
|
|
|
// // Print requested Transceiver encodings and parameters.
|
|
// // prettier-ignore
|
|
// logger.debug(`[createOffer] Transceiver send encodings (requested):\n${JSON.stringify(tcInit.sendEncodings, null, 2)}`);
|
|
// // prettier-ignore
|
|
// logger.debug(`[createOffer] Transceiver send parameters (accepted):\n${JSON.stringify(tc.sender.getParameters(), null, 2)}`);
|
|
// }
|
|
}
|
|
} else {
|
|
// To just receive media, create new recvonly transceivers.
|
|
for (const kind of ['audio', 'video']) {
|
|
// Check if the media kind should be used.
|
|
if (!this.configuration.mediaConstraints[kind]) {
|
|
continue;
|
|
}
|
|
|
|
this.configuration.mediaStream = new MediaStream();
|
|
this.pc.addTransceiver(kind, {
|
|
direction: this.configuration.mode,
|
|
streams: [this.configuration.mediaStream]
|
|
});
|
|
}
|
|
}
|
|
|
|
let sdpOffer: RTCSessionDescriptionInit;
|
|
try {
|
|
sdpOffer = await this.pc.createOffer();
|
|
} catch (error) {
|
|
let message = `[WebRtcPeer.createOffer] Browser failed creating an SDP Offer`;
|
|
if (error instanceof Error) {
|
|
message += `: ${error.message}`;
|
|
}
|
|
throw new Error(message);
|
|
}
|
|
|
|
return sdpOffer;
|
|
}
|
|
|
|
deprecatedPeerConnectionTrackApi() {
|
|
for (const track of this.configuration.mediaStream!.getTracks()) {
|
|
this.pc.addTrack(track, this.configuration.mediaStream!);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates an SDP answer from the local RTCPeerConnection to send to the other peer
|
|
* Only if the negotiation was initiated by the other peer
|
|
*/
|
|
createAnswer(): Promise<RTCSessionDescriptionInit> {
|
|
return new Promise((resolve, reject) => {
|
|
// TODO: Delete this conditional when all supported browsers are
|
|
// modern enough to implement the Transceiver methods.
|
|
if ('getTransceivers' in this.pc) {
|
|
logger.debug('[createAnswer] Method RTCPeerConnection.getTransceivers() is available; using it');
|
|
|
|
// Ensure that the PeerConnection already contains one Transceiver
|
|
// for each kind of media.
|
|
// The Transceivers should have been already created internally by
|
|
// the PC itself, when `pc.setRemoteDescription(sdpOffer)` was called.
|
|
|
|
for (const kind of ['audio', 'video']) {
|
|
// Check if the media kind should be used.
|
|
if (!this.configuration.mediaConstraints[kind]) {
|
|
continue;
|
|
}
|
|
|
|
let tc = this.pc.getTransceivers().find((tc) => tc.receiver.track.kind === kind);
|
|
|
|
if (tc) {
|
|
// Enforce our desired direction.
|
|
tc.direction = this.configuration.mode;
|
|
} else {
|
|
return reject(new Error(`${kind} requested, but no transceiver was created from remote description`));
|
|
}
|
|
}
|
|
|
|
this.pc
|
|
.createAnswer()
|
|
.then((sdpAnswer) => resolve(sdpAnswer))
|
|
.catch((error) => reject(error));
|
|
} else {
|
|
// TODO: Delete else branch when all supported browsers are
|
|
// modern enough to implement the Transceiver methods
|
|
|
|
let offerAudio,
|
|
offerVideo = true;
|
|
if (!!this.configuration.mediaConstraints) {
|
|
offerAudio =
|
|
typeof this.configuration.mediaConstraints.audio === 'boolean' ? this.configuration.mediaConstraints.audio : true;
|
|
offerVideo =
|
|
typeof this.configuration.mediaConstraints.video === 'boolean' ? this.configuration.mediaConstraints.video : true;
|
|
const constraints: RTCOfferOptions = {
|
|
offerToReceiveAudio: offerAudio,
|
|
offerToReceiveVideo: offerVideo
|
|
};
|
|
(this.pc as RTCPeerConnection).createAnswer(constraints)
|
|
.then((sdpAnswer) => resolve(sdpAnswer))
|
|
.catch((error) => reject(error));
|
|
}
|
|
}
|
|
|
|
// else, there is nothing to do; the legacy createAnswer() options do
|
|
// not offer any control over which tracks are included in the answer.
|
|
});
|
|
}
|
|
|
|
/**
|
|
* This peer initiated negotiation. Step 1/4 of SDP offer-answer protocol
|
|
*/
|
|
processLocalOffer(offer: RTCSessionDescriptionInit): Promise<void> {
|
|
return new Promise((resolve, reject) => {
|
|
this.pc
|
|
.setLocalDescription(offer)
|
|
.then(() => {
|
|
const localDescription = this.pc.localDescription;
|
|
if (!!localDescription) {
|
|
logger.debug('Local description set', localDescription.sdp);
|
|
return resolve();
|
|
} else {
|
|
return reject('Local description is not defined');
|
|
}
|
|
})
|
|
.catch((error) => reject(error));
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Other peer initiated negotiation. Step 2/4 of SDP offer-answer protocol
|
|
*/
|
|
processRemoteOffer(sdpOffer: string): Promise<void> {
|
|
return new Promise((resolve, reject) => {
|
|
const offer: RTCSessionDescriptionInit = {
|
|
type: 'offer',
|
|
sdp: sdpOffer
|
|
};
|
|
logger.debug('SDP offer received, setting remote description', offer);
|
|
|
|
if (this.pc.signalingState === 'closed') {
|
|
return reject('RTCPeerConnection is closed when trying to set remote description');
|
|
}
|
|
this.setRemoteDescription(offer)
|
|
.then(() => resolve())
|
|
.catch((error) => reject(error));
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Other peer initiated negotiation. Step 3/4 of SDP offer-answer protocol
|
|
*/
|
|
processLocalAnswer(answer: RTCSessionDescriptionInit): Promise<void> {
|
|
return new Promise((resolve, reject) => {
|
|
logger.debug('SDP answer created, setting local description');
|
|
if (this.pc.signalingState === 'closed') {
|
|
return reject('RTCPeerConnection is closed when trying to set local description');
|
|
}
|
|
this.pc
|
|
.setLocalDescription(answer)
|
|
.then(() => resolve())
|
|
.catch((error) => reject(error));
|
|
});
|
|
}
|
|
|
|
/**
|
|
* This peer initiated negotiation. Step 4/4 of SDP offer-answer protocol
|
|
*/
|
|
processRemoteAnswer(sdpAnswer: string): Promise<void> {
|
|
return new Promise((resolve, reject) => {
|
|
const answer: RTCSessionDescriptionInit = {
|
|
type: 'answer',
|
|
sdp: sdpAnswer
|
|
};
|
|
logger.debug('SDP answer received, setting remote description');
|
|
|
|
if (this.pc.signalingState === 'closed') {
|
|
return reject('RTCPeerConnection is closed when trying to set remote description');
|
|
}
|
|
this.setRemoteDescription(answer)
|
|
.then(() => {
|
|
// DEBUG: Uncomment for details.
|
|
// {
|
|
// const tc = this.pc.getTransceivers().find((tc) => tc.sender.track?.kind === "video");
|
|
// // prettier-ignore
|
|
// logger.debug(`[processRemoteAnswer] Transceiver send parameters (effective):\n${JSON.stringify(tc?.sender.getParameters(), null, 2)}`);
|
|
// }
|
|
|
|
resolve();
|
|
})
|
|
.catch((error) => reject(error));
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @hidden
|
|
*/
|
|
async setRemoteDescription(sdp: RTCSessionDescriptionInit): Promise<void> {
|
|
return this.pc.setRemoteDescription(sdp);
|
|
}
|
|
|
|
/**
|
|
* Callback function invoked when an ICE candidate is received
|
|
*/
|
|
addIceCandidate(iceCandidate: RTCIceCandidate): Promise<void> {
|
|
return new Promise((resolve, reject) => {
|
|
logger.debug('Remote ICE candidate received', iceCandidate);
|
|
this.remoteCandidatesQueue.push(iceCandidate);
|
|
switch (this.pc.signalingState) {
|
|
case 'closed':
|
|
reject(new Error('PeerConnection object is closed'));
|
|
break;
|
|
case 'stable':
|
|
if (!!this.pc.remoteDescription) {
|
|
this.pc
|
|
.addIceCandidate(iceCandidate)
|
|
.then(() => resolve())
|
|
.catch((error) => reject(error));
|
|
} else {
|
|
this.iceCandidateList.push(iceCandidate);
|
|
resolve();
|
|
}
|
|
break;
|
|
default:
|
|
this.iceCandidateList.push(iceCandidate);
|
|
resolve();
|
|
}
|
|
});
|
|
}
|
|
|
|
addIceConnectionStateChangeListener(otherId: string) {
|
|
this.pc.addEventListener('iceconnectionstatechange', () => {
|
|
const iceConnectionState: RTCIceConnectionState = this.pc.iceConnectionState;
|
|
switch (iceConnectionState) {
|
|
case 'disconnected':
|
|
// Possible network disconnection
|
|
const msg1 =
|
|
'IceConnectionState of RTCPeerConnection ' +
|
|
this.configuration.id +
|
|
' (' +
|
|
otherId +
|
|
') change to "disconnected". Possible network disconnection';
|
|
logger.warn(msg1);
|
|
this.configuration.onIceConnectionStateException(ExceptionEventName.ICE_CONNECTION_DISCONNECTED, msg1);
|
|
break;
|
|
case 'failed':
|
|
const msg2 = 'IceConnectionState of RTCPeerConnection ' + this.configuration.id + ' (' + otherId + ') to "failed"';
|
|
logger.error(msg2);
|
|
this.configuration.onIceConnectionStateException(ExceptionEventName.ICE_CONNECTION_FAILED, msg2);
|
|
break;
|
|
case 'closed':
|
|
logger.log(
|
|
'IceConnectionState of RTCPeerConnection ' + this.configuration.id + ' (' + otherId + ') change to "closed"'
|
|
);
|
|
break;
|
|
case 'new':
|
|
logger.log('IceConnectionState of RTCPeerConnection ' + this.configuration.id + ' (' + otherId + ') change to "new"');
|
|
break;
|
|
case 'checking':
|
|
logger.log(
|
|
'IceConnectionState of RTCPeerConnection ' + this.configuration.id + ' (' + otherId + ') change to "checking"'
|
|
);
|
|
break;
|
|
case 'connected':
|
|
logger.log(
|
|
'IceConnectionState of RTCPeerConnection ' + this.configuration.id + ' (' + otherId + ') change to "connected"'
|
|
);
|
|
break;
|
|
case 'completed':
|
|
logger.log(
|
|
'IceConnectionState of RTCPeerConnection ' + this.configuration.id + ' (' + otherId + ') change to "completed"'
|
|
);
|
|
break;
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @hidden
|
|
*/
|
|
generateUniqueId(): string {
|
|
return uuidv4();
|
|
}
|
|
}
|
|
|
|
export class WebRtcPeerRecvonly extends WebRtcPeer {
|
|
constructor(configuration: WebRtcPeerConfiguration) {
|
|
configuration.mode = 'recvonly';
|
|
super(configuration);
|
|
}
|
|
}
|
|
|
|
export class WebRtcPeerSendonly extends WebRtcPeer {
|
|
constructor(configuration: WebRtcPeerConfiguration) {
|
|
configuration.mode = 'sendonly';
|
|
super(configuration);
|
|
}
|
|
}
|
|
|
|
export class WebRtcPeerSendrecv extends WebRtcPeer {
|
|
constructor(configuration: WebRtcPeerConfiguration) {
|
|
configuration.mode = 'sendrecv';
|
|
super(configuration);
|
|
}
|
|
}
|