Configurar um cliente Android básico

Este tutorial irá guiá-lo pelas etapas de configuração de um cliente Android básico que utiliza a Video API da Vonage.

Visão geral

Todas as aplicações que utilizam a Video API da Vonage exigem tanto um cliente e um servidor componente. O código do lado do cliente é o que é carregado no dispositivo do usuário final (celular, computador) e lida com a maior parte das funcionalidades do OpenTok, incluindo conectando para o sessão, publicação áudio e vídeo correntes para a sessão, e assinando para os fluxos de outros clientes. Para obter mais informações sobre clientes, servidores e sessões, consulte Noções básicas sobre a Video API.

Neste tutorial, você utilizará o SDK do OpenTok para Android, a biblioteca do lado do cliente da OpenTok para dispositivos Android, para criar de forma rápida e fácil um aplicativo de vídeo interativo em tempo real.

Aqui estão os tópicos que serão abordados neste tutorial:

Tempo estimado de conclusão: 25 minutos

Quer pular este tutorial? Você pode acessar o código completo do cliente Android no Básico-Bate-Papo-por-Vídeo-em-Java pasta da nossa Repositório de aplicativos de exemplo para Android no GitHub. O repositório inclui um arquivo README com documentação sobre como executar e explorar o código. Além disso, este tutorial aborda a versão em Java do aplicativo de exemplo do Android. Para uma versão em Kotlin com documentação, consulte o Repositório de aplicativos de exemplo para Android.

Requisitos

Para concluir este tutorial, você precisará de:

Etapa 1: Criação de um novo projeto

  1. Abra o Android Studio e selecione Novo projeto do Arquivo menu.

  2. Defina o SDK mínimo do aplicativo como API 16 (Android 4.1, Jelly Bean).

  3. Siga as etapas do assistente, certificando-se de que Atividade vazia está selecionado. Deixe o Nome da atividade definir como MainActivity, e deixe o Nome do layout definir como activity_main.

Etapa 2: Adicionando o SDK do OpenTok para Android

O aplicativo usa o Maven para carregar o SDK do OpenTok para Android:

  1. Edite o arquivo build.gradle do seu projeto (na raiz do projeto) e adicione o seguinte trecho de código ao allprojects/repositories seção:

    mavenCentral()

    Neste momento, o arquivo build.gradle deve estar assim:

    buildscript { repositories { google() jcenter() } dependencies { classpath 'com.android.tools.build:gradle:4.1.2' // NOTE: Do not place your application dependencies here; they belong // in the individual module build.gradle files } } allprojects { repositories { google() jcenter() mavenCentral() } } task clean(type: Delete) { delete rootProject.buildDir }

  2. Modifique o arquivo build.gradle do seu módulo (o arquivo app/build.gradle) e adicione o seguinte trecho de código à seção de dependências:

    implementation 'com.opentok.android:opentok-android-sdk:2.22.0'

    Ao usar o OpenTok para Android versão 2.16.0 ou superior, você precisará adicionar o seguinte ao android seção do arquivo build.gradle do aplicativo também:

    compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 }

    Neste momento, o arquivo build.gradle do seu módulo deve estar assim:

    apply plugin: 'com.android.application' android { compileSdkVersion 32 defaultConfig { applicationId "com.example.myapplication" minSdkVersion 16 targetSdkVersion 32 versionCode 1 versionName "1.0" testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" } buildTypes { release { minifyEnabled false proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' } } } dependencies { implementation fileTree(dir: 'libs', include: ['*.jar']) implementation 'androidx.appcompat:appcompat:1.0.2' implementation 'androidx.constraintlayout:constraintlayout:1.1.3' implementation 'androidx.annotation:annotation:1.1.0' implementation 'com.opentok.android:opentok-android-sdk:2.22.2' testImplementation 'junit:junit:4.12' androidTestImplementation 'androidx.test:runner:1.2.0' androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0' }

  3. Sincronize seu projeto.

Etapa 3: Configuração da autenticação

Para se conectar a uma sessão do OpenTok, o cliente precisará ter acesso a algumas credenciais de autenticação — um Chave de API, ID da sessão, e token. Em um aplicativo de produção, essas credenciais devem ser geradas por um servidor, mas, para agilizar o processo, vamos simplesmente definir os valores manualmente por enquanto:

  1. Crie o OpenTokConfig classe (Arquivo | Novo | Classe Java), adicione algumas variáveis estáticas para armazenar a chave da API, o ID da sessão e o token. Também adicionaremos algumas constantes para o identificador da mensagem de log e as permissões:

    public class OpenTokConfig { public static final String API_KEY = ""; public static final String SESSION_ID = ""; public static final String TOKEN = ""; }

  2. Ajuste o código definindo os valores de forma estática para o API_KEY, SESSION_ID e TOKEN.

    Para fazer isso, faça login na sua Account da Video API, crie um novo projeto da API do OpenTok ou use um projeto existente da API do OpenTok; em seguida, acesse a página do seu projeto e role a tela para baixo até a Ferramentas do projeto seção. A partir daí, você pode gerar manualmente um ID de sessão e um token. Use a chave de API do projeto juntamente com o ID de sessão e o token que você gerou.

Importante: Você pode continuar obtendo os valores do ID da sessão e do token da sua Account durante os testes e o desenvolvimento, mas, antes de entrar em produção, é necessário configurar um servidor. Abordaremos esse assunto em Próximos passos no final deste tutorial.

Para obter mais informações sobre sessões, tokens e servidores, consulte Noções básicas sobre a Video API.

Etapa 4: Solicitação de permissões

Como nosso aplicativo utiliza áudio e vídeo do dispositivo do usuário, precisaremos adicionar um código para solicitar permissões de áudio e vídeo. Vamos usar o EasyPermissions biblioteca para fazer isso.

  1. Comece adicionando a biblioteca EasyPermissions ao seu projeto — abra o build.gradle no seu módulo (o arquivo app/build.gradle) e adicione o seguinte trecho de código à seção de dependências:

    implementation 'pub.devrel:easypermissions:3.0.0'

  2. No seu AndroidManifest.xml arquivo, adicione este trecho de código dentro do manifest tags:

    <uses-permission android:name="android.permission.CAMERA" /> <uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="android.permission.RECORD_AUDIO" /> <uses-permission android:name="android.permission.WAKE_LOCK" /> <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" /> <uses-permission android:name="android.permission.READ_PHONE_STATE" /> <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" /> <uses-feature android:name="android.hardware.camera" /> <uses-feature android:name="android.hardware.camera.autofocus" />

  3. No seu MainActivity.java arquivo, adicione um novo método chamado onRequestPermissionsResult:

    @Override public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { super.onRequestPermissionsResult(requestCode, permissions, grantResults); EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this); }

    Este é um código padrão para utilizar a biblioteca EasyPermissions.

    Importante: Você terá que adicionar as importações manualmente, clicando em EasyPermissions (texto em vermelho) e pressionando a combinação de teclas Option + Enter no macOS ou Alt + Enter no Windows. Essa etapa pode ser necessária ao colar o código. Você também pode ativar a opção “Adicionar importações inequívocas dinamicamente” (Preferências | Editor | Importação automática) para adicionar importações automaticamente.

  4. Adicione o PERMISSIONS_REQUEST_CODE propriedade no topo do MainActivity.java arquivo:

    private static final int PERMISSIONS_REQUEST_CODE = 124;

  5. A seguir, vamos adicionar um requestPermissions() método:

    @AfterPermissionGranted(PERMISSIONS_REQUEST_CODE) private void requestPermissions() { String[] perms = { Manifest.permission.INTERNET, Manifest.permission.CAMERA, Manifest.permission.RECORD_AUDIO }; if (EasyPermissions.hasPermissions(this, perms)) { // initialize and connect to the session } else { EasyPermissions.requestPermissions(this, "This app needs access to your camera and mic to make video calls", PERMISSIONS_REQUEST_CODE, perms); } }

    Isso verifica se as permissões já foram concedidas. Caso contrário, solicitamos ao usuário as permissões de acesso à câmera e ao microfone por meio do EasyPermissions.requestPermissions método.

    Assim que as permissões forem concedidas, esse método será acionado novamente devido ao @AfterPermissionGranted(PERMISSIONS_REQUEST_CODE) anotação. Adicionaremos um código para inicializar os objetos de sessão e de visualização nas próximas etapas.

  6. Agora adicione requestPermission(); para chamar o método dentro do onCreate() método:

    @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); requestPermissions(); }

Etapa 5: Conectando-se à sessão

A seguir, vamos nos conectar à sessão do OpenTok. É necessário fazer isso antes de poder publicar seu fluxo de áudio e vídeo na sessão ou visualizar os fluxos dos outros participantes.

  1. Adicione um session propriedade à classe MainActivity (logo após as últimas linhas que você adicionou em Etapa 3):

    private Session session;

    A classe Session está definida no SDK do OpenTok para Android. Ela representa uma sessão do OpenTok e inclui métodos para interagir com a sessão.

  2. Para facilitar o registro em log, adicione um TAG propriedade no topo do MainActivity classe:

    private static final String TAG = MainActivity.class.getSimpleName();

  3. No requestPermissions() método que você criou na etapa anterior, adicione as seguintes linhas de código abaixo do // initialize and connect to the session comentário para instanciar o objeto Session e chamar seu connect(token) método:

    initializeSession(OpenTokConfig.API_KEY, OpenTokConfig.SESSION_ID, OpenTokConfig.TOKEN);

  4. Logo abaixo do requestPermissions() método, adicione as seguintes linhas de código:

    private void initializeSession(String apiKey, String sessionId, String token) { Log.i(TAG, "apiKey: " + apiKey); Log.i(TAG, "sessionId: " + sessionId); Log.i(TAG, "token: " + token); session = new Session.Builder(this, apiKey, sessionId).build(); session.setSessionListener(sessionListener); session.connect(token); }

    Este código utiliza o Session.Builder() para instanciar um objeto Session. O construtor recebe três parâmetros:

    • O contexto do aplicativo Android associado a este processo
    • A chave da API do OpenTok
    • O ID da sessão

    O Session.Builder.build() O método retorna uma nova instância de Session.

    O Session.setSessionListener() O método define o objeto que implementará a interface SessionListener. Essa interface inclui métodos de retorno de chamada que são acionados em resposta a eventos relacionados à sessão. (Vamos implementá-los nas próximas etapas).

    O Session.connect() método do session O objeto conecta o aplicativo cliente à sessão do OpenTok. É necessário estabelecer a conexão antes de enviar ou receber fluxos de áudio e vídeo na sessão (ou antes de interagir com a sessão de qualquer forma). O connect() O método recebe um parâmetro: o token de autenticação para que este cliente se conecte à sessão do OpenTok.

  5. A seguir, vamos criar o sessionListener propriedade. Adicione o código a seguir no início do arquivo MainActivity classe:

    private Session.SessionListener sessionListener = new Session.SessionListener() { @Override public void onConnected(Session session) { Log.d(TAG, "onConnected: Connected to session: " + session.getSessionId()); } @Override public void onDisconnected(Session session) { Log.d(TAG, "onDisconnected: Disconnected from session: " + session.getSessionId()); } @Override public void onStreamReceived(Session session, Stream stream) { Log.d(TAG, "onStreamReceived: New Stream Received " + stream.getStreamId() + " in session: " + session.getSessionId()); } @Override public void onStreamDropped(Session session, Stream stream) { Log.d(TAG, "onStreamDropped: Stream Dropped: " + stream.getStreamId() + " in session: " + session.getSessionId()); } @Override public void onError(Session session, OpentokError opentokError) { Log.e(TAG, "Session error: " + opentokError.getMessage()); } };

    • Quando o cliente se conecta à sessão do OpenTok, a implementação do SessionListener.onConnected(session) o método é chamado.

    • Quando o cliente se desconecta da sessão do OpenTok, a implementação do SessionListener.onDisconnected(session) o método é chamado.

    • Se o cliente não conseguir se conectar à sessão do OpenTok, a implementação do SessionListener.onError(session, error) o método é chamado.

    • Quando outro cliente publica um stream na sessão do OpenTok, a implementação do SessionListener.onStreamReceived(session, stream) o método é chamado.

    • Quando outro cliente interrompe a transmissão de um stream para a sessão do OpenTok, a implementação do SessionListener.onStreamDropped(session, stream) o método é chamado.

    Por enquanto, o aplicativo exibe mensagens no console do depurador sempre que algum desses eventos ocorre.

Faça a depuração do seu aplicativo. Se o aplicativo se conectar com sucesso à sessão do OpenTok, o SessionListener.onConnected(session) O método registra mensagens no console de depuração.

  1. Adicione os métodos abaixo ao MainActivity classe para notificar a sessão sobre os eventos do ciclo de vida da Activity:

    @Override protected void onPause() { super.onPause(); if (session != null) { session.onPause(); } } @Override protected void onResume() { super.onResume(); if (session != null) { session.onResume(); } }

Etapa 6: Ajustando a interface do usuário do aplicativo de exemplo

O SDK do OpenTok para Android expõe os vídeos que você publica e dos quais você se inscreve como objetos `View`. Você pode adicioná-los como filhos de ViewGroup objetos no seu aplicativo. Este aplicativo de exemplo utilizará FrameLayout objetos (que estendem ViewGroup) como contêineres para as visualizações do editor e do assinante:

  1. No Android Studio, abra o arquivo app/res/layout/activity_main.xml. Clique na guia “Texto”, na parte inferior do editor, para exibir o código XML do arquivo.

  2. Substitua o conteúdo do arquivo pelo código a seguir:

    <?xml version="1.0" encoding="utf-8"?> <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".MainActivity"> <FrameLayout android:layout_width="fill_parent" android:layout_height="fill_parent" app:layout_constraintBottom_toBottomOf="parent" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" app:layout_constraintTop_toTopOf="parent"> <FrameLayout android:id="@+id/subscriber_container" android:layout_width="fill_parent" android:layout_height="fill_parent" /> <FrameLayout android:id="@+id/publisher_container" android:layout_width="90dp" android:layout_height="120dp" android:layout_gravity="bottom|end" android:layout_marginEnd="16dp" android:layout_marginRight="16dp" android:layout_marginBottom="16dp" android:background="#CCCCCC" android:padding="2dp" /> </FrameLayout> </androidx.constraintlayout.widget.ConstraintLayout>

    Certifique-se de substituir todo o conteúdo do <TextView> elemento (por meio da tag de fechamento /> (tag).

  3. Agora declare publisherViewContainer e subscriberViewContainer como propriedades da classe MainActivity (logo após a declaração da session propriedade):

    private FrameLayout publisherViewContainer; private FrameLayout subscriberViewContainer;

  4. Por fim, no atual onCreate() método, inicialize esses objetos de visualização de layout adicionando as seguintes linhas de código abaixo do setContentView() chamada de método:

    publisherViewContainer = findViewById(R.id.publisher_container); subscriberViewContainer = findViewById(R.id.subscriber_container);

    Neste momento, o seu onCreate() O método deve ficar assim:

    @Override
protected void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    publisherViewContainer = findViewById(R.id.publisher_container);
    subscriberViewContainer = findViewById(R.id.subscriber_container);

    requestPermissions();
}

As etapas acima servem apenas para configurar um layout de exemplo para este aplicativo. Seu próprio aplicativo pode adicionar visualizações de editor e assinante como elementos filhos de outras ViewGroup objetos

Etapa 7: Publicação de um fluxo na sessão

Quando o aplicativo se conectar à sessão do OpenTok, queremos que ele transmita um fluxo de áudio e vídeo para a sessão, usando a câmera e o microfone:

  1. Adicione um publisher propriedade à classe MainActivity (após a declaração da session propriedade):

    private Publisher publisher;

    A classe Publisher está definida no SDK do OpenTok para Android.

  2. Modificar a implementação do SessionListener.onConnected() método para incluir código para publicar um stream na sessão:

    @Override public void onConnected(Session session) { Log.d(TAG, "onConnected: Connected to session: " + session.getSessionId()); publisher = new Publisher.Builder(MainActivity.this).build(); publisher.setPublisherListener(publisherListener); publisher.getRenderer().setStyle(BaseVideoRenderer.STYLE_VIDEO_SCALE, BaseVideoRenderer.STYLE_VIDEO_FILL); publisherViewContainer.addView(publisher.getView()); if (publisher.getView() instanceof GLSurfaceView) { ((GLSurfaceView) publisher.getView()).setZOrderOnTop(true); } session.publish(publisher); }

    O código acima utiliza Publisher.Builder() para instanciar um objeto Publisher. O construtor recebe um parâmetro: o contexto associado a este processo (embora possa ser diferente em um aplicativo de produção).

    O Publisher.setPublisherListener() O método define o objeto que implementará a interface PublisherListener. Essa interface inclui métodos de retorno de chamada que são acionados em resposta a eventos relacionados ao editor.

    Importante: O contexto utilizado depende do caso de uso específico. No entanto, geralmente é preferível que a sessão permaneça fora da Activity (por exemplo, entre atividades). Para Applications em produção, é mais prático usar o contexto do aplicativo em vez do contexto da atividade.

    Em seguida, o código passa o objeto Publisher como parâmetro da função Session.publish() método. Esse método transmite um fluxo de áudio e vídeo para a sessão do OpenTok, utilizando a câmera e o microfone do dispositivo Android. (Observe que, em um dispositivo virtual Android, o SDK do OpenTok para Android utiliza um vídeo de teste ao transmitir um fluxo).

    O objeto Publisher possui um getView() retorna um objeto View do Android. Essa view exibe o vídeo capturado pela câmera do dispositivo. O código adiciona essa view como uma subview da publisherViewContainer objeto.

  3. Para registrar eventos, adicione um publisherListener propriedade para o sessionListener do MainActivity:

    private PublisherKit.PublisherListener publisherListener = new PublisherKit.PublisherListener() { @Override public void onStreamCreated(PublisherKit publisherKit, Stream stream) { Log.d(TAG, "onStreamCreated: Publisher Stream Created. Own stream " + stream.getStreamId()); } @Override public void onStreamDestroyed(PublisherKit publisherKit, Stream stream) { Log.d(TAG, "onStreamDestroyed: Publisher Stream Destroyed. Own stream " + stream.getStreamId()); } @Override public void onError(PublisherKit publisherKit, OpentokError opentokError) { Log.e(TAG, "PublisherKit onError: " + opentokError.getMessage()); } };

    Observe que a classe `Publisher` estende a classe `PublisherKit` (também definida pelo SDK do OpenTok para Android). A classe `PublisherKit` é uma classe base que você pode usar para criar emissores avançados (como aqueles que utilizam capturadores ou renderizadores de vídeo personalizados).

Isso implementa o PublisherListener métodos:

  • onStreamCreated(publisherKit, stream) — É chamado quando o emissor inicia a transmissão para a sessão do OpenTok.

  • onStreamDestroyed(publisherKit, stream) — É chamado quando o emissor interrompe a transmissão para a sessão do OpenTok.

  • onError(error) — É chamado quando o cliente não consegue publicar na sessão do OpenTok. Um OpentokError o objeto é passado para o método.

Etapa 8: Assinatura de outros fluxos de clientes

Queremos que os clientes possam inscrever-se para (ou visualizar) as transmissões de outros clientes na sessão:

  1. Adicione um subscriber propriedade à classe MainActivity (após a declaração da publisher propriedade):

    private Subscriber subscriber;

    A classe `Subscriber` está definida no SDK do OpenTok para Android. Ela define um objeto que um cliente utiliza para se inscrever (visualizar) um stream publicado por outro cliente.

  2. Modificar a implementação do onStreamReceived(session, stream) método (uma das chamadas de retorno do SessionListener) para incluir código que permita assinar os fluxos de outros clientes na sessão:

    @Override public void onStreamReceived(Session session, Stream stream) { Log.d(TAG, "onStreamReceived: New Stream Received " + stream.getStreamId() + " in session: " + session.getSessionId()); if (subscriber == null) { subscriber = new Subscriber.Builder(MainActivity.this, stream).build(); subscriber.getRenderer().setStyle(BaseVideoRenderer.STYLE_VIDEO_SCALE, BaseVideoRenderer.STYLE_VIDEO_FILL); subscriber.setSubscriberListener(subscriberListener); session.subscribe(subscriber); subscriberViewContainer.addView(subscriber.getView()); } }

  3. Para registrar eventos, adicione subscriberListener imóvel logo abaixo sessionListener do MainActivity:

    SubscriberKit.SubscriberListener subscriberListener = new SubscriberKit.SubscriberListener() { @Override public void onConnected(SubscriberKit subscriberKit) { Log.d(TAG, "onConnected: Subscriber connected. Stream: " + subscriberKit.getStream().getStreamId()); } @Override public void onDisconnected(SubscriberKit subscriberKit) { Log.d(TAG, "onDisconnected: Subscriber disconnected. Stream: " + subscriberKit.getStream().getStreamId()); } @Override public void onError(SubscriberKit subscriberKit, OpentokError opentokError) { Log.e(TAG, "SubscriberKit onError: " + opentokError.getMessage()); } };

Quando outro cliente publica um fluxo em uma sessão, esse método é chamado e um objeto `Stream` é passado como parâmetro. A classe `Stream` está definida no SDK do OpenTok para Android e representa um fluxo de áudio e vídeo na sessão do OpenTok.

O código inicializa uma instância da classe Subscriber, definida no SDK do OpenTok para Android. O Subscriber.Builder() O construtor recebe dois parâmetros:

  • O contexto do aplicativo Android associado a este processo.

  • O objeto Stream (correspondente ao stream que você deseja visualizar)

O Session.subscribe(subscriber) O método assina o fluxo que acabou de ser recebido.

subscriberViewContainer.addView(subscriber.getView()) exibe a visualização do novo stream assinado na tela.

  1. Modificar a implementação do onStreamDropped(Session session, Stream stream) método (mais um dos callbacks do SessionListener):

    @Override public void onStreamDropped(Session session, Stream stream) { Log.i(TAG, "Stream Dropped"); if (subscriber != null) { subscriber = null; subscriberViewContainer.removeAllViews(); } }

    subscriberViewContainer.removeAllViews() remove a visualização de um assinante assim que a transmissão for interrompida.

Etapa 9: Executando o aplicativo

Agora que seu código está pronto, você pode executar o aplicativo no emulador do Android Studio. Isso criará um vídeo simulado do editor — como o emulador não tem acesso à sua webcam, o vídeo do editor exibirá um gráfico animado em vez da imagem da sua câmera.

Para adicionar um segundo editor (que aparecerá como assinante no seu emulador), execute o aplicativo uma segunda vez em um dispositivo Android conectado ou use o OpenTok Playground para se conectar à sessão em um navegador compatível, seguindo as etapas abaixo:

  1. Acesse OpenTok Playground (é necessário estar conectado à sua Account)

  2. Selecione o Participar de uma sessão já em andamento aba

  3. Copie o ID da sessão que você usou no arquivo MainActivity.java e cole-o em ID da sessão campo de entrada

  4. Clique Participar da sessão

  5. Na próxima tela, clique em Conectar-se, em seguida, clique em Publicar transmissão

  6. Você pode ajustar as opções do Publisher (opcional) e, em seguida, clicar em Continuar para se conectar e começar a publicar e se inscrever

Neste momento, você deve ver a transmissão da sua webcam, bem como a transmissão do emulador. Voltando ao emulador, você também deve ver o novo editor exibido na tela emulada.

Parabéns! Você concluiu o tutorial “Configurar um cliente Android básico”.
Você pode continuar experimentando e ajustando o código que desenvolveu aqui para o lado do cliente do seu aplicativo, mas lembre-se de que precisará implementar o componente de servidor da sua aplicação antes de entrar em produção (consulte Configurando seu servidor (abaixo).

Você pode visualizar uma versão completa deste aplicativo de exemplo no Básico-Bate-Papo-por-Vídeo-em-Java pasta do exemplos-do-SDK-de-vídeo-da-Vonage-para-Android repositório no GitHub. Esta versão finalizada inclui código para carregar o ID da sessão, o token e a chave de API a partir de um serviço web (em vez de usar valores fixos).

Próximos passos

Quando terminar esta seção, continue desenvolvendo e aprimorando seu aplicativo OpenTok com estes recursos úteis:

Configurando seu servidor

No tutorial acima, pedimos que você codificar diretamente suas credenciais de autenticação. No entanto, para um aplicativo de produção, o sessionId e token Os valores no seu código devem ser gerados pelo servidor de aplicativos e repassados ao cliente. Aqui estão algumas razões pelas quais você não deve usar credenciais codificadas diretamente no código-fonte do seu aplicativo de produção:

  • Os tokens expiram após um determinado período (especificado no momento da geração); portanto, é necessário gerar novos tokens regularmente
  • Você não poderá criar novas sessões dinamicamente; portanto, todos os usuários do seu aplicativo ficariam restritos a uma única “sala”

Você pode continuar testando seu aplicativo com valores codificados diretamente, mas, quando estiver pronto para configurar um servidor, há várias maneiras de fazer isso:

Opção 1 do servidor — Inicie um servidor REST simples no Heroku com um clique

Essa é provavelmente a maneira mais rápida de colocar um servidor em funcionamento, mas sua funcionalidade é limitada. Basta clicar no botão do Heroku abaixo; você será redirecionado para o site do Heroku e solicitado a inserir sua chave de API e seu segredo de API do OpenTok — você pode obter esses valores na página do seu projeto em seu Account da Video API. Se você não tiver um Account no Heroku, precisará se cadastrar (é grátis).

Deploy

Quer dar uma olhada no código? O botão acima executa o código do servidor a partir do aprendendo-opentok-php Repositório do GitHub. Acesse o repositório para revisar o código e consultar a documentação adicional — você pode até mesmo criar um fork do repositório e fazer alterações antes da implantação.

Prefere o Node.js? Visite o aprendendo-opentok-node repositório com a mesma funcionalidade usando Node.js (incluindo um botão de implantação no Heroku).

Depois que o servidor estiver implantado no Heroku, você precisará adicionar um código ao seu projeto para obter as credenciais do servidor. Confira a implementação do cliente no Básico-Bate-Papo-por-Vídeo-em-Java / Básico-Bate-papo-por-Vídeo-Kotlin projeto.

Opção 2 do servidor — Compilar do zero usando os SDKs do servidor

A Opção 1 utiliza endpoints REST para transmitir credenciais ao cliente, mas essa é apenas uma das muitas maneiras de implementar um servidor com o OpenTok. Se você deseja um nível maior de personalização, pode consultar o Documentação do SDK do servidor para a linguagem do lado do servidor de sua escolha (disponível para PHP, Node.js, Java, .NET, Python e Ruby). A documentação aborda o processo de configuração e os diversos métodos necessários para gerar sessões e tokens, além de outras funcionalidades do lado do servidor.