# Guida introduttiva all'SDK di trasmissione IVS per Android \$1 Streaming a bassa latenza
Questo documento illustra i passaggi necessari per iniziare a utilizzare l'SDK di trasmissione per lo streaming a bassa latenza di Amazon IVS per Android.
## Installare la libreria
Per aggiungere la libreria di trasmissione di Amazon IVS per Android al proprio ambiente di sviluppo Android, aggiungere la libreria al file `build.gradle` come mostrato di seguito (per l'ultima versione dell'SDK di trasmissione di Amazon IVS):
```
repositories {
mavenCentral()
}
dependencies {
implementation 'com.amazonaws:ivs-broadcast:1.40.0'
}
```
In alternativa, per installare manualmente l'SDK, scaricare la versione più recente da questo percorso:
+ [https://search.maven.org/artifact/com.amazonaws/ivs-broadcast](https://search.maven.org/artifact/com.amazonaws/ivs-broadcast)
## Utilizzo dell'SDK con i simboli di debug
Pubblichiamo anche una versione dell'SDK di trasmissione per Android che include i simboli di debug. È possibile utilizzare questa versione per migliorare la qualità dei report di debug (tracce dello stack) in Firebase Crashlytics se si verificano arresti anomali nell'SDK di trasmissione IVS, ad esempio `libbroadcastcore.so`. Quando segnali questi arresti anomali al team dell'SDK di IVS, le tracce dello stack di qualità superiore facilitano la risoluzione dei problemi.
Per utilizzare questa versione dell'SDK, inserisci quanto segue nei tuoi file di build di Gradle:
```
implementation "com.amazonaws:ivs-broadcast:$version:unstripped@aar"
```
Utilizza la riga precedente invece di questa:
```
implementation "com.amazonaws:ivs-broadcast:$version@aar"
```
### Caricamento dei simboli in Firebase Crashlytics
Assicurati che i tuoi file di build Gradle siano configurati per Firebase Crashlytics. Segui le istruzioni di Google qui:
[https://firebase.google.com/docs/crashlytics/ndk-reports](https://firebase.google.com/docs/crashlytics/ndk-reports)
Assicurati di includere `com.google.firebase:firebase-crashlytics-ndk` come dipendenza.
Quando crei l'app per il rilascio, il plug-in Firebase Crashlytics dovrebbe caricare i simboli automaticamente. Per caricare i simboli manualmente, esegui uno dei comandi seguenti:
```
gradle uploadCrashlyticsSymbolFileRelease
```
```
./gradlew uploadCrashlyticsSymbolFileRelease
```
Non è un problema se i simboli vengono caricati due volte, automaticamente e manualmente.
### Impedire che .apk Release diventi più grande
Prima di impacchettare il file `.apk` di rilascio, il plug-in Android Gradle tenta automaticamente di rimuovere le informazioni di debug dalle librerie condivise (inclusa la libreria `libbroadcastcore.so` dell'SDK di trasmissione IVS). Tuttavia, a volte ciò non accade. Di conseguenza, il file `.apk` potrebbe diventare più grande e si potrebbe ricevere un messaggio di avviso dal plug-in Android Gradle che indica che non è in grado di rimuovere i simboli di debug e sta impacchettando i file `.so` così come sono. In tal caso, segui questa procedura:
+ Installa un NDK per Android. Va bene qualsiasi versione recente.
+ Aggiungi `ndkVersion ` al file `build.gradle` dell'applicazione. Fallo anche se l'applicazione non contiene codice nativo.
Per ulteriori informazioni, consulta questo [report sul problema](https://issuetracker.google.com/issues/353554169).
## Creare il listener di eventi
La configurazione di un listener di eventi consente di ricevere aggiornamenti di stato, notifiche di modifica del dispositivo, errori e informazioni sull'audio della sessione.
```
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);
}
};
```
## Richiedere autorizzazioni
L'app deve richiedere l'autorizzazione per accedere alla fotocamera e al microfono dell'utente. (Questo non riguarda solo Amazon IVS, ma qualsiasi applicazione che abbia bisogno di accedere alle fotocamere e ai microfoni.)
Qui, controlliamo se l'utente ha già concesso le autorizzazioni e, in caso contrario, le chiediamo:
```
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;
}
}
```
Qui, otteniamo la risposta dell'utente:
```
@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();
}
}
```
## Creare la sessione di trasmissione
L'interfaccia di trasmissione è `com.amazonaws.ivs.broadcast.BroadcastSession`. Inizializzarla con un preset, come mostrato di seguito. Se si verificano errori durante l'inizializzazione (ad esempio un errore nella configurazione di un codec), `BroadcastListener` mostrerà un messaggio di errore e `broadcastSession.isReady` sarà `false`.
**Importante:** tutte le chiamate all'SDK di trasmissione Amazon IVS per Android *devono* essere eseguite sul thread su cui viene istanziato l'SDK. *L'esecuzione di una chiamata da un thread diverso causerà un errore irreversibile dell'SDK e interromperà la trasmissione*.
```
// 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));
```
Consultare anche [Creare la sessione di trasmissione (versione avanzata)](broadcast-android-use-cases.md#broadcast-android-create-session-advanced).
## Impostare ImagePreviewView per l'anteprima
Se si desidera visualizzare un'anteprima per un dispositivo fotocamera attivo, aggiungere un'anteprima `ImagePreviewView` per il dispositivo dalla gerarchia delle visualizzazioni.
```
// 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);
}
}
});
```
## Avviare una trasmissione
Al nome host che si riceve nel campo di risposta `ingestEndpoint` dell'operazione `GetChannel` è necessario anteporre `rtmps://` e posporre `/app`. L'URL completo deve essere in questo formato: `rtmps://{{ ingestEndpoint }}/app`
```
broadcastSession.start(IVS_RTMPS_URL, IVS_STREAMKEY);
```
L'SDK di trasmissione Android supporta solo l'acquisizione RTMPS (non l'acquisizione RTMP non sicura).
## Interrompere una trasmissione
```
broadcastSession.stop();
```
## Rilasciare una sessione di trasmissione
Quando il lettore non è più in uso *deve essere invocato* il metodo `broadcastSession.release()`, per liberare le risorse utilizzate dalla libreria.
```
@Override
protected void onDestroy() {
super.onDestroy();
previewHolder.removeAllViews();
broadcastSession.release();
}
```