Pierwsze kroki

Aby rozpocząć korzystanie z Transformer, wykonaj te czynności:

1. Dodaj Media3 Transformer jako zależność w projekcie.
2. Utwórz EditedMediaItem reprezentujący multimedia do przetworzenia i edycje, które mają zostać zastosowane.
3. Utwórz funkcję Transformer, która będzie opisywać wymagane dane wyjściowe i odbiorcę zdarzeń zakończenia i błędu.
4. Rozpocznij operację eksportowania, przekazując EditedMediaItem do edycji i ścieżkę wyjściową. Podczas eksportowania możesz przesłać zapytanie o bieżący postęp lub anulować .
5. Po zakończeniu eksportowania możesz w razie potrzeby przetworzyć dane wyjściowe. Możesz na przykład: udostępnić dane wyjściowe innej aplikacji lub przesłać je na serwer.

Poniżej znajdziesz więcej informacji o tych krokach, a w aplikacji demo dotyczącej przekształcania możesz zobaczyć kompletny 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.1")
implementation("androidx.media3:media3-effect:1.4.1")
implementation("androidx.media3:media3-common:1.4.1")

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

gdzie 1.4.1 to preferowana wersja. Najnowszą wersję znajdziesz w informacjach o wersji.

Więcej informacji o dostępnych modułach biblioteki znajdziesz na stronie 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
}

Rozpoczynanie przekształcenia

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ć strumieniowane progresywnie lub adaptacyjnie, ale dane wyjściowe są zawsze strumieniowane progresywnie. 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 instancji Transformer możesz wykonywać sekwencyjnie wiele operacji eksportu, ale nie można eksportować jednocześnie z tej samej instancji.

Uwaga na temat tworzenia wątków

Do instancji transformacji można uzyskać dostęp z jednego wątku aplikacji, a metody listenera 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.

Słuchanie zdarzeń

Metoda start jest asynchroniczna. Zwracany jest natychmiast, a aplikacja jest powiadamiana o zdarzeniach za pomocą detektora przekazanego 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 jego rozmiar i średnią szybkość transmisji bitów dźwięku i obrazu.

Otrzymuj powiadomienia o postępach

Aby sprawdzić bieżący postęp transformacji, wywołaj funkcję Transformer.getProgress. Zwrócona wartość wskazuje stan postępu. Jeśli stan postępu to PROGRESS_STATE_AVAILABLE, podana wartość ProgressHolder jest aktualizowana o bieżący odsetek postępu. Ten przykład pokazuje, jak okresowo wysyłać zapytania o stan transformacji. W tym celu możesz zastosować metodę updateProgressInUi, która umożliwia aktualizowanie paska 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łcenia

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ć zasobów, gdy dane wyjściowe nie są potrzebne.