Introduzione a Java Client SDK per Servizi multimediali di AzureGet started with the Java client SDK for Azure Media Services

Questa esercitazione illustra in modo dettagliato la procedura di implementazione di un servizio di base per la distribuzione di contenuto video con Servizi multimediali di Azure Media Services tramite Java Client SDK.This tutorial walks you through the steps of implementing a basic video content delivery service with Azure Media Services using the Java client SDK.

PrerequisitiPrerequisites

Per completare l'esercitazione è necessario quanto segue:The following are required to complete this tutorial:

Procedura: Importare il pacchetto Java Client SDK per Servizi multimediali di AzureHow to: Import the Azure Media Services Java client SDK package

Per iniziare a usare Media Services SDK per Java, aggiungere un riferimento alla versione corrente (0.9.8) del pacchetto azure-media da Azure Media Services Java SDKTo start using the Media Services SDK for Java, add a reference to the current version (0.9.8) of the azure-media package from the Azure Media Services Java SDK

Ad esempio, se lo strumento di compilazione è gradle, aggiungere la dipendenza seguente al file build.gradle:For example, if your build tool is gradle, add the following dependency to your build.gradle file:

compile group: 'com.microsoft.azure', name: 'azure-media', version: '0.9.8'

Importante

A partire dal pacchetto azure-media con versione 0.9.8, l'SDK include il supporto per l'autenticazione tramite Azure Active Directory (AAD) ed è stato rimosso il supporto per l'autenticazione tramite il Servizio di controllo di accesso di Azure.Starting with azure-media package version 0.9.8, the SDK added support for Auzre Active Directory (AAD) authentication and removed support for Azure Access Control Service (ACS) authentication. Il Servizio di controllo di accesso di Azure sarà deprecato a partire dall'1 giugno 2018.The ACS services will be deprecated on June 1, 2018. È consigliabile eseguire al più presto la migrazione al modello di autenticazione di Azure AD.We recommend that you migrate to the Azure AD authentication model as soon as possible. Per informazioni dettagliate sulla migrazione, leggere l'articolo Accedere all'API di Servizi multimediali di Azure con l'autenticazione di Azure AD.For details on migration, read the article Access the Azure Media Services API with Azure AD authentication.

Nota

È possibile trovare il codice sorgente di Azure Media Services Java SDK nel repository di GitHub.You can find the source code of the Azure Media Services Java SDK in our GitHub repository. Assicurarsi di passare al ramo 0.9, non al ramo principale.Make sure to switch to the 0.9 branch, and not the master branch.

Procedura: come usare Servizi multimediali di Azure con JavaHow to: Use Azure Media Services with Java

Nota

Quando l'account di Servizi multimediali viene creato, un endpoint di streaming predefinito viene aggiunto all'account con stato Arrestato.When your Media Services account is created a default streaming endpoint is added to your account in the Stopped state. Per avviare lo streaming del contenuto e sfruttare i vantaggi della creazione dinamica dei pacchetti e della crittografia dinamica, l'endpoint di streaming da cui si vuole trasmettere il contenuto deve essere nello stato In esecuzione.To start streaming your content and take advantage of dynamic packaging and dynamic encryption, the streaming endpoint from which you want to stream content has to be in the Running state.

Il codice seguente illustra come creare un asset, caricare un file multimediale nell'asset, eseguire un processo con un'attività per trasformare l'asset e creare un localizzatore per trasmettere il video.The following code shows how to create an asset, upload a media file to the asset, run a job with a task to transform the asset, and create a locator to stream your video.

Prima di usare il codice, configurare un account Servizi multimediali.Set up a Media Services account before using this code. Per informazioni su come configurare un account, vedere Creare un account Servizi multimediali di Azure con il portale di Azure.For information about setting up an account, see How to Create a Media Services Account.

Il codice si connette all'API di Servizi multimediali di Azure tramite l'autenticazione dell'entità servizio di Azure AD.The code connects to the Azure Media Services API using Azure AD service principal authentication. Creare un'applicazione di Azure AD e specificare i valori per le variabili seguenti nel codice:Create an Azure AD application and specify the values for the following variables in the code:

  • tenant: dominio del tenant di Azure AD in cui si trova l'applicazione di Azure ADtenant: The Azure AD tenant domain where the Azure AD application resides
  • clientId: ID client dell'applicazione di Azure ADclientId: The client ID of the Azure AD application
  • clientKey: chiave client dell'applicazione di Azure ADclientKey: The client key of the Azure AD application
  • restApiEndpoint: endpoint dell'API REST dell'account di Servizi multimediali di AzurerestApiEndpoint: The REST API endpoint of the Azure Media Services account

È possibile creare un'applicazione di Azure AD e ottenere i valori di configurazione precedenti dal portale di Azure.You can create an Azure AD application and obtain the preceding configuration values from the Azure portal. Per altre informazioni, vedere la sezione Autenticazione di un'entità servizio di Introduzione all'autenticazione di Azure AD tramite il portale di Azure.For more information, see the Service principal authentication section of Getting started with Azure AD authentication using the Azure portal.

Questo codice si basa inoltre su un file video archiviato in locale.The code also relies on a locally stored video file. È necessario modificare il codice per specificare un file locale da caricare.You must edit the code to provide your own local file to upload.

import java.io.*;
import java.net.URI;
import java.security.NoSuchAlgorithmException;
import java.util.EnumSet;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import com.microsoft.windowsazure.Configuration;
import com.microsoft.windowsazure.exception.ServiceException;
import com.microsoft.windowsazure.services.media.MediaConfiguration;
import com.microsoft.windowsazure.services.media.MediaContract;
import com.microsoft.windowsazure.services.media.MediaService;
import com.microsoft.windowsazure.services.media.WritableBlobContainerContract;
import com.microsoft.windowsazure.services.media.authentication.AzureAdClientSymmetricKey;
import com.microsoft.windowsazure.services.media.authentication.AzureAdTokenCredentials;
import com.microsoft.windowsazure.services.media.authentication.AzureAdTokenProvider;
import com.microsoft.windowsazure.services.media.authentication.AzureEnvironments;
import com.microsoft.windowsazure.services.media.models.AccessPolicy;
import com.microsoft.windowsazure.services.media.models.AccessPolicyInfo;
import com.microsoft.windowsazure.services.media.models.AccessPolicyPermission;
import com.microsoft.windowsazure.services.media.models.Asset;
import com.microsoft.windowsazure.services.media.models.AssetFile;
import com.microsoft.windowsazure.services.media.models.AssetFileInfo;
import com.microsoft.windowsazure.services.media.models.AssetInfo;
import com.microsoft.windowsazure.services.media.models.Job;
import com.microsoft.windowsazure.services.media.models.JobInfo;
import com.microsoft.windowsazure.services.media.models.JobState;
import com.microsoft.windowsazure.services.media.models.ListResult;
import com.microsoft.windowsazure.services.media.models.Locator;
import com.microsoft.windowsazure.services.media.models.LocatorInfo;
import com.microsoft.windowsazure.services.media.models.LocatorType;
import com.microsoft.windowsazure.services.media.models.MediaProcessor;
import com.microsoft.windowsazure.services.media.models.MediaProcessorInfo;
import com.microsoft.windowsazure.services.media.models.Task;

public class Program
{
    // Media Services account credentials configuration
    private static String tenant = "tenant.domain.com";
    private static String clientId = "<client id>";
    private static String clientKey = "<client key>";
    private static String restApiEndpoint = "https://account_name.restv2.region_name.media.azure.net/api/";

    // Media Services API
    private static MediaContract mediaService;

    // Encoder configuration
    // This is using the default Adaptive Streaming encoding preset. 
    // You can choose to use a custom preset, or any other sample defined preset. 
    // In addition you can use other processors, like Speech Analyzer, or Redactor if desired.
    private static String preferedEncoder = "Media Encoder Standard";
    private static String encodingPreset = "Adaptive Streaming";

    public static void main(String[] args)
    {
        ExecutorService executorService = Executors.newFixedThreadPool(1);

        try {
            // Setup Azure AD Service Principal Symmetric Key Credentials
            AzureAdTokenCredentials credentials = new AzureAdTokenCredentials(
                    tenant,
                    new AzureAdClientSymmetricKey(clientId, clientKey),
                    AzureEnvironments.AZURE_CLOUD_ENVIRONMENT);

            AzureAdTokenProvider provider = new AzureAdTokenProvider(credentials, executorService);

            // Create a new configuration with the credentials
            Configuration configuration = MediaConfiguration.configureWithAzureAdTokenProvider(
                    new URI(restApiEndpoint),
                    provider);

            // Create the media service provisioned with the new configuration
            mediaService = MediaService.create(configuration);

            // Upload a local file to an Asset
            AssetInfo uploadAsset = uploadFileAndCreateAsset("Video Name", "C:/path/to/video.mp4");
            System.out.println("Uploaded Asset Id: " + uploadAsset.getId());

            // Transform the Asset
            AssetInfo encodedAsset = encode(uploadAsset);
            System.out.println("Encoded Asset Id: " + encodedAsset.getId());

            // Create the Streaming Origin Locator
            String url = getStreamingOriginLocator(encodedAsset);

            System.out.println("Origin Locator URL: " + url);
            System.out.println("Sample completed!");

        } catch (ServiceException se) {
            System.out.println("ServiceException encountered.");
            System.out.println(se.toString());
        } catch (Exception e) {
            System.out.println("Exception encountered.");
            System.out.println(e.toString());
        } finally {
            executorService.shutdown();
        }
    }

    private static AssetInfo uploadFileAndCreateAsset(String assetName, String fileName)
        throws ServiceException, FileNotFoundException, NoSuchAlgorithmException {

        WritableBlobContainerContract uploader;
        AssetInfo resultAsset;
        AccessPolicyInfo uploadAccessPolicy;
        LocatorInfo uploadLocator = null;

        // Create an Asset
        resultAsset = mediaService.create(Asset.create().setName(assetName).setAlternateId("altId"));
        System.out.println("Created Asset " + fileName);

        // Create an AccessPolicy that provides Write access for 15 minutes
        uploadAccessPolicy = mediaService
            .create(AccessPolicy.create("uploadAccessPolicy", 15.0, EnumSet.of(AccessPolicyPermission.WRITE)));

        // Create a Locator using the AccessPolicy and Asset
        uploadLocator = mediaService
            .create(Locator.create(uploadAccessPolicy.getId(), resultAsset.getId(), LocatorType.SAS));

        // Create the Blob Writer using the Locator
        uploader = mediaService.createBlobWriter(uploadLocator);

        File file = new File(fileName);

        // The local file that will be uploaded to your Media Services account
        InputStream input = new FileInputStream(file);

        System.out.println("Uploading " + fileName);

        // Upload the local file to the media asset
        uploader.createBlockBlob(file.getName(), input);

        // Inform Media Services about the uploaded files
        mediaService.action(AssetFile.createFileInfos(resultAsset.getId()));
        System.out.println("Uploaded Asset File " + fileName);

        mediaService.delete(Locator.delete(uploadLocator.getId()));
        mediaService.delete(AccessPolicy.delete(uploadAccessPolicy.getId()));

        return resultAsset;
    }

    // Create a Job that contains a Task to transform the Asset
    private static AssetInfo encode(AssetInfo assetToEncode)
        throws ServiceException, InterruptedException {

        // Retrieve the list of Media Processors that match the name
        ListResult<MediaProcessorInfo> mediaProcessors = mediaService
                        .list(MediaProcessor.list().set("$filter", String.format("Name eq '%s'", preferedEncoder)));

        // Use the latest version of the Media Processor
        MediaProcessorInfo mediaProcessor = null;
        for (MediaProcessorInfo info : mediaProcessors) {
            if (null == mediaProcessor || info.getVersion().compareTo(mediaProcessor.getVersion()) > 0) {
                mediaProcessor = info;
            }
        }

        System.out.println("Using Media Processor: " + mediaProcessor.getName() + " " + mediaProcessor.getVersion());

        // Create a task with the specified Media Processor
        String outputAssetName = String.format("%s as %s", assetToEncode.getName(), encodingPreset);
        String taskXml = "<taskBody><inputAsset>JobInputAsset(0)</inputAsset>"
                + "<outputAsset assetCreationOptions=\"0\"" // AssetCreationOptions.None
                + " assetName=\"" + outputAssetName + "\">JobOutputAsset(0)</outputAsset></taskBody>";

        Task.CreateBatchOperation task = Task.create(mediaProcessor.getId(), taskXml)
                .setConfiguration(encodingPreset).setName("Encoding");

        // Create the Job; this automatically schedules and runs it.
        Job.Creator jobCreator = Job.create()
                .setName(String.format("Encoding %s to %s", assetToEncode.getName(), encodingPreset))
                .addInputMediaAsset(assetToEncode.getId()).setPriority(2).addTaskCreator(task);
        JobInfo job = mediaService.create(jobCreator);

        String jobId = job.getId();
        System.out.println("Created Job with Id: " + jobId);

        // Check to see if the Job has completed
        checkJobStatus(jobId);
        // Done with the Job

        // Retrieve the output Asset
        ListResult<AssetInfo> outputAssets = mediaService.list(Asset.list(job.getOutputAssetsLink()));
        return outputAssets.get(0);
    }


    public static String getStreamingOriginLocator(AssetInfo asset) throws ServiceException {
        // Get the .ISM AssetFile
        ListResult<AssetFileInfo> assetFiles = mediaService.list(AssetFile.list(asset.getAssetFilesLink()));
        AssetFileInfo streamingAssetFile = null;
        for (AssetFileInfo file : assetFiles) {
            if (file.getName().toLowerCase().endsWith(".ism")) {
                streamingAssetFile = file;
                break;
            }
        }

        AccessPolicyInfo originAccessPolicy;
        LocatorInfo originLocator = null;

        // Create a 30-day read only AccessPolicy
        double durationInMinutes = 60 * 24 * 30;
        originAccessPolicy = mediaService.create(
                AccessPolicy.create("Streaming policy", durationInMinutes, EnumSet.of(AccessPolicyPermission.READ)));

        // Create a Locator using the AccessPolicy and Asset
        originLocator = mediaService
                .create(Locator.create(originAccessPolicy.getId(), asset.getId(), LocatorType.OnDemandOrigin));

        // Create a Smooth Streaming base URL
        return originLocator.getPath() + streamingAssetFile.getName() + "/manifest";
    }

    private static void checkJobStatus(String jobId) throws InterruptedException, ServiceException {
        boolean done = false;
        JobState jobState = null;
        while (!done) {
            // Sleep for 5 seconds
            Thread.sleep(5000);

            // Query the updated Job state
            jobState = mediaService.get(Job.get(jobId)).getState();
            System.out.println("Job state: " + jobState);

            if (jobState == JobState.Finished || jobState == JobState.Canceled || jobState == JobState.Error) {
                done = true;
            }
        }
    }
}

Percorsi di apprendimento di Servizi multimedialiMedia Services learning paths

Altre informazioni sui percorsi di apprendimento di Servizi multimediali di Azure:Read about the Azure Media Services learning paths:

Fornire commenti e suggerimentiProvide feedback

Usare il forum di suggerimenti degli utenti per fornire commenti e suggerimenti su come migliorare Servizi multimediali di Azure.Use the User Voice forum to provide feedback and make suggestions on how to improve Azure Media Services. È anche possibile passare direttamente a una delle categorie seguenti:You also can go directly to one of the following categories:

Risorse aggiuntiveAdditional Resources

Per altre informazioni sullo sviluppo di app Java in Azure, vedere il Centro sviluppatori Java per Azure Java e Azure per sviluppatori Java.For more information about developing Java apps on Azure, see Azure Java Developer Center and Azure for Java developers.

Per la documentazione Java per Servizi multimediali, vedere la [documentazione sulle librerie di Azure per Java][documentazione sulle librerie di Azure per Java].For Media Services Javadoc documentation, see [Azure Libraries for Java documentation][Azure Libraries for Java documentation].