Cómo empezar

Para comenzar a usar Transformer, sigue estos pasos:

1. Agrega Media3 Transformer como una dependencia en tu proyecto.
2. Compila un elemento EditedMediaItem que represente el contenido multimedia que se procesará y las ediciones aplicar a ella.
3. Compila un Transformer que describa la salida requerida y un objeto de escucha para los eventos de finalización y error.
4. Inicia la operación de exportación y pasa el EditedMediaItem para editar y un de salida. Durante la exportación, puedes consultar el progreso actual o cancelar una sola operación.
5. Cuando finalice la exportación, controla el resultado según sea necesario. Por ejemplo, puedes compartir la salida a otra app o subirla a un servidor.

Continúa leyendo para obtener más detalles sobre estos pasos y consulta TransformerActivity en el demostración de transformador app para un ejemplo completo.

Agrega Transformer como dependencia de Media3

La manera más fácil de comenzar a usar Transformer es agregar dependencias de Gradle. en la biblioteca, en el archivo build.gradle del módulo de tu app:

Kotlin

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

Groovy

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

en la que 1.4.0 es tu versión preferida. La última versión que puedes encontrar consultando la versión notas.

Importante: Si usas otros módulos de Media3, incluido Media3 ExoPlayer, todos deben ser de la misma versión.

Puedes encontrar más información sobre los módulos de biblioteca disponibles en la Google Maven AndroidX Media3 .

Cómo activar la compatibilidad con Java 8

Si aún no está habilitado, debes activar la compatibilidad con Java 8 en todos los build.gradle que dependen de Transformer. Para ello, agrega lo siguiente al android sección:

compileOptions {
  targetCompatibility JavaVersion.VERSION_1_8
}

Inicia una transformación

A continuación, se muestra un ejemplo de cómo crear un EditedMediaItem para quitar audio de una entrada y, luego, crearás y configurarás una instancia de Transformer para exportarla Video H.265/HEVC, que da como resultado el resultado a outputPath.

Kotlin

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)

Java

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 obtener más información sobre los elementos multimedia, consulta Elementos multimedia de ExoPlayer . La entrada puede ser progresiva o adaptable de transmisión continua, pero la salida siempre es una transmisión progresiva. Para las entradas adaptables, el Para la transformación, siempre se seleccionan las pistas de mayor resolución. La entrada puede tener cualquier formato de contenedor compatible con ExoPlayer, pero el resultado siempre es un archivo MP4.

Puedes ejecutar múltiples operaciones de exportación de forma secuencial en la misma Transformer instancia, pero las exportaciones simultáneas con la misma instancia no lo son no es compatible.

Nota: La compatibilidad con la generación de contenido multimedia a través de la composición de varias entradas es se planea para versiones futuras de Transformer.

Nota sobre los subprocesos

Se debe acceder a las instancias de Transformer desde un solo subproceso de la aplicación, y se llama a los métodos de escucha en el mismo subproceso. Para la mayoría de los casos, el el subproceso de la aplicación puede ser solo el subproceso principal de la aplicación. Internamente, Transformer realiza su trabajo en segundo plano y publica sus llamadas al objeto de escucha métodos en el subproceso de la aplicación.

Cómo escuchar eventos

El método start es asíncrono. Se muestra de inmediato y la app notificaciones de eventos a través del objeto de escucha que se pasa al compilador de Transformer.

Kotlin

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)
  }
}

Java

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 incluye información sobre el archivo de salida, incluido el archivo. y las tasas de bits promedio de audio y video, según corresponda.

Recibe actualizaciones sobre tu progreso

Llama a Transformer.getProgress para consultar el progreso actual de un una transformación digital. El valor devuelto indica el estado de progreso. Si el progreso el estado es PROGRESS_STATE_AVAILABLE, entonces el ProgressHolder proporcionado es se actualiza con el porcentaje de progreso actual. En el siguiente ejemplo, se muestra cómo consultar de forma periódica el progreso de una transformación, en la que Se puede implementar el método updateProgressInUi para actualizar una barra de progreso.

Kotlin

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)
        }
      }
    }
)

Java

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);
        }
      }
    });

Cancela una transformación

Si el usuario elige retirarse de un flujo de exportación, cancela la operación de exportación. con Transformer.cancel. Los recursos como los códecs de video de hardware son limitados especialmente en dispositivos de gama baja, por lo que es importante hacer esto los recursos si el resultado no es necesario.