Gerenciar BLOBs de Apresentação no Android para Uso Eficiente de Memória

Visão geral

Aspose.Slides oferece manipulação baseada em BLOB para grandes dados binários em apresentações, ajudando a reduzir o consumo de memória ao trabalhar com imagens, áudio, vídeo e arquivos de apresentação de grande tamanho.

Este artigo mostra como usar o processamento baseado em BLOB para adicionar mídia grande a uma apresentação, exportar mídia grande de uma apresentação e carregar apresentações grandes de forma mais eficiente. Também explica como arquivos temporários podem ser usados durante o processamento e como alterar a pasta usada para armazená‑los.

Sobre BLOB

BLOB (Binary Large Object) é normalmente um item grande (foto, apresentação, documento ou mídia) salvo em formatos binários.

Aspose.Slides for Android via Java permite que você use BLOBs para objetos de forma a reduzir o consumo de memória quando arquivos grandes estão envolvidos.

Usar BLOB para reduzir o consumo de memória

Adicionar um arquivo grande via BLOB a uma apresentação

Aspose.Slides para Java permite que você adicione arquivos grandes (neste caso, um arquivo de vídeo grande) por meio de um processo que envolve BLOBs para reduzir o consumo de memória.

Este exemplo em Java mostra como adicionar um grande arquivo de vídeo pelo processo BLOB a uma apresentação:

String pathToVeryLargeVideo = "veryLargeVideo.avi";

// Cria uma nova apresentação à qual o vídeo será adicionado
Presentation pres = new Presentation();
try {
    FileInputStream fileStream = new FileInputStream(pathToVeryLargeVideo);
    try {
        // Vamos adicionar o vídeo à apresentação - escolhemos o comportamento KeepLocked porque
        //não pretendemos acessar o arquivo "veryLargeVideo.avi".
        IVideo video = pres.getVideos().addVideo(fileStream, LoadingStreamBehavior.KeepLocked);
        pres.getSlides().get_Item(0).getShapes().addVideoFrame(0, 0, 480, 270, video);

        // Salva a apresentação. Enquanto uma apresentação grande é gerada, o consumo de memória
        //permanece baixo ao longo do ciclo de vida do objeto pres 
        pres.save("presentationWithLargeVideo.pptx", SaveFormat.Pptx);
    } finally {
        if (fileStream != null) fileStream.close();
    }
} catch(IOException e) {
} finally {
    if (pres != null) pres.dispose();
}

Exportar um arquivo grande via BLOB de uma apresentação

Aspose.Slides for Android via Java permite que você exporte arquivos grandes (neste caso, um arquivo de áudio ou vídeo) por meio de um processo que envolve BLOBs a partir de apresentações. Por exemplo, pode ser necessário extrair um grande arquivo de mídia de uma apresentação, mas sem carregá‑lo na memória do computador. Exportando o arquivo pelo processo BLOB, você mantém o consumo de memória baixo.

Este código em Java demonstra a operação descrita:

String hugePresentationWithAudiosAndVideosFile = "LargeVideoFileTest.pptx";

LoadOptions loadOptions = new LoadOptions();
// Bloqueia o arquivo de origem e NÃO o carrega na memória
loadOptions.getBlobManagementOptions().setPresentationLockingBehavior(PresentationLockingBehavior.KeepLocked);

// cria a instância da Presentation, bloqueia o arquivo "hugePresentationWithAudiosAndVideos.pptx".
Presentation pres = new Presentation(hugePresentationWithAudiosAndVideosFile, loadOptions);
try {
    // Vamos salvar cada vídeo em um arquivo. Para evitar alto uso de memória, precisamos de um buffer que será usado
    // para transferir os dados do stream de vídeo da apresentação para um stream de um novo arquivo de vídeo criado.
    byte[] buffer = new byte[8 * 1024];

    // Itera pelos vídeos
    for (int index = 0; index < pres.getVideos().size(); index++) {
        IVideo video = pres.getVideos().get_Item(index);

        // Abre o stream de vídeo da apresentação. Observe que evitamos intencionalmente acessar propriedades
        // como video.BinaryData - porque essa propriedade retorna um array de bytes contendo um vídeo completo, o que então
        // faz com que os bytes sejam carregados na memória. Usamos video.GetStream, que retornará um Stream - e NÃO
        //  requer que carreguemos o vídeo inteiro na memória.
        InputStream presVideoStream = video.getStream();
        try {
            OutputStream outputFileStream = new FileOutputStream("video" + index + ".avi");
            try {
                int bytesRead;
                while ((bytesRead = presVideoStream.read(buffer, 0, buffer.length)) > 0) {
                    outputFileStream.write(buffer, 0, bytesRead);
                }
            } finally {
                outputFileStream.close();
            }
        } finally {
            presVideoStream.close();
        }
        // O consumo de memória permanecerá baixo independentemente do tamanho do vídeo ou da apresentação.
    }
    // Se necessário, você pode aplicar os mesmos passos para arquivos de áudio. 
} catch (IOException e) {
} finally {
    pres.dispose();
}

Adicionar uma imagem como BLOB em uma apresentação

Com os métodos da interface IImageCollection e da classe ImageCollection, você pode adicionar uma imagem grande como stream para que ela seja tratada como BLOB.

Este código Java mostra como adicionar uma imagem grande pelo processo BLOB:

String pathToLargeImage = "large_image.jpg";

// cria uma nova apresentação à qual a imagem será adicionada.
Presentation pres = new Presentation();
try {
	FileInputStream fileStream = new FileInputStream(pathToLargeImage);
	try {
		// Vamos adicionar a imagem à apresentação - escolhemos o comportamento KeepLocked porque nós
		// NÃO pretendemos acessar o arquivo "largeImage.png" file.
		IPPImage img = pres.getImages().addImage(fileStream, LoadingStreamBehavior.KeepLocked);
		pres.getSlides().get_Item(0).getShapes().addPictureFrame(ShapeType.Rectangle, 0, 0, 300, 200, img);

		// Salva a apresentação. Enquanto uma apresentação grande é gerada, o consumo de memória
		// permanece baixo ao longo do ciclo de vida do objeto pres
		pres.save("presentationWithLargeImage.pptx", SaveFormat.Pptx);
	} finally {
		if (fileStream != null) fileStream.close();
	}
} catch(IOException e) {
} finally {
	if (pres != null) pres.dispose();
}

Memória e apresentações grandes

Normalmente, para carregar uma apresentação grande, os computadores precisam de muita memória temporária. Todo o conteúdo da apresentação é carregado na memória e o arquivo (do qual a apresentação foi carregada) deixa de ser usado.

Considere uma grande apresentação PowerPoint (large.pptx) que contém um arquivo de vídeo de 1,5 GB. O método padrão para carregar a apresentação é descrito neste código Java:

Presentation pres = new Presentation("large.pptx");
try {
    pres.save("large.pdf", SaveFormat.Pdf);
} finally {
    if (pres != null) pres.dispose();
}

Mas esse método consome cerca de 1,6 GB de memória temporária.

Carregar uma apresentação grande como BLOB

Por meio do processo que envolve um BLOB, você pode carregar uma apresentação grande usando pouca memória. Este código Java descreve a implementação onde o processo BLOB é usado para carregar um arquivo de apresentação grande (large.pptx):

LoadOptions loadOptions = new LoadOptions();
loadOptions.getBlobManagementOptions().setPresentationLockingBehavior(PresentationLockingBehavior.KeepLocked);
loadOptions.getBlobManagementOptions().setTemporaryFilesAllowed(true);

Presentation pres = new Presentation("large.pptx", loadOptions);
try {
    pres.save("large.pdf", SaveFormat.Pdf);
} finally {
    if (pres != null) pres.dispose();
}

Alterar a pasta para arquivos temporários

Quando o processo BLOB é usado, o computador cria arquivos temporários na pasta padrão de arquivos temporários. Se desejar que os arquivos temporários sejam mantidos em outra pasta, pode alterar as configurações de armazenamento usando TempFilesRootPath:

LoadOptions loadOptions = new LoadOptions();
loadOptions.getBlobManagementOptions().setPresentationLockingBehavior(PresentationLockingBehavior.KeepLocked);
loadOptions.getBlobManagementOptions().setTemporaryFilesAllowed(true);
loadOptions.getBlobManagementOptions().setTempFilesRootPath("temp");

Descartar objetos Presentation para liberar memória

Ao processar apresentações grandes, certifique‑se de que a instância de Presentation seja descartada corretamente para que a memória ocupada seja liberada. Chame dispose() após terminar de usar a apresentação para liberar recursos não gerenciados.

Presentation presentation = new Presentation("large.pptx");

// ...processar a apresentação...
presentation.save("large.pdf", SaveFormat.Pdf);

// Libere recursos explicitamente.
presentation.dispose();

FAQ

Quais dados em uma apresentação Aspose.Slides são tratados como BLOB e controlados pelas opções de BLOB?

Objetos binários grandes, como imagens, áudio e vídeo, são tratados como BLOB. O próprio arquivo de apresentação também envolve manipulação de BLOB quando é carregado ou salvo. Esses objetos são regidos por políticas de BLOB que permitem gerenciar o uso de memória e transferir para arquivos temporários quando necessário.

Onde configuro as regras de manipulação de BLOB durante o carregamento da apresentação?

Use LoadOptions com BlobManagementOptions. Lá você define o limite em memória para BLOB, permite ou bloqueia arquivos temporários, escolhe o caminho raiz para arquivos temporários e seleciona o comportamento de bloqueio da origem.

As configurações de BLOB afetam o desempenho e como equilibrar velocidade vs memória?

Sim. Manter BLOB na memória maximiza a velocidade, mas aumenta o consumo de RAM; reduzir o limite de memória transfere mais trabalho para arquivos temporários, diminuindo a RAM ao custo de I/O adicional. Use o método setMaxBlobsBytesInMemory para alcançar o equilíbrio adequado para sua carga de trabalho e ambiente.

As opções de BLOB ajudam ao abrir apresentações extremamente grandes (por exemplo, gigabytes)?

Sim. BlobManagementOptions foram projetadas para esses cenários: habilitar arquivos temporários e usar bloqueio de origem pode reduzir significativamente o pico de uso de RAM e estabilizar o processamento de decks muito grandes.

Posso usar políticas de BLOB ao carregar a partir de streams em vez de arquivos de disco?

Sim. As mesmas regras se aplicam a streams: a instância da apresentação pode possuir e bloquear o stream de entrada (dependendo do modo de bloqueio escolhido), e arquivos temporários são usados quando permitidos, mantendo o uso de memória previsível durante o processamento.

Gerenciar Hiperlinks de Apresentação no Android