Pierwsze kroki

Aby zacząć korzystać z Transformer:

1. Dodaj Media3 Transformer jako zależność w projekcie.
2. Utwórz obiekt EditedMediaItem reprezentujący multimedia do przetworzenia i edycji i ich zastosowania.
3. Utwórz obiekt Transformer opisujący wymagane dane wyjściowe i detektor dla zdarzeń ukończenia i błędów.
4. Rozpocznij operację eksportu, podając EditedMediaItem w celu edycji oraz ścieżkę wyjściową. Podczas eksportowania możesz przesłać zapytanie o bieżący postęp lub anulować .
5. Po zakończeniu eksportowania obsługuj dane wyjściowe zgodnie z potrzebami. Możesz na przykład: udostępnić dane wyjściowe innej aplikacji lub przesłać je na serwer.

Czytaj dalej, aby uzyskać więcej informacji, i zobacz TransformerActivity w demonstracja transformera pełny przykład.

Dodaj Media3 Transformer jako zależność

Najłatwiejszym sposobem na rozpoczęcie korzystania z Transformera jest dodanie zależności Gradle w bibliotece w pliku build.gradle modułu aplikacji:

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

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

gdzie 1.4.0 jest preferowaną wersją. Najnowsza wersja może być można znaleźć w tym pliku notatki.

Więcej informacji o dostępnych modułach bibliotecznych znajdziesz na Google Maven AndroidX Media3 .

Włącz obsługę języka Java 8

Musisz włączyć obsługę języka Java 8 we wszystkich build.gradle, jeśli jeszcze nie jest włączona zależne od Transformer, przez dodanie tego kodu do android :

compileOptions {
  targetCompatibility JavaVersion.VERSION_1_8
}

Rozpocznij przekształcanie

Oto przykład tworzenia EditedMediaItem w celu usunięcia dźwięku z danych wejściowych a następnie utworzyć i skonfigurować instancję Transformer do wyeksportowania Wideo H.265/HEVC, przesyłam wynik do 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);

Aby dowiedzieć się więcej o elementach multimedialnych, zapoznaj się z sekcją ExoPlayer – elementy multimedialne . Dane wejściowe mogą być progresywne lub adaptacyjne ale dane wyjściowe to zawsze strumień progresywny. W przypadku adaptacyjnych danych wejściowych parametr Do przekształcenia zawsze wybierane są ścieżki o najwyższej rozdzielczości. Dane wejściowe może mieć dowolny format kontenera obsługiwany przez ExoPlayer, ale wyjściowym jest zawsze plik MP4.

Na tej samej karcie możesz wykonać kilka operacji eksportu Transformer, ale równocześnie eksporty z tą samą instancją nie są obsługiwane.

Uwaga na temat tworzenia wątków

Dostęp do instancji Transformatora trzeba uzyskiwać z poziomu pojedynczego wątku aplikacji, metody detektora są wywoływane w tym samym wątku. W większości przypadków może być tylko głównym wątkiem aplikacji. Wewnętrznie Transformer działa w tle i publikuje wywołania do detektora w wątku aplikacji.

Wykrywaj zdarzenia

Metoda start jest asynchroniczna. Aplikacja powraca natychmiast, a aplikacja powiadomienia o zdarzeniach przez detektor przekazany do kreatora 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 zawiera informacje o pliku wyjściowym, w tym o pliku rozmiaru i średniej szybkości transmisji bitów audio i wideo.

Otrzymuj powiadomienia o postępach

Wywołaj funkcję Transformer.getProgress, aby zapytać o bieżący postęp przekształcenia. Zwrócona wartość wskazuje stan postępu. Jeśli postęp stan to PROGRESS_STATE_AVAILABLE, podana wartość ProgressHolder to uzupełniono o bieżący procent postępu. Ten przykład pokazuje, jak okresowo wysyła zapytanie o postęp przekształcenia, gdzie Można wdrożyć metodę updateProgressInUi, aby zaktualizować pasek postępu.

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

Anulowanie przekształcania

Jeśli użytkownik zdecyduje się wycofać proces eksportu, anuluj operację eksportu. dzięki Transformer.cancel. Ilość zasobów, takich jak sprzętowe kodeki wideo, jest ograniczona, zwłaszcza na niższych urządzeniach, więc to ważne, by zyskać jeśli dane wyjściowe nie są potrzebne.