As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Use a biblioteca de produtores do Android
Você pode usar a biblioteca de produtores Android fornecida pelo Amazon Kinesis Video Streams para escrever código de aplicativo, com configuração mínima, para enviar dados de mídia de um dispositivo Android para um stream de vídeo do Kinesis.
Execute as etapas a seguir para integrar seu código ao Kinesis Video Streams para que seu aplicativo possa começar a transmitir dados para seu stream de vídeo do Kinesis:
1. Crie uma instância do objeto `KinesisVideoClient`.
1. Crie um objeto `MediaSource` fornecendo informações de fonte de mídia. Por exemplo, ao criar uma fonte de mídia de câmera, você fornece informações como a identificação da câmera e a especificação da codificação usada pela câmera.
Quando quiser iniciar o streaming, você precisará criar uma fonte de mídia personalizada.
## Procedimento: usar o SDK do produtor Android
Este procedimento demonstra como usar o cliente produtor Android do Kinesis Video Streams em seu aplicativo Android para enviar dados para seu stream de vídeo do Kinesis.
Este procedimento inclui as seguintes etapas:
+ [Pré-requisitos](producersdk-android-prerequisites.md)
+ [Baixe e configure o código da biblioteca do produtor Android](producersdk-android-downloadcode.md)
+ [Examine o código](producersdk-android-writecode.md)
+ [Execute e verifique o código](producersdk-android-reviewcode.md)
# Pré-requisitos
Recomendamos o [Android Studio](https://developer.android.com/studio/index.html) para examinar, editar e executar o código do aplicativo. Recomendamos usar a versão estável mais recente.
No código de amostra, você fornece as credenciais do Amazon Cognito.
**Topics**
+ [Configurar um grupo de usuários](#set-up-user-pool)
+ [Configurar um pool de identidades](#set-up-identity-pool)
## Configurar um grupo de usuários
**Para configurar um grupo de usuários**
1. Faça login no [console do Amazon Cognito](https://console.aws.amazon.com/cognito/home) e verifique se a região está correta.
1. Na navegação à esquerda, escolha **Grupos de usuários**.
1. Na seção **Grupos de usuários**, escolha **Criar grupo de usuários**.
1. Complete as seguintes seções:
1. **Etapa 1: Configurar a experiência de login - Na** seção **Opções de login do grupo de usuários do Cognito, selecione as opções apropriadas**.
Escolha **Próximo**.
1. **Etapa 2: Configurar os requisitos de segurança** - Selecione as opções apropriadas.
Escolha **Próximo**.
1. **Etapa 3: Configurar a experiência de inscrição** - Selecione as opções apropriadas.
Escolha **Próximo**.
1. **Etapa 4: Configurar a entrega de mensagens** - Selecione as opções apropriadas.
No campo de **seleção de função do IAM**, selecione uma função existente ou crie uma nova função.
Escolha **Próximo**.
1. **Etapa 5: integre seu aplicativo** - Selecione as opções apropriadas.
No campo **Cliente inicial do aplicativo**, escolha **Cliente confidencial**.
Escolha **Próximo**.
1. **Etapa 6: Revisar e criar** - Revise suas seleções das seções anteriores e escolha **Criar grupo de usuários**.
1. Na página **Grupos de usuários**, selecione o pool que você acabou de criar.
Copie o **ID do grupo de usuários** e anote isso para mais tarde. No `awsconfiguration.json` arquivo, isso é`CognitoUserPool.Default.PoolId`.
1. Selecione a guia **Integração de aplicativos** e vá até a parte inferior da página.
1. Na seção **Lista de clientes do aplicativo**, escolha o **nome do cliente do aplicativo** que você acabou de criar.
Copie o **ID do cliente** e anote isso para mais tarde. No `awsconfiguration.json` arquivo, isso é`CognitoUserPool.Default.AppClientId`.
1. Mostre o **segredo do cliente** e anote isso para mais tarde. No `awsconfiguration.json` arquivo, isso é`CognitoUserPool.Default.AppClientSecret`.
## Configurar um pool de identidades
**Para configurar um grupo de identidades**
1. Faça login no [console do Amazon Cognito](https://console.aws.amazon.com/cognito/home) e verifique se a região está correta.
1. Na navegação à esquerda, escolha **Pools de identidade**.
1. Selecione **Criar banco de identidades**.
1. Configure o banco de identidades.
1. **Etapa 1: Configurar a confiança do grupo de identidades** - Conclua as seguintes seções:
+ **Acesso do usuário** - Selecione Acesso **autenticado**
+ **Fontes de identidade autenticadas** - Selecione o grupo de usuários **do Amazon Cognito**
Escolha **Próximo**.
1. **Etapa 2: Configurar permissões** - Na seção **Função autenticada**, preencha os seguintes campos:
+ **Função do IAM** - selecione **Criar uma nova função do IAM**
+ **Nome da função do IAM** - insira um nome e anote-o para uma etapa posterior.
Escolha **Próximo**.
1. **Etapa 3: Conectar provedores de identidade** - Na seção **Detalhes do grupo de usuários**, preencha os seguintes campos:
+ **ID do grupo de usuários** - Selecione o grupo de usuários que você criou anteriormente.
+ **ID do cliente do aplicativo** - Selecione o ID do cliente do aplicativo que você criou anteriormente.
Escolha **Próximo**.
1. **Etapa 4: Configurar propriedades** - Digite um nome no campo **Nome do pool de identidades**.
Escolha **Próximo**.
1. **Etapa 5: Revisar e criar** - Revise suas seleções em cada uma das seções e selecione **Criar grupo de identidades**.
1. Na página **Conjuntos de identidades**, selecione seu novo grupo de identidades.
Copie o **ID do grupo de identidades** e anote isso para mais tarde. No `awsconfiguration.json` arquivo, isso é`CredentialsProvider.CognitoIdentity.Default.PoolId`.
1. Atualize as permissões para a função do IAM.
1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Na navegação à esquerda, escolha **Funções**.
1. Encontre e selecione a função que você criou acima.
**nota**
Use a barra de pesquisa, se necessário.
1. Selecione a política de permissões anexada.
Selecione **Editar**.
1. Selecione a guia **JSON** e substitua a política pela seguinte:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"cognito-identity:*",
"kinesisvideo:*"
],
"Resource": [
"*"
]
}
]
}
```
------
Escolha **Próximo**.
1. Selecione a caixa ao lado de **Definir esta nova versão como padrão**, se ela ainda não estiver selecionada.
Selecione **Salvar alterações**.
# Baixe e configure o código da biblioteca do produtor Android
Nesta seção do procedimento da biblioteca de produtores do Android, você baixa o código de exemplo do Android e abre o projeto no Android Studio.
Para ver os pré-requisitos e outros detalhes sobre esse exemplo, consulte Como [usar a biblioteca de produtores do Android](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-sdk-android.html).
1. Crie um diretório e, em seguida, clone o AWS Mobile SDK para Android do GitHub repositório.
```
git clone https://github.com/awslabs/aws-sdk-android-samples
```
1. Abra o [Android Studio](https://developer.android.com/studio/index.html).
1. Na tela de abertura, escolha **Open an existing Android Studio project**.
1. Navegue até o diretório `aws-sdk-android-samples/AmazonKinesisVideoDemoApp` e escolha **OK**.
1. Abra o arquivo `AmazonKinesisVideoDemoApp/src/main/res/raw/awsconfiguration.json`.
No `CredentialsProvider` nó, forneça o ID do grupo de identidades do procedimento **Para configurar um grupo de identidades** na seção [Pré-requisitos](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-sdk-android.html#producersdk-android-prerequisites) e forneça seu Região da AWS (por exemplo,). **us-west-2**
No `CognitoUserPool` nó, forneça o segredo do cliente do aplicativo, o ID do cliente do aplicativo e o ID do pool no procedimento **Para configurar um grupo de usuários** na seção [Pré-requisitos](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-sdk-android.html#producersdk-android-prerequisites) e forneça seu Região da AWS (por exemplo,). **us-west-2**
1. Seu arquivo `awsconfiguration.json` será semelhante ao seguinte:
```
{
"Version": "1.0",
"CredentialsProvider": {
"CognitoIdentity": {
"Default": {
"PoolId": "us-west-2:01234567-89ab-cdef-0123-456789abcdef",
"Region": "us-west-2"
}
}
},
"IdentityManager": {
"Default": {}
},
"CognitoUserPool": {
"Default": {
"AppClientSecret": "abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmno",
"AppClientId": "0123456789abcdefghijklmnop",
"PoolId": "us-west-2_qRsTuVwXy",
"Region": "us-west-2"
}
}
}
```
1. Atualize o `AmazonKinesisVideoDemoApp/src/main/java/com/amazonaws/kinesisvideo/demoapp/KinesisVideoDemoApp.java` com sua região (no exemplo a seguir, está definido como **US\$1WEST\$12**):
```
public class KinesisVideoDemoApp extends Application {
public static final String TAG = KinesisVideoDemoApp.class.getSimpleName();
public static Regions KINESIS_VIDEO_REGION = Regions.US_WEST_2;
```
Para obter informações sobre Região da AWS constantes, consulte [Regiões](https://aws-amplify.github.io/aws-sdk-android/docs/reference/com/amazonaws/regions/Regions.html).
# Examine o código
Nesta seção do [procedimento da biblioteca de produtores do Android](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-sdk-android.html), você examina o código de exemplo.
O aplicativo de teste do Android (`AmazonKinesisVideoDemoApp`) mostra o padrão de codificação a seguir:
+ Crie uma instância de `KinesisVideoClient`.
+ Crie uma instância de `MediaSource`.
+ Inicie o streaming. Inicie o`MediaSource`, e ele começa a enviar dados para o cliente.
As seguintes seções fornecem detalhes.
## Crie uma instância de KinesisVideoClient
Você cria um objeto `[KinesisVideoClient](https://github.com/aws-amplify/aws-sdk-android/blob/main/aws-android-sdk-kinesisvideo/src/main/java/com/amazonaws/kinesisvideo/client/KinesisVideoClient.java)` chamando a operação `[createKinesisVideoClient](https://github.com/aws-amplify/aws-sdk-android/blob/main/aws-android-sdk-kinesisvideo/src/main/java/com/amazonaws/mobileconnectors/kinesisvideo/client/KinesisVideoAndroidClientFactory.java)`.
```
mKinesisVideoClient = KinesisVideoAndroidClientFactory.createKinesisVideoClient(
getActivity(),
KinesisVideoDemoApp.KINESIS_VIDEO_REGION,
KinesisVideoDemoApp.getCredentialsProvider());
```
Para `KinesisVideoClient` fazer chamadas de rede, ele precisa de credenciais para autenticar. Você passa uma instância de`AWSCredentialsProvider`, que lê suas credenciais do Amazon Cognito do `awsconfiguration.json` arquivo que você modificou na seção anterior.
## Crie uma instância de MediaSource
Para enviar bytes para seu stream de vídeo do Kinesis, você deve produzir os dados. O Amazon Kinesis Video Streams `[MediaSource](https://github.com/aws-amplify/aws-sdk-android/blob/main/aws-android-sdk-kinesisvideo/src/main/java/com/amazonaws/kinesisvideo/internal/client/mediasource/MediaSource.java)` fornece a interface, que representa a fonte de dados.
Por exemplo, a biblioteca Android do Kinesis Video Streams `[AndroidCameraMediaSource](https://github.com/aws-amplify/aws-sdk-android/blob/main/aws-android-sdk-kinesisvideo/src/main/java/com/amazonaws/mobileconnectors/kinesisvideo/mediasource/android/AndroidCameraMediaSource.java)` fornece a implementação `MediaSource` da interface. Essa classe lê dados de uma das câmeras do dispositivo.
No exemplo de código a seguir (do arquivo `[fragment/StreamConfigurationFragment.java](https://github.com/awslabs/aws-sdk-android-samples/blob/main/AmazonKinesisVideoDemoApp/src/main/java/com/amazonaws/kinesisvideo/demoapp/fragment/StreamConfigurationFragment.java)`), é criada a configuração para a origem da mídia:
```
private AndroidCameraMediaSourceConfiguration getCurrentConfiguration() {
return new AndroidCameraMediaSourceConfiguration(
AndroidCameraMediaSourceConfiguration.builder()
.withCameraId(mCamerasDropdown.getSelectedItem().getCameraId())
.withEncodingMimeType(mMimeTypeDropdown.getSelectedItem().getMimeType())
.withHorizontalResolution(mResolutionDropdown.getSelectedItem().getWidth())
.withVerticalResolution(mResolutionDropdown.getSelectedItem().getHeight())
.withCameraFacing(mCamerasDropdown.getSelectedItem().getCameraFacing())
.withIsEncoderHardwareAccelerated(
mCamerasDropdown.getSelectedItem().isEndcoderHardwareAccelerated())
.withFrameRate(FRAMERATE_20)
.withRetentionPeriodInHours(RETENTION_PERIOD_48_HOURS)
.withEncodingBitRate(BITRATE_384_KBPS)
.withCameraOrientation(-mCamerasDropdown.getSelectedItem().getCameraOrientation())
.withNalAdaptationFlags(StreamInfo.NalAdaptationFlags.NAL_ADAPTATION_ANNEXB_CPD_AND_FRAME_NALS)
.withIsAbsoluteTimecode(false));
}
```
No exemplo de código a seguir (do arquivo `[fragment/StreamingFragment.java](https://github.com/awslabs/aws-sdk-android-samples/blob/main/AmazonKinesisVideoDemoApp/src/main/java/com/amazonaws/kinesisvideo/demoapp/fragment/StreamingFragment.java)`), é criada a origem da mídia:
```
mCameraMediaSource = (AndroidCameraMediaSource) mKinesisVideoClient
.createMediaSource(mStreamName, mConfiguration);
```
## Inicie a fonte de mídia
Inicie a fonte de mídia para que ele possa começar a gerar dados e enviá-los ao cliente. O exemplo de código a seguir é do arquivo `[fragment/StreamingFragment.java](https://github.com/awslabs/aws-sdk-android-samples/blob/main/AmazonKinesisVideoDemoApp/src/main/java/com/amazonaws/kinesisvideo/demoapp/fragment/StreamingFragment.java)`:
```
mCameraMediaSource.start();
```
# Execute e verifique o código
Para executar o aplicativo de exemplo do Android para a [biblioteca de produtores do Android](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-sdk-android.html), faça o seguinte.
1. Conecte a um dispositivo Android.
1. Escolha **Run**, **Run...** e selecione **Edit configurations...**.
1. Escolha o ícone de adição (**\$1**), **aplicativo Android**. No campo **Name** (Nome), insira **AmazonKinesisVideoDemoApp**. No menu suspenso **Módulo**, escolha. **AmazonKinesisVideoDemoApp** Escolha **OK**.
1. Selecione **Run**, **Run**.
1. Na tela **Select a Deployment Target**, escolha seu dispositivo conectado e selecione **OK**.
1. No **AWSKinesisVideoDemoApp**aplicativo no dispositivo, escolha **Criar nova conta**.
1. Insira valores para **USERNAME**, **Password**, **Given name**, **Email address** e **Phone number**, e a seguir escolha **Sign up**.
**nota**
Esses valores têm as seguintes restrições:
**Password:** deve conter letras maiúsculas e minúsculas, números e caracteres especiais. Você pode alterar essas restrições na sua página de grupo de usuários no console do [Amazon Cognito](https://console.aws.amazon.com/cognito/home).
**Email address:** deve ser um endereço válido para que você possa receber um código de confirmação.
**Phone number:** deve estar no seguinte formato: **\$1******, por exemplo, **\$112065551212**.
1. Insira o código que você recebe por e-mail e escolha **Confirmar**. Escolha **OK**.
1. Na próxima página, mantenha os valores padrão e escolha **Stream**.
1. Faça login Console de gerenciamento da AWS e abra o console do [Kinesis Video](https://console.aws.amazon.com//kinesisvideo/home/) Streams na região Oeste dos EUA (Oregon).
Na página **Manage Streams**, selecione **demo-stream**.
1. O vídeo de streaming é reproduzido no player incorporado. Provavelmente será necessário esperar um tempo curto (até dez segundos em condições típicas de processador e de largura de banda) enquanto os quadros são acumulados antes do vídeo ser exibido.
**nota**
Se a tela do dispositivo girar (por exemplo, de horizontal para vertical), o aplicativo interromperá o streaming de vídeo.
O exemplo de código cria um streaming. Conforme `MediaSource` no código é iniciado, ele começa a enviar quadros da câmera para o `KinesisVideoClient`. **Em seguida, o cliente envia os dados para um stream de vídeo do Kinesis chamado demo-stream.**