【山大会议】私人聊天频道 WebRTC 工具类

最新推荐文章于 2024-06-10 21:57:03 发布
最新推荐文章于 2024-06-10 21:57:03 发布
阅读量2k 收藏
点赞数
分类专栏： 山东大学2019级项目实训 文章标签： webrtc 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53126706/article/details/125161756
版权

文章目录

序言

在山大会议中，我们不仅要实现多人视频会议，我们还需要实现一个类似 QQ、微信 这样的即时通讯服务。在这个一对一的私人聊天服务中，我们添加了一个一对一的私人视频通话功能，一来是增加软件功能的多样性，二来也是为实现多人聊天做铺垫，先熟悉 WebRTC 在实际环境下的运行。

逻辑设计

首先，我们需要对私人视频通话的代码逻辑进行设计。我们之前在 【山大会议】WebRTC基础之对等体连接 这篇文章中介绍过基本的 WebRTC 对等体连接的过程。它的建立本质上是一个两次握手的过程：

  • 发起方向接收方发送 OFFER 请求，并携带上自己的 SessionDescriptionProtocol （以后简写为 sdp）；
  • 接收方接到发送方的 sdp ，创建 ANSWER ，生成 sdp 返回给发送方；
  • 发送方接到接收方的 sdp 后，建立起 WebRTC 对等体连接。

在私人视频聊天模块中，我们决定采用去中心化的、P2P的架构设计，中心服务器仅做信令转发功能，由此可以绕过服务器本身带宽不足，难以支撑起高分辨率画面的问题。
其次，由于我们加入了会话加密功能，发起方可以选择本次通话是否需要加密，而接收方则需要知道对方是否开启了加密，以提示用户是否进行加密对话。
由于我们的服务器没有 SSL 证书，服务器与客户端发送的数据均是明文，这意味着我们无法在不可信信道上传递密钥。因此，我们采用了一种协商算法来生成一次性的密钥，而协商的过程也需要一次握手。最终，我们将过程简化，得到了最终的连接建立过程的逻辑流程：

为了描述的方便起见，我们将 主动方 称为 A ，被动方 称为 B 。

  1. A 向 B 发起会话请求，其中携带密钥协商所需要的一些信息；
  2. B 接到 A 的请求，根据携带的 协商信息 判断 A 是否开启加密，并作出回复，如果同意进行会话且 A 启用了加密，则继续根据 协商信息 计算得到 公钥 与 私钥 ，将 公钥 发回给 A；
  3. A 接到应答消息后，判断 B 是否同意会话，如果同意则生成 OFFER 请求，携带 sdp 发送给 B ，如果开启了加密，则获取 B 发回的 公钥 ，通过算法得出 私钥；
  4. B 接到 OFFER 请求与 sdp，将 sdp 保存为 远程描述符 ，并创建 ANSWER 请求得到 本地描述符 ，并将其发送回 A；
  5. A 接到 ANSWER ，将其中的 sdp 保存为 远程描述符 ，双方分别添加 Ice候选者 ，建立起对等体连接。

私人 WebRTC 工具类代码

// ChatRTC.tsx
import {
	AlertOutlined,
	CheckOutlined,
	CloseOutlined,
	ExclamationCircleOutlined,
} from '@ant-design/icons';
import Modal from 'antd/lib/modal';
import { globalMessage } from 'Components/GlobalMessage/GlobalMessage';
import { EventEmitter } from 'events';
import React from 'react';
import { ChatSocket } from 'Utils/ChatSocket/ChatSocket';
import {
	CALL_STATUS_ANSWERING,
	CALL_STATUS_CALLING,
	CALL_STATUS_FREE,
	CALL_STATUS_OFFERING,
	ChatWebSocketType,
	DEVICE_TYPE,
	PRIVATE_WEBRTC_ANSWER_TYPE,
	receiverCodecs,
	senderCodecs,
} from 'Utils/Constraints';
import eventBus from 'Utils/EventBus/EventBus';
import { getDeviceStream, getMainContent } from 'Utils/Global';
import { AUDIO_TYPE, buildPropmt } from 'Utils/Prompt/Prompt';
import { setCallStatus, setNowChattingId, setNowWebrtcFriendId } from 'Utils/Store/actions';
import store from 'Utils/Store/store';
import { eWindow } from 'Utils/Types';
import { setupReceiverTransform, setupSenderTransform } from 'Utils/WebRTC/RtcEncrypt';

interface ChatRtcProps {
	socket: ChatSocket;
	myId: number;
}

export class ChatRTC extends EventEmitter {
	callAudioPrompt: (() => void)[];
	answerAudioPrompt: (() => void)[];
	socket: ChatSocket;
	myId: number;
	localStream: null | MediaStream;
	remoteStream: null | MediaStream;
	sender?: number;
	receiver?: number;
	peer!: RTCPeerConnection;
	answerModal!: null | {
		destroy: () => void;
	};
	offerModal!: null | {
		destroy: () => void;
	};
	candidateQueue: Array<any>;
	useSecurity: boolean;
	security: string;

	constructor(props: ChatRtcProps) {
		super();
		this.callAudioPrompt = buildPropmt(AUDIO_TYPE.WEBRTC_CALLING, true);
		this.answerAudioPrompt = buildPropmt(AUDIO_TYPE.WEBRTC_ANSWERING, true);

		this.socket = props.socket;
		this.myId = props.myId;
		this.localStream = null;
		this.remoteStream = null;
		this.useSecurity = false;
		this.security = '[]';
		this.candidateQueue = new Array();

		this.socket.on('ON_PRIVATE_WEBRTC_REQUEST', (msg) => {
			this.responseCall(msg);
		});

		this.socket.on('ON_PRIVATE_WEBRTC_RESPONSE', ({ accept, sender, receiver, security }) => {
			if (sender === this.sender && receiver === this.receiver) {
				this.callAudioPrompt[1]();
				if (this.offerModal) {
					this.offerModal.destroy();
					this.offerModal = null;
				}
				if (accept === PRIVATE_WEBRTC_ANSWER_TYPE.ACCEPT) {
					this.createOffer(security);
				} else {
					switch (accept) {
						case PRIVATE_WEBRTC_ANSWER_TYPE.BUSY:
							globalMessage.error({
								content: '对方正在通话中',
								duration: 1.5,
							});
							break;
						case PRIVATE_WEBRTC_ANSWER_TYPE.OFFLINE:
							globalMessage.error({
								content: '呼叫的用户不在线',
								duration: 1.5,
							});
							break;
						case PRIVATE_WEBRTC_ANSWER_TYPE.REJECT:
							globalMessage.error({
								content: '对方拒绝了您的通话邀请',
								duration: 1.5,
							});
							break;
					}
					this.onEnded();
				}
			}
		});

		this.socket.on('ON_PRIVATE_WEBRTC_OFFER', (msg) => {
			if (msg.sender === this.sender && msg.receiver === this.receiver)
				this.createAnswer(msg.sdp);
		});

		this.socket.on('ON_PRIVATE_WEBRTC_ANSWER', (msg) => {
			this.receiveAnswer(msg.sdp);
		});

		this.socket.on('ON_PRIVATE_WEBRTC_CANDIDATE', (msg) => {
			if (msg.sender === this.sender && msg.receiver === this.receiver) {
				this.handleCandidate(msg);
			}
		});

		this.socket.on('ON_PRIVATE_WEBRTC_DISCONNECT', (msg) => {
			globalMessage.info('对方已挂断通话');
			this.onHangUp(msg);
		});
	}

	callRemote(targetId: number, myName: string, offerModal: any) {
		this.useSecurity = localStorage.getItem('securityPrivateWebrtc') === 'true';
		this.callAudioPrompt[0]();
		store.dispatch(setCallStatus(CALL_STATUS_OFFERING));
		store.dispatch(setNowWebrtcFriendId(targetId));
		this.sender = this.myId;
		this.receiver = targetId;
		let pgArr: Array<string> = [];
		(async () => {
			if (this.useSecurity) {
				pgArr = await eWindow.ipc.invoke('DIFFIE_HELLMAN');
			}
			this.socket.send({
				type: ChatWebSocketType.CHAT_PRIVATE_WEBRTC_REQUEST,
				sender: this.myId,
				senderName: myName,
				security: JSON.stringify(pgArr),
				receiver: targetId,
			});
			this.offerModal = offerModal;
		})();
	}

	responseCall(msg: any) {
		this.sender = msg.sender;
		this.receiver = this.myId;

		const rejectOffer = (reason: number) => {
			this.socket.send({
				type: ChatWebSocketType.CHAT_PRIVATE_WEBRTC_RESPONSE,
				security: '',
				accept: reason,
				sender: msg.sender,
				receiver: msg.receiver,
			});
		};

		if (store.getState().callStatus === CALL_STATUS_FREE) {
			eventBus.emit('GET_PRIVATE_CALLED');
			this.answerAudioPrompt[0]();
			store.dispatch(setNowChattingId(msg.sender));
			const pgArr = JSON.parse(msg.security);
			const useSecurity = pgArr.length === 3;
			this.answerModal = Modal.confirm({
				icon: useSecurity ? <AlertOutlined /> : <ExclamationCircleOutlined />,
				title: '视频通话邀请',
				content: (
					<span>
						用户 {msg.senderName}(id: {msg.sender})向您发出视频通话请求，是否接受？
						{useSecurity ? (
							<span>
								<br />
								注意：对方启用了私聊视频会话加密功能，接受此会话可能会导致您的CPU占用被大幅度提高，请与对方确认后选择是否接受此会话
							</span>
						) : (
							''
						)}
					</span>
				),
				cancelText: (
					<>
						<CloseOutlined />
						拒绝接受
					</>
				),
				okText: (
					<>
						<CheckOutlined />
						同意请求
					</>
				),
				onOk: () => {
					this.useSecurity = useSecurity;
					if (useSecurity) {
						eWindow.ipc
							.invoke('DIFFIE_HELLMAN', pgArr[0], pgArr[1], pgArr[2])
							.then((serverArr) => {
								const [privateKey, publicKey] = serverArr;
								this.security = privateKey;
								this.socket.send({
									type: ChatWebSocketType.CHAT_PRIVATE_WEBRTC_RESPONSE,
									accept: PRIVATE_WEBRTC_ANSWER_TYPE.ACCEPT,
									sender: this.sender,
									receiver: this.receiver,
									security: publicKey,
								});
							});
					} else {
						this.socket.send({
							type: ChatWebSocketType.CHAT_PRIVATE_WEBRTC_RESPONSE,
							accept: PRIVATE_WEBRTC_ANSWER_TYPE.ACCEPT,
							sender: this.sender,
							receiver: this.receiver,
							security: '',
						});
					}

					store.dispatch(setCallStatus(CALL_STATUS_ANSWERING));
					store.dispatch(setNowWebrtcFriendId(msg.sender));
				},
				onCancel: () => {
					rejectOffer(PRIVATE_WEBRTC_ANSWER_TYPE.REJECT);
					this.answerModal = null;
					this.sender = undefined;
					this.receiver = undefined;
				},
				afterClose: this.answerAudioPrompt[1],
				centered: true,
				getContainer: getMainContent,
			});
		} else rejectOffer(PRIVATE_WEBRTC_ANSWER_TYPE.BUSY);
	}

	async createOffer(publicKey: string) {
		this.peer = this.buildPeer();
		this.localStream = new MediaStream();
		this.localStream.addTrack(
			(await getDeviceStream(DEVICE_TYPE.VIDEO_DEVICE)).getVideoTracks()[0]
		);
		this.localStream.addTrack(
			(await getDeviceStream(DEVICE_TYPE.AUDIO_DEVICE)).getAudioTracks()[0]
		);
		for (const track of this.localStream.getTracks()) {
			this.peer.addTrack(track, this.localStream);
		}

		// NOTE: 加密
		if (publicKey) {
			const privateKey = await eWindow.ipc.invoke('DIFFIE_HELLMAN', publicKey);
			this.security = privateKey;
			this.peer.getSenders().forEach((sender) => {
				setupSenderTransform(sender, privateKey);
			});
		} else {
			this.peer
				.getTransceivers()
				.find((t) => t.sender.track?.kind === 'video')
				?.setCodecPreferences(senderCodecs);
		}

		this.peer
			.createOffer({
				offerToReceiveAudio: true,
				offerToReceiveVideo: true,
			})
			.then((sdp) => {
				this.peer.setLocalDescription(sdp);
				this.socket.send({
					type: ChatWebSocketType.CHAT_PRIVATE_WEBRTC_OFFER,
					sdp: sdp.sdp,
					sender: this.sender,
					receiver: this.receiver,
				});
			});
	}

	async createAnswer(remoteSdp: any) {
		this.peer = this.buildPeer();

		this.peer.setRemoteDescription(
			new RTCSessionDescription({
				sdp: remoteSdp,
				type: 'offer',
			})
		);

		while (this.candidateQueue.length > 0) {
			this.peer.addIceCandidate(this.candidateQueue.shift());
		}

		this.localStream = new MediaStream();
		this.localStream.addTrack(
			(await getDeviceStream(DEVICE_TYPE.VIDEO_DEVICE)).getVideoTracks()[0]
		);
		this.localStream.addTrack(
			(await getDeviceStream(DEVICE_TYPE.AUDIO_DEVICE)).getAudioTracks()[0]
		);
		this.emit('LOCAL_STREAM_READY', this.localStream);
		for (const track of this.localStream.getTracks()) {
			this.peer.addTrack(track, this.localStream);
		}

		// NOTE: 加密
		if (this.useSecurity) {
			this.peer.getSenders().forEach((sender) => {
				setupSenderTransform(sender, this.security);
			});
		} else {
			this.peer
				.getTransceivers()
				.find((t) => t.sender.track?.kind === 'video')
				?.setCodecPreferences(senderCodecs);
		}

		this.peer
			.createAnswer({
				mandatory: {
					OfferToReceiveAudio: true,
					OfferToReceiveVideo: true,
				},
			})
			.then((sdp) => {
				this.peer.setLocalDescription(sdp);
				this.socket.send({
					type: ChatWebSocketType.CHAT_PRIVATE_WEBRTC_ANSWER,
					sdp: sdp.sdp,
					sender: this.sender,
					receiver: this.receiver,
				});
				store.dispatch(setCallStatus(CALL_STATUS_CALLING));
			});
	}

	async receiveAnswer(remoteSdp: any) {
		this.peer.setRemoteDescription(
			new RTCSessionDescription({
				sdp: remoteSdp,
				type: 'answer',
			})
		);
		store.dispatch(setCallStatus(CALL_STATUS_CALLING));
		this.emit('LOCAL_STREAM_READY', this.localStream);
	}

	handleCandidate(data: RTCIceCandidateInit) {
		this.candidateQueue = this.candidateQueue || new Array();
		if (data.candidate) {
			// NOTE: 需要等待 signalingState 变为 stable 才能添加候选者
			if (this.peer && this.peer.signalingState === 'stable') {
				this.peer.addIceCandidate(data);
			} else {
				this.candidateQueue.push(data);
			}
		}
	}

	hangUp() {
		this.callAudioPrompt[1]();
		this.socket.send({
			type: ChatWebSocketType.CHAT_PRIVATE_WEBRTC_DISCONNECT,
			sender: this.sender,
			receiver: this.receiver,
			target: store.getState().nowWebrtcFriendId,
		});
		this.offerModal = null;
		this.onEnded();
	}

	onHangUp(data: { sender: number; receiver: number }) {
		const { sender, receiver } = data;
		if (sender === this.sender && receiver === this.receiver) {
			if (this.answerModal) {
				this.answerAudioPrompt[1]();
				this.answerModal.destroy();
			}
			this.answerModal = null;
			this.onEnded();
		}
	}

	/**
	 * 创建 RTCPeer 连接
	 * @returns 创建后的 RTCPeer 连接
	 */
	private buildPeer(): RTCPeerConnection {
		const peer = new (RTCPeerConnection as any)({
			iceServers: [
				{
					urls: 'stun:stun.stunprotocol.org:3478',
				},
			],
			encodedInsertableStreams: this.useSecurity,
		}) as RTCPeerConnection;
		peer.onicecandidate = (evt) => {
			if (evt.candidate) {
				const message = {
					type: ChatWebSocketType.CHAT_PRIVATE_WEBRTC_CANDIDATE,
					candidate: evt.candidate.candidate,
					sdpMid: evt.candidate.sdpMid,
					sdpMLineIndex: evt.candidate.sdpMLineIndex,
					sender: this.sender,
					receiver: this.receiver,
					target: store.getState().nowWebrtcFriendId,
				};
				this.socket.send(message);
			}
		};
		peer.ontrack = (evt) => {
			// NOTE: 解密
			if (this.useSecurity) setupReceiverTransform(evt.receiver, this.security);
			else
				peer.getTransceivers()
					.find((t) => t.receiver.track.kind === 'video')
					?.setCodecPreferences(receiverCodecs);

			this.remoteStream = this.remoteStream || new MediaStream();
			this.remoteStream.addTrack(evt.track);
			if (this.remoteStream.getTracks().length === 2)
				this.emit('REMOTE_STREAM_READY', this.remoteStream);
		};

		// NOTE: 断连检测
		peer.oniceconnectionstatechange = () => {
			if (peer.iceConnectionState === 'disconnected') {
				this.emit('ICE_DISCONNECT');
			}
		};
		peer.onconnectionstatechange = () => {
			if (peer.connectionState === 'failed') {
				this.emit('RTC_CONNECTION_FAILED');
			}
		};
		return peer;
	}

	changeVideoTrack(newTrack: MediaStreamTrack) {
		if (this.localStream && this.peer) {
			const oldTrack = this.localStream.getVideoTracks()[0];
			this.localStream.removeTrack(oldTrack);
			this.localStream.addTrack(newTrack);
			this.peer
				.getSenders()
				.find((s) => s.track === oldTrack)
				?.replaceTrack(newTrack);
		}
	}

	/**
	 * 结束通话后清空数据
	 */
	onEnded() {
		this.sender = undefined;
		this.receiver = undefined;
		this.useSecurity = false;
		this.security = '[]';
		store.dispatch(setNowWebrtcFriendId(null));
		this.localStream = null;
		this.remoteStream = null;
		if (this.peer) this.peer.close();
		this.candidateQueue = new Array();
		store.dispatch(setCallStatus(CALL_STATUS_FREE));
	}
}
小栗帽今天吃什么
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java webrtc视频会议_JAVA webRtc的实现视频会议系统
weixin_42237496的博客
02-24 2323
这里实现的是1对1视频。多人博主也已经实现。我最初期的样式代码。webRtc整体结构是这样的。 发起端(sname) 向服务器发送 offer和icedata服务器接收到offer和icedata 向目标端(dname) 发送 (sname)的信息目标端(dname)接收到发起端(sname)的offer和icedata 将其绑定并且向发起端发送answer 和icedata这就是原理...
WebRTC 视频聊天Demo
qq_20992591的博客
08-01 894
WebRTC 视频聊天 前端视频聊天 浏览器视频聊天
个人写的一个小型聊天软件
06-01
NULL 博文链接：https://yangbobestone.iteye.com/blog/1039581
WebRTC 教程五：WebRTC搭建视频聊天室
m0_60259116的博客
06-08 1958
WebRTC 聊天室：总体演示WebRTC 视频聊天: 设计WebRTC 视频聊天
webrtc视频聊天室-webrtc直播推流
热门推荐
xiaomaomixj的博客
09-11 2万+
webrtc视频聊天室-webrtc直播推流-可用于毕业设计，支持多人视频通话，全员消息发送，私人消息发送，图片和视频的预览等等...
Vue中webSocket+webRtc实现多人会议，webRtc实现
Amiel_Tian的博客
01-26 1142
已经搭建好`websocket`双端通信（可以先模拟），用于实时交换双方信息。交换的信息也就是所谓的信令。实现`webRtc`进行多人会议，屏幕共享、摄像头共享。
基于WebRTC开源框架的实时视频聊天项目，搭建私人实时通信服务
Deng's Blog
02-02 6873
文章主要介绍了如何基于WebRTC开源框架搭建私人实时通信服务。
基于webrtc的音视频聊天，视频会议的实现
xqtt29的博客
11-06 1760
简介 WebRTC，名称源自网页即时通信（英语：Web Real-Time Communication）的缩写，是一个支持网页浏览器进行实时语音对话或视频对话的API。WebRTC提供了视频会议的核心技术，包括音视频的采集、编解码、网络传输、显示等功能，并且还支持跨平台：windows，linux，mac，android。 在WebRTC的API中，有三个核心知识点，分别为： 1. MediaStream：获取音频和视频流 2. RTCPeerConnection：音频和视频数据流 3. RTCDataC
WebRTC 教程四： WebRTC聊天室设计和搭建
m0_60259116的博客
06-07 1071
WebRTC 教程四： WebRTC聊天室设计和搭建
基于Springboot实现的多人视频在线会议服务器前端(webrtc项目)源码+使用说明.7z
12-18
基于Springboot实现的多人视频在线会议服务器前端(webrtc项目)源码+使用说明.7z 【多人视频在线会议-后端源码】https://download.csdn.net/download/DeepLearning_/87317683 视频会议的前端 使用webrtc实现图像传输...
python期末大作业-基于WebRTC的视频会议系统.zip
06-24
python期末大作业-基于WebRTC的视频会议系统。已经通过的高分项目。python期末大作业-基于WebRTC的视频会议系统。已经通过的高分项目。python期末大作业-基于WebRTC的视频会议系统。已经通过的高分项目。python期末...
基于webrtc的视频会议系统源码.zip
02-21
【资源说明】 1、该资源包括项目的全部源码，下载可以直接使用！ 2、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设...基于webrtc的视频会议系统源码.zip基于webrtc的视频会议系统源码.zip
浏览器视频聊天,多人视频聊天,webrtc,java
03-01
这个版本支持一对一聊天,多对多聊天,以及传送文件等功能, 源码地址:https://github.com/js1688/cat 会持续更新 成果展现地址:https://www.tanjun.xyz 也可以直接下载此文件,maven构建项目所以源码才几十KB而已 没用...
webrtc视频聊天
12-17
使用webrtc技术进行视频聊天，webstock进行凭证，用p2p进行视频聊天
使用WebRTC实现多人视频会议
liuxinzhi1982的专栏
07-19 1023
WebRTC实现多人视频会议
WebRTC音视频通话-WebRTC视频自定义RTCVideoCapturer相机
一名开发者
08-15 6621
WebRTC音视频通话-WebRTC视频自定义RTCVideoCapturer相机。主要获得相机采集的画面CVPixelBufferRef，将处理后的CVPixelBufferRef生成RTCVideoFrame，通过调用WebRTC的localVideoSource中实现的didCaptureVideoFrame方法
[Vue-常见错误]浏览器显示Uncaught runtime errors
一个喜欢什么都研究一下的小小后端程序员
06-09 321
在vue.config.js中配置关闭Uncaught runtime errors显示。
JS中一个dom元素能绑定多少事件
最新发布
ggq53219的博客
06-10 500
在JavaScript中，一个DOM元素可以绑定的事件数量并没有明确的限制，这主要取决于浏览器的实现和内存限制。然而，在实际应用中，为同一个DOM元素绑定过多的事件监听器可能会导致性能问题，尤其是在事件处理函数执行复杂操作的情况下。总之，虽然JavaScript中DOM元素可以绑定的事件数量没有明确的限制，但在实际应用中应注意避免过度绑定和优化事件处理函数，以确保良好的性能和用户体验。
webrtc 压测工具
07-28
WebRTC 压测工具是用于对WebRTC实时通信系统进行性能测试和负载测试的工具。WebRTC是一种开放的实时通信技术，它可以在Web浏览器中直接实现视频、音频和数据的实时传输。 WebRTC压测工具可用于评估系统在高负载情况下的性能表现、稳定性和可扩展性。它可以模拟大量用户同时进行实时通信，并收集关键指标的数据，如延迟、丢包率、带宽使用等。 压测工具通常包含以下功能： 1. 并发测试：能够模拟多个用户同时进行音视频通话、数据传输等操作，以测试系统在高并发场景下的性能。 2. 负载测试：能够模拟大量用户同时请求服务，测试系统的负载能力和稳定性。 3. 延迟测试：能够测量信令传输和媒体传输的延迟，评估系统的实时性能。 4. 丢包率测试：能够模拟网络质量较差的环境，检测系统在丢包情况下的表现。 5. 带宽测试：测试系统对带宽的使用情况，评估通信质量和视频流畅度。 6. 报表和分析：提供详细的测试报告和分析数据，帮助开发人员优化系统性能和解决潜在问题。 总之，WebRTC压测工具是评估实时通信系统性能的重要工具，可以帮助开发人员测试系统在不同负载情况下的表现并进行优化，保证用户在实时通信中获得良好体验。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小栗帽今天吃什么

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值