Comenzar

Para comenzar a usar Transformer, sigue estos pasos:

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

Sigue leyendo para obtener más detalles sobre estos pasos y consulta TransformerActivity en la app de demostración de transformador para ver un ejemplo completo.

Agrega Media3 Transformer como dependencia

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

Kotlin

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

Groovy

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

en la que 1.3.1 es tu versión preferida. Puedes encontrar la versión más reciente en las notas de la versión.

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

Cómo activar la compatibilidad con Java 8

Si aún no está habilitada, debes activar la compatibilidad con Java 8 en todos los archivos build.gradle que dependen de Transformer agregando lo siguiente en la sección android:

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 el audio de un archivo de entrada y, luego, crear y configurar una instancia de Transformer para exportar video H.265/HEVC, que genera el resultado en 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 la página de elementos multimedia de ExoPlayer. La entrada puede ser progresiva o adaptable, pero la salida siempre es progresiva. En el caso de las entradas adaptables, siempre se seleccionan las pistas con la resolución más alta para la transformación. La entrada puede ser de cualquier formato de contenedor compatible con ExoPlayer, pero el resultado siempre es un archivo MP4.

Puedes ejecutar varias operaciones de exportación de forma secuencial en la misma instancia de Transformer, pero no se admiten exportaciones simultáneas con la misma instancia.

Nota sobre los subprocesos

Se debe acceder a las instancias de transformador desde un solo subproceso de la aplicación, y los métodos de los objetos de escucha se llaman en el mismo subproceso. En la mayoría de los casos, el subproceso de la aplicación puede ser solo el principal. De forma interna, Transformer hace su trabajo en segundo plano y publica sus llamadas a los métodos de objetos de escucha en el subproceso de la aplicación.

Escucha eventos

El método start es asíncrono. Se muestra de inmediato y se notifica a la app sobre los eventos a través del objeto de escucha que se pasó 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, lo que incluye el tamaño del archivo y las tasas de bits promedio para audio y video, según corresponda.

Recibe actualizaciones del progreso

Llama a Transformer.getProgress para consultar el progreso actual de una transformación. El valor que se muestra indica el estado de progreso. Si el estado de progreso es PROGRESS_STATE_AVAILABLE, el ProgressHolder proporcionado 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 decide 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, en especial en dispositivos de gama baja, por lo que es importante hacer esto para liberar recursos si la salida no es necesaria.