Como começar

Para começar a usar o Transformer, siga estas etapas:

1. Adicione o Media3 Transformer como uma dependência no seu projeto.
2. Crie um EditedMediaItem que represente a mídia a ser processada e editada. se aplicam a ela.
3. Criar um Transformer, descrevendo a saída necessária e um listener para eventos de conclusão e erro.
4. Inicie a operação de exportação, transmitindo o EditedMediaItem para edição e uma caminho de saída. Durante a exportação, você pode consultar o progresso atual ou cancelar o operação
5. Quando a exportação for concluída, processe a saída conforme necessário. Por exemplo, é possível compartilhar a saída com outro app ou fazer upload para um servidor.

Continue lendo para saber mais sobre essas etapas e consulte TransformerActivity na demonstração do transformador app para um exemplo completo.

Adicionar o Media3 Transformer como uma dependência

A maneira mais fácil de começar a usar o Transformer é adicionar dependências do Gradle. na biblioteca no arquivo build.gradle do módulo do app:

implementation("androidx.media3:media3-transformer:1.4.1")
implementation("androidx.media3:media3-effect:1.4.1")
implementation("androidx.media3:media3-common:1.4.1")

implementation "androidx.media3:media3-transformer:1.4.1"
implementation "androidx.media3:media3-effect:1.4.1"
implementation "androidx.media3:media3-common:1.4.1"

em que 1.4.1 é sua versão preferida. A versão mais recente pode ser encontrado consultando a versão .

Mais informações sobre os módulos de biblioteca disponíveis podem ser encontradas na Google Maven AndroidX Media3 .

Ativar a compatibilidade com Java 8

Se esse recurso ainda não estiver ativado, ative a compatibilidade com Java 8 em todos os build.gradle que dependem do Transformer adicionando o seguinte ao arquivo android :

compileOptions {
  targetCompatibility JavaVersion.VERSION_1_8
}

Iniciar uma transformação

Veja um exemplo de como criar um EditedMediaItem para remover áudio de uma entrada em seguida, criando e configurando uma instância do Transformer para exportar Vídeo H.265/HEVC, gerando o resultado em outputPath.

val inputMediaItem = MediaItem.fromUri("path_to_input_file")
val editedMediaItem =
    EditedMediaItem.Builder(inputMediaItem).setRemoveAudio(true).build()
val transformer = Transformer.Builder(context)
    .setVideoMimeType(MimeTypes.VIDEO_H265)
    .addListener(transformerListener)
    .build()
transformer.start(editedMediaItem, outputPath)

MediaItem inputMediaItem = MediaItem.fromUri("path_to_input_file");
EditedMediaItem editedMediaItem =
    new EditedMediaItem.Builder(inputMediaItem).setRemoveAudio(true).build();
Transformer transformer =
    new Transformer.Builder(context)
        .setVideoMimeType(MimeTypes.VIDEO_H265)
        .addListener(transformerListener)
        .build();
transformer.start(editedMediaItem, outputPath);

Para saber mais sobre os itens de mídia, consulte os itens de mídia do ExoPlayer . A entrada pode ser progressiva ou adaptativa stream, mas a saída é sempre um stream progressivo. Para entradas adaptáveis, as faixas de maior resolução são sempre selecionadas para a transformação. A entrada pode ter qualquer formato de contêiner compatível com o ExoPlayer, mas a saída será sempre um arquivo MP4.

Você pode executar várias operações de exportação sequencialmente no mesmo Transformer, mas as exportações simultâneas com a mesma instância não são suporte.

Observação sobre linhas de execução

As instâncias do Transformer devem ser acessadas a partir de uma única linha de execução de aplicativo e a métodos de listener são chamados na mesma linha de execução. Na maioria dos casos, a linha de execução do aplicativo pode ser apenas a linha de execução principal do aplicativo. Internamente, O Transformer faz o trabalho em segundo plano e publica as chamadas para o listener na linha de execução do aplicativo.

Ouvir eventos

O método start é assíncrono. Ele retorna imediatamente e o aplicativo notificadas sobre eventos pelo listener transmitido para o builder Transformer.

val transformerListener: Transformer.Listener =
    object : Transformer.Listener {
  override fun onCompleted(composition: Composition, result: ExportResult) {
    playOutput()
  }

  override fun onError(composition: Composition, result: ExportResult,
                       exception: ExportException) {
    displayError(exception)
  }
}

Transformer.Listener transformerListener =
    new Transformer.Listener() {
      @Override
      public void onCompleted(Composition composition, ExportResult result) {
        playOutput();
      }

      @Override
      public void onError(Composition composition, ExportResult result,
          ExportException exception) {
        displayError(exception);
      }
    };

ExportResult inclui informações sobre o arquivo de saída, incluindo o arquivo tamanho e taxas médias de bits para áudio e vídeo, conforme aplicável.

Receber atualizações de progresso

Chame Transformer.getProgress para consultar o progresso atual de uma transformação digital. O valor retornado indica o estado do progresso. Se o progresso estado for PROGRESS_STATE_AVAILABLE, então o ProgressHolder fornecido será atualizada com a porcentagem de progresso atual. O exemplo abaixo mostra como consultar periodicamente o progresso de uma transformação, na qual o O método updateProgressInUi pode ser implementado para atualizar uma barra de progresso.

transformer.start(inputMediaItem, outputPath)
val progressHolder = ProgressHolder()
mainHandler.post(
    object : Runnable {
      override fun run() {
        val progressState: @ProgressState Int = transformer.getProgress(progressHolder)
        updateProgressInUi(progressState, progressHolder)
        if (progressState != Transformer.PROGRESS_STATE_NOT_STARTED) {
          mainHandler.postDelayed(/* r= */this,  /* delayMillis= */500)
        }
      }
    }
)

transformer.start(inputMediaItem, outputPath);
ProgressHolder progressHolder = new ProgressHolder();
mainHandler.post(
    new Runnable() {
      @Override
      public void run() {
        @Transformer.ProgressState int progressState = transformer.getProgress(progressHolder);
        updateProgressInUi(progressState, progressHolder);
        if (progressState != PROGRESS_STATE_NOT_STARTED) {
          mainHandler.postDelayed(/* r= */ this, /* delayMillis= */ 500);
        }
      }
    });

Cancelar uma transformação

Se o usuário optar por sair de um fluxo de exportação, cancele a operação de exportação com Transformer.cancel. Recursos como codecs de vídeo de hardware são limitados, especialmente em dispositivos mais simples. Assim, é importante fazer isso para liberar recursos se a saída não for necessária.