Einen einfachen Android-Client einrichten

Dieses Tutorial führt Sie Schritt für Schritt durch die Einrichtung eines einfachen Android-Clients, der die Vonage Video API nutzt.

Übersicht

Alle Applikationen, die die Vonage Video API verwenden, benötigen sowohl eine Kunde und eine Server Komponente. Der clientseitige Code wird auf dem Gerät des Endnutzers (Smartphone, Computer) geladen und übernimmt den Großteil der OpenTok-Funktionalität, darunter Verbindung zum Sitzung, Veröffentlichung Audio-Video Ströme zur Sitzung, und Abonnieren Sie zu den Streams anderer Clients. Weitere Informationen über Clients, Server und Sitzungen finden Sie unter Video API-Grundlagen.

In diesem Lernprogramm werden Sie die OpenTok Android SDK, die clientseitige Bibliothek von OpenTok für Android-Geräte, mit der sich schnell und einfach eine interaktive Echtzeit-Video-Application erstellen lässt.

In diesem Tutorial werden folgende Themen behandelt:

• Anforderungen
• Schritt 1: Ein neues Projekt erstellen
• Schritt 2: Hinzufügen des OpenTok-Android-SDKs
• Schritt 3: Einrichtung der Authentifizierung
• Schritt 4: Berechtigungen anfordern
• Schritt 5: Verbindung zur Sitzung herstellen
• Schritt 6: Anpassen der Benutzeroberfläche der Beispiel-App
• Schritt 7: Einen Stream in der Sitzung veröffentlichen
• Schritt 8: Andere Client-Streams abonnieren
• Schritt 9: Die App ausführen
• Nächste Schritte
• Einrichten Ihres Servers

Geschätzte Bearbeitungszeit: 25 Minuten

Möchten Sie dieses Tutorial überspringen? Sie können den fertigen Android-Client-Code im Abschnitt Basic-Video-Chat-Java Ordner unseres Android Beispielanwendung Repo auf GitHub. Das Repo enthält eine README mit Dokumentation zum Ausführen und Erforschen des Codes. In diesem Tutorial wird auch die Java-Version der Android-Beispielanwendung behandelt. Eine Kotlin-Version mit Dokumentation finden Sie in der Android Beispielanwendung Repo.

Anforderungen

Für dieses Tutorial benötigen Sie:

• Ein gültiger Vonage Video API Account - falls Sie noch keinen haben, können Sie sich für eine kostenlose Testversion anmelden
• Android-Studio

Schritt 1: Ein neues Projekt erstellen

1. Öffnen Sie Android Studio und wählen Sie Neues Projekt von der Datei Menü.

2. Legen Sie das Mindest-SDK für die App auf API 16 (Android 4.1, Jelly Bean) fest.

3. Klicken Sie sich durch den Assistenten und stellen Sie sicher, dass Leere Aktivität ausgewählt ist. Lassen Sie die Aktivität Name eingestellt auf MainActivityund lassen Sie die Layout Name eingestellt auf activity_main.

Schritt 2: Hinzufügen des OpenTok-Android-SDKs

Die App nutzt Maven, um das OpenTok-Android-SDK zu laden:

1. Bearbeiten Sie die build.gradle für Ihr Projekt (im Stammverzeichnis Ihres Projekts) und fügen Sie den folgenden Codeschnipsel in die allprojects/repositories Abschnitt:

   mavenCentral()

   Zu diesem Zeitpunkt sollte die build.gradle-Datei wie folgt aussehen:

   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. Ändern Sie build.gradle für Ihr Modul (die Datei app/build.gradle) und fügen Sie den folgenden Codeschnipsel zum Abschnitt dependencies hinzu:

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

   Wenn Sie OpenTok Android 2.16.0 oder höher verwenden, müssen Sie Folgendes zur android Abschnitt der build.gradle-Datei der Anwendung:

   compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 }

   Zu diesem Zeitpunkt sollte die build.gradle-Datei für Ihr Modul wie folgt aussehen:

   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. Synchronisieren Sie Ihr Projekt.

Schritt 3: Einrichtung der Authentifizierung

Um eine Verbindung zu einer OpenTok-Sitzung herzustellen, benötigt der Client Zugriff auf bestimmte Authentifizierungsdaten – ein API-Schlüssel, Sitzungs-IDund Token. In einer Produktionsanwendung sollten diese Anmeldeinformationen von einem Server, aber um den Vorgang zu beschleunigen, werden wir die Werte vorerst einfach fest einprogrammieren:

1. Erstellen Sie die OpenTokConfig Klasse (Datei | Neu | Java-Klasse) und fügen Sie einige statische Variablen hinzu, um den API-Schlüssel, die Sitzungs-ID und das Token zu speichern. Außerdem fügen wir einige Konstanten für unsere Protokollmeldungskennung und die Berechtigungen hinzu:

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

2. Passen Sie den Code an, indem Sie die Werte für die API_KEY, SESSION_ID und TOKEN.

   Melden Sie sich dazu in Ihrem Video API-Konto, erstellen Sie entweder ein neues OpenTok-API-Projekt oder verwenden Sie ein bestehendes OpenTok-API-Projekt. Rufen Sie anschließend Ihre Projektseite auf und scrollen Sie nach unten zum Projekt-Tools Abschnitt. Von dort aus können Sie eine Sitzungs-ID und ein Token manuell erzeugen. Verwenden Sie den API-Schlüssel des Projekts zusammen mit der Sitzungs-ID und dem Token, die Sie erzeugt haben.

Das ist wichtig: Während der Test- und Entwicklungsphase können Sie die Werte für die Sitzungs-ID und das Token weiterhin über Ihren Account abrufen, doch bevor Sie in die Produktion gehen, müssen Sie einen Server einrichten. Darauf gehen wir näher ein in Nächste Schritte am Ende dieses Tutorials.

Weitere Informationen zu Sitzungen, Token und Servern finden Sie unter Video API-Grundlagen.

Schritt 4: Berechtigungen anfordern

Da unsere App Audio- und Videodaten vom Gerät des Benutzers verwendet, müssen wir etwas Code hinzufügen, um Audio- und Videoberechtigungen anzufordern. Wir verwenden die EasyPermissions Bibliothek, um dies zu tun.

1. Beginnen Sie damit, die EasyPermissions-Bibliothek zu Ihrem Projekt hinzuzufügen - öffnen Sie die build.gradle für Ihr Modul (die Datei app/build.gradle) und fügen Sie den folgenden Codeschnipsel in den Abschnitt dependencies ein:

   implementation 'pub.devrel:easypermissions:3.0.0'

2. In Ihrem AndroidManifest.xml Datei, fügen Sie diesen Codeschnipsel innerhalb der 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. In Ihrem MainActivity.java fügen Sie eine neue Methode namens onRequestPermissionsResult:

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

   Dies ist ein Standardcode zur Verwendung der EasyPermissions-Bibliothek.

   Das ist wichtig: Sie müssen die Importe manuell hinzufügen, indem Sie auf EasyPermissions (roter Text) und durch Drücken der Tastenkombination „Option + Enter“ unter macOS bzw. „Alt + Enter“ unter Windows. Dieser Schritt kann beim Einfügen des Codes erforderlich sein. Sie können auch die Option „Eindeutige Importe automatisch hinzufügen“ (Einstellungen | Editor | Auto-Import) aktivieren, um Importe automatisch hinzuzufügen.

4. Fügen Sie die PERMISSIONS_REQUEST_CODE Eigenschaft am Anfang der MainActivity.java Datei:

   private static final int PERMISSIONS_REQUEST_CODE = 124;

5. Als nächstes fügen wir eine requestPermissions() Methode:

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

   Dabei wird geprüft, ob die Berechtigungen bereits erteilt wurden. Ist dies nicht der Fall, wird der Benutzer aufgefordert, die Berechtigungen für Kamera und Mikrofon mit dem Befehl EasyPermissions.requestPermissions Methode.

   Sobald die Berechtigungen erteilt wurden, wird diese Methode aufgrund der @AfterPermissionGranted(PERMISSIONS_REQUEST_CODE) Annotation. In den nächsten Schritten werden wir etwas Code zur Initialisierung der Sitzungs- und Ansichtsobjekte hinzufügen.

6. Jetzt hinzufügen requestPermission(); um die Methode innerhalb der onCreate() Methode:

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

Schritt 5: Verbindung zur Sitzung herstellen

Als Nächstes stellen wir eine Verbindung zur OpenTok-Sitzung her. Dies müssen Sie tun, bevor Sie Ihren Audio-Video-Stream in der Sitzung veröffentlichen oder die Streams anderer Teilnehmer anzeigen können.

1. Hinzufügen einer session Eigenschaft zur Klasse MainActivity (direkt nach den letzten Zeilen, die Sie in Schritt 3):

   private Session session;

   Die Klasse „Session“ ist im OpenTok Android SDK definiert. Sie repräsentiert eine OpenTok-Sitzung und enthält Methoden zur Interaktion mit der Sitzung.

2. Um die Protokollierung zu vereinfachen, fügen Sie einen TAG Eigenschaft am Anfang der MainActivity Klasse:

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

3. In der requestPermissions() Methode, die Sie im letzten Schritt erstellt haben, fügen Sie die folgenden Codezeilen unter der // initialize and connect to the session Kommentar zur Instanziierung des Session-Objekts und zum Aufruf seiner connect(token) Methode:

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

4. Direkt unterhalb des requestPermissions() Methode fügen Sie die folgenden Codezeilen hinzu:

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

   Dieser Code verwendet die Session.Builder() um ein Session-Objekt zu instanziieren. Der Konstruktor benötigt drei Parameter:

   • Der mit diesem Prozess verbundene Android-Anwendungskontext
   • Der OpenTok-API-Schlüssel
   • Die Sitzungs-ID

   Die Session.Builder.build() Methode gibt eine neue Session-Instanz zurück.

   Die Session.setSessionListener() Methode legt das Objekt fest, das die SessionListener-Schnittstelle implementiert. Diese Schnittstelle umfasst Callback-Methoden, die als Reaktion auf sitzungsbezogene Ereignisse aufgerufen werden. (Wir werden sie in den nächsten Schritten implementieren).

   Die Session.connect() Methode der session Das Objekt stellt die Verbindung zwischen der Client-Anwendung und der OpenTok-Sitzung her. Sie müssen die Verbindung herstellen, bevor Sie Audio- und Videostreams in der Sitzung senden oder empfangen (oder bevor Sie in irgendeiner Weise mit der Sitzung interagieren). Das connect() Die Methode nimmt einen Parameter entgegen: das Authentifizierungstoken, mit dem sich dieser Client bei der OpenTok-Sitzung anmelden kann.

5. Als Nächstes werden wir die sessionListener Eigenschaft. Fügen Sie den folgenden Code am Anfang der Datei MainActivity Klasse:

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

   • Wenn der Client eine Verbindung zur OpenTok-Sitzung herstellt, erfolgt die Implementierung der SessionListener.onConnected(session) Methode aufgerufen wird.

   • Wenn der Client die Verbindung zur OpenTok-Sitzung trennt, erfolgt die Implementierung der SessionListener.onDisconnected(session) Methode aufgerufen wird.

   • Falls der Client keine Verbindung zur OpenTok-Sitzung herstellen kann, erfolgt die Implementierung der SessionListener.onError(session, error) Methode aufgerufen wird.

   • Wenn ein anderer Client einen Stream in der OpenTok-Sitzung veröffentlicht, sorgt die Implementierung der SessionListener.onStreamReceived(session, stream) Methode aufgerufen wird.

   • Wenn ein anderer Client die Übertragung eines Streams an die OpenTok-Sitzung einstellt, sorgt die Implementierung der SessionListener.onStreamDropped(session, stream) Methode aufgerufen wird.

   Im Moment gibt die Anwendung auf der Debugger-Konsole aus, wenn eines dieser Ereignisse eintritt.

Führen Sie ein Debugging Ihrer Anwendung durch. Wenn die App erfolgreich eine Verbindung zur OpenTok-Sitzung herstellt, wird die SessionListener.onConnected(session) Methode protokolliert auf der Debug-Konsole.

7. Fügen Sie die folgenden Methoden zur MainActivity Klasse, um die Sitzung über Ereignisse im Lebenszyklus von Aktivitäten zu informieren:

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

Schritt 6: Anpassen der Benutzeroberfläche der Beispiel-App

Das OpenTok-Android-SDK stellt Videos, die Sie veröffentlichen und abonnieren, als „View“-Objekte bereit. Sie können diese als untergeordnete Elemente von ViewGroup Objekte in Ihrer Anwendung. Diese Beispielanwendung verwendet FrameLayout Objekte (die die ViewGroup) als Container für die Publisher- und Subscriber-Ansichten:

1. Öffnen Sie in Android Studio die Datei „app/res/layout/activity_main.xml“. Klicken Sie unten im Editor auf die Registerkarte „Text“, um den XML-Code der Datei anzuzeigen.

2. Ersetzen Sie den Inhalt der Datei durch den folgenden Code:

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

   Achten Sie darauf, den gesamten Inhalt der Datei <TextView> Element (durch das schließende /> Tag).

3. Erklären Sie jetzt publisherViewContainer und subscriberViewContainer als Eigenschaften der Klasse MainActivity (direkt nach der Deklaration für die session Eigenschaft):

   private FrameLayout publisherViewContainer; private FrameLayout subscriberViewContainer;

4. Schließlich ist in der bestehenden onCreate() Methode initialisieren Sie diese Layout-Ansichtsobjekte, indem Sie die folgenden Codezeilen unter der setContentView() Methodenaufruf:

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

   Zu diesem Zeitpunkt wird Ihr onCreate() Methode sollte wie folgt aussehen:

   Kopieren

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

Mit den obigen Schritten wird lediglich ein Beispiellayout für diese Anwendung eingerichtet. Ihre eigene App kann Verleger- und Abonnentenansichten als Kinder von anderen ViewGroup Objekte

Schritt 7: Einen Stream in der Sitzung veröffentlichen

Wenn die App eine Verbindung zur OpenTok-Sitzung herstellt, soll sie mithilfe der Kamera und des Mikrofons einen Audio-Video-Stream in die Sitzung übertragen:

1. Hinzufügen einer publisher Eigenschaft zur Klasse MainActivity (nach der Deklaration der session Eigenschaft):

   private Publisher publisher;

   Die Klasse „Publisher“ ist im OpenTok Android SDK definiert.

2. Ändern Sie die Implementierung der SessionListener.onConnected() Methode, um Code zur Veröffentlichung eines Streams in der Sitzung einzuschließen:

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

   Der obige Code verwendet Publisher.Builder() um ein Publisher-Objekt zu instanziieren. Der Konstruktor nimmt einen Parameter an: den mit diesem Prozess verbundenen Kontext (obwohl dieser in einer Produktionsanwendung anders sein kann).

   Die Publisher.setPublisherListener() Methode legt das Objekt fest, das die PublisherListener-Schnittstelle implementieren wird. Diese Schnittstelle umfasst Callback-Methoden, die als Reaktion auf verlagsbezogene Ereignisse aufgerufen werden.

   Das ist wichtig: Der von Ihnen verwendete Kontext hängt von dem jeweiligen Anwendungsfall ab. In der Regel ist es jedoch erwünscht, dass die Sitzung außerhalb der Aktivität stattfindet (z. B. zwischen den Aktivitäten). Für produktive Anwendungen ist es praktisch, den Anwendungskontext anstelle des Aktivitätskontexts zu verwenden.

   Der Code übergibt dann das Publisher-Objekt als einen Parameter der Session.publish() Methode. Diese Methode überträgt einen Audio-Video-Stream an die OpenTok-Sitzung und nutzt dabei die Kamera und das Mikrofon des Android-Geräts. (Beachten Sie, dass das OpenTok-Android-SDK bei einem virtuellen Android-Gerät beim Übertragen eines Streams ein Testvideo verwendet.)

   Das Publisher-Objekt hat eine getView() zurück, das ein Android-Ansichtsobjekt zurückgibt. Diese Ansicht zeigt das von der Kamera des Geräts aufgenommene Video an. Der Code fügt diese Ansicht als eine Unteransicht der publisherViewContainer Objekt.

3. Um Ereignisse zu protokollieren, fügen Sie eine publisherListener Eigenschaft zum sessionListener der 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()); } };

   Beachten Sie, dass die Klasse „Publisher“ die Klasse „PublisherKit“ (die ebenfalls im OpenTok Android SDK definiert ist) erweitert. Die Klasse „PublisherKit“ ist eine Basisklasse, mit der Sie erweiterte Publisher erstellen können (z. B. Publisher, die benutzerdefinierte Video-Capturer oder Renderer verwenden).

Dies implementiert die PublisherListener Methoden:

• onStreamCreated(publisherKit, stream) — Wird aufgerufen, wenn der Publisher mit dem Streaming in die OpenTok-Sitzung beginnt.

• onStreamDestroyed(publisherKit, stream) — Wird aufgerufen, wenn der Publisher das Streaming zur OpenTok-Sitzung beendet.

• onError(error) — Wird aufgerufen, wenn der Client die Veröffentlichung in der OpenTok-Sitzung nicht durchführen kann. Ein OpentokError Objekt an die Methode übergeben wird.

Schritt 8: Andere Client-Streams abonnieren

Wir möchten, dass die Kunden in der Lage sind abonnieren auf die Streams anderer Clients in der Sitzung zugreifen (oder diese anzeigen):

1. Hinzufügen einer subscriber Eigenschaft zur Klasse MainActivity (nach der Deklaration der publisher Eigenschaft):

   private Subscriber subscriber;

   Die Klasse „Subscriber“ ist im OpenTok Android SDK definiert. Sie definiert ein Objekt, mit dem ein Client einen von einem anderen Client veröffentlichten Stream abonnieren (anzeigen) kann.

2. Ändern Sie die Implementierung der onStreamReceived(session, stream) Methode (einer der SessionListener-Callbacks), um Code zum Abonnieren der Streams anderer Clients in die Sitzung aufzunehmen:

   @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. So protokollieren Sie Ereignisse Hinzufügen subscriberListener das Grundstück direkt darunter sessionListener der 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()); } };

Wenn ein anderer Client einen Stream in einer Sitzung veröffentlicht, wird diese Methode aufgerufen, wobei ein Stream-Objekt übergeben wird. Die Stream-Klasse ist im OpenTok-Android-SDK definiert und repräsentiert einen Audio-Video-Stream in der OpenTok-Sitzung.

Der Code initialisiert eine Instanz der Klasse „Subscriber“, die im OpenTok Android SDK definiert ist. Die Subscriber.Builder() Konstruktor benötigt zwei Parameter:

• Der mit diesem Prozess verbundene Android-Anwendungskontext.

• Das Stream-Objekt (für den Stream, den Sie anzeigen möchten)

Die Session.subscribe(subscriber) Die Methode abonniert den soeben empfangenen Stream.

subscriberViewContainer.addView(subscriber.getView()) platziert die Ansicht des neuen abonnierten Streams auf dem Bildschirm.

9. Ändern Sie die Implementierung der onStreamDropped(Session session, Stream stream) Methode (eine weitere der SessionListener Callbacks):

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

   subscriberViewContainer.removeAllViews() entfernt die Ansicht eines Abonnenten, sobald der Stream unterbrochen wurde.

Schritt 9: Die App ausführen

Jetzt, da Ihr Code vollständig ist, können Sie die App im Android Studio-Emulator ausführen. Dadurch wird ein simuliertes Veröffentlichungsvideo erstellt - da der Emulator nicht auf Ihre Webcam zugreifen kann, wird das Veröffentlichungsvideo eine animierte Grafik anstelle Ihres Kamerafeeds anzeigen.

Um einen zweiten Herausgeber hinzuzufügen (der in Ihrem Emulator als Abonnent angezeigt wird), führen Sie die App entweder ein zweites Mal auf einem angeschlossenen Android-Gerät aus oder verwenden Sie die OpenTok Playground um eine Verbindung zur Sitzung in einem unterstützten Webbrowser herzustellen, indem Sie die folgenden Schritte ausführen:

1. Gehe zu OpenTok Playground (Sie müssen sich bei Ihrem Account)

2. Wählen Sie die An einer bestehenden Sitzung teilnehmen Registerkarte

3. Kopieren Sie die Sitzungs-ID, die Sie in Ihrer Datei MainActivity.java verwendet haben, und fügen Sie sie ein Sitzungs-ID Eingabefeld

4. Klicken Sie auf Sitzung beitreten

5. Klicken Sie auf dem nächsten Bildschirm auf Verbinden Sieund klicken Sie dann auf Stream veröffentlichen

6. Sie können die Publisher-Optionen anpassen (nicht erforderlich) und dann auf Weiter um eine Verbindung herzustellen und mit der Veröffentlichung und dem Abonnement zu beginnen

Zu diesem Zeitpunkt sollten Sie sehen, dass der Stream von Ihrer Webcam und der Stream vom Emulator veröffentlicht wird. Wenn Sie zum Emulator zurückkehren, sollte der neue Herausgeber auch auf dem emulierten Bildschirm angezeigt werden.

Herzlichen Glückwunsch! Sie haben den Lehrgang "Einrichten eines einfachen Android-Clients" abgeschlossen.
Sie können mit dem Code, den Sie hier entwickelt haben, weiter spielen und ihn für die Client-Seite Ihrer Anwendung anpassen, aber denken Sie daran, dass Sie die Serverkomponente Ihrer Anwendung, bevor sie in Produktion geht (siehe Einrichten Ihres Servers unten).

Eine fertige Version dieser Beispielanwendung finden Sie in der Basic-Video-Chat-Java Ordner des vonage-video-android-sdk-Beispiele Repo auf GitHub. Diese fertige Version fügt Code hinzu, um die Sitzungs-ID, das Token und den API-Schlüssel von einem Webdienst zu laden (anstatt hart kodierte Werte zu verwenden).

Nächste Schritte

Wenn Sie hier fertig sind, können Sie Ihre OpenTok-Application mit diesen hilfreichen Ressourcen weiter ausbauen und verbessern:

• Richten Sie Ihren Server ein – Bevor Sie in den Produktivbetrieb gehen, müssen Sie einen Server einrichten, um Anmeldedaten zu generieren
• Grundlagen der Video API – Falls Sie es noch nicht getan haben, nehmen Sie sich ein paar Minuten Zeit, um genau zu erfahren, wie OpenTok funktioniert.
• Code-Beispiele – eine Sammlung von Beispiel-Apps, die verschiedene OpenTok-Funktionen und Anwendungsfälle veranschaulichen
• Entwicklerhandbücher – ausführliche Dokumentation zu allen Funktionen und Merkmalen von OpenTok
• Weitere Tutorials – Anleitungen zur Implementierung weiterer OpenTok-Funktionen und Anwendungsfälle
• Android SDK-Referenz – Entdecken Sie die Methoden und Ereignisse des OpenTok Android SDK

Einrichten Ihres Servers

Im obigen Tutorial haben wir Sie gebeten, Ihre Anmeldedaten fest einprogrammieren. Für eine Produktionsanwendung gilt jedoch, dass die sessionId und token Die Werte in Ihrem Code müssen von Ihrem Anwendungsserver generiert und an den Client übergeben werden. Hier sind einige Gründe, warum Sie in Ihrer Produktionsanwendung keine fest eingestellten Anmeldedaten verwenden sollten:

• Token verfallen nach einer bestimmten Zeit (die bei der Generierung festgelegt wird), daher müssen regelmäßig neue generiert werden.
• Sie können keine neuen Sitzungen dynamisch erstellen, sodass alle Nutzer Ihrer App in einem einzigen „Raum“ festsitzen würden.

Sie können Ihre Anwendung weiterhin mit fest programmierten Werten testen, aber wenn Sie bereit sind, einen Server einzurichten, gibt es dafür verschiedene Möglichkeiten:

Server-Option 1 – Starten Sie mit einem Klick einen einfachen REST-Server auf Heroku

Dies ist wahrscheinlich der schnellste Weg, einen Server in Betrieb zu nehmen, allerdings ist der Funktionsumfang dabei eingeschränkt. Klicken Sie einfach auf die Heroku-Schaltfläche unten. Sie werden dann zur Heroku-Website weitergeleitet und aufgefordert, Ihren OpenTok-API-Schlüssel und Ihr API-Geheimnis einzugeben – diese Werte finden Sie auf Ihrer Projektseite in Ihrem Video API-Konto. Falls Sie noch keinen Heroku-Account haben, müssen Sie sich registrieren (das ist kostenlos).

Möchtest du dir den Code ansehen? Über die Schaltfläche oben wird der Servercode aus der Lernen mit OpenTok PHP GitHub-Repo. Besuchen Sie das Repo, um den Code sowie die zusätzliche Dokumentation einzusehen – Sie können das Repo sogar forken und vor der Bereitstellung Änderungen vornehmen.

Bevorzugen Sie Node.js? Besuchen Sie die Lernen mit OpenTok Node Repo für dieselbe Funktionalität mit Node.js (einschließlich einer Schaltfläche zum Bereitstellen auf Heroku).

Sobald der Server auf Heroku bereitgestellt ist, müssen Sie Ihrem Projekt etwas Code hinzufügen, um die Anmeldedaten vom Server abzurufen. Sehen Sie sich die Client-Implementierung in der Basic-Video-Chat-Java / Basic-Video-Chat-Kotlin Projekt.

Server-Option 2 – Komplette Neuerstellung mithilfe der Server-SDKs

Option 1 nutzt REST-Endpunkte zur Übertragung von Anmeldedaten an den Client, doch dies ist nur eine von vielen Möglichkeiten, einen Server mit OpenTok zu implementieren. Wenn Sie ein höheres Maß an Anpassung wünschen, können Sie sich die Dokumentation von OpenTok ansehen. Dokumentation zum Server-SDK für die Serversprache Ihrer Wahl (verfügbar für PHP, Node.js, Java, .NET, Python und Rubinrot). Die Dokumentation behandelt den Einrichtungsprozess und die verschiedenen Methoden, die Sie zum Generieren von Sitzungen und Tokens benötigen, sowie weitere serverseitige Funktionen.