# Conceitos básicos do SDK de Transmissão para Android do IVS \$1 Streaming de baixa latência
Este documento descreve as etapas envolvidas ao começar a usar o SDK de Transmissão para Android para streaming de baixa latência do Amazon IVS.
## Instalar a biblioteca
Para adicionar a biblioteca de transmissão do Amazon IVS para Android a seu ambiente de desenvolvimento do Android, adicione a biblioteca ao seu arquivo `build.gradle` do módulo, conforme mostrado aqui (para a versão mais recente do SDK de Transmissão do Amazon IVS):
```
repositories {
mavenCentral()
}
dependencies {
implementation 'com.amazonaws:ivs-broadcast:1.40.0'
}
```
Como alternativa, para instalar o SDK manualmente, baixe a versão mais recente neste local:
+ [https://search.maven.org/artifact/com.amazonaws/ivs-broadcast](https://search.maven.org/artifact/com.amazonaws/ivs-broadcast)
## Usar o SDK com símbolos de depuração
Também publicamos uma versão do SDK de Transmissão para Android que inclui símbolos de depuração. Você pode usar essa versão para melhorar a qualidade dos relatórios de depuração (rastreamentos de pilha) no Firebase Crashlytics, caso encontre falhas no SDK de Transmissão do IVS, ou seja, `libbroadcastcore.so`. Quando você relata essas falhas à equipe do SDK do IVS, os rastreamentos de pilha de maior qualidade facilitam a correção dos problemas.
Para usar essa versão do SDK, coloque o seguinte nos arquivos de compilação do Gradle:
```
implementation "com.amazonaws:ivs-broadcast:$version:unstripped@aar"
```
Usar a linha acima em vez desta:
```
implementation "com.amazonaws:ivs-broadcast:$version@aar"
```
### Upload de símbolos para o Firebase Crashlytics
Certifique-se de que os arquivos de compilação do Gradle estejam configurados para o Firebase Crashlytics. Siga as instruções do Google aqui:
[https://firebase.google.com/docs/crashlytics/ndk-reports](https://firebase.google.com/docs/crashlytics/ndk-reports)
Certifique-se de incluir `com.google.firebase:firebase-crashlytics-ndk` como dependência.
Ao criar a aplicação para lançamento, o plug-in do Firebase Crashlytics deve fazer o upload dos símbolos automaticamente. Para fazer o upload dos símbolos manualmente, execute um dos seguintes comandos:
```
gradle uploadCrashlyticsSymbolFileRelease
```
```
./gradlew uploadCrashlyticsSymbolFileRelease
```
(Não haverá problema algum se os símbolos forem carregados duas vezes, tanto automática quanto manualmente.)
### Impedir que o arquivo .apk de lançamento fique maior
Antes de empacotar o arquivo `.apk` de lançamento, o plug-in do Gradle para Android tenta automaticamente remover as informações de depuração das bibliotecas compartilhadas (incluindo a biblioteca `libbroadcastcore.so` do SDK de Transmissão do IVS). No entanto, às vezes isso não acontece. Como resultado, o arquivo `.apk` pode ficar maior e é possível que você receba uma mensagem de aviso do plug-in do Gradle para Android informando que ele não consegue remover os símbolos de depuração e que está empacotando os arquivos `.so` da forma como estão. Se isso acontecer, faça o seguinte:
+ Instale um Android NDK. Qualquer versão recente funcionará.
+ Adicione `ndkVersion ` ao arquivo `build.gradle` da aplicação. Faça isso mesmo que a aplicação não contenha código nativo.
Para obter mais informações, consulte este [relatório de problemas](https://issuetracker.google.com/issues/353554169).
## Criar listener de eventos
A configuração de um listener de eventos permite receber atualizações de estado, notificações de alteração de dispositivo, erros e informações sobre áudio de sessão.
```
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);
}
};
```
## Solicitar permissões
Sua aplicação deverá solicitar permissão para acessar a câmera e o microfone do usuário. (Isso não é específico do Amazon IVS; é necessário para qualquer aplicação que precise acessar câmeras e microfones.)
Aqui, verificamos se o usuário já concedeu permissões e, caso contrário, nós as solicitamos:
```
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;
}
}
```
Aqui, recebemos a resposta do usuário:
```
@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();
}
}
```
## Criar a sessão de transmissão
A interface da transmissão é `com.amazonaws.ivs.broadcast.BroadcastSession`. Inicialize-a com uma predefinição, conforme mostrado abaixo. Se houver algum erro durante a inicialização (como uma falha na configuração de um codec), o `BroadcastListener` receberá uma mensagem de erro e `broadcastSession.isReady` será `false`.
**Importante:** todas as chamadas para o Amazon IVS Broadcast SDK for Android *deverão* ser feitas no thread em que o SDK está instanciado. *Uma chamada de um thread diferente fará com que o SDK emita um erro fatal e interrompa a transmissão*.
```
// 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));
```
Também consulte [Criar a sessão de transmissão (versão avançada)](broadcast-android-use-cases.md#broadcast-android-create-session-advanced) .
## Definir o ImagePreviewView para pré-visualização
Caso você queira ver uma pré-visualização em um dispositivo de câmera ativo, adicione uma pré-visualização `ImagePreviewView` ao dispositivo para sua hierarquia de exibição.
```
// 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);
}
}
});
```
## Iniciar uma transmissão
O nome de host que você recebe no campo de resposta `ingestEndpoint` da operação `GetChannel` precisa ser precedido de `rtmps://` e ter `/app` anexado. O URL completo deve estar no seguinte formato: `rtmps://{{ ingestEndpoint }}/app`
```
broadcastSession.start(IVS_RTMPS_URL, IVS_STREAMKEY);
```
O SDK de Transmissão para Android oferece suporte somente à ingestão de RTMPS (e não à ingestão insegura de RTMP).
## Interromper uma transmissão
```
broadcastSession.stop();
```
## Lançar sessão de transmissão do Android
É *necessário chamar* o método `broadcastSession.release()` quando a sessão de transmissão não estiver mais em uso para liberar os recursos usados pela biblioteca.
```
@Override
protected void onDestroy() {
super.onDestroy();
previewHolder.removeAllViews();
broadcastSession.release();
}
```