Tworzenie

Jetpack Compose to nowoczesny deklaratywny zestaw narzędzi interfejsu dla Androida. Narzędzie Compose ułatwia pisanie i obsługę interfejsu użytkownika aplikacji dzięki udostępnianiu deklaratywnego interfejsu API, który pozwala renderować interfejs aplikacji bez konieczności bezterminowej mutacji widoków frontendu. Terminologia wymaga wyjaśnień, ale ma duże znaczenie 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 UI 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órych są one widoczne. Ł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. Złożoność konserwacji oprogramowania rośnie wraz z liczbą wyświetleń, które wymagają 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. Metoda polega na koncepcyjnym ponownym wygenerowaniu całego ekranu od zera, a następnie wprowadzeniem tylko niezbędnych zmian. Takie podejście pozwala uniknąć skomplikowanego procesu ręcznego aktualizowania hierarchii widoków stanowych. 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 należy na bieżąco rysować ponownie. Ma to wpływ na sposób projektowania komponentów UI, co omówiliśmy w sekcji Zmiana kompozycji.

Prosta funkcja kompozycyjna

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 kompozycyjna, która przekazuje dane i używa ich do renderowania widżetu tekstowego na ekranie.

Kilka informacji o tej funkcji:

  • Do funkcji dodano adnotację @Composable. Wszystkie funkcje kompozytowe muszą mieć tę adnotację. Informuje ona kompilator Compose, że dana funkcja ma przekształcać dane w interfejs użytkownika.

  • Funkcja przyjmuje dane. Funkcje kompozycyjne mogą akceptować parametry, które umożliwiają logikę 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 tworzenia, które generują interfejs, nie muszą niczego zwracać, ponieważ opisują pożądany stan ekranu, zamiast tworzyć widżety interfejsu.

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

    • Funkcja działa w ten sam sposób w przypadku wielokrotnego wywoływania tego samego argumentu i nie używa innych wartości, takich jak zmienne globalne czy 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 rzecz biorąc, wszystkie funkcje kompozycyjne powinny być zapisywane z tymi właściwościami, z powodów omówionych w artykule Ponowna kompozycja.

Zmiana paradygmatu na deklaratywny

W przypadku wielu imperatywnych pakietów narzędzi interfejsu użytkownika zorientowanych obiektowo inicjalizacja interfejsu odbywa się przez utworzenie drzewa widżetów. Często odbywa się to przez napełnienie pliku XML układu. 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 metodzie deklaratywnej w Compose widżety są względnie bezstanowe i nie ujawniają funkcji ustawiania ani pobierania. W rzeczywistości widżety nie są widoczne jako obiekty. Interfejs użytkownika aktualizujesz, wywołując tę samą funkcję składającą się z innych argumentów. Ułatwia to przekazywanie informacji do wzorców architektonicznych takich jak ViewModel, jak opisano w Przewodniku po architekturze aplikacji. Następnie komponenty są odpowiedzialne za przekształcanie bieżącego stanu aplikacji w interfejs za każdym razem, gdy dane obserwowalne są aktualizowane.

Ilustracja przepływu danych w interfejsie tworzenia wiadomości: od obiektów wysokiego poziomu aż do ich elementów podrzędnych.

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, a następnie przekazuje odpowiednie dane do tych komponentów i dalej w hierarchii.

Gdy użytkownik wejdzie w interakcję z interfejsem, wywoła on zdarzenia takie jak onClick. Te zdarzenia powinny powiadomić logikę aplikacji, która może zmienić stan aplikacji. Gdy stan się zmieni, funkcje kompozytowe zostaną ponownie wywołane z nowymi danymi. Powoduje to, że elementy interfejsu są ponownie rysowane. Ten proces nazywamy ponowną kompozycjami.

Ilustracja pokazują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 dowolny 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 pobiera listę imion i generuje powitanie dla każdego użytkownika. Funkcje kompozycyjne bywają dość zaawansowane. Aby określić, czy chcesz wyświetlić konkretny element interfejsu, możesz korzystać z instrukcji if. 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.

Zmiana kompozycji

W imperatywnym modelu UI, aby zmienić widżet, wywołujesz metodę settera, która zmienia jego stan wewnętrzny. W komponencie Compose ponownie wywołujesz funkcję kompozytową, podając nowe dane. W ten sposób funkcja zostanie ponownie skompilowana – 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. Aby wyświetlić nową wartość, funkcja Compose ponownie wywołuje funkcję lambda z funkcja Text. 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.

Przekomponowanie to proces ponownego wywoływania funkcji kompozycyjnych po zmianie danych wejściowych. Dzieje się tak, gdy zmienią 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. Dzięki pomijaniu wszystkich funkcji i elementów lambda, które nie mają zmienionych parametrów, funkcja Compose może sprawnie tworzyć nowe kompozycje.

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 w pozostałych częściach aplikacji. Na przykład te działania są niebezpiecznymi skutkami ubocznymi:

  • Zapisywanie właściwości obiektu udostępnionego
  • Aktualizuję element do obserwacji w: ViewModel
  • Aktualizowanie udostępnionych ustawień

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

Ten kod tworzy kompozyt do aktualizowania wartości w komponencie SharedPreferences. Funkcja kompozycyjna nie powinna odczytywać ani zapisywać danych z udostępnionych ustawień. Zamiast tego kod przenosi operacje odczytu i zapisu do ViewModel w tle. Logika aplikacji przekazuje bieżącą wartość z wywołaniem zwrotnym, aby aktywować 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 optymistycznych i może zostać anulowana.
  • Funkcja składana może być wykonywana dość często, nawet w każdej klatce animacji.
  • Funkcje kompozycyjne mogą być wykonywane równolegle.
  • Funkcje kompozycyjne 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 część interfejsu użytkownika jest nieprawidłowa, Compose stara się ponownie skompilować tylko te części, które wymagają aktualizacji. Oznacza to, że może ono pominąć ponowne wykonanie komponentu w przypadku pojedynczego przycisku bez wykonywania żadnych innych komponentów znajdujących się powyżej lub poniżej niego w drzewie interfejsu.

Każda funkcja składana i funkcja lambda może się sama przekształcić. Oto przykład, który pokazuje, jak zmiana kompozycji 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 element header się zmieni, funkcja tworzenia wiadomości może przejść do funkcji lambda Column bez wykonywania któregoś z elementów 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 lambd 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 zmienią się ponownie. Jeśli parametr się zmieni przed zakończeniem rekompozycji, usługa Compose może anulować rekompozycję i ponownie ją uruchomić z nowym parametrem.

Po anulowaniu ponownej kompozycji funkcja tworzenia usuwa drzewo interfejsu z ponownej kompozycji. 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 prowadzić do niespójnego stanu aplikacji.

Aby zapewnić optymistyczną zmianę kompozycji, wszystkie funkcje kompozycyjne i lambdy muszą być idempotentne i wolne od skutków ubocznych.

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

W niektórych przypadkach funkcja kompozycyjna może być uruchamiana dla każdej klatki animacji w interfejsie. 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

Funkcja tworzenia wiadomości może zoptymalizować przekomponowanie, uruchamiając funkcje kompozycyjne równolegle. Dzięki temu Compose mógłby korzystać z wielu rdzeni i uruchamiać funkcje kompozytowe poza ekranem z niższym priorytetem.

W ramach tej optymalizacji funkcja kompozycyjna może być wykonywana w puli 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 kompozytowe 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 modyfikującego zmienne w komponencie lambda – zarówno dlatego, że nie jest on bezpieczny w wątkach, jak i ponieważ jest to niedopuszczalny efekt uboczny funkcji kompozycyjnej 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 element items jest modyfikowany 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 frameworkowi na zmianę wątków w celu wykonania kompozytowanych funkcji lambda.

Funkcje kompozycyjne mogą być wykonywane w dowolnej kolejności

Jeśli 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. Funkcja tworzenia umożliwia rozpoznawanie, że niektóre elementy interfejsu mają wyższy priorytet niż inne, i wybranie ich jako pierwszego.

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 do numerów StartScreen, MiddleScreen i EndScreen mogą następować w dowolnej kolejności. Oznacza to, że nie możesz na przykład ustawić za pomocą funkcji StartScreen() żadnej zmiennej globalnej (efekt uboczny) i korzystać z tego efektu w funkcji MiddleScreen(). Każda z tych funkcji musi być niezależna.

Więcej informacji

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

Filmy