WebRTC API
==========

**WebRTC** (Web Real-Time Communications) é uma tecnologia que permite aplicativos e sites da Web a capturarem e opcionalmente transmitirem mídia de áudio e/ou vídeo, assim como trocar informação arbitrária entre navegadores sem a necessidade de um intermediador. O conjunto de padrões que abrangem WebRTC possibilita o compartilhamento de informação e a realização de teleconferência peer-to-peer, dispensando a instalação de *plug-ins* ou quaisquer softwares de terceiros.

WebRTC consiste em diversas APIs e protocolos interrelacionados que trabalham juntos. A documentação que você encontrará aqui o ajudará a entender os fundamentos de WebRTC, como configurar e usar, tanto informação, quanto conexões de mídia e mais.

Conceitos e uso
---------------

WebRTC serve à diversas propostas; junto com a Media Capture and Streams API (en-US), eles fornecem poder multimídia para a Web, incluindo suporte para áudio e vídeo conferência, troca de arquivos, compartilhamento de tela, gerenciamento de identidade e interface com sistemas telefônicos legados, incluindo suporte para envio de sinais DTMF (en-US) (touch-tone dialing). As conexões entre pares podem ser feitas sem a necessidade de drivers ou plug-ins especiais e, muitas vezes, sem servidores intermediários.

As conexões entre dois pares são representadas pela interface `RTCPeerConnection` (en-US). Uma vez que uma conexão foi estabelecida e aberta usando `RTCPeerConnection`, *streams* de mídia (`MediaStream` (en-US)s) e/ou canais de dados (`RTCDataChannel`s) podem ser adicionados à conexão.

Dados de mídia podem consistir em qualquer número de *tracks*(faixas) de dados de mídia; *tracks*, que são representados por objetos baseados na interface `MediaStreamTrack` (en-US) , que podem conter um número dentre tipos de dados de mídia, incluíndo áudio, vídeo e texto (como legendas ou até mesmo nomes de capítulos). A maioria das transmissões consiste de ao menos uma faixa de áudio e comumente também uma faixa de vídeo, e podem ser usadas para enviar e receber ambas as mídias ao vivo ou dados salvos de mídia (como um filme transmitido).

Você também pode usar a conexão entre dois *peers* para trocar dados arbitrários binários usando a interface `RTCDataChannel`. Isto pode ser usado para informação de *back-channel* (canal de volta), troca de *metadata*, pacotes de *status* de games, transferência de arquivos, ou até mesmo como um canal primário para transferir dados.

### Interoperabilidade

O WebRTC é geralmente bem suportado em navegadores modernos, mas algumas incompatibilidades permanecem. A biblioteca adapter.js é um calço para isolar aplicativos dessas incompatibilidades.

Referência WebRTC
-----------------

WebRTC provê interfaces que trabalham em conjunto para realizar uma variedade de tarefas, nós dividimos as interfaces na listagem abaixo por categoria. Por favor, atente-se a sidebar para uma listagem em ordem alfabética.

### Configuração e gerenciamento e conexão

Essas interfaces, dicionários e tipos são usados para configurar, abrir e gerenciar conexões WebRTC. Estão inclusas as interfaces que representam conexões de mídia de mesmo nível, canais de dados e interfaces usadas ao trocar informações sobre as capacidades de cada par para selecionar a melhor configuração possível para uma conexão de mídia bidirecional.

#### Interfaces

`RTCPeerConnection` (en-US)

Representa uma conexão WebRTC entre o computador local e um ponto remoto. Ele é usado para lidar com o streaming eficiente de dados entre os dois pares.

`RTCDataChannel`

Representa um canal de dados bidirecional entre dois pares de uma conexão.

`RTCDataChannelEvent` (en-US)

Representa eventos que ocorrem ao anexar um `RTCDataChannel` a um `RTCPeerConnection` (en-US). O único evento enviado com esta interface é `datachannel` (en-US).

`RTCSessionDescription` (en-US)

Representa os parâmetros de uma sessão. Cada `RTCSessionDescription` consiste em uma descrição `type` (en-US) indicando qual parte do processo de negociação de oferta/resposta ela descreve e do descritor SDP da sessão.

`RTCStatsReport` (en-US)

Fornece estatísticas detalhadas de informações para uma conexão ou para uma *track* individual na conexão; o relatório pode ser obtido chamando `RTCPeerConnection.getStats()` (en-US). Detalhes sobre o uso de estatísticas WebRTC podem ser encontrados em WebRTC Statistics API.

`RTCIceCandidate` (en-US)

Representa um servidor *Interactive Connectivity Establishment* (Estabelecimento de Conectividade Interativa) candidato (ICE (en-US)) para estabelecer um `RTCPeerConnection` (en-US).

`RTCIceTransport`

Representa informações sobre um transporte ICE (en-US).

`RTCPeerConnectionIceEvent` (en-US)

Representa eventos que ocorrem em relação aos candidatos ICE com o destino, geralmente um `RTCPeerConnection` (en-US). Apenas um evento é deste tipo: `icecandidate` (en-US).

`RTCRtpSender` (en-US)

Gerencia a codificação e a transmissão de dados para um `MediaStreamTrack` (en-US) em um `RTCPeerConnection` (en-US).

`RTCRtpReceiver` (en-US)

Gerencia a recepção e decodificação de dados para um `MediaStreamTrack` (en-US) em um `RTCPeerConnection` (en-US).

`RTCTrackEvent` (en-US)

A interface usada para representar um evento `track` (en-US), que indica que um objeto `RTCRtpReceiver` (en-US) foi adicionado ao `RTCPeerConnection` (en-US), indicando que um novo `MediaStreamTrack` (en-US) de entrada foi criado e adicionado ao `RTCPeerConnection`.

`RTCSctpTransport` (en-US)

Fornece informações que descrevem um transporte de *Stream Control Transmission Protocol ou **SCTP (en-US)*** (Protocolo de Transmissão de Controle de Fluxo) e também fornece uma maneira de acessar a segurança da *Datagram Transport Layer Security ou **DTLS (en-US)*** (Camada de Transporte de Datagrama Subjacente) através do qual os pacotes SCTP para todos os canais de dados de uma `RTCPeerConnection` (en-US) são enviados e recebidos.

#### Dicionários

`RTCIceServer` (en-US)

Define como se conectar a um único servidor ICE (en-US) (como um servidor STUN (en-US) ou TURN (en-US)).

`RTCRtpContributingSource` (en-US)

Contém informações sobre uma determinada *fonte de contribuição (CSRC)*, incluindo a hora mais recente em que um pacote para o qual a fonte contribuiu foi reproduzido.

#### Eventos

`bufferedamountlow` (en-US)

A quantidade de dados atualmente armazenados em buffer pelo canal de dados — conforme indicado por sua propriedade `bufferedAmount` (en-US) — diminuiu para ficar igual ou inferior ao tamanho mínimo de dados em buffer do canal, conforme especificado por `bufferedAmountLowThreshold` (en-US).

`close` (en-US)

O canal de dados concluiu o processo de fechamento e agora está no estado 'fechado'. Seu transporte de dados subjacente está completamente fechado neste ponto. Você pode ser notificado *antes* do fechamento, observando o evento `closing`.

`closing` (en-US)

O `RTCDataChannel` fez a transição para o estado `closing`, indicando que será fechado em breve. Você pode detectar a conclusão do processo de fechamento observando o evento `close`.

`connectionstatechange` (en-US)

O estado da conexão foi alterado, pode ser acessada em `connectionState`.

`datachannel` (en-US)

Um novo `RTCDataChannel` está disponível após o peer remoto abrir um novo canal de dados. O tipo deste evento é `RTCDataChannelEvent` (en-US).

`error` (en-US)

Um `RTCErrorEvent` (en-US) indicando que ocorreu um erro no canal de dados.

`error` (en-US)

Um `RTCErrorEvent` (en-US) indicando que ocorreu um erro no `RTCDtlsTransport` (en-US). Este erro será `dtls-failure` ou `fingerprint-failure`.

`gatheringstatechange` (en-US)

O estado de coleta do `RTCIceTransport` mudou.

`icecandidate` (en-US)

Um `RTCPeerConnectionIceEvent` (en-US) que é enviado sempre que o dispositivo local identifica um novo candidato ICE que precisa ser adicionado ao par local chamando `setLocalDescription()` (en-US).

`icecandidateerror` (en-US)

Um `RTCPeerConnectionIceErrorEvent` (en-US) indicando que ocorreu um erro durante a coleta de candidatos ICE.

`iceconnectionstatechange` (en-US)

Enviado para um `RTCPeerConnection` (en-US) quando o estado de sua conexão ICE - encontrado na propriedade `iceconnectionstate` (en-US) - muda.

`icegatheringstatechange` (en-US)

Enviado para um `RTCPeerConnection` (en-US) quando seu estado de coleta de ICE - encontrado na propriedade `icegatheringstate` (en-US) - muda.

`message` (en-US)

Uma mensagem foi recebida no canal de dados. O evento é do tipo `MessageEvent` (en-US).

`negotiationneeded` (en-US)

Informa ao `RTCPeerConnection` que ele precisa realizar negociação de sessão chamando `createOffer()` (en-US) seguido por `setLocalDescription()` (en-US).

`open` (en-US)

O transporte de dados subjacente para o `RTCDataChannel` foi aberto ou reaberto com sucesso.

`selectedcandidatepairchange` (en-US)

O par atualmente selecionado de candidatos ICE foi alterado para o `RTCIceTransport` no qual o evento é disparado.

`track` (en-US)

O evento `track`, do tipo `RTCTrackevent` (en-US) é enviado para um `RTCPeerConnection` (en-US) quando uma nova trilha é adicionada à conexão após a negociação bem-sucedida da mídia transmissão.

`signalingstatechange` (en-US)

Enviado para a conexão de mesmo nível quando seu `signalingstate` (en-US) foi alterado. Isso acontece como resultado de uma chamada para `setLocalDescription()` (en-US) ou `setRemoteDescription()` (en-US).

`statechange`

O estado do `RTCDtlsTransport` mudou.

`statechange` (en-US)

O estado do `RTCIceTransport` mudou.

`statechange` (en-US)

O estado do `RTCSctpTransport` mudou.

#### Tipos

`RTCSctpTransport.state` (en-US)

Indica o estado de uma instância `RTCSctpTransport` (en-US).

### Identidade e segurança

A API WebRTC inclui várias interfaces para gerenciar segurança e identidade.

`RTCIdentityProvider`

Permite que um agente de usuário possa solicitar que uma declaração de identidade seja gerada ou validada.

`RTCIdentityAssertion` (en-US)

Representa a identidade de um ponto remoto da conexão atual. Se nenhum par ainda foi definido e verificado, esta interface retorna `null`. Uma vez definido, não pode ser alterado.

`RTCIdentityProviderRegistrar`

Registra um provedor de identidade (idP).

`RTCCertificate`

Representa um certificado que um `RTCPeerConnection` (en-US) usa para autenticar.

### Telefonia

Essas interfaces e eventos estão relacionadas à interatividade com redes telefônicas públicas comutadas (PTSNs) Elas são primariamente usadas para enviar sons de discagem por tom - ou pacotes que representam esses tons - pela rede para um par remoto.

#### Interfaces

`RTCDTMFSender` (en-US)

Gerencia a codificação e a transmissão da sinalização de multifrequência de tom duplo (DTMF (en-US)) para um `RTCPeerConnection` (en-US).

`RTCDTMFToneChangeEvent` (en-US)

Usado pelo evento `tonechange` (en-US) para indicar que um tom DTMF começou ou terminou. Este evento não propaga "bolhas" (exceto onde indicado de outra forma) e não é cancelável (exceto onde indicado de outra forma).

#### Eventos

`tonechange` (en-US)

Um novo tom DTMF (en-US) começou a tocar na conexão, ou o último tom no `toneBuffer` (en-US) do `RTCDTMFSender` foi enviado e o buffer agora está vazio. O tipo do evento é `RTCDTMFToneChangeEvent` (en-US).

Guias
-----

Introdução aos protocolos WebRTC

Este artigo apresenta os protocolos sobre os quais a API WebRTC é construída.

Conectividade WebRTC (en-US)

Um guia de como as conexões WebRTC funcionam e como os vários protocolos e interfaces podem ser usados ​​juntos para criar aplicativos de comunicação poderosos.

Vida útil de uma sessão WebRTC (en-US)

WebRTC permite criar comunicação *peer-to-peer* de dados arbitrários, áudio ou vídeo — ou qualquer combinação deles — em um aplicativo de navegador. Neste artigo, veremos o tempo de vida de uma sessão WebRTC, desde o estabelecimento da conexão até o fechamento da conexão quando ela não for mais necessária.

Estabelecendo uma conexão: O padrão de negociação perfeito (en-US)

**Negociação perfeita** é um padrão de design recomendado para o seu processo de sinalização, que fornece transparência na negociação enquanto permite que ambos os lados sejam o *`offerer`* (ofertante) ou o *`answerer`* (respondente), sem necessidade de muito código para diferenciar os dois.

Sinalização e chamada de vídeo bidirecional (en-US)

Um tutorial e exemplo que transforma um sistema de chat baseado em WebSocket criado para um exemplo anterior e adiciona suporte para abertura de chamadas de vídeo entre os participantes. A conexão WebSocket do servidor de bate-papo é usada para sinalização WebRTC.

Codecs usados ​​pelo WebRTC (en-US)

Um guia para os codecs que o WebRTC exige que os navegadores suportem, bem como os opcionais suportados por vários navegadores populares. Está incluído um guia para ajudá-lo a escolher os melhores codecs para suas necessidades.

Usando canais de dados WebRTC (en-US)

Este guia aborda como você pode usar uma conexão de mesmo nível e um `RTCDataChannel` associado para trocar dados arbitrários entre dois pares.

Usando DTMF com WebRTC (en-US)

O suporte do WebRTC para interagir com gateways que se conectam a sistemas telefônicos antigos inclui suporte para enviar tons DTMF usando a interface `RTCDTMFSender` (en-US). Este guia mostra como fazer isso.

Tutoriais
---------

Melhorando a compatibilidade usando o adaptador WebRTC.js (en-US)

A organização WebRTC fornece no GitHub o adaptador WebRTC para solucionar problemas de compatibilidade em implementações WebRTC de diferentes navegadores. O adaptador é um shim JavaScript que permite que seu código seja escrito de acordo com a especificação para que "simplesmente funcione" em todos os navegadores com suporte a WebRTC.

Uma simples amostra de RTCDataChannel

A interface `RTCDataChannel` é um recurso que permite abrir um canal entre dois pares através do qual você pode enviar e receber dados arbitrários. A API é intencionalmente semelhante à API WebSocket, para que o mesmo modelo de programação possa ser usado para cada uma.

Construindo um telefone conectado à Internet com Peer.js (en-US)

Este tutorial é um guia passo a passo sobre como construir um telefone usando Peer.js

Especificações
--------------

| Specification |
| --- |
| WebRTC: Real-Time Communication in Browsers  |
| Media Capture and Streams  |
| Media Capture from DOM Elements  |

### Protocolos adequados para WebRTC

* Negociação de protocolo de camada de aplicativo para comunicações em tempo real na Web (en-US)
* Requisitos de processamento e codec de áudio WebRTC (en-US)
* Canais de dados RTCWeb (en-US)
* Protocolo de Canal de Dados RTCWeb (en-US)
* Comunicação Web em Tempo Real (WebRTC): Transporte de Mídia e Uso de RTP (en-US)
* Arquitetura de segurança WebRTC (en-US)
* Transportes para RTCWEB (en-US)
### Protocolos de suporte relacionados

* Estabelecimento de Conectividade Interativa (ICE): Um Protocolo para Tradutor de Endereço de Rede (NAT) Traversal para Protocolo de Oferta/Resposta (en-US)
* Utilitários de travessia de sessão para NAT (STUN) (en-US)
* Esquema de URI para o protocolo Session Traversal Utilities for NAT (STUN) (en-US)
* Traversal Using Relays around NAT (TURN) Uniform Resource Identifiers (en-US)
* Um modelo de oferta/resposta com protocolo de descrição de sessão (SDP) (en-US)
* Session Traversal Utilities for NAT (STUN) Extension for Third Party Authorization (en-US)
Veja também
-----------

* `MediaDevices`
* `MediaStreamEvent` (en-US)
* `MediaStreamTrack` (en-US)
* `MessageEvent` (en-US)
* `MediaStream` (en-US)
* API de captura de mídia e fluxos (en-US)
* Firefox multistream e renegociação para Jitsi Videobridge (en-US)
* Peering através do WebRTC Fog com SocketPeer (en-US)
* Inside the Party Bus: Construindo um aplicativo da Web com vários fluxos de vídeo ao vivo + gráficos interativos (en-US)
* Tecnologias de mídia da Web (en-US)
* API de estatísticas WebRTC