# IVS-Broadcast-SDK: Android-Handbuch \$1 Streaming mit niedriger Latenz
Das Android-Broadcast-SDK von IVS-Streaming mit niedriger Latenz bietet die für Broadcasting an IVS auf Android erforderlichen Schnittstellen.
Das Paket `com.amazonaws.ivs.broadcast` implementiert die in diesem Dokument beschriebene Schnittstelle. Folgende Operationen werden unterstützt:
+ Richten Sie eine Broadcast ein (initialisieren).
+ Broadcasting verwalten.
+ Eingabegeräte anfügen und trennen.
+ Eine Zusammensetzungssitzung verwalten.
+ Empfangen von Ereignissen.
+ Erhalten von Fehlermeldungen.
**Aktuelle Version des Broadcast-SDK für Android:** 1.40.0 ([Versionshinweise](https://docs.aws.amazon.com/ivs/latest/LowLatencyUserGuide/release-notes.html#mar12-26-broadcast-android-ll))
Informationen zu den wichtigsten Methoden, die im Amazon-IVS-Android-Broadcast-SDK verfügbar sind, finden Sie in der **Referenzdokumentation** unter [https://aws.github.io/amazon-ivs-broadcast-docs/1.40.0/android/](https://aws.github.io/amazon-ivs-broadcast-docs/1.40.0/android/).
**Beispiel-Code:** Siehe die Android-Beispiel-Sammlung auf GitHub: [https://github.com/aws-samples/amazon-ivs-broadcast-android-sample](https://github.com/aws-samples/amazon-ivs-broadcast-android-sample).
**Plattformanforderungen:** Android 9.0 und höher
# Erste Schritte mit dem IVS-Android-Broadcast-SDK \$1 Streaming mit niedriger Latenz
Dieses Dokument führt Sie durch die Schritte zum Einstieg in das Android-Broadcast-SDK für Amazon-IVS-Streaming mit niedriger Latenz.
## Bibliothek installieren
Wenn Sie der Android-Entwicklungsumgebung die Amazon-IVS-Android-Broadcast-Bibliothek hinzufügen möchten, fügen Sie die Bibliothek der `build.gradle` – wie hier gezeigt – (für die neueste Version des Amazon-IVS-Broadcast-SDK) zu Ihren Modulen hinzu:
```
repositories {
mavenCentral()
}
dependencies {
implementation 'com.amazonaws:ivs-broadcast:1.40.0'
}
```
Um das SDK manuell zu installieren, laden Sie alternativ die neueste Version von diesem Speicherort herunter:
+ [https://search.maven.org/artifact/com.amazonaws/ivs-broadcast](https://search.maven.org/artifact/com.amazonaws/ivs-broadcast)
## Verwenden des SDK mit Debug-Symbolen
Wir veröffentlichen auch eine Version des Android-Broadcast-SDK, die Debug-Symbole enthält. Sie können diese Version verwenden, um die Qualität von Debug-Berichten (Stack-Traces) in Firebase Crashlytics zu verbessern, falls im IVS-Broadcast-SDK Abstürze auftreten, d. h. `libbroadcastcore.so`. Wenn Sie diese Abstürze dem SDK-Team von IVS melden, erleichtern die qualitativ hochwertigeren Stack-Traces die Behebung der Probleme.
Um diese Version des SDK zu verwenden, fügen Sie Folgendes in Ihre Gradle-Build-Dateien ein:
```
implementation "com.amazonaws:ivs-broadcast:$version:unstripped@aar"
```
Verwenden Sie die obige Zeile anstelle von:
```
implementation "com.amazonaws:ivs-broadcast:$version@aar"
```
### Hochladen von Symbolen zu Firebase Crashlytics
Stellen Sie sicher, dass Ihre Gradle-Build-Dateien für Firebase Crashlytics eingerichtet sind. Folgen Sie den Anweisungen von Google hier:
[https://firebase.google.com/docs/crashlytics/ndk-reports](https://firebase.google.com/docs/crashlytics/ndk-reports)
Achten Sie darauf, `com.google.firebase:firebase-crashlytics-ndk` als Abhängigkeit anzugeben.
Wenn Sie Ihre App für die Veröffentlichung erstellen, muss das Firebase-Crashlytics-Plugin Symbole automatisch hochladen. Führen Sie einen der folgenden Befehle aus, um Symbole manuell hochzuladen:
```
gradle uploadCrashlyticsSymbolFileRelease
```
```
./gradlew uploadCrashlyticsSymbolFileRelease
```
(Es schadet nicht, wenn Symbole zweimal hochgeladen werden, sowohl automatisch als auch manuell.)
### Verhindern, dass Ihre APK-Version größer wird
Vor dem Verpacken der `.apk`-Release-Datei versucht das Android-Gradle-Plugin automatisch, Debug-Informationen aus gemeinsam genutzten Bibliotheken (einschließlich der `libbroadcastcore.so`-Bibliothek des IVS-Broadcast-SDK) zu entfernen. Manchmal geschieht dies jedoch nicht. Infolgedessen könnte Ihre `.apk`-Datei größer werden und Sie könnten vom Android-Gradle-Plugin eine Warnmeldung erhalten, dass es Debug-Symbole nicht entfernen kann und die `.so`-Dateien unverändert verpackt. Wenn dies passiert, gehen Sie wie folgt vor:
+ Installieren Sie ein Android-NDK. Jede aktuelle Version funktioniert.
+ Fügen Sie `ndkVersion ` zur `build.gradle`-Datei Ihrer Anwendung hinzu. Tun Sie dies auch dann, wenn Ihre Anwendung selbst keinen nativen Code enthält.
Weitere Informationen finden Sie in diesem [Problembericht](https://issuetracker.google.com/issues/353554169).
## Erstellen Sie den Ereignis-Listener
Durch das Einrichten eines Ereignis-Listener können Sie Statusaktualisierungen, Geräteänderungsbenachrichtigungen, Fehler und Sitzungsaudio-Informationen erhalten.
```
BroadcastSession.Listener broadcastListener =
new BroadcastSession.Listener() {
@Override
public void onStateChanged(@NonNull BroadcastSession.State state) {
Log.d(TAG, "State=" + state);
}
@Override
public void onError(@NonNull BroadcastException exception) {
Log.e(TAG, "Exception: " + exception);
}
};
```
## Berechtigungen anfordern
Ihre App muss die Berechtigung für den Zugriff auf die Kamera und das Mikrofon des Benutzers anfordern. (Dies ist nicht spezifisch für Amazon IVS; es ist für alle Anwendungen erforderlich, die Zugriff auf Kameras und Mikrofone benötigen.)
Hier prüfen wir, ob der Benutzer bereits Berechtigungen erteilt hat und fragen, wenn nicht, nach ihnen:
```
final String[] requiredPermissions =
{ Manifest.permission.CAMERA, Manifest.permission.RECORD_AUDIO };
for (String permission : requiredPermissions) {
if (ContextCompat.checkSelfPermission(this, permission)
!= PackageManager.PERMISSION_GRANTED) {
// If any permissions are missing we want to just request them all.
ActivityCompat.requestPermissions(this, requiredPermissions, 0x100);
break;
}
}
```
Hier erhalten wir die Antwort des Benutzers:
```
@Override
public void onRequestPermissionsResult(int requestCode,
@NonNull String[] permissions,
@NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode,
permissions, grantResults);
if (requestCode == 0x100) {
for (int result : grantResults) {
if (result == PackageManager.PERMISSION_DENIED) {
return;
}
}
setupBroadcastSession();
}
}
```
## Broadcast-Sitzung erstellen
Die Broadcast-Schnittstelle ist `com.amazonaws.ivs.broadcast.BroadcastSession`. Initialisieren Sie sie mit einer Voreinstellung wie unten gezeigt. Wenn während der Initialisierung Fehler auftreten (z. B. ein Fehler bei der Konfiguration eines Codecs), wird Ihr `BroadcastListener` eine Fehlermeldung erhalten und `broadcastSession.isReady` wird `false` sein.
**Wichtig:** Alle Anrufe an das Amazon IVS Broadcast SDK for Android *müssen* auf dem Thread erstellt werden, auf dem das SDK instanziiert wird. *Ein Aufruf von einem anderen Thread führt dazu, dass das SDK einen schwerwiegenden Fehler auslöst und die Übertragung stoppt*.
```
// Create a broadcast-session instance and sign up to receive broadcast
// events and errors.
Context ctx = getApplicationContext();
broadcastSession = new BroadcastSession(ctx,
broadcastListener,
Presets.Configuration.STANDARD_PORTRAIT,
Presets.Devices.FRONT_CAMERA(ctx));
```
Lesen Sie auch [Erstellen der Broadcast-Sitzung (Advanced-Version)](broadcast-android-use-cases.md#broadcast-android-create-session-advanced) .
## Festlegen der ImagePreviewView für die Vorschau
Wenn Sie eine Vorschau für ein aktives Kameragerät anzeigen möchten, fügen Sie die Vorschau `ImagePreviewView` für das Gerät zu Ihrer View-Hierarchie hinzu.
```
// awaitDeviceChanges will fire on the main thread after all pending devices
// attachments have been completed
broadcastSession.awaitDeviceChanges(() -> {
for(Device device: session.listAttachedDevices()) {
// Find the camera we attached earlier
if(device.getDescriptor().type == Device.Descriptor.DeviceType.CAMERA) {
LinearLayout previewHolder = findViewById(R.id.previewHolder);
ImagePreviewView preview = ((ImageDevice)device).getPreviewView();
preview.setLayoutParams(new LinearLayout.LayoutParams(
LinearLayout.LayoutParams.MATCH_PARENT,
LinearLayout.LayoutParams.MATCH_PARENT));
previewHolder.addView(preview);
}
}
});
```
## Starten eines Broadcastings
Dem Hostnamen, den Sie im Antwortfeld `ingestEndpoint` des Vorgangs `GetChannel` erhalten, muss `rtmps://` vorangestellt und `/app` angehängt werden. Die vollständige URL sollte sich in folgendem Format sein: `rtmps://{{ ingestEndpoint }}/app`
```
broadcastSession.start(IVS_RTMPS_URL, IVS_STREAMKEY);
```
Das Android-Broadcast-SDK unterstützt nur RTMPS-Ingest (kein unsicheres RTMP-Ingest).
## Anhalten eines Broadcastings
```
broadcastSession.stop();
```
## Broadcast-Sitzung freigeben
Die `broadcastSession.release()`-Methode *muss aufgerufen werden*, wenn der Player nicht mehr verwendet wird, um die Ressourcen freizugeben, die von der Bibliothek verwendet werden.
```
@Override
protected void onDestroy() {
super.onDestroy();
previewHolder.removeAllViews();
broadcastSession.release();
}
```
# Fortgeschrittene Anwendungsfälle für das IVS-Android-Broadcast-SDK \$1 Streaming mit niedriger Latenz
Hier stellen wir einige fortschrittliche Anwendungsfälle vor. Beginnen Sie mit dem obigen Basis-Setup und fahren Sie hier fort.
## Broadcast-Konfiguration erstellen
Hier erstellen wir eine benutzerdefinierte Konfiguration mit zwei Mischersteckplätzen, die es uns erlauben, zwei Videoquellen an den Mischer zu binden. Eine (`custom`) ist Vollbild und hinter der anderen angelegt (`camera`), die kleiner und in der unteren rechten Ecke ist. Beachten Sie, dass wir für den `custom`-Slot keine Position, Größe oder Seitenverhältnis festlegen. Da wir diese Parameter nicht einstellen, verwendet der Slot die Videoeinstellungen für Größe und Position.
```
BroadcastConfiguration config = BroadcastConfiguration.with($ -> {
$.audio.setBitrate(128_000);
$.video.setMaxBitrate(3_500_000);
$.video.setMinBitrate(500_000);
$.video.setInitialBitrate(1_500_000);
$.video.setSize(1280, 720);
$.mixer.slots = new BroadcastConfiguration.Mixer.Slot[] {
BroadcastConfiguration.Mixer.Slot.with(slot -> {
// Do not automatically bind to a source
slot.setPreferredAudioInput(
Device.Descriptor.DeviceType.UNKNOWN);
// Bind to user image if unbound
slot.setPreferredVideoInput(
Device.Descriptor.DeviceType.USER_IMAGE);
slot.setName("custom");
return slot;
}),
BroadcastConfiguration.Mixer.Slot.with(slot -> {
slot.setzIndex(1);
slot.setAspect(BroadcastConfiguration.AspectMode.FILL);
slot.setSize(300, 300);
slot.setPosition($.video.getSize().x - 350,
$.video.getSize().y - 350);
slot.setName("camera");
return slot;
})
};
return $;
});
```
## Erstellen der Broadcast-Sitzung (Advanced-Version)
Erstellen Sie eine `BroadcastSession` wie im [grundlegenden Beispiel](broadcast-android-getting-started.md#broadcast-android-create-session), geben Sie jedoch hier Ihre benutzerdefinierte Konfiguration an. Geben Sie auch `null` für das Gerätearray an, da wir diese manuell hinzufügen werden.
```
// Create a broadcast-session instance and sign up to receive broadcast
// events and errors.
Context ctx = getApplicationContext();
broadcastSession = new BroadcastSession(ctx,
broadcastListener,
config, // The configuration we created above
null); // We’ll manually attach devices after
```
## Iterieren und Anschließen eines Kamerageräts
Hier iterieren wir durch Eingabegeräte, die das SDK erkannt hat. Auf Android 7 (Nougat) gibt dies nur Standard-Mikrofongeräte zurück, da das Amazon-IVS-Broadcast-SDK die Auswahl nicht standardmäßiger Geräte auf dieser Android-Version nicht unterstützt.
Sobald wir ein Gerät gefunden haben, das wir verwenden möchten, rufen wir `attachDevice` auf, um es anzuhängen. Eine Lambda-Funktion wird auf dem Hauptthread aufgerufen, wenn das Anhängen des Eingabegeräts abgeschlossen ist. Im Falle eines Fehlers erhalten Sie einen Fehler im Listener.
```
for(Device.Descriptor desc: BroadcastSession.listAvailableDevices(getApplicationContext())) {
if(desc.type == Device.Descriptor.DeviceType.CAMERA &&
desc.position == Device.Descriptor.Position.FRONT) {
session.attachDevice(desc, device -> {
LinearLayout previewHolder = findViewById(R.id.previewHolder);
ImagePreviewView preview = ((ImageDevice)device).getPreviewView();
preview.setLayoutParams(new LinearLayout.LayoutParams(
LinearLayout.LayoutParams.MATCH_PARENT,
LinearLayout.LayoutParams.MATCH_PARENT));
previewHolder.addView(preview);
// Bind the camera to the mixer slot we created above.
session.getMixer().bind(device, "camera");
});
break;
}
}
```
## Kameras austauschen
```
// This assumes you’ve kept a reference called "currentCamera" that points to
// a front facing camera
for(Device device: BroadcastSession.listAvailableDevices()) {
if(device.type == Device.Descriptor.DeviceType.CAMERA &&
Device.position != currentCamera.position) {
// Remove the preview view for the old device.
// setImagePreviewTextureView is an example function
// that handles your view hierarchy.
setImagePreviewView(null);
session.exchangeDevices(currentCamera, device, camera -> {
// Set the preview view for the new device.
setImagePreviewView(camera.getPreviewView());
currentCamera = camera;
});
break;
}
}
```
## Erstellen einer Eingabe-Oberfläche
Um Audio- oder Image-Daten einzugeben, die von Ihrer App generiert werden, verwenden Sie `createImageInputSource` oder `createAudioInputSource`. Beide Methoden erstellen und verbinden virtuelle Geräte, die wie jedes andere Gerät an den Mischer gebunden werden können.
Das von `createImageInputSource` zurückgegebene `SurfaceSource` hat eine `getInputSurface`-Methode, die Ihnen eine `Surface` gibt, die Sie mit der Camera2-API, OpenGL oder Vulkan oder allem anderen verwenden können, das auf ein Surface schreiben kann.
Das von `createAudioInputSource` zurückgegebene `AudioDevice` kann lineare PCM-Daten empfangen, die von AudioRecorder oder auf andere Weise generiert wurden.
```
SurfaceSource source = session.createImageInputSource();
Surface surface = source.getInputSurface();
session.getMixer().bind(source, “custom”);
```
## Trennen eines Geräts
Wenn Sie ein Gerät trennen und nicht ersetzen möchten, trennen Sie es mit `Device` oder `Device.Descriptor`.
```
session.detachDevice(currentCamera);
```
## Bildschirm- und System-Audioaufnahme
Das Amazon IVS Broadcast SDK for Android enthält einige Helfer, die die Erfassung des Bildschirms des Geräts (Android 6 und höher) und des Systemaudio (Android 10 und höher) vereinfachen. Wenn Sie diese manuell verwalten möchten, können Sie eine benutzerdefinierte Image-Eingabequelle und eine benutzerdefinierte Audioeingangsquelle erstellen.
Um eine Bildschirm- und System-Audioaufnahme-Sitzung zu erstellen, müssen Sie zunächst eine Berechtigungsanforderungsabsicht erstellen:
```
public void startScreenCapture() {
MediaProjectionManager manager =
(MediaProjectionManager) getApplicationContext()
.getSystemService(Context.MEDIA_PROJECTION_SERVICE);
if(manager != null) {
Intent intent = manager.createScreenCaptureIntent();
startActivityIfNeeded(intent, SCREEN_CAPTURE_REQUEST_ID);
}
}
```
Um dieses Feature zu verwenden, müssen Sie eine Klasse bereitstellen, die `com.amazonaws.ivs.broadcast.SystemCaptureService` erweitert. Sie müssen keine ihrer Methoden außer Kraft setzen, aber die Klasse muss da sein, um mögliche Kollisionen zwischen Services zu vermeiden.
Sie müssen auch ein paar Elemente zu Ihrem Android-Manifest hinzufügen:
```
...
```
Ihre Klasse, die `SystemCaptureService` erweitert, muss im ``-Element benannt werden. Unter Android 9 und höher muss `foregroundServiceType` eine `mediaProjection` sein.
Sobald die Berechtigungsabsicht zurückgegeben wurde, können Sie mit der Erstellung des Bildschirms und der Audioaufnahmesitzung des Systems fortfahren. Unter Android 8 und höher müssen Sie eine Benachrichtigung bereitstellen, die im Benachrichtigungsbereich Ihres Benutzers angezeigt wird. Das Amazon IVS Broadcast SDK for Android bietet die bequeme Methode `createServiceNotificationBuilder`. Alternativ können Sie Ihre eigene Benachrichtigung mitteilen.
```
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if(requestCode != SCREEN_CAPTURE_REQUEST_ID
|| Activity.RESULT_OK != resultCode) {
return;
}
Notification notification = null;
if(Build.VERSION.SDK_INT >= 26) {
Intent intent = new Intent(getApplicationContext(),
NotificationActivity.class);
notification = session
.createServiceNotificationBuilder("example",
"example channel", intent)
.build();
}
session.createSystemCaptureSources(data,
ExampleSystemCaptureService.class,
Notification,
devices -> {
// This step is optional if the mixer slots have been given preferred
// input device types SCREEN and SYSTEM_AUDIO
for (Device device : devices) {
session.getMixer().bind(device, "game");
}
});
}
```
## Empfohlene Broadcast-Einstellungen erhalten
Um die Verbindung Ihres Benutzers vor dem Starten einer Übertragung zu bewerten, verwenden Sie die `recommendedVideoSettings`-Methode, um einen kurzen Test durchzuführen. Während der Test läuft, erhalten Sie mehrere Empfehlungen, die von den meisten bis am wenigsten empfohlen bestellt werden. In dieser Version des SDK ist es nicht möglich, die aktuelle `BroadcastSession` neu zu konfigurieren, daher müssen Sie sie `release()` und dann eine neue mit den empfohlenen Einstellungen erstellen. Sie erhalten weiterhin `BroadcastSessionTest.Results` bis `Result.status` `SUCCESS` ist oder `ERROR`. Sie können den Fortschritt mit überprüfen `Result.progress`.
Amazon IVS unterstützt eine maximale Bitrate von 8,5 Mbit/s (für Kanäle, deren `type` `STANDARD` oder `ADVANCED` ist), so dass die `maximumBitrate`, die von dieser Methode zurückgegeben wird, nie 8,5 Mbps überschreitet. Um kleine Schwankungen der Netzwerkleistung zu berücksichtigen, ist die von dieser Methode empfohlene `initialBitrate` etwas niedriger als die im Test gemessene tatsächliche Bitrate. (Die Verwendung von 100 % der verfügbaren Bandbreite ist in der Regel nicht ratsam.)
```
void runBroadcastTest() {
this.test = session.recommendedVideoSettings(RTMPS_ENDPOINT, RTMPS_STREAMKEY,
result -> {
if (result.status == BroadcastSessionTest.Status.SUCCESS) {
this.recommendation = result.recommendations[0];
}
});
}
```
## Verwenden der automatischen Wiederverbindung
IVS unterstützt die automatische Wiederverbindung mit einem Broadcast, falls der Broadcast unerwartet beendet wird, ohne die `stop`-API aufzurufen, z. B. bei einem vorübergehenden Verlust der Netzwerkkonnektivität. Rufen Sie `setEnabled(true)` für `BroadcastConfiguration.autoReconnect` auf, um die automatische Wiederverbindung zu aktivieren.
Wenn der Stream aus irgendeinem Grund unerwartet beendet wird, versucht das SDK die Wiederverbindung bis zu fünf Mal. Dabei folgt es einer linearen Backoff-Strategie. Es benachrichtigt Ihre Anwendung mithilfe der Methode `BroadcastSession.Listener.onRetryStateChanged` über den Status der erneuten Versuche.
Die automatische Wiederverbindung nutzt im Hintergrund die IVS-Funktion für die [Stream-Übernahme](streaming-config.md#streaming-config-stream-takeover), indem eine Prioritätsnummer, beginnend mit 1, an das Ende des bereitgestellten Stream-Schlüssels angehängt wird. Für die Dauer der `BroadcastSession`-Instance wird diese Zahl bei jedem erneuten Verbindungsversuch um 1 erhöht. Das bedeutet Folgendes: Wenn die Verbindung des Geräts während eines Broadcasts viermal unterbrochen wird und für jede Unterbrechung 1–4 Wiederholungsversuche erforderlich sind, kann die Priorität des letzten Streamups zwischen 5 und 17 liegen. Aus diesem Grund *empfehlen wir, die IVS-Stream-Übernahme von einem anderen Gerät nicht zu verwenden, solange die automatische Wiederverbindung im SDK für denselben Kanal aktiviert ist*. Es gibt keine Garantie dafür, welche Priorität das SDK zu diesem Zeitpunkt verwendet, und das SDK versucht, die Verbindung mit einer höheren Priorität wiederherzustellen, wenn ein anderes Gerät den Stream übernimmt.
## Verwenden von Bluetooth-Mikrofonen
Um mit Bluetooth-Mikrofongeräten zu senden, müssen Sie eine Bluetooth-SCO-Verbindung herstellen:
```
Bluetooth.startBluetoothSco(context);
// Now bluetooth microphones can be used
…
// Must also stop bluetooth SCO
Bluetooth.stopBluetoothSco(context);
```
# Bekannte Probleme und Problemumgehungen im IVS-Android-Broadcast-SDK \$1 Streaming mit niedriger Latenz
In diesem Dokument werden bekannte Probleme aufgeführt, die bei der Verwendung des Android-Broadcast-SDK für Amazon-IVS-Streaming mit niedriger Latenz auftreten können, und es werden mögliche Problemumgehungen vorgeschlagen.
+ Die Verwendung eines externen Mikrofons, das über Bluetooth verbunden ist, kann instabil sein. Wenn ein Bluetooth-Gerät während einer Broadcast-Sitzung verbunden oder getrennt wird, funktioniert die Mikrofoneingabe möglicherweise nicht mehr, bis das Gerät explizit getrennt und wieder angeschlossen ist.
**Problemumgehung:** Wenn Sie ein Bluetooth-Headset verwenden möchten, verbinden Sie es, bevor Sie das Broadcasting starten und lassen Sie es während des gesamten Broadcastings verbunden.
+ Das Broadcast-SDK unterstützt keinen Zugriff auf externe Kameras, die über USB verbunden sind.
**Problemumgehung:** Verwenden Sie keine externen Kameras, die über USB verbunden sind.
+ Das Absenden von Audiodaten schneller als in Echtzeit (mit einer benutzerdefinierten Audioquelle) führt zu einer Audiodrift.
**Problemumgehung:** Senden Sie Audiodaten nicht schneller als in Echtzeit ab.
+ Geräte mit Android 6 und 7 können die Callbacks `onDeviceAdded` und `onDeviceRemoved` des Broadcast-SDK für Mikrofone nicht empfangen, da diese Android-Versionen nur das Standardmikrofon des Systems zulassen.
**Workaround:** Für diese Geräte verwendet das Broadcast-SDK das Standardmikrofon des Systems.
+ Wenn eine `ImagePreviewView` in einem übergeordneten Element entfernt wird (`removeView()` wird z. B. im übergeordneten Element aufgerufen), wird die `ImagePreviewView` sofort freigegeben. Die `ImagePreviewView` zeigt keine Frames an, wenn sie einer anderen übergeordneten Ansicht hinzugefügt wird.
**Problemumgehung:** Fordern Sie mit `getPreview` eine andere Vorschau an.
+ Einige Android-Videoencoder können nicht mit einer Videogröße von weniger als 176 × 176 konfiguriert werden. Die Konfiguration einer kleineren Größe verursacht einen Fehler und verhindert das Streaming.
**Problemumgehung:** Konfigurieren Sie die Videogröße nicht auf weniger als 176 × 176.
+ Die Aktivierung von B-Frames kann die Komprimierungsqualität verbessern. Einige Encoder bieten jedoch bei aktivierten B-Frames eine weniger präzise Steuerung der Bitrate, was bei Netzwerkschwankungen zu Problemen führen kann.
**Problemumgehung:** Wenn für Ihren Anwendungsfall die Einhaltung einer konstanten Bitrate wichtiger ist als die Effizienz der Komprimierung, sollten Sie B-Frames deaktivieren.