Guida introduttiva

Per iniziare a utilizzare Transformer:

1. Aggiungi Media3 Transformer come dipendenza nel progetto.
2. Crea una EditedMediaItem che rappresenti i contenuti multimediali da elaborare e le modifiche vi si applicano.
3. Crea un'Transformer, che descrive l'output richiesto e un listener per gli eventi di completamento e di errore.
4. Avvia l'operazione di esportazione, passando il EditedMediaItem per la modifica e un del percorso di output. Durante l'esportazione, puoi eseguire query sullo stato di avanzamento corrente o annullare l'operazione.
5. Al termine dell'esportazione, gestisci l'output in base alle tue esigenze. Ad esempio, puoi condividere l'output con un'altra app o caricarlo su un server.

Continua a leggere per ulteriori dettagli su questi passaggi e consulta TransformerActivity nel demo di transformer app per un un esempio completo.

Aggiungi Media3 Transformer come dipendenza

Il modo più semplice per iniziare a utilizzare Transformer è aggiungere dipendenze Gradle nella raccolta nel file build.gradle del modulo dell'app:

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"

dove 1.4.1 è la tua versione preferita. L'ultima versione può essere trovate consultando il rilascio note.

Puoi trovare ulteriori informazioni sui moduli della libreria disponibili nella pagina Media3 di Google Maven AndroidX.

Attivare il supporto di Java 8

Se non è già attivato, devi attivare il supporto di Java 8 in tutti i build.gradle file che dipendono da Transformer aggiungendo quanto segue alla sezione android :

compileOptions {
  targetCompatibility JavaVersion.VERSION_1_8
}

Avvia una trasformazione

Di seguito è riportato un esempio di creazione di un evento EditedMediaItem per rimuovere l'audio da un input del file, creando e configurando un'istanza Transformer da esportare Video H.265/HEVC con output del risultato su 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);

Per ulteriori informazioni sugli elementi multimediali, consulta la sezione Elementi multimediali ExoPlayer . L'input può essere progressivo o adattivo ma l'output è sempre un flusso progressivo. Per gli input adattivi, vengono sempre selezionate tracce con la risoluzione più alta per la trasformazione. L'input può essere di qualsiasi formato container supportato da ExoPlayer, ma l'output è sempre un file MP4.

Puoi eseguire più operazioni di esportazione in sequenza sulla stessa Transformer, ma le esportazioni simultanee con la stessa istanza non lo sono supportati.

Una nota sulla threading

È necessario accedere alle istanze del trasformatore da un singolo thread dell'applicazione e i metodi listener vengono chiamati sullo stesso thread. Nella maggior parte dei casi, il thread dell'applicazione può essere solo il thread principale dell'applicazione. Internamente, Transformer svolge il proprio lavoro in background e pubblica le chiamate ai metodi listener sul thread dell'applicazione.

Ascolta gli eventi

Il metodo start è asincrono. Viene visualizzata immediatamente e l'app una notifica relativa agli eventi passati tramite il listener al generatore di 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 include informazioni sul file di output, incluso il file e la velocità in bit media per audio e video, se applicabile.

Ricevi aggiornamenti sui progressi

Chiama Transformer.getProgress per eseguire una query sull'avanzamento corrente di una trasformazione. Il valore restituito indica lo stato di avanzamento. Se lo stato di avanzamento è PROGRESS_STATE_AVAILABLE, il valore ProgressHolder fornito viene aggiornato con la percentuale di avanzamento corrente. L'esempio seguente mostra come interrogano periodicamente l'avanzamento di una trasformazione, Il metodo updateProgressInUi può essere implementato per aggiornare una barra di avanzamento.

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

Annulla una trasformazione

Se l'utente sceglie di uscire da un flusso di esportazione, annulla l'operazione di esportazione con Transformer.cancel. Le risorse come i codec video hardware sono limitate, soprattutto sui dispositivi di fascia bassa, quindi è importante farlo per liberare risorse se l'output non è necessario.