Tworzenie

Jetpack Compose to nowoczesny deklaratywny zestaw narzędzi interfejsu dla Androida. Compose ułatwia pisanie i utrzymywanie interfejsu aplikacji, udostępniając deklaratywny interfejs API, który umożliwia renderowanie interfejsu aplikacji bez imperatywnego modyfikowania widoków front-endu. Terminologia wymaga wyjaśnienia, ale jej konsekwencje są ważne dla projektu aplikacji.

Paradygmat programowania deklaratywnego

Hierarchia widoków w Androidzie była dotychczas reprezentowana jako drzewo widgetów interfejsu. Stan aplikacji zmienia się na przykład z powodu interakcji z użytkownikiem, dlatego hierarchia interfejsu musi być aktualizowana, aby wyświetlać aktualne dane. Najczęstszym sposobem aktualizowania interfejsu jest przejście po drzewie za pomocą funkcji takich jak findViewById() oraz zmiana węzłów przez wywołanie metod takich jak button.setText(String), container.addChild(View) lub img.setImageBitmap(Bitmap). Te metody zmieniają stan wewnętrzny widżetu.

Ręczne manipulowanie widokami zwiększa prawdopodobieństwo wystąpienia błędów. Jeśli dane są renderowane w kilku miejscach, łatwo zapomnieć o zaktualizowaniu jednego z widoków, w którym się one wyświetlają. Łatwo też tworzyć nieprawidłowe stany, gdy 2 aktualizacje kolidują ze sobą w nieoczekiwany sposób. Na przykład aktualizacja może próbować ustawić wartość węzła, który został właśnie usunięty z interfejsu użytkownika. Ogólnie złożoność konserwacji oprogramowania wzrasta wraz z liczbą widoków wymagających aktualizacji.

W ciągu ostatnich kilku lat cała branża zaczęła przechodzić na deklaratywny model interfejsu użytkownika, który znacznie upraszcza proces tworzenia i aktualizowania interfejsów. Polega ona na odtwarzaniu całej zawartości ekranu od podstaw, a następnie wprowadzaniu tylko niezbędnych zmian. Dzięki temu unikniesz złożoności ręcznego aktualizowania hierarchii widoku stanu. Compose to deklaratywny framework interfejsu użytkownika.

Jednym z wyzwań związanych z regenerowaniem całego ekranu jest to, że może to być kosztowne pod względem czasu, mocy obliczeniowej i zużycia baterii. Aby ograniczyć ten koszt, Compose inteligentnie wybiera, które części interfejsu użytkownika należy w danym momencie narysować ponownie. Ma to pewne konsekwencje dla sposobu projektowania komponentów interfejsu użytkownika, o których mowa w artykule Recomposition.

Prosta funkcja typu „composable”

Za pomocą Compose możesz tworzyć interfejs użytkownika, definiując zestaw funkcji kompozytowych, które pobierają dane i wydają elementy UI. Prostym przykładem jest widżet Greeting, który przyjmuje String i wydaje widżet Text, wyświetlający wiadomość powitalną.

Zrzut ekranu telefonu z tekstem „Hello World” i kodem prostej funkcji kompozytowej, która generuje interfejs użytkownika

Rysunek 1. Prosta funkcja kompozytowa, która otrzymuje dane i wykorzystuje je do renderowania widżetu tekstowego na ekranie.

Kilka istotnych informacji o tej funkcji:

  • Funkcja jest oznaczona adnotacją @Composable. Wszystkie funkcje kompozytowe muszą mieć tę adnotację. Informuje ona kompilator Compose, że dana funkcja ma za zadanie konwertować dane na potrzeby interfejsu użytkownika.

  • Funkcja pobiera dane. Funkcje kompozytowe mogą przyjmować parametry, które umożliwiają logice aplikacji opisywanie interfejsu użytkownika. W tym przypadku nasz widżet przyjmuje parametr String, aby witać użytkownika po imieniu.

  • Funkcja wyświetla tekst w interfejsie. Robi to przez wywołanie funkcji składanej Text(), która faktycznie tworzy element interfejsu tekstowego. Funkcje typu composable generują hierarchię UI, wywołując inne funkcje typu composable.

  • Funkcja nie zwraca nic. Funkcje kompozytowe, które emitują interfejs użytkownika, nie muszą zwracać niczego, ponieważ opisują pożądany stan ekranu zamiast tworzyć widżety interfejsu.

  • Ta funkcja jest szybka, idempotentna i nie powoduje skutków ubocznych.

    • Funkcja działa tak samo, gdy jest wywoływana wielokrotnie z tym samym argumentem, i nie używa innych wartości, takich jak zmienne globalne ani wywołania funkcji random().
    • Funkcja opisuje interfejs użytkownika bez żadnych efektów ubocznych, takich jak modyfikowanie właściwości lub zmiennych globalnych.

    Ogólnie wszystkie funkcje z możliwością składania powinny być napisane z użyciem tych właściwości ze względu na powody opisane w sekcji Rekompozycja.

Zmiana paradygmatu deklaratywnego

W przypadku wielu imperatywnych pakietów narzędzi UI zorientowanych obiektowo inicjalizacja interfejsu użytkownika polega na tworzeniu drzewa widżetów. Często odbywa się to przez napełnienie pliku XML. Każdy widget ma własny stan wewnętrzny i metody getter i setter, które umożliwiają logice aplikacji interakcję z widżetem.

W ramach podejścia deklaratywnego w Compose widżety są w większości bezstanowe i nie udostępniają funkcji setter ani getter. W rzeczywistości widżety nie są wyświetlane jako obiekty. Interfejs użytkownika aktualizujesz, wywołując tę samą funkcję składającą z różnymi argumentami. Dzięki temu możesz łatwo określać stany w ramach wzorów architektonicznych, takich jak ViewModel, jak opisano w przewodniku po architekturze aplikacji. Następnie Twoje komponenty są odpowiedzialne za przekształcanie bieżącego stanu aplikacji w interfejs za każdym razem, gdy dane obserwowalne zostaną zaktualizowane.

Ilustracja przepływu danych w interfejsie Compose, od obiektów najwyższego poziomu do ich podrzędnych elementów.

Rysunek 2. Logika aplikacji dostarcza danych do funkcji składanej najwyższego poziomu. Ta funkcja używa danych do opisu interfejsu, wywołując inne komponenty, i przekazuje odpowiednie dane do tych komponentów oraz dalej w hierarchii.

Gdy użytkownik wchodzi w interakcję z interfejsem, ten wywołuje zdarzenia takie jak onClick. Zdarzenia te powinny informować logikę aplikacji, która może następnie zmienić stan aplikacji. Gdy stan się zmieni, funkcje kompozytowe zostaną ponownie wywołane z nowymi danymi. Powoduje to ponowne rysowanie elementów interfejsu. Ten proces nazywa się rekompozycją.

Ilustracja przedstawiająca, jak elementy interfejsu reagują na interakcje, wywołując zdarzenia, które są obsługiwane przez logikę aplikacji.

Rysunek 3. Użytkownik wszedł w interakcję z elementem interfejsu, co spowodowało wywołanie zdarzenia. Logika aplikacji reaguje na zdarzenie, a funkcje składane są automatycznie wywoływane ponownie (w razie potrzeby z nowymi parametrami).

Zawartość dynamiczna

Funkcje składane są pisane w Kotlinie, a nie w XML, więc mogą być tak dynamiczne jak każdy inny kod Kotlin. Załóżmy na przykład, że chcesz utworzyć interfejs użytkownika, który wyświetla listę użytkowników:

@Composable
fun Greeting(names: List<String>) {
    for (name in names) {
        Text("Hello $name")
    }
}
ThinkingInComposeSnippets.kt

Ta funkcja przyjmuje listę nazwisk i generuje pozdrowienie dla każdego użytkownika. Funkcje typu „composable” mogą być dość zaawansowane. Za pomocą instrukcji if możesz określić, czy chcesz wyświetlić dany element interfejsu. Możesz używać pętli. Możesz wywoływać funkcje pomocnicze. Masz pełną elastyczność w przypadku języka źródłowego. Ta wydajność i elastyczność to jedna z głównych zalet Jetpack Compose.

Rekompozycja

W imperatywnym modelu UI, aby zmienić widżet, wywołujesz metodę settera, która zmienia jego stan wewnętrzny. W komponowaniu ponownie wywołujesz funkcję składającą z nowymi danymi. W efekcie funkcja zostanie zrekonstruowana – w razie potrzeby widżety emitowane przez funkcję zostaną ponownie narysowane z nowymi danymi. Framework Compose może inteligentnie przekomponować tylko te komponenty, które uległy zmianie.

Weź pod uwagę tę funkcję składającą, która wyświetla przycisk:

@Composable
fun ClickCounter(clicks: Int, onClick: () -> Unit) {
    Button(onClick = onClick) {
        Text("I've been clicked $clicks times")
    }
}
ThinkingInComposeSnippets.kt

Za każdym kliknięciem przycisku wywołujący aktualizuje wartość clicks. Funkcja compose wywołuje funkcję lambda z funkcja Text, aby wyświetlić nową wartość. Ten proces nazywa się rekompozycją. Inne funkcje, które nie zależą od wartości, nie są przekształcane.

Jak już wspomnieliśmy, ponowne tworzenie całego drzewa interfejsu może być kosztowne pod względem obliczeniowym, co zużywa moc obliczeniową i czas pracy baterii. Compose rozwiązuje ten problem za pomocą inteligentnego przekomponowania.

Rekompozycja to proces ponownego wywoływania funkcji składanych po zmianie danych wejściowych. Dzieje się tak, gdy zmieniają się dane wejściowe funkcji. Gdy funkcja Compose ponownie tworzy wyrażenie na podstawie nowych danych wejściowych, wywołuje tylko te funkcje i funkcje lambda, które mogły ulec zmianie, a pozostałe pomija. Pomijanie wszystkich funkcji i lambda, które nie mają zmienionych parametrów, pozwala Compose efektywnie przeredagować kod.

Nigdy nie polegaj na efektach ubocznych wykonywania funkcji składanych, ponieważ może to spowodować pominięcie ich ponownego składania. Jeśli tak zrobisz, użytkownicy mogą zauważyć dziwne i nieprzewidywalne działanie aplikacji. Skutkiem ubocznym jest każda zmiana widoczna dla reszty aplikacji. Na przykład te działania są niebezpiecznymi skutkami ubocznymi:

  • Zapisywanie wartości właściwości obiektu udostępnionego
  • Aktualizuję observable w ViewModel
  • Aktualizowanie udostępnionych ustawień

Funkcje składane mogą być ponownie wykonywane tak często, jak każda klatka, np. podczas renderowania animacji. Funkcje składane powinny być szybkie, aby uniknąć zacięcia podczas animacji. Jeśli chcesz wykonać kosztowne operacje, np. odczytać dane z wspólnych preferencji, zrób to w tle w ramach coroutine i przekaż wynik jako parametr do funkcji kompozytowej.

Ten kod tworzy kompozyt do aktualizowania wartości w komponencie SharedPreferences. Składnik nie może odczytywać ani zapisywać danych z wspólnych preferencji. Zamiast tego kod przenosi operacje odczytu i zapisu do ViewModel w tle. Logika aplikacji przekazuje bieżącą wartość za pomocą funkcji wywołania zwrotnego, aby wywołać aktualizację.

@Composable
fun SharedPrefsToggle(
    text: String,
    value: Boolean,
    onValueChanged: (Boolean) -> Unit
) {
    Row {
        Text(text)
        Checkbox(checked = value, onCheckedChange = onValueChanged)
    }
}
ThinkingInComposeSnippets.kt

W tym dokumencie omawiamy kilka kwestii, o których należy pamiętać podczas korzystania z Compose:

  • Rekompozycja pomija jak najwięcej funkcji i funkcji lambda.
  • Rekompozycja jest optymistyczna i może zostać anulowana.
  • Funkcja składana może być wykonywana dość często, nawet w każdej klatce animacji.
  • Funkcje typu „composable” mogą być wykonywane równolegle.
  • Funkcje składane mogą być wykonywane w dowolnej kolejności.

W kolejnych sekcjach dowiesz się, jak tworzyć funkcje złożone, które umożliwiają rekompozycję. W każdym przypadku sprawdzoną metodą jest utrzymywanie funkcji składanych w taki sposób, aby były szybkie, idempotentne i bez efektów ubocznych.

Rekompozycja pomija jak najwięcej

Jeśli niektóre części interfejsu są nieprawidłowe, Compose stara się zrekompilować tylko te części, które wymagają aktualizacji. Oznacza to, że może ono pominąć ponowne wykonanie komponentu przycisku bez wykonywania innych komponentów znajdujących się powyżej lub poniżej niego w drzewie interfejsu użytkownika.

Każda funkcja składana i funkcja lambda może się sama przekształcić. Oto przykład, który pokazuje, jak rekompozycja może pominąć niektóre elementy podczas renderowania listy:

/**
 * Display a list of names the user can click with a header
 */
@Composable
fun NamePicker(
    header: String,
    names: List<String>,
    onNameClicked: (String) -> Unit
) {
    Column {
        // this will recompose when [header] changes, but not when [names] changes
        Text(header, style = MaterialTheme.typography.bodyLarge)
        HorizontalDivider()

        // LazyColumn is the Compose version of a RecyclerView.
        // The lambda passed to items() is similar to a RecyclerView.ViewHolder.
        LazyColumn {
            items(names) { name ->
                // When an item's [name] updates, the adapter for that item
                // will recompose. This will not recompose when [header] changes
                NamePickerItem(name, onNameClicked)
            }
        }
    }
}

/**
 * Display a single name the user can click.
 */
@Composable
private fun NamePickerItem(name: String, onClicked: (String) -> Unit) {
    Text(name, Modifier.clickable(onClick = { onClicked(name) }))
}
ThinkingInComposeSnippets.kt

Każdy z tych zakresów może być jedynym zakresem wykonywanym podczas rekompozycji. Gdy header ulegnie zmianie, kompozytor może przejść do funkcji lambda Column bez wykonywania żadnej z jej funkcji nadrzędnych. Podczas wykonywania Column usługa Compose może pominąć elementy LazyColumn, jeśli names się nie zmienił.

Ponownie, wykonywanie wszystkich funkcji składanych lub funkcji lambda nie powinno powodować efektów ubocznych. Jeśli chcesz wykonać efekt uboczny, wywołaj go z powrotem.

Rekompozycja jest optymistyczna

Rekompozycja rozpoczyna się, gdy Compose uzna, że parametry komponentu mogły się zmienić. Rekompozycja jest optymistyczna, co oznacza, że usługa Compose spodziewa się, że rekompozycja zostanie ukończona, zanim parametry się zmienią. Jeśli parametr zmieni się przed zakończeniem rekompozycji, usługa Compose może anulować rekompozycję i ponownie ją rozpocząć z nowym parametrem.

Gdy anulujesz rekompozycję, Compose odrzuci drzewo interfejsu użytkownika z rekompozycji. Jeśli masz jakieś efekty uboczne, które zależą od wyświetlanego interfejsu, efekt uboczny zostanie zastosowany, nawet jeśli kompozycja zostanie anulowana. Może to spowodować niespójny stan aplikacji.

Aby obsłużyć optymistyczną rekompozycję, upewnij się, że wszystkie funkcje i funkcje lambda są idempotentne i nie mają efektów ubocznych.

Funkcje składane mogą być wykonywane dość często.

W niektórych przypadkach funkcja składana może być wykonywana w przypadku każdego klatka animacji interfejsu użytkownika. Jeśli funkcja wykonuje kosztowne operacje, takie jak odczyt z pamięci urządzenia, może powodować zakłócenia interfejsu.

Jeśli na przykład widget próbuje odczytać ustawienia urządzenia, może odczytać te ustawienia setki razy na sekundę, co może mieć katastrofalne skutki dla wydajności aplikacji.

Jeśli funkcja składana potrzebuje danych, powinna zdefiniować parametry tych danych. Następnie możesz przenieść wymagające dużych zasobów obliczeniowych operacje do innego wątku, poza kompozycją, i przekazać dane do Compose za pomocą mutableStateOf lub LiveData.

Funkcje składane można wykonywać równolegle

Compose może optymalizować rekompozycję, wykonując funkcje kompozytowe równolegle. Dzięki temu Compose mógłby korzystać z wielu rdzeni i uruchamiać funkcje kompozytowe nieaktywne na ekranie z mniejszym priorytetem.

Ta optymalizacja oznacza, że funkcja składana może być wykonywana w grupie wątków w tle. Jeśli funkcja składana wywołuje funkcję w komponencie ViewModel, może wywołać tę funkcję z kilku wątków jednocześnie.

Aby zapewnić prawidłowe działanie aplikacji, wszystkie funkcje składane nie powinny mieć żadnych efektów ubocznych. Zamiast tego wywołuj skutki uboczne z powrotem do wywołania funkcji, takie jak onClick, które zawsze są wykonywane w wątku interfejsu użytkownika.

Gdy wywoływana jest funkcja składana, może ona zostać wywołana w innym wątku niż wywołujący. Oznacza to, że należy unikać kodu, który modyfikuje zmienne w kompozytowalnej funkcji lambda, ponieważ taki kod nie jest bezpieczny w zakresie wątków i ponieważ jest niedopuszczalnym efektem ubocznym w przypadku kompozytowalnej funkcji lambda.

Oto przykład komponentu wyświetlającego listę i liczbę elementów:

@Composable
fun ListComposable(myList: List<String>) {
    Row(horizontalArrangement = Arrangement.SpaceBetween) {
        Column {
            for (item in myList) {
                Text("Item: $item")
            }
        }
        Text("Count: ${myList.size}")
    }
}
ThinkingInComposeSnippets.kt

Ten kod nie powoduje żadnych efektów ubocznych i przekształca listę danych wejściowych w interfejs. To świetny kod do wyświetlania małej listy. Jeśli jednak funkcja zapisuje dane do zmiennej lokalnej, kod nie będzie bezpieczny w wielu wątkach ani poprawny:

@Composable
fun ListWithBug(myList: List<String>) {
    var items = 0

    Row(horizontalArrangement = Arrangement.SpaceBetween) {
        Column {
            for (item in myList) {
                Card {
                    Text("Item: $item")
                    items++ // Avoid! Side-effect of the column recomposing.
                }
            }
        }
        Text("Count: $items")
    }
}
ThinkingInComposeSnippets.kt

W tym przykładzie wartość items jest modyfikowana przy każdej rekompozycji. Może to być każdy kadr animacji lub moment aktualizacji listy. W obu przypadkach interfejs użytkownika wyświetli nieprawidłową liczbę. Z tego powodu takie zapisy nie są obsługiwane w Compose. Zabraniając tych zapisów, pozwalamy platformie na zmianę wątków w celu wykonania kompozytowanych funkcji lambda.

Funkcje typu „composable” mogą być wykonywane w dowolnej kolejności

Gdy spojrzysz na kod funkcji składanej, możesz założyć, że kod jest wykonywany w kolejności, w jakiej się pojawia. Nie ma jednak gwarancji, że tak się stanie. Jeśli funkcja składana zawiera wywołania innych funkcji składanych, mogą one być wykonywane w dowolnej kolejności. Compose może rozpoznać, że niektóre elementy interfejsu mają wyższy priorytet niż inne, i najpierw je narysować.

Załóżmy na przykład, że masz kod, który rysuje 3 ekrany w układzie z kartami:

@Composable
fun ButtonRow() {
    MyFancyNavigation {
        StartScreen()
        MiddleScreen()
        EndScreen()
    }
}
ThinkingInComposeSnippets.kt

Połączenia z numerami StartScreen, MiddleScreen i EndScreen mogą być nawiązywane w dowolnej kolejności. Oznacza to, że nie możesz np. ustawić za pomocą funkcji StartScreen() żadnej zmiennej globalnej (efekt uboczny), z której korzysta funkcja MiddleScreen(). Zamiast tego każda z tych funkcji musi być samodzielna.

Więcej informacji

Aby dowiedzieć się więcej o komponowaniu i funkcjach kompozytowanych, zapoznaj się z tymi dodatkowymi materiałami.

Filmy