Erste Schritte

Die ersten Schritte mit Transformer umfassen die folgenden Schritte:

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

Weitere Informationen zu diesen Schritten finden Sie unten. Ein vollständiges Beispiel finden Sie in der Transformer-Demo-App unter TransformerActivity.

Media3 Transformer als Abhängigkeit hinzufügen

Am einfachsten beginnen Sie mit Transformer, indem Sie Gradle-Abhängigkeiten für die Bibliothek in der Datei build.gradle Ihres App-Moduls hinzufügen:

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

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

Dabei ist 1.7.1 Ihre bevorzugte 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 von Transformer abhängen. Fügen Sie dazu Folgendes in den android-Abschnitt ein:

compileOptions {
  targetCompatibility JavaVersion.VERSION_1_8
}

Transformation starten

Im folgenden Beispiel wird ein EditedMediaItem erstellt, um Audio für eine Eingabedatei zu entfernen. Anschließend wird eine Transformer-Instanz erstellt und konfiguriert, um H.265/HEVC-Video zu exportieren. Das Ergebnis wird in outputPath ausgegeben.

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 Media-Elementen finden Sie auf der Seite ExoPlayer-Media-Elemente. Die Eingabe kann ein progressiver oder ein adaptiver Stream sein, die Ausgabe ist jedoch immer ein progressiver Stream. Bei adaptiven Eingaben werden immer die Tracks mit der höchsten Auflösung für die Transformation ausgewählt. Die Eingabe kann in einem beliebigen von ExoPlayer unterstützten Containerformat erfolgen, die Ausgabe ist jedoch immer eine MP4-Datei.

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

Hinweis zu Threads

Auf Transformer-Instanzen muss über einen einzelnen Anwendungs-Thread zugegriffen werden und die Listener-Methoden werden im selben Thread aufgerufen. In den meisten Fällen kann der Anwendungs-Thread einfach der Hauptthread der Anwendung sein. Intern führt Transformer seine Aufgaben im Hintergrund aus und sendet seine Aufrufe an Listener-Methoden im Anwendungs-Thread.

Auf Ereignisse warten

Die Methode start ist asynchron. Die Funktion wird sofort zurückgegeben und die App wird über den Listener, der an den Transformer-Builder übergeben wurde, über Ereignisse benachrichtigt.

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 Bitraten für Audio und Video, sofern zutreffend.

Fortschritts-Updates erhalten

Rufen Sie 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. Die Methode updateProgressInUi kann implementiert werden, um eine Fortschrittsanzeige 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 einen Exportvorgang abbrechen möchte, brechen Sie den Exportvorgang mit Transformer.cancel ab. Ressourcen wie Hardware-Videocodecs sind begrenzt, insbesondere auf Low-End-Geräten. Daher ist es wichtig, diese Ressourcen freizugeben, wenn die Ausgabe nicht benötigt wird.