Avaliação gratuita *Internet Service Required
Este tópico ainda não foi avaliado como - Avalie este tópico

Ingerir ativos com o SDK do Media Services para .NET

Este tópico faz parte da série Serviços de Mídia do Windows Azure intitulada Criando aplicativos com o SDK do Media Services para .NET e mostra como ingerir conteúdo para o Serviços de Mídia. Em um aplicativo Serviços de Mídia, as tarefas de ingestão são o processo de carregamento e conteúdo (ativos, arquivos de mídia e assim por diante) ao sistema. O objeto de conteúdo mais fundamental no Serviços de Mídia é um IAsset, que é uma coleção de metadados sobre um conjunto de arquivos de mídia. Cada IAsset contém um ou mais objetos IAssetFile. Para obter explicações mais detalhadas sobre o que é um Asset no Serviços de Mídia, consulte Asset.

Existem alguns modos diferentes de ingerir ativos no Serviços de Mídia:

  • Crie um Asset, crie um ou mais AssetFiles que sejam associados ao Asset e depois carregue os AssetFiles no Serviços de Mídia do Windows Azure. Use esta abordagem quando estiver trabalhando com conjuntos menores de arquivos de mídia e quando não tiver uma solução de carregamento em separado. Todos os exemplos neste tópico são deste tipo.

  • Faça uma ingestão em massa de um conjunto de arquivos preparando um manifesto e carregue-os no Serviços de Mídia do Windows Azure usando uma solução de carregamento em separado. Para obter mais informações sobre essa abordagem, consulte Ingestão de ativos em massa.

TipDica
Ao carregar um grande número de ativos, considere o seguinte.

O código neste tópico mostra como realizar as seguintes tarefas comuns:

noteObservação
Para criar qualquer ativo, primeiro você deve ter uma referência ao contexto de servidor do Serviços de Mídia, conforme descrito no tópico Conectar ao Media Services usando o SDK do Media Services. Nos exemplos de código a seguir o objeto de contexto é representado pela variável chamada _context.

Criando um ativo vazio

Para que você possa carregar um arquivo no servidor do Serviços de Mídia, deverá criar um ativo usando o método Create ou CreateAsync. Ambos recebem o nome do ativo e as opções de criptografia como parâmetros.

Quando você cria ativos, é possível especificar três opções diferentes para criptografá-los.

  • AssetCreationOptions.None: sem criptografia.

  • AssetCreationOptions.CommonEncryptionProtected: para arquivos Protegidos por Criptografia Comum (CENC). Um exemplo é um conjunto de arquivos que já estão criptografados com PlayReady.

  • AssetCreationOptions.StorageEncrypted: criptografia de armazenamento. Criptografa um arquivo de entrada não criptografado antes de carregá-lo no armazenamento Azure.

    noteObservação
    Observe que o Serviços de Mídia somente fornece criptografia de armazenamento em disco e não na transmissão, como a solução Gerenciamento de direitos digitais (DRM).

O método CreateEmptyAsset mostra como criar um ativo vazio.

Copiar 
static private IAsset CreateEmptyAsset(string assetName, AssetCreationOptions assetCreationOptions)
{
    var asset = _context.Assets.Create(assetName, assetCreationOptions);

    Console.WriteLine("Asset name: " + asset.Name);
    Console.WriteLine("Time created: " + asset.Created.Date.ToString());

    return asset;
}

Carregando um único arquivo

O código nesta sessão faz o seguinte:

  1. Cria um Asset vazio usando o método CreateEmptyAsset definido na etapa anterior.

  2. Cria uma instância do AssetFile associada ao ativo Asset.

  3. Carrega os arquivos de mídia associados ao ativo AssetFile no Serviços de Mídia.

noteObservação
A instância do AssetFile e o arquivo de mídia real são dois objetos diferentes. A instância do AssetFile contém metadados sobre o arquivo de mídia, enquanto o arquivo de mídia contém o conteúdo de mídia real.

Copiar 
static public IAsset CreateAssetAndUploadSingleFile( AssetCreationOptions assetCreationOptions, string singleFilePath)
{   
    var assetName = "UploadSingleFile_" + DateTime.UtcNow.ToString();
    var asset = CreateEmptyAsset(assetName, assetCreationOptions);
    var fileName = Path.GetFileName(singleFilePath);
    var assetFile = asset.AssetFiles.Create(fileName);

    Console.WriteLine("Created assetFile {0}", assetFile.Name);
    Console.WriteLine("Upload {0}", assetFile.Name);

    assetFile.Upload(singleFilePath);
    Console.WriteLine("Done uploading of {0}", assetFile.Name);

    return asset;

}

Carregar múltiplos arquivos do diretório local e exibir o progresso do carregamento

O código nesta sessão faz o seguinte:

  1. Cria um ativo vazio usando o método CreateEmptyAsset definido na etapa anterior.

  2. Cria uma instância AccessPolicy que define as permissões e a duração de acesso ao ativo.

  3. Cria um instância Locator que fornece acesso ao ativo.

  4. Cria uma instância BlobTransferClient. Esse tipo representa um cliente que opera nos blobs do Windows Azure. Nesse exemplo usamos o cliente para monitorar o progresso do carregamento.

  5. Enumera os arquivos no diretório especificado e cria uma instância AssetFile para cada arquivo.

  6. Carrega os arquivos no Serviços de Mídia usando o método UploadAsync.

    TipDica
    Use o método UploadAsync para garantir que as chamadas não estejam bloqueadas e que os arquivos sejam carregados em paralelo.

Copiar 
static public IAsset CreateAssetAndUploadMultipleFiles(AssetCreationOptions assetCreationOptions, string folderPath)
{
      var assetName = "UploadMultipleFiles_" + DateTime.UtcNow.ToString();
      var asset = CreateEmptyAsset(assetName, assetCreationOptions);
      var accessPolicy = _context.AccessPolicies.Create(assetName, TimeSpan.FromDays(30), AccessPermissions.Write | AccessPermissions.List);
      var locator = _context.Locators.CreateLocator(LocatorType.Sas, asset, accessPolicy);

      var blobTransferClient = new BlobTransferClient();
      blobTransferClient.NumberOfConcurrentTransfers = 20;
      blobTransferClient.ParallelTransferThreadCount = 20;
      blobTransferClient.TransferProgressChanged += blobTransferClient_TransferProgressChanged;

       var filePaths = Directory.EnumerateFiles(folderPath);

       Console.WriteLine("There are {0} files in {1}", filePaths.Count(), folderPath);

       if (!filePaths.Any())
       {
           throw new FileNotFoundException(String.Format("No files in directory, check folderPath: {0}", folderPath));
       }

       var uploadTasks = new List<Task>();
       foreach (var filePath in filePaths)
       {
            var assetFile = asset.AssetFiles.Create(Path.GetFileName(filePath));

            Console.WriteLine("Start uploading of {0}", assetFile.Name);
            uploadTasks.Add(assetFile.UploadAsync(filePath, blobTransferClient, locator, CancellationToken.None));
       }

      Task.WaitAll(uploadTasks.ToArray());
      Console.WriteLine("Done uploading the files");

      blobTransferClient.TransferProgressChanged -= blobTransferClient_TransferProgressChanged;
      locator.Delete();
      accessPolicy.Delete();

      return asset;

}

static void  blobTransferClient_TransferProgressChanged(object sender, BlobTransferProgressChangedEventArgs e)
{
    Console.WriteLine("{0}% upload competed for {1}.", e.ProgressPercentage, e.LocalFile);
}

Você está pronto para prosseguir para o próximo tópico: Ingestão de ativos em massa.

Consulte também


Data da compilação:

2013-06-04
Isso foi útil para você?
(1500 caracteres restantes)

Contribuições da comunidade

ADICIONAR
© 2013 Microsoft. Todos os direitos reservados.
facebook page visit twitter rss feed newsletter