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à.
# Usa la libreria Android Producer
Puoi utilizzare la libreria Android Producer fornita da Amazon Kinesis Video Streams per scrivere codice applicativo, con una configurazione minima, per inviare dati multimediali da un dispositivo Android a un flusso video Kinesis.
Esegui i seguenti passaggi per integrare il codice con Kinesis Video Streams in modo che l'applicazione possa avviare lo streaming di dati sullo streaming video Kinesis:
1. Crea un'istanza dell'oggetto `KinesisVideoClient`.
1. Crea un oggetto `MediaSource` fornendo informazioni sull'origine multimediale. Ad esempio, durante la creazione di un'origine multimediale fotocamera, devi fornire informazioni quali l'identificazione della fotocamera e specificare la codifica utilizzata dalla fotocamera.
Quando vuoi avviare lo streaming, devi creare un'origine multimediale personalizzata.
## Procedura: utilizza l'Android Producer SDK
Questa procedura illustra come utilizzare il client produttore Android Kinesis Video Streams nell'applicazione Android per inviare dati al flusso video Kinesis.
La procedura include le seguenti fasi:
+ [Prerequisiti](producersdk-android-prerequisites.md)
+ [Scarica e configura il codice della libreria Android Producer](producersdk-android-downloadcode.md)
+ [Esamina il codice](producersdk-android-writecode.md)
+ [Esegui e verifica il codice](producersdk-android-reviewcode.md)
# Prerequisiti
Ti consigliamo di utilizzare [Android Studio](https://developer.android.com/studio/index.html) per esaminare, modificare ed eseguire il codice dell'applicazione. Si consiglia di utilizzare l'ultima versione stabile.
Nel codice di esempio, fornisci le credenziali di Amazon Cognito.
**Topics**
+ [Configura un pool di utenti](#set-up-user-pool)
+ [Configura un pool di identità](#set-up-identity-pool)
## Configura un pool di utenti
**Per configurare un pool di utenti**
1. Accedi alla [console Amazon Cognito](https://console.aws.amazon.com/cognito/home) e verifica che la regione sia corretta.
1. Nella barra di navigazione a sinistra scegli **User pool**.
1. Nella sezione **Pool di utenti**, scegli **Crea pool di utenti**.
1. Completa le seguenti sezioni:
1. **Passaggio 1: Configurazione dell'esperienza di accesso** - Nella sezione delle opzioni di **accesso al pool di utenti di Cognito**, seleziona le opzioni appropriate.
Seleziona **Avanti**.
1. **Passaggio 2: Configurazione dei requisiti di sicurezza**: seleziona le opzioni appropriate.
Seleziona **Avanti**.
1. **Passaggio 3: Configura l'esperienza di registrazione**: seleziona le opzioni appropriate.
Seleziona **Avanti**.
1. **Fase 4: Configurazione del recapito dei messaggi** - Seleziona le opzioni appropriate.
Nel campo di **selezione del ruolo IAM**, seleziona un ruolo esistente o crea un nuovo ruolo.
Seleziona **Avanti**.
1. **Passaggio 5: Integra la tua app**: seleziona le opzioni appropriate.
Nel campo **Client iniziale dell'app**, scegli **Client riservato**.
Seleziona **Avanti**.
1. **Passaggio 6: Rivedi e crea**: rivedi le selezioni effettuate nelle sezioni precedenti, quindi scegli **Crea pool di utenti**.
1. Nella pagina **Pool di utenti**, seleziona il pool che hai appena creato.
Copia l'**ID del pool di utenti** e prendine nota per dopo. Nel `awsconfiguration.json` file, questo è`CognitoUserPool.Default.PoolId`.
1. Seleziona la scheda **Integrazione dell'app** e vai in fondo alla pagina.
1. Nella sezione **Elenco dei client dell'app**, scegli il **nome del client dell'app** che hai appena creato.
Copia l'**ID cliente** e prendine nota per dopo. Nel `awsconfiguration.json` file, questo è`CognitoUserPool.Default.AppClientId`.
1. Mostra il **segreto del Cliente** e prendine nota per dopo. Nel `awsconfiguration.json` file, questo è`CognitoUserPool.Default.AppClientSecret`.
## Configura un pool di identità
**Per configurare un pool di identità**
1. Accedi alla [console Amazon Cognito](https://console.aws.amazon.com/cognito/home) e verifica che la regione sia corretta.
1. Nella barra di navigazione a sinistra, scegli **Identity pool**.
1. Scegli **Crea pool di identità**.
1. Configura il pool di identità.
1. **Passaggio 1: Configurare l'affidabilità del pool di identità**: completare le seguenti sezioni:
+ **Accesso utente**: seleziona Accesso **autenticato**
+ **Fonti di identità autenticate**: seleziona il pool di **utenti Amazon Cognito**
Seleziona **Avanti**.
1. **Fase 2: Configurazione delle autorizzazioni** - Nella sezione **Ruolo autenticato**, completa i seguenti campi:
+ **Ruolo IAM**: seleziona **Crea un nuovo** ruolo IAM
+ **Nome del ruolo IAM**: inserisci un nome e prendine nota per un passaggio successivo.
Seleziona **Avanti**.
1. **Passaggio 3: Connect identity provider** - Nella sezione **Dettagli del pool di utenti** completa i seguenti campi:
+ **ID del pool di utenti**: seleziona il pool di utenti creato in precedenza.
+ **ID client dell'app**: seleziona l'ID client dell'app che hai creato in precedenza.
Seleziona **Avanti**.
1. **Passaggio 4: Configurazione delle proprietà**: digitare un nome nel campo **Nome del pool di identità**.
Seleziona **Avanti**.
1. **Passaggio 5: Rivedi e crea**: rivedi le selezioni in ciascuna delle sezioni, quindi seleziona **Crea pool di identità**.
1. Nella pagina **Pool di identità**, seleziona il tuo nuovo pool di identità.
Copia l'**ID del pool di identità** e prendine nota per dopo. Nel `awsconfiguration.json` file, questo è`CredentialsProvider.CognitoIdentity.Default.PoolId`.
1. Aggiorna le autorizzazioni per il ruolo IAM.
1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nella barra di navigazione a sinistra, scegli **Ruoli**.
1. Trova e seleziona il ruolo che hai creato sopra.
**Nota**
Usa la barra di ricerca, se necessario.
1. Seleziona la politica di autorizzazione allegata.
Seleziona **Edit (Modifica)**.
1. Seleziona la scheda **JSON** e sostituisci la politica con la seguente:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"cognito-identity:*",
"kinesisvideo:*"
],
"Resource": [
"*"
]
}
]
}
```
------
Seleziona **Avanti**.
1. Seleziona la casella accanto a **Imposta questa nuova versione come predefinita** se non è già selezionata.
Seleziona **Salva modifiche**.
# Scarica e configura il codice della libreria Android Producer
In questa sezione della procedura della libreria Android Producer, scarichi il codice di esempio Android e apri il progetto in Android Studio.
Per i prerequisiti e altri dettagli su questo esempio, consulta [Utilizzo della libreria Android Producer](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-sdk-android.html).
1. Create una directory, quindi clonatela AWS Mobile SDK per Android GitHub dal repository.
```
git clone https://github.com/awslabs/aws-sdk-android-samples
```
1. Apri [Android Studio](https://developer.android.com/studio/index.html).
1. Nella schermata iniziale, scegli **Apri un progetto di Android Studio esistente**.
1. Passa alla directory `aws-sdk-android-samples/AmazonKinesisVideoDemoApp` e scegli **OK**.
1. Apri il file `AmazonKinesisVideoDemoApp/src/main/res/raw/awsconfiguration.json`.
Nel `CredentialsProvider` nodo, fornisci l'ID del pool di identità indicato nella procedura **Per impostare un pool di identità** nella sezione [Prerequisiti](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-sdk-android.html#producersdk-android-prerequisites) e fornisci il tuo Regione AWS (ad esempio,). **us-west-2**
Nel `CognitoUserPool` nodo, fornisci il segreto del client dell'app, l'ID client dell'app e l'ID del pool dalla procedura **Per impostare un pool di utenti** nella sezione [Prerequisiti](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-sdk-android.html#producersdk-android-prerequisites) e fornisci i tuoi Regione AWS (ad esempio,**us-west-2**).
1. Il file `awsconfiguration.json` sarà simile a quanto riportato di seguito:
```
{
"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. Aggiorna il file `AmazonKinesisVideoDemoApp/src/main/java/com/amazonaws/kinesisvideo/demoapp/KinesisVideoDemoApp.java` con la tua regione (nell'esempio seguente, è impostato su **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;
```
[Per informazioni sulle Regione AWS costanti, vedi Regioni.](https://aws-amplify.github.io/aws-sdk-android/docs/reference/com/amazonaws/regions/Regions.html)
# Esamina il codice
In questa sezione della [procedura della libreria Android Producer](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-sdk-android.html), si esamina il codice di esempio.
L'applicazione per i test di Android (`AmazonKinesisVideoDemoApp`) mostra il seguente modello di codifica:
+ Creare un'istanza di `KinesisVideoClient`.
+ Creare un'istanza di `MediaSource`.
+ Avvia lo streaming. Avvia il`MediaSource`, e inizia a inviare dati al client.
Nelle seguenti sezioni sono fornite maggiori informazioni.
## Crea un'istanza di KinesisVideoClient
Per creare l'oggetto `[KinesisVideoClient](https://github.com/aws-amplify/aws-sdk-android/blob/main/aws-android-sdk-kinesisvideo/src/main/java/com/amazonaws/kinesisvideo/client/KinesisVideoClient.java)`, richiama l'operazione `[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());
```
Per eseguire chiamate alla rete, `KinesisVideoClient` ha bisogno di credenziali da autenticare. Passi un'istanza di`AWSCredentialsProvider`, che legge le tue credenziali di Amazon Cognito `awsconfiguration.json` dal file che hai modificato nella sezione precedente.
## Crea un'istanza di MediaSource
Per inviare byte al flusso video Kinesis, devi produrre i dati. 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)` fornisce l'interfaccia che rappresenta l'origine dei dati.
Ad esempio, la libreria Android 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)` fornisce l'implementazione `MediaSource` dell'interfaccia. Questa classe legge i dati da una delle fotocamere del dispositivo.
Nel seguente esempio di codice (dal file `[fragment/StreamConfigurationFragment.java](https://github.com/awslabs/aws-sdk-android-samples/blob/main/AmazonKinesisVideoDemoApp/src/main/java/com/amazonaws/kinesisvideo/demoapp/fragment/StreamConfigurationFragment.java)`), viene creata la configurazione per l'origine multimediale:
```
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));
}
```
Nel seguente esempio di codice (dal file `[fragment/StreamingFragment.java](https://github.com/awslabs/aws-sdk-android-samples/blob/main/AmazonKinesisVideoDemoApp/src/main/java/com/amazonaws/kinesisvideo/demoapp/fragment/StreamingFragment.java)`), viene creata la configurazione per l'origine multimediale:
```
mCameraMediaSource = (AndroidCameraMediaSource) mKinesisVideoClient
.createMediaSource(mStreamName, mConfiguration);
```
## Avvia la sorgente multimediale
Avvia l'origine multimediale in modo che inizi a generare dati e a inviarli al client. I seguenti esempi di codice sono tratti dal file `[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();
```
# Esegui e verifica il codice
Per eseguire l'applicazione di esempio Android per la [libreria Android Producer](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-sdk-android.html), procedi come segue.
1. Esegui la connessione a un dispositivo Android.
1. Scegli **Run (Esegui)**, **Run... (Esegui...)**, quindi scegli **Edit configurations... (Modifica configurazioni...)**.
1. Scegli l'icona più (**\$1**), **App Android**. Nel campo **Name (Nome)**, inserire **AmazonKinesisVideoDemoApp**. Nel menu a discesa **Modulo**, scegli **AmazonKinesisVideoDemoApp**. Scegli **OK**.
1. Scegli **Run (Esegui)**, **Run (Esegui)**.
1. Nella schermata **Select Deployment Target (Seleziona destinazione distribuzione)** scegli il dispositivo connesso, quindi scegli **OK**.
1. Nell'**AWSKinesisVideoDemoApp**applicazione sul dispositivo, scegli **Crea nuovo account**.
1. Inserisci i valori per **USERNAME (NOME UTENTE)**, **Password**, **Given name (Nome specificato)**, **Email address (Indirizzo e-mail)** e **Phone number (Numero di telefono)**, quindi scegli **Sign up (Iscrizione)**.
**Nota**
Questi valori hanno le seguenti limitazioni:
**Password:** deve contenere lettere maiuscole e minuscole, numeri e caratteri speciali. Puoi modificare questi vincoli nella pagina del pool di utenti sulla console [Amazon Cognito](https://console.aws.amazon.com/cognito/home).
**Email address (Indirizzo e-mail):** deve essere un indirizzo valido a cui ricevere un codice di conferma.
**Phone number (Numero di telefono):** deve avere il seguente formato: **\$1******, ad esempio, **\$112065551212** .
1. **Inserisci il codice che ricevi via e-mail e scegli Conferma.** Scegli **OK**.
1. Nella pagina successiva, mantieni i valori predefiniti e scegli **Stream**.
1. Accedere Console di gestione AWS e aprire la console [Kinesis Video](https://console.aws.amazon.com//kinesisvideo/home/) Streams nella regione Stati Uniti occidentali (Oregon).
Nella pagina **Manage Streams (Gestisci flussi)**, scegli **demo-stream**.
1. Il video streaming viene riprodotto nel lettore integrato. La visualizzazione del video potrebbe richiedere una breve attesa (fino a 10 secondi con la larghezza di banda e le condizioni del processore abituali) affinché vengano caricati i fotogrammi.
**Nota**
Se lo schermo del dispositivo ruota (ad esempio, da verticale a orizzontale), l'applicazione interrompe lo streaming del video.
L'esempio di codice crea un flusso. Appena `MediaSource` nel codice viene avviato, inizia a inviare fotogrammi dalla fotocamera a `KinesisVideoClient`. **Il client invia quindi i dati a un flusso video Kinesis denominato demo-stream.**