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á.

# Exemplo: envio de dados para o Kinesis Video Streams PutMedia usando a API
<a name="examples-putmedia"></a>

Este exemplo demonstra como usar a [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)API. Mostra como enviar dados que já estão em formato de contêiner (MKV). Se seus dados precisarem ser reunidos em um formato de contêiner antes do envio (por exemplo, se você estiver reunindo dados de vídeo da câmera em quadros), consulte[Faça o upload para o Kinesis Video Streams](producer-sdk.md).

**nota**  
A `PutMedia` operação está disponível somente em C\$1\$1 e Java SDKs. Isso se deve ao gerenciamento full-duplex de conexões, fluxo de dados e confirmações. Não é compatível com outros idiomas.

**Topics**
+ [Baixe e configure o código](#examples-putmedia-download)
+ [Escreva e examine o código](#examples-putmedia-write)
+ [Execute e verifique o código](#examples-putmedia-run)

## Baixe e configure o código
<a name="examples-putmedia-download"></a>

Siga as etapas para baixar o código de exemplo Java, importar o projeto em seu Java IDE, configurar os locais da biblioteca e configurar o código para usar suas AWS credenciais.

1. Crie um diretório e clone o código-fonte de exemplo do GitHub repositório. O exemplo de `PutMedia` é parte da [Java](producer-sdk-javaapi.md).

   ```
   git clone https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-java
   ```

1. Abra o Java IDE que você está usando (por exemplo, [Eclipse](https://www.eclipse.org/) ou [IntelliJ IDEA](https://www.jetbrains.com/idea/)) e importe o projeto Apache Maven que você baixou: 
   + **No Eclipse:** selecione **File** (Arquivo), **Import** (Importar), **Maven** (Maven), **Existing Maven Projects** (Projetos existentes do Maven) e navegue até a raiz do pacote obtido por download. Selecione o arquivo `pom.xml`.
   + **No IntelliJ Idea: ** escolha **Import**. Navegue até o arquivo `pom.xml` na raiz do pacote que você obteve por download.

    Para obter mais informações, consulte a documentação relacionada ao IDE.

1. Atualize o projeto para que o IDE possa localizar as bibliotecas que você importou.
   + Para IntelliJ IDEA, faça o seguinte:

     1. Abra o menu de contexto (clique com o botão direito do mouse) da **lib** do projeto e escolha **Add as library**.

     1. Escolha **Arquivo** e, em seguida, escolha **Estrutura do projeto**. 

     1. Em **Configurações do projeto**, escolha **Módulos**. 

     1. Na guia **Sources** (Fontes), defina **Language Level** (Nível de linguagem) como **7** ou um número superior.
   + Para Eclipse, faça o seguinte:

     1. Abra o menu contextual (clique direito) no projeto e escolha **Properties**, **Java Build Path**, **Source**. Faça o seguinte:

        1. Na guia **Source**, clique duas vezes em **Native library location**.

        1. No assistente **Native Library Folder Configuration**, escolha **Workspace**.

        1. Na caixa de seleção **Native Library Folder**, escolha o diretório **lib** no projeto.

     1. Abra o menu de contexto (clique com o botão direito do mouse) do projeto e escolha **Properties**. Faça o seguinte:

        1. Na guia **Libraries**, escolha **Add Jars**.

        1. No assistente **JAR selection**, escolha tudo .jars no diretório `lib` do projeto.

## Escreva e examine o código
<a name="examples-putmedia-write"></a>

O exemplo de API `PutMedia` () mostra o padrão de codificação a seguir:`PutMediaDemo`

**Topics**
+ [Crie o PutMediaClient](#producersdk-javaapi-writecode-putmediaapi-putmediaclient)
+ [Transmitir mídia e pausar o thread](#producersdk-javaapi-writecode-putmediaapi-run)

Os exemplos de código nesta seção são da classe `PutMediaDemo`.

### Crie o PutMediaClient
<a name="producersdk-javaapi-writecode-putmediaapi-putmediaclient"></a>

A criação do `PutMediaClient` objeto requer os seguintes parâmetros:
+ O URI endpoint `PutMedia`.
+ Um `InputStream` apontando para o arquivo MKV para streaming.
+ Nome do streaming. Este exemplo usa o mesmo streaming criado em [Use a biblioteca de produtores Java](producer-sdk-javaapi.md) (`my-stream`). Para usar outro streaming, altere o seguinte parâmetro:

  ```
  private static final String STREAM_NAME="my-stream";
  ```
**nota**  
O exemplo `PutMedia` da API não cria um stream. Você deve criar um stream usando o aplicativo de teste do[Use a biblioteca de produtores Java](producer-sdk-javaapi.md), o console do Kinesis Video Streams ou o. AWS CLI
+ O time stamp atual.
+ O tipo de código de hora. O exemplo usa `RELATIVE`, indicando que o time stamp é relativo ao início do contêiner.
+ Um objeto `AWSKinesisVideoV4Signer` que verifica se os pacotes recebidos foram enviados pelo remetente autorizado.
+ A largura de banda máxima de upstream em Kbps.
+ Um objeto `AckConsumer` para confirmações de recebimento do pacote.

O código a seguir cria o objeto `PutMediaClient`:

```
/* actually URI to send PutMedia request */
final URI uri = URI.create(KINESIS_VIDEO_DATA_ENDPOINT + PUT_MEDIA_API);

/* input stream for sample MKV file */
final InputStream inputStream = new FileInputStream(MKV_FILE_PATH);

/* use a latch for main thread to wait for response to complete */
final CountDownLatch latch = new CountDownLatch(1);

/* a consumer for PutMedia ACK events */
final AckConsumer ackConsumer = new AckConsumer(latch);

/* client configuration used for AWS SigV4 signer */
final ClientConfiguration configuration = getClientConfiguration(uri);

/* PutMedia client */
final PutMediaClient client = PutMediaClient.builder()
        .putMediaDestinationUri(uri)
        .mkvStream(inputStream)
        .streamName(STREAM_NAME)
        .timestamp(System.currentTimeMillis())
        .fragmentTimeCodeType("RELATIVE")
        .signWith(getKinesisVideoSigner(configuration))
        .upstreamKbps(MAX_BANDWIDTH_KBPS)
        .receiveAcks(ackConsumer)
        .build();
```

### Transmitir mídia e pausar o thread
<a name="producersdk-javaapi-writecode-putmediaapi-run"></a>

Após a criação do cliente, a amostra inicia o streaming assíncrono com `putMediaInBackground`. Em seguida, o thread principal é pausado com `latch.await` até que `AckConsumer` retorne. Nesse momento, o cliente é fechado.

```
 /* start streaming video in a background thread */
            client.putMediaInBackground();

            /* wait for request/response to complete */
            latch.await();

            /* close the client */
            client.close();
```

## Execute e verifique o código
<a name="examples-putmedia-run"></a>

Para executar o exemplo da API `PutMedia`, faça o seguinte:

1. Crie um stream chamado `my-stream` no console do Kinesis Video Streams ou usando o. AWS CLI

1. Altere seu diretório de trabalho para o diretório do Java Producer SDK:

   ```
   cd /<YOUR_FOLDER_PATH_WHERE_SDK_IS_DOWNLOADED>/amazon-kinesis-video-streams-producer-sdk-java/
   ```

1. Compile o SDK do Java e o aplicativo de demonstração:

   ```
   mvn package
   ```

1. Crie um nome de arquivo temporário no diretório `/tmp`:

   ```
   jar_files=$(mktemp)
   ```

1. Crie uma string de classpath de dependências do repositório local para um arquivo:

   ```
   mvn -Dmdep.outputFile=$jar_files dependency:build-classpath
   ```

1. Defina o valor da variável de ambiente `LD_LIBRARY_PATH` da seguinte forma:

   ```
   export LD_LIBRARY_PATH=/<YOUR_FOLDER_PATH_WHERE_SDK_IS_DOWNLOADED>/amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build/downloads/local/lib:$LD_LIBRARY_PATH
   $ classpath_values=$(cat $jar_files)
   ```

1. Execute a demonstração na linha de comando da seguinte forma, fornecendo suas AWS credenciais:

   ```
   java -classpath target/kinesisvideo-java-demo-1.0-SNAPSHOT.jar:$classpath_values -Daws.accessKeyId=${ACCESS_KEY} -Daws.secretKey=${SECRET_KEY} -Djava.library.path=/opt/amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build com.amazonaws.kinesisvideo.demoapp.DemoAppMain
   ```

1. Abra o console do [Kinesis Video](https://console.aws.amazon.com//kinesisvideo/home/) Streams e escolha seu stream **na página** Gerenciar Streams. O vídeo é reproduzido no painel **Video Preview**.