Introduction à WebRTC-js tutoriel-php.cn

Introduction à WebRTC

PHPz

Libérer： 2024-09-04 07:00:36

original

244 Les gens l'ont consulté

Introduction to WebRTC

Guide d'installation et de codage

WebRTC (Web Real-Time Communication) est une technologie open source qui permet une communication en temps réel via de simples API dans les navigateurs Web et les applications mobiles. Il permet le partage d'audio, de vidéo et de données directement entre pairs sans avoir besoin d'un serveur intermédiaire, ce qui le rend parfait pour des applications telles que la vidéoconférence, la diffusion en direct et le partage de fichiers.

Dans ce blog, nous aborderons les sujets suivants :

Qu'est-ce que WebRTC ?
Principales fonctionnalités de WebRTC
Installation de WebRTC
Créer une application WebRTC de base
Comprendre le code
Conclusion

Qu’est-ce que WebRTC ?

WebRTC est un ensemble de normes et de protocoles qui permettent la communication audio, vidéo et de données en temps réel entre les navigateurs Web. Il comprend plusieurs éléments clés :

getUserMedia : capture les flux audio et vidéo de l'appareil de l'utilisateur.
RTCPeerConnection : gère la connexion peer-to-peer et gère le streaming audio et vidéo.
RTCDataChannel : permet le transfert de données en temps réel entre pairs.

Principales fonctionnalités de WebRTC

Communication en temps réel : communication à faible latence avec un délai minimal.
Compatibilité des navigateurs : pris en charge par la plupart des navigateurs Web modernes (Chrome, Firefox, Safari, Edge).
Aucun plugin requis : fonctionne directement dans le navigateur sans plugins ni logiciels supplémentaires.
Sécurisé : utilise le cryptage pour une communication sécurisée.

Installation de WebRTC

WebRTC est une technologie côté client et ne nécessite pas d'installation de serveur spécifique. Cependant, vous aurez besoin d'un serveur Web pour servir vos fichiers HTML et JavaScript. Pour le développement local, vous pouvez utiliser un simple serveur HTTP.

Conditions préalables

Node.js : Pour mettre en place un serveur local.
Un navigateur Web moderne : Chrome, Firefox, Safari ou Edge.

Configuration d'un serveur local

Installer Node.js : Téléchargez et installez Node.js depuis nodejs.org.
Créer un répertoire de projet : ouvrez un terminal et créez un nouveau répertoire pour votre projet.
```
mkdir webrtc-project
cd webrtc-project
```
Copier après la connexion
Initialiser un projet Node.js :
```
npm init -y
```
Copier après la connexion
Installer le serveur HTTP :
```
npm install --save http-server
```
Copier après la connexion
Créez vos fichiers de projet :
- index.html
- main.js

Créez un fichier index.html avec le contenu suivant :

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>WebRTC Example</title>
</head>
<body>
    <h1>WebRTC Example</h1>
    <video id="localVideo" autoplay muted></video>
    <video id="remoteVideo" autoplay></video>
    <script src="main.js"></script>
</body>
</html>
```

Copier après la connexion

Création d'une application WebRTC de base

Nous allons créer une simple application d'appel vidéo peer-to-peer. Cet exemple utilisera deux onglets de navigateur pour simuler la connexion homologue.

Explication du code

Capturer une vidéo locale : utilisez getUserMedia pour capturer une vidéo de la caméra de l'utilisateur.
Créer une connexion homologue : établissez une connexion homologue entre les homologues locaux et distants.
Offre d'échange et réponse : utilisez SDP (Session Description Protocol) pour échanger les détails de connexion.
Gérer les candidats ICE : échangez des candidats ICE pour établir la connexion.

Créez un fichier main.js avec le contenu suivant :

const localVideo = document.getElementById('localVideo');
const remoteVideo = document.getElementById('remoteVideo');

let localStream;
let peerConnection;
const serverConfig = { iceServers: [{ urls: 'stun:stun.l.google.com:19302' }] };
const constraints = { video: true, audio: true };

// Get local video stream
navigator.mediaDevices.getUserMedia(constraints)
    .then(stream => {
        localStream = stream;
        localVideo.srcObject = stream;
        setupPeerConnection();
    })
    .catch(error => {
        console.error('Error accessing media devices.', error);
    });

function setupPeerConnection() {
    peerConnection = new RTCPeerConnection(serverConfig);

    // Add local stream to the peer connection
    localStream.getTracks().forEach(track => peerConnection.addTrack(track, localStream));

    // Handle remote stream
    peerConnection.ontrack = event => {
        remoteVideo.srcObject = event.streams[0];
    };

    // Handle ICE candidates
    peerConnection.onicecandidate = event => {
        if (event.candidate) {
            sendSignal({ 'ice': event.candidate });
        }
    };

    // Create an offer and set local description
    peerConnection.createOffer()
        .then(offer => {
            return peerConnection.setLocalDescription(offer);
        })
        .then(() => {
            sendSignal({ 'offer': peerConnection.localDescription });
        })
        .catch(error => {
            console.error('Error creating an offer.', error);
        });
}

// Handle signals (for demo purposes, this should be replaced with a signaling server)
function sendSignal(signal) {
    console.log('Sending signal:', signal);
    // Here you would send the signal to the other peer (e.g., via WebSocket)
}

function receiveSignal(signal) {
    if (signal.offer) {
        peerConnection.setRemoteDescription(new RTCSessionDescription(signal.offer))
            .then(() => peerConnection.createAnswer())
            .then(answer => peerConnection.setLocalDescription(answer))
            .then(() => sendSignal({ 'answer': peerConnection.localDescription }));
    } else if (signal.answer) {
        peerConnection.setRemoteDescription(new RTCSessionDescription(signal.answer));
    } else if (signal.ice) {
        peerConnection.addIceCandidate(new RTCIceCandidate(signal.ice));
    }
}

// Simulate receiving a signal from another peer
// This would typically be handled by a signaling server
setTimeout(() => {
    receiveSignal({
        offer: {
            type: 'offer',
            sdp: '...' // SDP offer from the other peer
        }
    });
}, 1000);

Copier après la connexion

Comprendre le code

Capture multimédia : navigator.mediaDevices.getUserMedia capture le flux vidéo local.
Configuration de la connexion homologue : RTCPeerConnection gère la connexion homologue.
Offre et réponse : les offres et réponses SDP sont utilisées pour négocier la connexion.
Candidats ICE : les candidats ICE sont utilisés pour établir une connectivité entre pairs.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!