Como carregar um arquivo (HTML)

Artigo
12/12/2015

[ Este artigo destina-se aos desenvolvedores do Windows 8.x e do Windows Phone 8.x que escrevem aplicativos do Windows Runtime. Se você estiver desenvolvendo para o Windows 10, consulte documentação mais recente]

Este tópico mostrará a você como carregar dados ou um arquivo de um dispositivo para a Internet.

Os aplicativos podem usar as APIs abordadas neste tópico para habilitar a interação com os serviços Web, para consumir ou compartilhar formatos de mídia populares, como fotos, música e vídeo.

Para transferências de arquivos maiores, baseados em fluxo ou formados por várias partes (vídeo, música e imagens grandes) e com um tempo de vida operacional que pode se estender além de várias suspensões de aplicativo e/ou alterações na disponibilidade da rede, o seu aplicativo também pode usar Background Transfer.

Para obter uma aparência de alto nível em Transferência em Segundo Plano, consulte Transferindo dados em segundo plano.

Pré-requisitos

Para obter instruções sobre a criação de um aplicativo da Windows Store em JavaScript , consulte Criar seu primeiro aplicativo do Tempo de Execução do Windows em JavaScript. Além disso, as promessas de JavaScript são usadas neste tópico para concluir as operações assíncronas. Para obter mais informações sobre esse padrão de programação, consulte Programação assíncrona em JavaScript usando promessas.

Para garantir que seu aplicativo está pronto para a rede, defina a capacidade no arquivo Package.appxmanifest do projeto. Para obter uma definição de cada recurso de rede, veja Como configurar recursos de isolamento de rede.

Estes exemplos de Transferência em Segundo Plano usam JavaScript e se baseiam no Exemplo de Transferência em Segundo Plano.

Operações de carregamento da Transferência em Segundo Plano

O uso da Transferência em Segundo Plano envolve um carregamento como uma UploadOperation, que expõe vários métodos de controle que são usados para reiniciar ou cancelar a operação. Os eventos de aplicativo (por exemplo, suspensão ou encerramento) e as alterações de conectividade são manipulados automaticamente pelo sistema por UploadOperation; os downloads continuarão durante os períodos de suspensão do aplicativo ou serão pausados e persistirão após o encerramento do aplicativo. Além disso, a configuração da propriedade CostPolicy indicará se o aplicativo tentará ou não começar ou continuar uploads enquanto uma rede limitada está sendo usada para conectividade com a Internet.

Os exemplos a seguir orientarão você na criação e inicialização de um upload básico e mostrarão como enumerar e reintroduzir operações que persistiram desde a sessão anterior do aplicativo.

Carregar um arquivo

A criação de um carregamento começa com BackgroundUploader. Esta classe é usada para fornecer os métodos que permitem que seu aplicativo configure o carregamento antes de criar o UploadOperationresultante. O exemplo a seguir mostra como fazer isso com os objetos Uri e StorageFile necessários.

Identificar o arquivo e o destino para o upload

Antes de podermos começar a criação de um UploadOperation, primeiro precisamos identificar o URI o local de carregamento e o arquivo que será carregado. No exemplo a seguir, o valor da uriString é preenchido usando uma cadeia de caracteres da entrada da Interface do Usuário e o valor do file usando o objeto StorageFile retornado pela operação PickSingleFileAsync.

function uploadFile() {
    var filePicker = new Windows.Storage.Pickers.FileOpenPicker();
    filePicker.fileTypeFilter.replaceAll(["*"]);

    filePicker.pickSingleFileAsync().then(function (file) {
        if (!file) {
            printLog("No file selected");
            return;
        }

        var upload = new UploadOp();
        var uriString = document.getElementById("serverAddressField").value;
        upload.start(uriString, file);

        // Store the upload operation in the uploadOps array.
        uploadOperations.push(upload);
    });
}

Criar e inicializar a operação de upload

Na etapa anterior, os valores de uriString e file são passados para uma instância do nosso próximo exemplo, UploadOp, onde são usadas para configurar e iniciar uma nova operação de carregamento. Primeiro, uriString é analisado para criar o objeto Uri necessário.

Depois, as propriedade do StorageFile (file) fornecido são usadas por BackgroundUploader para preencher o cabeçalho de solicitação e definir a propriedade SourceFile com o objeto StorageFile. O método SetRequestHeader é chamado para inserir as informações do nome do arquivo fornecidas como uma cadeia de caracteres e a propriedade StorageFile.Name.

Por fim, o BackgroundUploader crie o UploadOperation (upload).

function UploadOp() {
    var upload = null;
    var promise = null;

    this.start = function (uriString, file) {
        try {

            var uri = new Windows.Foundation.Uri(uriString);
            var uploader = new Windows.Networking.BackgroundTransfer.BackgroundUploader();

            // Set a header, so the server can save the file (this is specific to the sample server).
            uploader.setRequestHeader("Filename", file.name);

            // Create a new upload operation.
            upload = uploader.createUpload(uri, file);

            // Start the upload and persist the promise to be able to cancel the upload.
            promise = upload.startAsync().then(complete, error, progress);
        } catch (err) {
            displayError(err);
        }
    };
    // On application activation, reassign callbacks for a upload
    // operation persisted from previous application state.
    this.load = function (loadedUpload) {
        try {
            upload = loadedUpload;
            promise = upload.attachAsync().then(complete, error, progress);
        } catch (err) {
            displayError(err);
        }
    };
}

Observe as chamadas de método assíncrono definidas usando promessas de JavaScript. Observando uma linha do último exemplo:

promise = upload.startAsync().then(complete, error, progress);

A chamada de método assíncrono é seguida por uma instrução then que indica métodos, definidos pelo aplicativo, que são chamados quando é retornado um resultado da chamada de método assíncrono. Para obter mais informações sobre esse padrão de programação, consulte Programação assíncrona em JavaScript usando promessas.

Carregar vários arquivos

Identificar os arquivos e o destino para o upload

Em um cenário que envolve vários arquivos transferidos com uma só UploadOperation, o processo começa da maneira usual, fornecendo primeiro as informações necessárias de URI de destino e de arquivo local. De modo similar ao exemplo da seção anterior, o URI é fornecido como uma cadeia de caracteres pelo usuário final e FileOpenPicker pode ser usado para fornecer a capacidade de indicar arquivos também pela interface de usuário. Nesse cenário, porém, o aplicativo deve chamar o método PickMultipleFilesAsync para permitir a seleção de vários arquivos pela interface do usuário.
```
function uploadFiles() {
   var filePicker = new Windows.Storage.Pickers.FileOpenPicker();
   filePicker.fileTypeFilter.replaceAll(["*"]);

   filePicker.pickMultipleFilesAsync().then(function (files) {
      if (files === 0) {
         printLog("No file selected");
            return;
      }

      var upload = new UploadOperation();
      var uriString = document.getElementById("serverAddressField").value;
      upload.startMultipart(uriString, files);

      // Persist the upload operation in the global array.
      uploadOperations.push(upload);
   });
}
```
Criar objetos para os parâmetros fornecidos

Os dois próximos exemplos usam o código contido em um método de exemplo único, startMultipart, que foi chamado no fim da última etapa. Para fins de instrução, o código no método que cria uma matriz de objetos BackgroundTransferContentPart foi dividida do código que cria o UploadOperation resultante.

Primeiro, a cadeia de caracteres do URI fornecida pelo usuário é inicializada como um Uri. Em seguida, a matriz de objetos IStorageFile (files) passada para esse método é iterada, cada objeto é usado para criar um novo objeto BackgroundTransferContentPart que, em seguida, é colocado na matriz contentParts.
```
upload.startMultipart = function (uriString, files) {
    try {
        var uri = new Windows.Foundation.Uri(uriString);
        var uploader = new Windows.Networking.BackgroundTransfer.BackgroundUploader();

        var contentParts = [];
        files.forEach(function (file, index) {
            var part = new Windows.Networking.BackgroundTransfer.BackgroundTransferContentPart("File" + index, file.name);
            part.setFile(file);
            contentParts.push(part);
        });
```

Criar e inicializar a operação de carregamento de várias partes

Com nossa matriz contentParts preenchida com todos os objetos BackgroundTransferContentPart que representam cada IStorageFile para carregamento, estamos prontos para chamar CreateUploadAsync usando o Uri para indicar onde a solicitação será enviada.

        // Create a new upload operation.
        uploader.createUploadAsync(uri, contentParts).then(function (uploadOperation) {

           // Start the upload and persist the promise to be able to cancel the upload.
           upload = uploadOperation;
           promise = uploadOperation.startAsync().then(complete, error, progress);
        });

     } catch (err) {
         displayError(err);
     }
 };

Enumerar operações persistentes na inicialização

Na conclusão ou no cancelamento de uma UploadOperation, todos os recursos de sistema associados são liberados. No entanto, se o aplicativo for encerrado antes da ocorrência dessas ações, todas as operações ativas serão pausadas e os recursos associados a cada uma delas permanecerão ocupados. Se as operações não forem enumeradas e reintroduzidas na próxima sessão de aplicativo, elas não serão concluídas e continuarão ocupando os recursos do dispositivo.

Antes de definir a função que enumera operações persistidas, precisamos criar uma matriz que conterá os objetos UploadOperation que ela retornará:
```
var uploadOperations = [];
```
Depois, nós definimos a função que enumera operações persistentes e as armazena em nossa matriz. Observe que o método load chamado para reatribuir retornos de chamada para UploadOperation, se persistir à terminação do aplicativo, está na classe UploadOp que definimos posteriormente nesta seção.
```
function Windows.Networking.BackgroundTransfer.BackgroundUploader.getCurrentUploadsAsync() {
    .then(function (uploads) {
        for (var i = 0; i < uploads.size; i++) {
            var upload = new UploadOp();
            upload.load(uploads[i]);
            uploadOperations.push(upload);
        }
    }
};
```
Observação

Para os aplicativos da Loja do Windows Phone, as transferências em segundo plano continuam a progredir enquanto seu aplicativo não está em primeiro plano. Como seu aplicativo não está em execução nesse cenário, ele não receberá uma notificação quando a transferência for concluída. Quando seu aplicativo for retomado, se você verificar o progresso de uma transferência concluída, o status será BackgroundTransferStatus.Running. No entanto, quando você anexar à transferência como no código de exemplo acima, o manipulador de conclusão da tarefa será gerado e o status de transferência será atualizado.

Tempos limite de solicitação

Existem dois cenários principais de tempo limite de conexão para levar em consideração.

Ao estabelecer uma nova conexão para a transferência, a solicitação da conexão é anulada se não é estabelecida dentro de cinco minutos.
Depois de uma conexão ser estabelecida, uma mensagem de solicitação de HTTP que não tenha recebido uma resposta em dois minutos será anulada.

Observação Em qualquer um desses cenários, supondo que haja conectividade com a Internet, a Transferência em Segundo Plano repetirá automaticamente a solicitação no máximo três vezes. Caso a conectividade com a Internet não seja detectada, outras solicitações esperarão até que a conexão seja estabelecida.

Instrução de depuração

Parar uma sessão de depuração no Microsoft Visual Studio é comparável a fechar seu aplicativo; uploads PUT são pausados e uploads POST são finalizados. Mesmo durante a depuração, seu aplicativo deve enumerar e então reiniciar ou cancelar quaisquer uploads que persistam. Por exemplo, você pode fazer com que seu aplicativo cancele as operações de upload enumeradas e existentes na inicialização do aplicativo se não houver interesse nas operações anteriores para essa sessão de depuração.

Enquanto numera downloads/uploads na inicialização do aplicativo, durante uma sessão de depuração, seu aplicativo poderá cancelá-los se não houver interesse nas operações anteriores para essa sessão de depuração. Observe que se houver atualizações de projeto do Visual Studio, como alterações no manifesto do aplicativo, e o aplicativo tiver sido desinstalado e reimplantado, o GetCurrentUploadsAsync não poderá enumerar operações criadas usando a implantação de aplicativo anterior.

Consulte Depurando e testando aplicativos da Windows Store para obter mais informações.

Quando usar a Transferência em segundo plano durante o desenvolvimento, pode acontecer que os caches internos das operações de transferência ativas e concluídas poderão sair da sincronização. Isso pode resultar na incapacidade de iniciar novas operações de transferência ou de interagir com as operações existentes e objetos do BackgroundTransferGroup. Em alguns casos, a tentativa de interagir com operações existentes pode gerar uma falha. Isso pode ocorrer se a propriedade TransferBehavior estiver definida para Parallel. Esse problema ocorre somente em determinados cenários, durante o desenvolvimento, e não se aplica a usuários finais de seu aplicativo.

Quatro cenários usando o Visual Studio podem causar esse problema.

Você pode criar um novo projeto com o mesmo nome de aplicativo de um projeto existente, mas em uma linguagem diferente (de C++ para C#, por exemplo).
Você pode alterar a arquitetura de destino (de x86 para x64, por exemplo) em um projeto existente.
Você pode alterar a cultura (de neutra para en-US, por exemplo) em um projeto existente.
Você pode adicionar ou remover um recurso no manifesto do pacote (adicionando Autenticação Empresarial, por exemplo) em um projeto existente.

Aplicativos comuns em serviço, incluindo atualizações de manifesto, que adicionam ou removem recursos, não geram esse problema nas implantações de usuário final para seu aplicativos.

Para contornar esse problema, desinstale completamente todas as versões do aplicativo e reimplante com a nova linguagem, arquitetura, cultura ou recurso. Isso pode ser feito por meio da tela Iniciar ou usando PowerShell e o cmdlet Remove-AppxPackage.

Resumo e próximas etapas

Neste tópico, nós revisamos como carregar arquivos usando as APIs de Background Transfer no JavaScript.

Você também pode baixar arquivos no seu aplicativo da Windows Store. Para ver uma explicação sobre os conceitos fundamentais e exemplos, consulte Como baixar um arquivo.