Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Esempio: invio di dati a Kinesis Video PutMedia Streams utilizzando l'API
Questo esempio dimostra come utilizzare l'[PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)API. Mostra come inviare dati già in formato contenitore (MKV). Se i dati devono essere assemblati in un formato contenitore prima dell'invio (ad esempio, se state assemblando i dati video della videocamera in fotogrammi), consultate. [Caricamento su Kinesis Video Streams](producer-sdk.md)
**Nota**
L'`PutMedia`operazione è disponibile solo in C\$1\$1 e Java. SDKs Ciò è dovuto alla gestione full-duplex delle connessioni, del flusso di dati e dei riconoscimenti. Non è supportato in altre lingue.
**Topics**
+ [Scarica e configura il codice](#examples-putmedia-download)
+ [Scrivi ed esamina il codice](#examples-putmedia-write)
+ [Esegui e verifica il codice](#examples-putmedia-run)
## Scarica e configura il codice
Segui i passaggi per scaricare il codice di esempio Java, importare il progetto nel tuo IDE Java, configurare le posizioni delle librerie e configurare il codice per utilizzare AWS le tue credenziali.
1. Crea una directory e clona il codice sorgente di esempio dal GitHub repository. L'esempio `PutMedia` è parte della [Java](producer-sdk-javaapi.md).
```
git clone https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-java
```
1. Apri l'IDE Java che stai utilizzando (ad esempio, [Eclipse](https://www.eclipse.org/) o [IntelliJ](https://www.jetbrains.com/idea/) IDEA) e importa il progetto Apache Maven che hai scaricato:
+ **In Eclipse:** scegliere **File**, **Import (Importa)**, **Maven**, **Existing Maven Projects (Progetti Maven esistenti)** e andare alla radice del pacchetto scaricato. Selezionare il file `pom.xml`.
+ **In IntelliJ Idea: ** scegliere **Import (Importa)**. Andare al file `pom.xml` nella radice del pacchetto scaricato.
Per ulteriori informazioni, consulta la documentazione IDE correlata.
1. Aggiornare il progetto per fare in modo che l'IDE possa individuare le librerie importate.
+ Per IntelliJ IDEA, procedere come segue:
1. Facendo clic con il pulsante destro del mouse, aprire il menu contestuale della directory **lib** del progetto e scegliere **Add as library (Aggiungi come libreria)**.
1. **Scegliete **File, quindi scegliete Struttura del** progetto.**
1. In **Project Settings (Impostazioni progetto)**, scegliere **Modules (Moduli)**.
1. Nella scheda **Sources (Origini)**, impostare **Language Level (Livello linguaggio)** su **7** o superiore.
+ Per Eclipse, procedere come segue:
1. Facendo clic con il pulsante destro del mouse, aprire il menu contestuale del progetto e scegliere **Proprerties (Proprietà)**, **Java Build Path (Percorso di compilazione Java)**, **Source (Origine)**. Quindi, esegui queste operazioni:
1. Nella scheda **Source (Origine)**, fare doppio clic su **Native library location (Percorso libreria nativa)**.
1. Nella procedura guidata **Native Library Folder Configuration (Configurazione cartella libreria nativa)**, scegliere **Workspace (Area di lavoro)**.
1. Nel menu di selezione **Native Library Folder (Cartella libreria nativa)**, scegliere la directory **lib** nel progetto.
1. Facendo clic con il pulsante destro del mouse, aprire il menu contestuale del progetto e scegliere **Properties (Proprietà)**. Quindi, esegui queste operazioni:
1. Nella scheda **Libraries (Librerie)**, scegliere **Add Jars (Aggiungi Jar)**.
1. Nella procedura guidata **JAR selection (Selezione JAR)**, scegliere tutti i file .jar nella directory `lib` del progetto.
## Scrivi ed esamina il codice
L'esempio dell'API `PutMedia` (`PutMediaDemo`) mostra i seguenti modelli di codifica:
**Topics**
+ [Crea il PutMediaClient](#producersdk-javaapi-writecode-putmediaapi-putmediaclient)
+ [Trasmetti contenuti multimediali e metti in pausa il thread](#producersdk-javaapi-writecode-putmediaapi-run)
Gli esempi di codice riportati in questa sezione sono presi dalla classe `PutMediaDemo`.
### Crea il PutMediaClient
La creazione `PutMediaClient` dell'oggetto richiede i seguenti parametri:
+ L'URI dell'endpoint `PutMedia`.
+ Un `InputStream` diretto al file MKV di cui effettuare lo streaming.
+ Il nome del flusso. In questo esempio viene utilizzato il flusso creato in [Usa la libreria Java Producer](producer-sdk-javaapi.md) (`my-stream`). Per utilizzare un flusso diverso, modificare il parametro seguente:
```
private static final String STREAM_NAME="my-stream";
```
**Nota**
L'esempio di `PutMedia` API non crea uno stream. È necessario creare uno stream utilizzando l'applicazione di test per[Usa la libreria Java Producer](producer-sdk-javaapi.md), la console Kinesis Video Streams o il. AWS CLI
+ Il timestamp corrente.
+ Il tipo di timecode. L'esempio utilizza il codice `RELATIVE`, che indica che il timestamp è relativo all'inizio del container.
+ Un oggetto `AWSKinesisVideoV4Signer` che verifica che i pacchetti ricevuti siano stati inviati da un mittente autorizzato.
+ La larghezza di banda di upstream massima in Kbps.
+ Un oggetto `AckConsumer` per la ricezione delle conferme di ricezione dei pacchetti.
Il codice seguente crea l'oggetto `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();
```
### Trasmetti contenuti multimediali e metti in pausa il thread
In seguito alla creazione del client, il campione avvia lo streaming asincrono con `putMediaInBackground`. Il thread principale viene quindi messo in pausa tramite `latch.await` fino al ritorno di `AckConsumer` e a questo punto il client viene chiuso.
```
/* start streaming video in a background thread */
client.putMediaInBackground();
/* wait for request/response to complete */
latch.await();
/* close the client */
client.close();
```
## Esegui e verifica il codice
Per eseguire l'esempio dell'API `PutMedia`, procedere come segue:
1. Crea uno stream denominato `my-stream` nella console Kinesis Video Streams o utilizzando. AWS CLI
1. Per modificare la directory di lavoro nella directory SDK del producer Java:
```
cd //amazon-kinesis-video-streams-producer-sdk-java/
```
1. Per compilare l'SDK Java e l'applicazione di demo:
```
mvn package
```
1. Creare un filename temporaneo nella directory `/tmp`:
```
jar_files=$(mktemp)
```
1. Creare una stringa di classpath di dipendenze dall'archivio locale a un file:
```
mvn -Dmdep.outputFile=$jar_files dependency:build-classpath
```
1. Impostare il valore della variabile di ambiente `LD_LIBRARY_PATH` come segue:
```
export LD_LIBRARY_PATH=//amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build/downloads/local/lib:$LD_LIBRARY_PATH
$ classpath_values=$(cat $jar_files)
```
1. Esegui la demo dalla riga di comando come segue, fornendo le tue AWS credenziali:
```
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. **Apri la console [Kinesis Video](https://console.aws.amazon.com//kinesisvideo/home/) Streams e scegli il tuo stream nella pagina Gestisci stream.** Viene avviata la riproduzione del video nel riquadro **Video Preview (Anteprima video)**.