Erste Schritte

So starten Sie mit Transformer:

1. Füge Media3 Transformer als Abhängigkeit in dein Projekt ein.
2. Erstelle eine EditedMediaItem, die die zu verarbeitenden Medien und die darauf anzuwendenden Änderungen darstellt.
3. Erstellen Sie eine Transformer, in der die erforderliche Ausgabe und ein Listener für Abschluss- und Fehlerereignisse beschrieben werden.
4. Starten Sie den Exportvorgang, indem Sie die zu bearbeitende EditedMediaItem und einen Ausgabepfad übergeben. Während des Exports können Sie den aktuellen Fortschritt abfragen oder den Vorgang abbrechen.
5. Wenn der Export abgeschlossen ist, können Sie die Ausgabe nach Bedarf verarbeiten. Sie können die Ausgabe beispielsweise für eine andere App freigeben oder auf einen Server hochladen.

Weitere Informationen zu diesen Schritten finden Sie weiter unten. Ein vollständiges Beispiel finden Sie unter TransformerActivity in der Demo-App für Transformers.

Media3 Transformer als Abhängigkeit hinzufügen

Die einfachste Möglichkeit, mit Transformer zu beginnen, besteht darin, der build.gradle-Datei Ihres App-Moduls Gradle-Abhängigkeiten von der Bibliothek hinzuzufügen:

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

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

Dabei ist 1.5.0 die gewünschte Version. Die neueste Version finden Sie in den Versionshinweisen.

Weitere Informationen zu den verfügbaren Bibliotheksmodulen finden Sie auf der Google Maven AndroidX Media3-Seite.

Java 8-Unterstützung aktivieren

Falls noch nicht geschehen, müssen Sie die Java 8-Unterstützung in allen build.gradle-Dateien aktivieren, die vom Transformer abhängen. Fügen Sie dazu Folgendes in den Abschnitt android ein:

compileOptions {
  targetCompatibility JavaVersion.VERSION_1_8
}

Transformation starten

Im folgenden Beispiel wird eine EditedMediaItem erstellt, um Audio aus einer Eingabedatei zu entfernen. Anschließend wird eine Transformer-Instanz erstellt und konfiguriert, um H.265/HEVC-Videos zu exportieren und die Ergebnisse in outputPath auszugeben.

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

Weitere Informationen zu Medienelementen findest du auf der Seite zu ExoPlayer-Medienelementen. Die Eingabe kann ein progressiver oder ein adaptiver Stream sein, die Ausgabe ist jedoch immer ein progressiver Stream. Bei adaptiven Eingaben werden für die Transformation immer die Tracks mit der höchsten Auflösung ausgewählt. Die Eingabe kann jedes von ExoPlayer unterstützte Containerformat haben. Die Ausgabe ist jedoch immer eine MP4-Datei.

Sie können mehrere Exportvorgänge nacheinander für dieselbe Transformer-Instanz ausführen. Gleichzeitige Exporte mit derselben Instanz werden jedoch nicht unterstützt.

Hinweis zu Threads

Auf Transformatorinstanzen muss über einen einzigen Anwendungsthread zugegriffen werden und die Listenermethoden werden im selben Thread aufgerufen. In den meisten Fällen kann der Anwendungs-Thread einfach der Hauptthread der Anwendung sein. Intern arbeitet Transformer im Hintergrund und sendet seine Aufrufe an Listenermethoden im Anwendungsthread.

Auf Ereignisse warten

Die Methode start ist asynchron. Sie kehrt sofort zurück und die App wird über den Listener, der an den Transformer-Builder übergeben wird, über Ereignisse informiert.

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 enthält Informationen zur Ausgabedatei, einschließlich der Dateigröße und der durchschnittlichen Bitrate für Audio und Video.

Informationen zum Fortschritt erhalten

Rufe Transformer.getProgress auf, um den aktuellen Fortschritt einer Transformation abzufragen. Der zurückgegebene Wert gibt den Fortschrittsstatus an. Wenn der Fortschrittsstatus PROGRESS_STATE_AVAILABLE ist, wird der angegebene ProgressHolder mit dem aktuellen Fortschrittsprozentsatz aktualisiert. Das folgende Beispiel zeigt, wie der Fortschritt einer Transformation regelmäßig abgefragt wird. Dabei kann die Methode updateProgressInUi implementiert werden, um einen Fortschrittsbalken zu aktualisieren.

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

Transformation abbrechen

Wenn der Nutzer den Exportvorgang abbrechen möchte, brechen Sie den Exportvorgang mit Transformer.cancel ab. Ressourcen wie Hardware-Videocodecs sind insbesondere auf Geräten der unteren Preisklasse begrenzt. Daher ist es wichtig, Ressourcen freizugeben, wenn die Ausgabe nicht benötigt wird.