Get started with the Java client SDK for Azure Media Services

This tutorial walks you through the steps of implementing a basic video content delivery service with Azure Media Services using the Java client SDK.


The following are required to complete this tutorial:

How to: Import the Azure Media Services Java client SDK package

To 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

For example, if your build tool is gradle, add the following dependency to your build.gradle file:

compile group: '', name: 'azure-media', version: '0.9.8'


Starting with azure-media package version 0.9.8, the SDK added support for Azure Active Directory (AAD) authentication and removed support for Azure Access Control Service (ACS) authentication. The ACS services will be deprecated on June 1, 2018. We recommend that you migrate to the Azure AD authentication model as soon as possible. For details on migration, read the article Access the Azure Media Services API with Azure AD authentication.


You can find the source code of the Azure Media Services Java SDK in our GitHub repository. Make sure to switch to the 0.9 branch, and not the master branch.

How to: Use Azure Media Services with Java


When your Media Services account is created a default streaming endpoint is added to your account in the Stopped state. 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.

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.

Set up a Media Services account before using this code. For information about setting up an account, see How to Create a Media Services Account.

The code connects to the Azure Media Services API using Azure AD service principal authentication. Create an Azure AD application and specify the values for the following variables in the code:

  • tenant: The Azure AD tenant domain where the Azure AD application resides
  • clientId: The client ID of the Azure AD application
  • clientKey: The client key of the Azure AD application
  • restApiEndpoint: The REST API endpoint of the Azure Media Services account

You can create an Azure AD application and obtain the preceding configuration values from the Azure portal. For more information, see the Service principal authentication section of Getting started with Azure AD authentication using the Azure portal.

The code also relies on a locally stored video file. You must edit the code to provide your own local file to upload.

import java.util.EnumSet;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class Program
    // Media Services account credentials configuration
    private static String tenant = "";
    private static String clientId = "<client id>";
    private static String clientKey = "<client key>";
    private static String restApiEndpoint = "";

    // 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(
                    new AzureAdClientSymmetricKey(clientId, clientKey),

            AzureAdTokenProvider provider = new AzureAdTokenProvider(credentials, executorService);

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

            // 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.");
        } catch (Exception e) {
            System.out.println("Exception encountered.");
        } finally {

    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
        System.out.println("Uploaded Asset File " + fileName);


        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)

        // Create the Job; this automatically schedules and runs it.
        Job.Creator jobCreator = Job.create()
                .setName(String.format("Encoding %s to %s", assetToEncode.getName(), encodingPreset))
        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
        // 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;

        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

            // 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;

Media Services learning paths

Read about the Azure Media Services learning paths:

Provide feedback

Use the User Voice forum to provide feedback and make suggestions on how to improve Azure Media Services. You also can go directly to one of the following categories:

Additional Resources

For more information about developing Java apps on Azure, see Azure Java Developer Center and Azure for Java developers.

For Media Services Javadoc documentation, see [Azure Libraries for Java documentation][Azure Libraries for Java documentation].