Esempio: invio di dati a Kinesis Video PutMedia Streams utilizzando l'API

Questo esempio dimostra come utilizzare l'API. PutMedia 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. Librerie per produttori di Kinesis Video Streams

Nota

L'PutMediaoperazione è disponibile solo negli SDK C++ e Java. Ciò è dovuto alla gestione full duplex delle connessioni, del flusso di dati e dei riconoscimenti. Non è supportato in altre lingue.

Passaggio 1: 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 Library.

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

2. Apri l'IDE Java che stai utilizzando (ad esempio, Eclipse o IntelliJ 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.

3. 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).

     2. Scegliete File, quindi scegliete Struttura del progetto.

     3. In Project Settings (Impostazioni progetto), scegliere Modules (Moduli).

     4. 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).

        2. Nella procedura guidata Native Library Folder Configuration (Configurazione cartella libreria nativa), scegliere Workspace (Area di lavoro).

        3. Nel menu di selezione Native Library Folder (Cartella libreria nativa), scegliere la directory lib nel progetto.

     2. 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).

        2. Nella procedura guidata JAR selection (Selezione JAR), scegliere tutti i file .jar nella directory lib del progetto.

Passaggio 2: scrivere ed esaminare il codice

L'esempio dell'API PutMedia (PutMediaDemo) mostra i seguenti modelli di codifica:

Argomenti

• Crea il PutMediaClient
• Trasmetti contenuti multimediali e metti in pausa il thread

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 Utilizzo di Java Producer Library (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 perUtilizzo di Java Producer Library, 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();

Passaggio 3: 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

2. Per modificare la directory di lavoro nella directory SDK del producer Java:

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

3. Per compilare l'SDK Java e l'applicazione di demo:

   mvn package

4. Creare un filename temporaneo nella directory /tmp:

   jar_files=$(mktemp)

5. Creare una stringa di classpath di dipendenze dall'archivio locale a un file:

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

6. Impostare il valore della variabile di ambiente LD_LIBRARY_PATH come segue:

   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)

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

8. Apri la console Kinesis Video Streams e scegli il tuo stream nella pagina Gestisci stream. Viene avviata la riproduzione del video nel riquadro Video Preview (Anteprima video).