Google berkomitmen untuk memajukan ekuitas ras bagi masyarakat Hitam. Lihat bagaimana.
Halaman ini diterjemahkan oleh Cloud Translation API.
Switch to English

Memulai dengan koneksi peer

koneksi peer adalah bagian dari spesifikasi WebRTC yang berhubungan dengan menghubungkan dua aplikasi pada komputer yang berbeda untuk berkomunikasi menggunakan protokol peer-to-peer. Komunikasi antara rekan-rekan dapat video, data biner audio atau sewenang-wenang (untuk klien mendukung RTCDataChannel API). Dalam rangka untuk menemukan bagaimana dua rekan-rekan dapat terhubung, baik klien perlu menyediakan konfigurasi ICE Server. Ini adalah baik STUN atau MENGHIDUPKAN-server, dan peran mereka adalah untuk memberikan calon ICE untuk setiap klien yang kemudian ditransfer ke rekan jauh. Ini mentransfer calon ICE yang biasa disebut signaling.

pemberian isyarat

The WebRTC spesifikasi termasuk API untuk berkomunikasi dengan ICE (Internet Connectivity Pendirian) Server, tetapi komponen signaling bukan bagian dari itu. Signaling diperlukan agar dua rekan-rekan untuk berbagi bagaimana mereka harus terhubung. Biasanya ini diselesaikan melalui berbasis HTTP biasa Web API (yaitu, layanan REST atau mekanisme RPC lainnya) di mana aplikasi web dapat menyampaikan informasi yang diperlukan sebelum sambungan rekan dimulai.

Kode tindak potongan menunjukkan bagaimana layanan sinyal fiktif ini dapat digunakan untuk mengirim dan menerima pesan asynchronous. Ini akan menjadi digunakan pada contoh yang tersisa dalam panduan ini di mana diperlukan.

 // Set up an asynchronous communication channel that will be
// used during the peer connection setup
const signalingChannel = new SignalingChannel(remoteClientId);
signalingChannel.addEventListener('message', message => {
    // New message from remote client received
});

// Send an asynchronous message to the remote client
signalingChannel.send('Hello!');
 

Sinyal dapat diimplementasikan dalam berbagai cara, dan spesifikasi WebRTC tidak memilih solusi tertentu.

Memulai koneksi peer

Setiap koneksi rekan ditangani oleh RTCPeerConnection objek. Konstruktor untuk kelas ini mengambil satu RTCConfiguration objek sebagai parameter. Objek ini mendefinisikan bagaimana koneksi rekan diatur dan harus berisi informasi tentang server ICE untuk digunakan.

Setelah RTCPeerConnection dibuat kita perlu membuat sebuah tawaran SDP atau jawaban, tergantung pada apakah kita yang menelepon rekan atau menerima rekan. Setelah tawaran SDP atau jawaban dibuat, harus dikirim ke rekan jauh melalui saluran yang berbeda. Melewati SDP objek untuk rekan-rekan jauh disebut sinyal dan tidak tercakup oleh spesifikasi WebRTC.

Untuk memulai setup koneksi rekan dari sisi memanggil, kita membuat RTCPeerConnection objek dan kemudian memanggil createOffer() untuk membuat RTCSessionDescription objek. Deskripsi sesi ini ditetapkan sebagai deskripsi lokal menggunakan setLocalDescription() dan kemudian dikirim melalui saluran signaling kami ke sisi penerima. Kami juga menyiapkan pendengar ke saluran signaling kami ketika jawaban deskripsi sesi Ditawarkan kami diterima dari sisi penerima.

 async function makeCall() {
    const configuration = {'iceServers': [{'urls': 'stun:stun.l.google.com:19302'}]}
    const peerConnection = new RTCPeerConnection(configuration);
    signalingChannel.addEventListener('message', async message => {
        if (message.answer) {
            const remoteDesc = new RTCSessionDescription(message.answer);
            await peerConnection.setRemoteDescription(remoteDesc);
        }
    });
    const offer = await peerConnection.createOffer();
    await peerConnection.setLocalDescription(offer);
    signalingChannel.send({'offer': offer});
}
 

Di sisi menerima, kita tunggu tawaran yang masuk sebelum kita membuat kita RTCPeerConnection misalnya. Setelah selesai kita menetapkan tawaran yang diterima menggunakan setRemoteDescription() . Berikutnya, kita sebut createAnswer() untuk membuat jawaban dengan tawaran yang diterima. Jawaban ini ditetapkan sebagai deskripsi lokal menggunakan setLocalDescription() dan kemudian dikirim ke sisi memanggil atas server signaling kami.

 const peerConnection = new RTCPeerConnection(configuration);
signalingChannel.addEventListener('message', async message => {
    if (message.offer) {
        peerConnection.setRemoteDescription(new RTCSessionDescription(message.offer));
        const answer = await peerConnection.createAnswer();
        await peerConnection.setLocalDescription(answer);
        signalingChannel.send({'answer': answer});
    }
});
 

Setelah dua rekan-rekan telah menetapkan kedua deskripsi sesi lokal dan remote mereka tahu kemampuan remote peer. Ini tidak berarti bahwa hubungan antara rekan-rekan siap. Untuk bekerja kita perlu mengumpulkan calon ICE pada setiap rekan dan mentransfer (melalui saluran signaling) ke rekan lainnya.

calon ICE

Sebelum dua rekan dapat communitcate menggunakan WebRTC, mereka perlu informasi konektivitas pertukaran. Karena kondisi jaringan dapat bervariasi dependning pada sejumlah faktor, layanan eksternal biasanya digunakan untuk menemukan kandidat yang mungkin untuk menghubungkan ke rekan. Layanan ini disebut ICE dan baik menggunakan STUN atau server MENGHIDUPKAN. STUN singkatan Sesi Traversal Utilitas untuk NAT, dan biasanya digunakan secara tidak langsung dalam sebagian besar aplikasi WebRTC.

MENGHIDUPKAN (Traversal Menggunakan Relay NAT) adalah solusi yang lebih canggih yang menggabungkan protokol STUN dan sebagian besar layanan berbasis WebRTC komersial menggunakan server MENGHIDUPKAN untuk membangun koneksi antara rekan-rekan. The WebRTC API mendukung STUN dan MENGHIDUPKAN langsung, dan itu dikumpulkan di bawah istilah yang lebih lengkap Konektivitas Internet Pendirian. Ketika membuat koneksi WebRTC, kita biasanya memberikan satu atau beberapa server ICE dalam konfigurasi untuk RTCPeerConnection objek.

Trickle ICE

Setelah RTCPeerConnection objek dibuat, kerangka dasar menggunakan server ICE yang disediakan untuk mengumpulkan calon konektivitas pembentukan (calon ICE). Acara icegatheringstatechange di RTCPeerConnection sinyal dalam apa negara pengumpulan ICE adalah ( new , gathering atau complete ).

Meskipun dimungkinkan untuk rekan menunggu sampai pertemuan ICE selesai, biasanya jauh lebih efisien untuk menggunakan teknik "tetesan es" dan mengirimkan masing-masing calon ICE ke rekan jauh karena mendapat ditemukan. Hal ini secara signifikan akan mengurangi waktu setup untuk konektivitas rekan dan memungkinkan panggilan video untuk memulai dengan kurang penundaan.

Untuk mengumpulkan calon ICE, cukup tambahkan pendengar untuk icecandidate acara. The RTCPeerConnectionIceEvent dipancarkan pada pendengar yang akan berisi candidate properti yang mewakili calon baru yang harus dikirim ke remote peer (Lihat Signaling).

 // Listen for local ICE candidates on the local RTCPeerConnection
peerConnection.addEventListener('icecandidate', event => {
    if (event.candidate) {
        signalingChannel.send({'new-ice-candidate': event.candidate});
    }
});

// Listen for remote ICE candidates and add them to the local RTCPeerConnection
signalingChannel.addEventListener('message', async message => {
    if (message.iceCandidate) {
        try {
            await peerConnection.addIceCandidate(message.iceCandidate);
        } catch (e) {
            console.error('Error adding received ice candidate', e);
        }
    }
});
 

koneksi didirikan

Setelah calon ICE sedang diterima, kita harus mengharapkan negara untuk koneksi rekan kami akhirnya akan berubah ke keadaan terhubung. Untuk mendeteksi ini, kita menambahkan pendengar untuk kami RTCPeerConnection mana kita mendengarkan connectionstatechange acara.

 // Listen for connectionstatechange on the local RTCPeerConnection
peerConnection.addEventListener('connectionstatechange', event => {
    if (peerConnection.connectionState === 'connected') {
        // Peers connected!
    }
});
 

RTCPeerConnection dokumentasi API