Dodano obsługę animacji przewidywanego przejścia wstecz

Podczas korzystania z interfejsów API systemu możesz wyrazić zgodę na wyświetlanie animacji w aplikacji i obsługę przejść niestandardowych.

Po włączeniu tej opcji aplikacja będzie wyświetlać animacje w przypadku powrotu do ekranu głównego, przełączania aktywności i przełączania zadań.

Możesz też zaktualizować zależność komponentu Material Design do wersji 1.10.0 MDC na Androida, aby uzyskać animacje komponentów Material Design, takie jak:

• Bottom sheets
• Arkusze boczne
• Wyszukiwarka

Więcej informacji znajdziesz w wskazówkach dla programistów komponentów treści na GitHubie.

Film pokazuje krótki przykład przewidujących animacji powrotu w ramach aktywności i powrotu do ekranu głównego za pomocą aplikacji Ustawienia na Androidzie.

1. W animacji użytkownik przesuwa palcem, aby wrócić do poprzedniego ekranu ustawień – przykład animacji obejmującej różne czynności.
2. Na poprzednim ekranie użytkownik zaczyna przesuwać palcem w drugą stronę, co powoduje wyświetlenie podglądu ekranu głównego z tapetą – przykład animacji powrotu do ekranu głównego.
3. Użytkownik przesuwa palcem w prawo, co powoduje animację okna, które zmniejsza się do ikony na ekranie głównym.
4. Użytkownik wrócił na ekran główny.

Dowiedz się więcej o dodawaniu obsługi przewidujących gestów wstecz.

Dodawanie niestandardowych przejść i animacji w aplikacji

Możesz tworzyć niestandardowe animacje i przejścia w usłudze w aplikacji, niestandardowe animacje między aktywnościami oraz niestandardowe animacje między fragmentami za pomocą przewidujących gestów wstecz.

Dodawanie niestandardowych przejść za pomocą interfejsu Progress API

W wersji Activity 1.8.0-alpha01 lub nowszej z AndroidX możesz używać interfejsów API Progresywny przewidujący powrót, aby tworzyć niestandardowe animacje dla przewidującego powrotu gestów w aplikacji. Interfejsy API Progresywny ułatwiają animowanie widoków, ale mają ograniczenia w animowaniu przejść między fragmentami. W ramach OnBackPressedCallbackwprowadziliśmy metody handleOnBackProgressed, handleOnBackCancelled i handleOnBackStarted, aby animować obiekty podczas przesuwania palcem w tył. Użyj tych metod, jeśli chcesz dostosować coś więcej niż domyślne animacje udostępniane przez system lub animacje komponentów Material.

Spodziewamy się, że większość aplikacji będzie używać zgodnych wstecznie interfejsów API AndroidX, ale w interfejsie OnBackAnimationCallback dostępne są też podobne interfejsy API platformy, które można testować w wersji Androida 14 w wersji na potrzeby testów dla deweloperów 1 lub nowszej.

Korzystanie z interfejsów Progress API w ramach AndroidX Transitions

Interfejsy Progress API można używać z AndroidX Transitions w wersji 1.5.0-alpha01 lub nowszej na Androidzie 14 i nowszych, aby tworzyć przejścia z funkcją przewidywania cofnięcia.

1. Zamiast beginDelayedTransition użyj TransitionManager#controlDelayedTransition, aby odtwarzać przejścia, gdy użytkownik przesunie palcem w lewo.
2. Utwórz przejście w handleOnBackStarted.
3. Odtwórz przejście za pomocą zdarzenia wstecz w komponentach handleOnBackProgressed, odnosząc currentFraction do BackEvent.progress, co pokazuje, jak daleko użytkownik przesunął palcem w dół.
4. Zakończ przejście, gdy użytkownik wykonał gest wstecz w handleOnBackPressed.
5. Na koniec zresetuj stan przejścia w handleOnBackCancelled.

Na tym filmie, w kodzie Kotlina i pliku XML demonstrujemy przejście między 2 polem zaimplementowane za pomocą OnBackPressedCallback:

    class MyFragment : Fragment() {

    val transitionSet = TransitionSet().apply {
        addTransition(Fade(Fade.MODE_OUT))
        addTransition(ChangeBounds())
        addTransition(Fade(Fade.MODE_IN))
    }
    ...
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        val callback = object : OnBackPressedCallback(enabled = false) {

            var controller: TransitionSeekController? = null

            @RequiresApi(34)
            override fun handleOnBackStarted(backEvent: BackEvent) {
                // Create the transition
                controller = TransitionManager.controlDelayedTransition(
                    binding.card,
                    transitionSet
                )
                changeTextVisibility(ShowText.SHORT)
            }

            @RequiresApi(34)
            override fun handleOnBackProgressed(backEvent: BackEvent) {
                // Play the transition as the user swipes back
                if (controller?.isReady == true) {
                    controller?.currentFraction = backEvent.progress
                }
            }

            override fun handleOnBackPressed() {
                // Finish playing the transition when the user commits back
                controller?.animateToEnd()
                this.isEnabled = false
            }

            @RequiresApi(34)
            override fun handleOnBackCancelled() {
                // If the user cancels the back gesture, reset the state
                transition(ShowText.LONG)
            }
        }

        binding.shortText.setOnClickListener {
            transition(ShowText.LONG)
            callback.isEnabled = true
        }

        this.requireActivity().onBackPressedDispatcher.addCallback(callback)
    }

    private fun transition(showText: ShowText) {
        TransitionManager.beginDelayedTransition(
            binding.card,
            transitionSet
        )
        changeTextVisibility(showText)
    }

    enum class ShowText { SHORT, LONG }
    private fun changeTextVisibility(showText: ShowText) {
        when (showText) {
            ShowText.SHORT -> {
                binding.shortText.isVisible = true
                binding.longText.isVisible = false
            }
            ShowText.LONG -> {
                binding.shortText.isVisible = false
                binding.longText.isVisible = true
            }
        }
    }
}
  

<?xml version="1.0" encoding="utf-8"?>
...
    <androidx.constraintlayout.widget.ConstraintLayout
        android:id="@+id/card"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        ...>

        <TextView
            android:id="@+id/short_text"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            ... />

        <TextView
            android:id="@+id/long_text"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:visibility="gone"
            .../>

    </androidx.constraintlayout.widget.ConstraintLayout>

Podczas korzystania z przejść prognozowanego powrotu pamiętaj o tych kwestiach:

• Użyj isSeekingSupported, aby sprawdzić, czy przejście obsługuje funkcję przewidywania wstecz.
• Użyj override isSeekingSupported, aby zwrócić wartość true dla niestandardowych przejść.
• Utwórz 1 kontroler na animację.
• Przejścia wstecz na podstawie przewidywania są obsługiwane w przypadku przejść AndroidX, ale nie w przypadku przejść w ramach frameworka. Zrezygnuj z przejść frameworka i zamiast nich używaj przejść Animator i AndroidX.
• Przejścia z przewidywaniem wstecz są obsługiwane na urządzeniach z Androidem 14 lub nowszym i nie są zgodne z wstecz.
• Obsługiwane są też przejścia utworzone za pomocą scen XML. W funkcji handleOnBackStarted ustaw argument TransitionSeekController na wartość zwracaną przez funkcję TransitionManager.createSeekController, a nie przez funkcję controlDelayedTransition.

Dodawanie przejść między aktywnościami niestandardowymi w Androidzie 14 i nowszych

Aby mieć pewność, że niestandardowe przejścia między aktywnościami będą obsługiwać funkcję przewidywanego powrotu na Androidzie 14 i nowszych wersjach, zamiast overridePendingTransition możesz użyć overrideActivityTransition. Oznacza to, że animacja przejścia jest odtwarzana, gdy użytkownik przesuwa palcem w lewo.

Aby pokazać, jak to działa, wyobraź sobie sytuację, w której aktywność B znajduje się nad aktywnością A w steku. W przypadku animacji aktywności niestandardowych należy postępować w ten sposób:

• Wywołuj otwieranie lub zamykanie przejść w metodzie onCreate w ramach aktywności B.
• Gdy użytkownik przechodzi do aktywności B, użyj OVERRIDE_TRANSITION_OPEN. Gdy użytkownik przesunie palcem, aby wrócić do czynności A, użyj elementu OVERRIDE_TRANSITION_CLOSE.

• W przypadku parametru OVERRIDE_TRANSITION_CLOSE wartość enterAnim to animacja wejścia aktywności A, a wartość exitAnim to animacja wyjścia z aktywności B.

Dodanie obsługi przewidywanego przejścia wstecz z użyciem fragmentów

Wdrożenie przewidywanego przywracania za pomocą fragmentów może odbywać się na 2 sposoby.

Korzystanie z dotychczasowych interfejsów API

Zalecamy używanie istniejących interfejsów API. Te interfejsy API umożliwiają przesuwanie palcem po krawędzi ekranu, aby za pomocą gestów manipulować przejściami w Animatorze lub Androidx. To, czy gest zostanie wykonany i czy wrócisz do poprzedniego fragmentu, czy zostanie anulowany i pozostaniesz na bieżącym fragmencie, zależy od tego, czy gest zostanie wykonany i czy wrócisz do poprzedniego fragmentu, czy zostanie anulowany i pozostaniesz na bieżącym fragmencie. Więcej informacji znajdziesz w artykule Przechodzenie między fragmentami za pomocą animacji.

Pamiętaj o tych kwestiach:

• Zaimportuj Transitions 1.5.0 lub nowszą oraz Fragments 1.7.0 lub nowszą. Większość obsługi przewidywanego cofnięcia w Fragments opiera się na możliwości Transitions do przewijania animacji, co jest możliwe tylko w Transitions w wersji 1.5.0 lub nowszej.
• Do obsługi sterowania przyciskiem Wstecz używaj fragmentów (z użyciem komponentu FragmentManager lub komponentu nawigacji). Funkcja przewidującego cofnięcia nie jest obsługiwana, jeśli zarządzasz własnym stosem cofnięcia. Przejdź do warstwy podrzędnej, która nie jest znana FragmentManager.
• Niektóre biblioteki obsługują funkcję przewidywanego cofnięcia. Aby się upewnić, sprawdź dokumentację.
• Obsługiwane są biblioteki Animator i AndroidX Transition.
• Klasa Animation i biblioteka Transition nie są obsługiwane.
• Animacje predykcyjne działają tylko na urządzeniach z Androidem w wersji 14 lub nowszej.

Używaj fragmentów prognozowanych w tych sytuacjach:

• Animuj komponent nawigacji.
• Twórz animacje za pomocą aplikacji setCustomAnimations.
• Animuj przejścia wejścia i wyjścia za pomocą setEnterTransition, setExitTransition, setReenterTransition i setReturnTransition.
• Animowanie przejść wspólnych elementów za pomocą elementów setSharedElementEnterTransition i setSharedElementReturnTransition.

Niektóre materialne animacje obsługują funkcję przewidywania wstecz od wersji 1.12.02-alpha02 lub nowszej, w tym MaterialFadeThrough, MaterialSharedAxis i MaterialFade. Uwaga: aplikacja MaterialContainerTransform nie obsługuje funkcji prognozowania opinii.

Używanie wywołań zwrotnych

Za pomocą wywołań zwrotnych możesz tworzyć przejścia między fragmentami, ale jest też znane ograniczenie dotyczące używania wywołań zwrotnych, które polega na tym, że użytkownicy nie mogą zobaczyć poprzedniego fragmentu po przesunięciu palcem w drugą stronę. Aby utworzyć przejście elementu współdzielonego między fragmentami, które odpowiada prognozowanemu przekierowaniu, wykonaj te czynności:

Utwórz OnBackPressedCallback. W ramach handleOnBackProgressed zmienić rozmiar fragmentu i przesunąć go. Następnie wyjmij z grupy elementów. Następnie uruchom przejście elementu współdzielonego za pomocą funkcji setSharedElementReturnTransition poza wywołaniem zwrotnym.

Więcej informacji znajdziesz w przykładowym kodzie na GitHubie.

Wymagania

Z tabeli poniżej dowiesz się, co jest kontrolowane przez targetSdkVersion i compileSdkVersion, wersję urządzenia, zależności, flagi manifestu i flagi fragmentu. Ta tabela odnosi się do wymagań dotyczących kodu.

Dodatkowe materiały

• Przykłady kodu do przewidywania odpowiedzi
• Podstawy dotyczące filmów z tyłu pojazdu
• Tworzenie przyszłości filmów na Androidzie