Avviare un'attività utilizzando un'animazione

Le transizioni delle attività nelle app Material Design forniscono collegamenti visivi tra stati diversi attraverso il movimento e le trasformazioni tra elementi comuni. Puoi specificare animazioni personalizzate per le transizioni di entrata e uscita e per transizioni di elementi condivisi tra le attività.

Figura 1. R la transizione con elementi condivisi.

  • Una transizione enter determina il modo in cui le visualizzazioni in un'attività entra in scena. Ad esempio, nella transizione di tipo explode, viene restituito il valore le viste entrano nella scena dall'esterno e volano verso l'interno fino al centro della schermo.
  • Una transizione di uscita determina il modo in cui le visualizzazioni vengono chiuse in un'attività la scena. Ad esempio, nella transizione di uscita explode, le visualizzazioni esci dalla scena lontano dal centro.
  • Una transizione di elementi condivisi determina in che modo le visualizzazioni vengono condivise tra due attività passano da una di queste attività all'altra. Ad esempio: Se due attività hanno la stessa immagine in posizioni e dimensioni diverse, La transizione di changeImageTransform elemento condiviso viene tradotta e scala l'immagine in modo uniforme tra queste attività.

Android supporta le seguenti transizioni di entrata e uscita:

  • explode: sposta le visualizzazioni verso l'interno o verso l'esterno dal centro della scena.
  • slide: sposta le visualizzazioni all'interno o all'esterno di uno dei bordi scena.
  • fade: aggiunge o rimuove una visualizzazione dalla scena modificando la relativa opacità.

Qualsiasi transizione che estende la classe Visibility è supportata come transizione di entrata o di uscita. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API per Transition .

Android supporta anche queste transizioni di elementi condivisi:

  • changeBounds: anima le modifiche nei limiti del layout del target visualizzazioni.
  • changeClipBounds: anima le modifiche nei limiti del clip del target visualizzazioni.
  • changeTransform: anima le modifiche in scala e nella rotazione di di visualizzazioni target.
  • changeImageTransform: anima le modifiche di dimensioni e scala di le immagini target.

Quando attivi le transizioni delle attività nella tua app, la dissolvenza incrociata predefinita la transizione si attiva tra le attività di entrata e uscita.

Figura 2. Una transizione di scena con un elemento condiviso.

Per un esempio di codice che si anima tra attività utilizzando elementi condivisi, consulta ActivitySceneTransactionBasic.

Controllare la versione del sistema

Le API di transizione delle attività sono disponibili su Android 5.0 (API 21) e versioni successive. Per preservare la compatibilità con le versioni precedenti di Android, controlla la il sistema version in fase di runtime richiama le API per una qualsiasi di queste caratteristiche:

Kotlin

// Check if we're running on Android 5.0 or higher
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    // Apply activity transition
} else {
    // Swap without transition
}

Java

// Check if we're running on Android 5.0 or higher
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    // Apply activity transition
} else {
    // Swap without transition
}

Specifica transizioni personalizzate

Innanzitutto, attiva le transizioni dei contenuti delle finestre con android:windowActivityTransitions quando definisci uno stile che eredita dal tema Materiale. Puoi anche specificare entrare, uscire e transizioni di elementi condivisi nella definizione dello stile:

<style name="BaseAppTheme" parent="android:Theme.Material">
  <!-- enable window content transitions -->
  <item name="android:windowActivityTransitions">true</item>

  <!-- specify enter and exit transitions -->
  <item name="android:windowEnterTransition">@transition/explode</item>
  <item name="android:windowExitTransition">@transition/explode</item>

  <!-- specify shared element transitions -->
  <item name="android:windowSharedElementEnterTransition">
    @transition/change_image_transform</item>
  <item name="android:windowSharedElementExitTransition">
    @transition/change_image_transform</item>
</style>

In questo esempio, la transizione change_image_transform è definita come segue:

<!-- res/transition/change_image_transform.xml -->
<!-- (see also Shared Transitions below) -->
<transitionSet xmlns:android="http://schemas.android.com/apk/res/android">
  <changeImageTransform/>
</transitionSet>

L'elemento changeImageTransform corrisponde al ChangeImageTransform corso. Per ulteriori informazioni, consulta l'API riferimento per Transition.

Per attivare le transizioni dei contenuti delle finestre nel codice, chiama il metodo Funzione Window.requestFeature():

Kotlin

// Inside your activity (if you did not enable transitions in your theme)
with(window) {
    requestFeature(Window.FEATURE_ACTIVITY_TRANSITIONS)

    // Set an exit transition
    exitTransition = Explode()
}

Java

// Inside your activity (if you did not enable transitions in your theme)
getWindow().requestFeature(Window.FEATURE_ACTIVITY_TRANSITIONS);

// Set an exit transition
getWindow().setExitTransition(new Explode());

Per specificare le transizioni nel codice, chiama queste funzioni con un Oggetto Transition:

Le setExitTransition() e Le funzioni setSharedElementExitTransition() definiscono l'uscita per l'attività di chiamata. Le setEnterTransition() e Le funzioni setSharedElementEnterTransition() definiscono l'immissione di transizione per l'attività chiamata.

Per ottenere il massimo effetto di una transizione, devi abilitare i contenuti delle finestre le transizioni nelle attività di chiamata e nelle attività chiamate. In caso contrario, la chiamata avvia la transizione di uscita, ma poi vedrai la finestra transizioni come scala o dissolvenza.

Per avviare una transizione di tipo Invio il prima possibile, utilizza la classe Window.setAllowEnterTransitionOverlap() all'attività chiamata. In questo modo puoi ottenere transizioni di entrata più significative.

Avviare un'attività utilizzando le transizioni

Se attivi le transizioni e imposti una transizione di uscita per un'attività, la transizione si attiva quando avvii un'altra attività, come descritto di seguito:

Kotlin

startActivity(intent,
              ActivityOptions.makeSceneTransitionAnimation(this).toBundle())

Java

startActivity(intent,
              ActivityOptions.makeSceneTransitionAnimation(this).toBundle());

Se imposti una transizione di entrata per la seconda attività, anche quella transizione si attiva all'inizio dell'attività. Per disattivare le transizioni all'avvio un'altra attività, fornisci un bundle di opzioni null.

Avviare un'attività con un elemento condiviso

Per creare un'animazione di transizione schermo tra due attività con un elemento condiviso, procedi nel seguente modo:

  1. Attiva le transizioni dei contenuti delle finestre nel tema.
  2. Specifica una transizione di elementi condivisi nel tuo stile.
  3. Definisci la transizione come una risorsa XML.
  4. Assegna un nome comune agli elementi condivisi in entrambi i layout con il Attributo android:transitionName.
  5. Usa la funzione ActivityOptions.makeSceneTransitionAnimation().

Kotlin

// Get the element that receives the click event
val imgContainerView = findViewById<View>(R.id.img_container)

// Get the common element for the transition in this activity
val androidRobotView = findViewById<View>(R.id.image_small)

// Define a click listener
imgContainerView.setOnClickListener( {
    val intent = Intent(this, Activity2::class.java)
    // Create the transition animation - the images in the layouts
    // of both activities are defined with android:transitionName="robot"
    val options = ActivityOptions
            .makeSceneTransitionAnimation(this, androidRobotView, "robot")
    // Start the new activity
    startActivity(intent, options.toBundle())
})

Java

// Get the element that receives the click event
final View imgContainerView = findViewById(R.id.img_container);

// Get the common element for the transition in this activity
final View androidRobotView = findViewById(R.id.image_small);

// Define a click listener
imgContainerView.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        Intent intent = new Intent(this, Activity2.class);
        // Create the transition animation - the images in the layouts
        // of both activities are defined with android:transitionName="robot"
        ActivityOptions options = ActivityOptions
            .makeSceneTransitionAnimation(this, androidRobotView, "robot");
        // Start the new activity
        startActivity(intent, options.toBundle());
    }
});

Per le viste dinamiche condivise generate nel codice, utilizza View.setTransitionName() per specificare un nome di elemento comune in entrambi attività.

Per invertire l'animazione della transizione della scena al termine della seconda attività, richiama il metodo Activity.finishAfterTransition() anziché Activity.finish().

Avviare un'attività con più elementi condivisi

Per creare un'animazione di transizione di una scena tra due attività che hanno più di un elemento condiviso, definisci gli elementi condivisi in entrambi i layout con android:transitionName o utilizza l'attributo View.setTransitionName() funzionano in entrambe le attività e crea un ActivityOptions come segue:

Kotlin

// Rename the Pair class from the Android framework to avoid a name clash
import android.util.Pair as UtilPair
...
val options = ActivityOptions.makeSceneTransitionAnimation(this,
        UtilPair.create(view1, "agreedName1"),
        UtilPair.create(view2, "agreedName2"))

Java

ActivityOptions options = ActivityOptions.makeSceneTransitionAnimation(this,
        Pair.create(view1, "agreedName1"),
        Pair.create(view2, "agreedName2"));