Configurar un cliente básico de Android

Este tutorial te guiará paso a paso por el proceso de configuración de un cliente básico para Android que utilice la Video API de Vonage.

Visión general

Todas las aplicaciones que utilizan la Video API de Vonage requieren tanto un cliente y un servidor componente. El código del lado del cliente es el que se carga en el dispositivo del usuario final (teléfono, ordenador) y se encarga de la mayor parte de las funciones de OpenTok, entre las que se incluyen conectando a la sesión, edición audio-vídeo arroyos a la sesión, y suscribiéndose a a los flujos de otros clientes. Para más información sobre clientes, servidores y sesiones, véase Conceptos básicos de la Video API.

En este tutorial, utilizará la función SDK de OpenTok para Android, la biblioteca del lado del cliente de OpenTok para dispositivos Android, que permite crear de forma rápida y sencilla una aplicación de vídeo interactiva en tiempo real.

Estos son los temas que se tratarán en este tutorial:

Tiempo estimado: 25 minutos

¿Quieres saltarte este tutorial? Puedes ir directamente al código completo del cliente para Android en el Basic-Video-Chat-Java de nuestra Repo de aplicaciones de ejemplo para Android en GitHub. El repositorio incluye un archivo README con documentación sobre cómo ejecutar y explorar el código. Además, este tutorial trata sobre la versión en Java de la aplicación de ejemplo para Android. Para ver una versión en Kotlin con documentación, consulta el Repo de aplicaciones de ejemplo para Android.

Requisitos

Para completar este tutorial, necesitarás:

Paso 1: Crear un nuevo proyecto

  1. Abre Android Studio y selecciona Nuevo proyecto del Archivo menú.

  2. Configura el SDK mínimo de la aplicación en API 16 (Android 4.1, Jelly Bean).

  3. Sigue los pasos del asistente, asegurándote de que Actividad vacía está seleccionado. Deje el Nombre de la actividad ajustado a MainActivityy dejar el Nombre de la maquetación ajustado a activity_main.

Paso 2: Incorporación del SDK de OpenTok para Android

La aplicación utiliza Maven para cargar el SDK de OpenTok para Android:

  1. Edita el archivo `build.gradle` de tu proyecto (en la carpeta raíz del mismo) y añade el siguiente fragmento de código al allprojects/repositories sección:

    mavenCentral()

    En este punto el archivo build.gradle debería tener este aspecto:

    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 build.gradle para su módulo (el archivo app/build.gradle) y añada el siguiente fragmento de código a la sección de dependencias:

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

    Si utilizas OpenTok para Android 2.16.0 o una versión posterior, tendrás que añadir lo siguiente al android del archivo build.gradle de la aplicación:

    compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 }

    En este punto, el archivo build.gradle para su módulo debe tener este aspecto:

    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. Sincroniza tu proyecto.

Paso 3: Configuración de la autenticación

Para conectarse a una sesión de OpenTok, el cliente necesitará tener acceso a unas credenciales de autenticación: un Clave API, ID de sesióny ficha. En una aplicación de producción, estas credenciales deberían generarlas un servidor, pero para agilizar el proceso, por ahora simplemente vamos a introducir los valores de forma fija:

  1. Crear el OpenTokConfig clase (Archivo | Nuevo | Clase Java), añade algunas variables estáticas para almacenar la clave de la API, el ID de sesión y el token. También añadiremos algunas constantes para nuestro identificador de mensajes de registro y los permisos:

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

  2. Ajuste el código mediante la codificación de los valores para el API_KEY, SESSION_ID y TOKEN.

    Para ello, inicia sesión en tu Account de la Video API, crea un nuevo proyecto de la API de OpenTok o utiliza uno ya existente; a continuación, ve a la página de tu proyecto y desplázate hacia abajo hasta la sección Herramientas del proyecto sección. Desde allí, puedes generar manualmente un ID de sesión y un token. Utiliza la clave API del proyecto junto con el ID de sesión y el token que hayas generado.

Importante: Puedes seguir obteniendo los valores del ID de sesión y del token de tu Account durante las fases de prueba y desarrollo, pero antes de pasar a producción debes configurar un servidor. Trataremos este tema en Próximos pasos al final de este tutorial.

Para más información sobre sesiones, tokens y servidores, consulte Conceptos básicos de la Video API.

Paso 4: Solicitar permisos

Dado que nuestra aplicación utiliza el audio y el vídeo del dispositivo del usuario, tendremos que añadir algo de código para solicitar los permisos de audio y vídeo. Utilizaremos el EasyPermissions biblioteca para hacer esto.

  1. Empiece por añadir la biblioteca EasyPermissions a su proyecto: abra el archivo build.gradle en tu módulo (el archivo app/build.gradle) y añade el siguiente fragmento de código a la sección de dependencias:

    implementation 'pub.devrel:easypermissions:3.0.0'

  2. En su AndroidManifest.xml añada este fragmento de código dentro del archivo 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. En su MainActivity.java archivo, añade un nuevo método llamado 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 es un código de ejemplo para utilizar la biblioteca EasyPermissions.

    Importante: Tendrás que añadir las importaciones manualmente, haciendo clic en EasyPermissions (texto en rojo) y pulsando la combinación de teclas Opción + Intro en macOS o Alt + Intro en Windows. Este paso puede ser necesario al pegar el código. También puedes activar la opción «Añadir importaciones inequívocas sobre la marcha» (Preferencias | Editor | Importación automática) para añadir las importaciones automáticamente.

  4. Añade el PERMISSIONS_REQUEST_CODE en la parte superior de MainActivity.java archivo:

    private static final int PERMISSIONS_REQUEST_CODE = 124;

  5. A continuación añadiremos un 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); } }

    Esto comprueba si ya se han concedido los permisos. Si no es así, solicitamos al usuario los permisos de cámara y micrófono mediante el EasyPermissions.requestPermissions método.

    Una vez concedidos los permisos, este método se ejecutará de nuevo debido a la @AfterPermissionGranted(PERMISSIONS_REQUEST_CODE) anotación. Añadiremos algo de código para inicializar los objetos sesión y vista en los próximos pasos.

  6. Ahora añade requestPermission(); para llamar al método dentro del onCreate() método:

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

Paso 5: Conexión a la sesión

A continuación, nos conectaremos a la sesión de OpenTok. Debes hacerlo antes de poder publicar tu transmisión de audio y vídeo en la sesión o ver las transmisiones de los demás participantes.

  1. Añade un session a la clase MainActivity (justo después de las últimas líneas que has añadido en Paso 3):

    private Session session;

    La clase `Session` está definida en el SDK de OpenTok para Android. Representa una sesión de OpenTok e incluye métodos para interactuar con ella.

  2. Para facilitar el registro, añade un TAG en la parte superior de MainActivity clase:

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

  3. En el requestPermissions() que creó en el último paso, añada las siguientes líneas de código bajo el método // initialize and connect to the session para instanciar el objeto Session y llamar a su connect(token) método:

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

  4. Justo debajo del requestPermissions() añada las siguientes líneas 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 el Session.Builder() para crear una instancia de un objeto Session. El constructor admite tres parámetros:

    • El contexto de la aplicación de Android asociado a este proceso
    • La clave de la API de OpenTok
    • El identificador de sesión

    El Session.Builder.build() devuelve una nueva instancia de Session.

    El Session.setSessionListener() Este método establece el objeto que implementará la interfaz SessionListener. Esta interfaz incluye métodos de devolución de llamada que se activan en respuesta a eventos relacionados con la sesión. (Los implementaremos en los siguientes pasos).

    El Session.connect() método del session El objeto conecta la aplicación cliente a la sesión de OpenTok. Debes conectarte antes de enviar o recibir flujos de audio y vídeo en la sesión (o antes de interactuar con la sesión de cualquier forma). El connect() El método admite un parámetro: el token de autenticación que permite a este cliente conectarse a la sesión de OpenTok.

  5. A continuación, crearemos el sessionListener propiedad. Añada el siguiente código en la parte superior del archivo MainActivity clase:

    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()); } };

    • Cuando el cliente se conecta a la sesión de OpenTok, la implementación de la SessionListener.onConnected(session) se llama al método.

    • Cuando el cliente se desconecta de la sesión de OpenTok, la implementación de la SessionListener.onDisconnected(session) se llama al método.

    • Si el cliente no consigue conectarse a la sesión de OpenTok, la implementación de la SessionListener.onError(session, error) se llama al método.

    • Cuando otro cliente publica una transmisión en la sesión de OpenTok, la implementación de la SessionListener.onStreamReceived(session, stream) se llama al método.

    • Cuando otro cliente deja de publicar un flujo en la sesión de OpenTok, la implementación de la SessionListener.onStreamDropped(session, stream) se llama al método.

    Por ahora, la aplicación muestra un mensaje en la consola del depurador cuando se produce cualquiera de estos eventos.

Depura tu aplicación. Si la aplicación se conecta correctamente a la sesión de OpenTok, el SessionListener.onConnected(session) se registra en la consola de depuración.

  1. Añade los métodos siguientes al MainActivity para notificar a la sesión los eventos del ciclo de vida de la actividad:

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

Paso 6: Ajustar la interfaz de usuario de la aplicación de ejemplo

El SDK de OpenTok para Android presenta los vídeos que publicas y a los que te suscribes como objetos «View». Puedes añadirlos como elementos secundarios de ViewGroup en tu aplicación. Esta aplicación de ejemplo utilizará FrameLayout objetos (que heredan de ViewGroup) como contenedores de las vistas del editor y del abonado:

  1. En Android Studio, abre el archivo app/res/layout/activity_main.xml. Haz clic en la pestaña «Texto», situada en la parte inferior del editor, para mostrar el código XML del archivo.

  2. Sustituya el contenido del archivo por el siguiente código:

    <?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>

    Asegúrese de sustituir todo el contenido del <TextView> (mediante el cierre /> tag).

  3. Ahora declara publisherViewContainer y subscriberViewContainer como propiedades de la clase MainActivity (justo después de la declaración de la session propiedad):

    private FrameLayout publisherViewContainer; private FrameLayout subscriberViewContainer;

  4. Por último, en el onCreate() inicialice estos objetos de vista de diseño añadiendo las siguientes líneas de código bajo el método setContentView() Llamada a un método:

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

    Llegados a este punto, tu onCreate() El método debería tener este aspecto:

    @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();
}

Los pasos anteriores se limitan a configurar un diseño de ejemplo para esta aplicación. Tu propia aplicación puede añadir vistas de editor y suscriptor como hijas de otras vistas ViewGroup objetos

Paso 7: Publicación de un flujo en la sesión

Cuando la aplicación se conecte a la sesión de OpenTok, queremos que publique un flujo de audio y vídeo en la sesión, utilizando la cámara y el micrófono:

  1. Añade un publisher a la clase MainActivity (después de la declaración de la propiedad session propiedad):

    private Publisher publisher;

    La clase «Publisher» está definida en el SDK de OpenTok para Android.

  2. Modificar la aplicación del SessionListener.onConnected() Método para incluir código que permita publicar un flujo en la sesión:

    @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); }

    El código anterior utiliza Publisher.Builder() para instanciar un objeto Publisher. El constructor toma un parámetro: el contexto asociado con este proceso (aunque puede ser diferente en una aplicación de producción).

    El Publisher.setPublisherListener() establece el objeto que implementará la interfaz PublisherListener. Esta interfaz incluye métodos de devolución de llamada en respuesta a eventos relacionados con el editor.

    Importante: El contexto que se utilice dependerá del caso de uso concreto. Sin embargo, por lo general es preferible que la sesión se mantenga fuera de la actividad (por ejemplo, entre actividades). En el caso de las aplicaciones de producción, resulta más conveniente utilizar el contexto de la aplicación en lugar del contexto de la actividad.

    A continuación, el código pasa el objeto Publisher como parámetro de la función Session.publish() método. Este método transmite un flujo de audio y vídeo a la sesión de OpenTok utilizando la cámara y el micrófono del dispositivo Android. (Ten en cuenta que, en un dispositivo virtual Android, el SDK de OpenTok para Android utiliza un vídeo de prueba al transmitir un flujo).

    El objeto Publisher tiene un getView() que devuelve un objeto Android View. Esta vista muestra el vídeo capturado desde la cámara del dispositivo. El código añade esta vista como una subvista del objeto publisherViewContainer objeto.

  3. Para registrar eventos, añada un publisherListener a la propiedad sessionListener de la 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()); } };

    Ten en cuenta que la clase `Publisher` hereda de la clase `PublisherKit` (también definida por el SDK de OpenTok para Android). La clase `PublisherKit` es una clase base que puedes utilizar para crear emisores avanzados (como, por ejemplo, emisores que utilicen capturadores de vídeo o renderizadores personalizados).

Esto implementa el PublisherListener métodos:

  • onStreamCreated(publisherKit, stream) — Se invoca cuando el editor comienza a transmitir a la sesión de OpenTok.

  • onStreamDestroyed(publisherKit, stream) — Se invoca cuando el emisor deja de transmitir a la sesión de OpenTok.

  • onError(error) — Se invoca cuando el cliente no consigue publicar en la sesión de OpenTok. Un OpentokError se pasa al método.

Paso 8: Suscribirse a otras transmisiones de clientes

Queremos que los clientes puedan suscríbase a para ver las transmisiones de otros clientes en la sesión:

  1. Añade un subscriber a la clase MainActivity (después de la declaración de la propiedad publisher propiedad):

    private Subscriber subscriber;

    La clase «Subscriber» se define en el SDK de OpenTok para Android. Define un objeto que utiliza un cliente para suscribirse (visualizar) a una transmisión publicada por otro cliente.

  2. Modificar la aplicación del onStreamReceived(session, stream) (uno de los callbacks de SessionListener) para incluir código para suscribirse a los streams de otros clientes la sesión:

    @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, añade subscriberListener propiedad situada justo debajo sessionListener de la 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()); } };

Cuando otro cliente publica una transmisión en una sesión, se invoca este método y se le pasa un objeto `Stream`. La clase `Stream` está definida en el SDK de OpenTok para Android y representa una transmisión de audio y vídeo en la sesión de OpenTok.

El código inicializa una instancia de la clase «Subscriber», definida en el SDK de OpenTok para Android. El Subscriber.Builder() El constructor toma dos parámetros:

  • El contexto de la aplicación de Android asociado a este proceso.

  • El objeto Stream (correspondiente al flujo que deseas visualizar)

El Session.subscribe(subscriber) El método se suscribe al flujo que acaba de recibirse.

subscriberViewContainer.addView(subscriber.getView()) coloca en la pantalla la vista del nuevo flujo suscrito.

  1. Modificar la aplicación del onStreamDropped(Session session, Stream stream) (otro de los callbacks de SessionListener):

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

    subscriberViewContainer.removeAllViews() elimina la visualización de un suscriptor una vez que se ha interrumpido la transmisión.

Paso 9: Ejecutar la aplicación

Ahora que el código está completo, puede ejecutar la aplicación en el emulador de Android Studio. Como el emulador no puede acceder a la cámara web, el vídeo del editor mostrará un gráfico animado en lugar de la imagen de la cámara.

Para añadir un segundo editor (que se mostrará como suscriptor en el emulador), ejecute la aplicación por segunda vez en un dispositivo Android conectado o utilice la función OpenTok Playground para conectarse a la sesión en un navegador web compatible siguiendo los pasos que se indican a continuación:

  1. Ir a OpenTok Playground (debe estar conectado a su Account)

  2. Selecciona el Unirse a una sesión existente pestaña

  3. Copie el identificador de sesión que utilizó en su archivo MainActivity.java y péguelo en ID de sesión campo de entrada

  4. Haz clic Unirse a la sesión

  5. En la pantalla siguiente, pulse Conectar, y a continuación haz clic en Publicar flujo

  6. Puede ajustar las opciones del editor (no es necesario) y, a continuación, haga clic en Continúe en para conectarse y empezar a publicar y suscribirse

En este momento deberías ver la transmisión que se está publicando desde tu cámara web, así como la transmisión que está publicando el emulador. Al volver al emulador, también deberías ver el nuevo editor que aparece en la pantalla emulada.

¡Enhorabuena! Has terminado el tutorial 'Configurar un cliente Android básico'.
Puedes seguir jugando y ajustando el código que has desarrollado aquí para el lado del cliente de tu aplicación, pero ten en cuenta que tendrás que implementar la función componente de servidor de su aplicación antes de pasar a producción (véase Configuración del servidor más abajo).

Puede ver una versión completa de esta aplicación de ejemplo en la página Basic-Video-Chat-Java carpeta de la ejemplos-del-SDK-de-vídeo-de-Vonage-para-Android en GitHub. Esta versión completa añade código para cargar el ID de sesión, el token y la clave API desde un servicio web (en lugar de utilizar valores codificados).

Próximos pasos

Cuando hayas terminado aquí, sigue desarrollando y mejorando tu aplicación de OpenTok con estos útiles recursos:

Configuración del servidor

En el tutorial anterior, te pedimos que introducir las credenciales de autenticación de forma estática. Sin embargo, en el caso de una aplicación de producción, el sessionId y token Los valores de tu código deben ser generados por el servidor de la aplicación y transmitidos al cliente. A continuación te explicamos un par de razones por las que no es recomendable incluir credenciales codificadas de forma fija en tu aplicación de producción:

  • Los tokens caducan tras un tiempo determinado (especificado en el momento de su generación), por lo que es necesario generar otros nuevos periódicamente.
  • No podrás crear nuevas sesiones de forma dinámica, por lo que todos los usuarios de tu aplicación se quedarían atrapados en una única «sala».

Puedes seguir probando tu aplicación con valores fijados de forma estática, pero cuando estés listo para configurar un servidor, hay varias formas de hacerlo:

Opción de servidor 1: poner en marcha un servidor REST sencillo en Heroku con un solo clic

Probablemente esta sea la forma más rápida de poner en marcha un servidor, pero tiene una funcionalidad limitada. Solo tienes que hacer clic en el botón de Heroku que aparece a continuación; se te redirigirá a la página web de Heroku y se te pedirá tu clave API y tu secreto API de OpenTok; puedes encontrar estos valores en la página de tu proyecto en tu Account de la Video API. Si no tienes un Account de Heroku, tendrás que registrarte (es gratis).

Deploy

¿Quieres echar un vistazo al código? El botón de arriba ejecuta el código del servidor desde el aprender-opentok-php Repositorio de GitHub. Visita el repositorio para revisar el código y consultar la documentación adicional; incluso puedes crear una bifurcación del repositorio y realizar cambios antes de la implementación.

¿Prefieres Node.js? Visita la aprender-opentok-node Repositorio con la misma funcionalidad utilizando Node.js (incluido un botón de implementación en Heroku).

Una vez que el servidor esté implementado en Heroku, tendrás que añadir algo de código a tu proyecto para recuperar las credenciales del servidor. Consulta la implementación del cliente en el Basic-Video-Chat-Java / Chat de vídeo básico en Kotlin proyecto.

Opción 2 para el servidor: compilar desde cero utilizando los SDK del servidor

La opción 1 utiliza puntos finales REST para transmitir las credenciales al cliente, pero esa es solo una de las muchas formas de implementar un servidor con OpenTok. Si deseas un mayor nivel de personalización, puedes consultar la documentación de OpenTok sobre Documentación del SDK del servidor para el lenguaje del lado del servidor que elijas (disponible para PHP, Node.js, Java, .NET, Python y Rubí). La documentación explica el proceso de configuración y los distintos métodos que necesitarás para generar sesiones y tokens, así como otras funcionalidades del lado del servidor.