Кто вызывает @Composable функцию

Выполнение и вызов @Composable функций в Jetpack Compose

В системе Jetpack Compose, декларативного UI фреймворка для Android, @Composable функции не вызываются напрямую разработчиком в традиционном смысле (например, как обычные функции через их имя в коде). Их выполнение управляется специальным механизмом Compose Runtime. Этот механизм автоматически вызывает и организует выполнение composable функций для построения и обновления UI дерева.

Основные принципы вызова

1. Инициирующий вызов: Composition

    Первичный вызов происходит через **Composer**, который создает и управляет **Composition** — структурой данных, описывающей текущее UI дерево. Это делается, например, внутри `setContent { }` метода `Activity`:

```kotlin
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContent {
        // Эта точка — начало Composition. Compose Runtime начинает
        // "вызывать" (или, точнее, выполнять) корневую @Composable функцию.
        MyApp()
    }
}
```

    `setContent` устанавливает корневую composable функцию для всей UI иерархии. Compose Runtime начинает отсюда строить дерево.

1. Рекурсивный и декларативный вызов в процессе Composition

    Внутри тела одной @Composable функции вызов других @Composable функций выглядит как обычный код, но выполняется под контролем Compose Runtime. Runtime отслеживает порядок и контекст этих вызовов, чтобы правильно строить дерево.

```kotlin
@Composable
fun MyScreen() {
    Column(modifier = Modifier.fillMaxSize()) {
        // Эти строчки — декларативные описания того, ЧТО должно быть в UI.
        // Их фактическое выполнение управляется Compose Runtime.
        Header(title = "Добро пожаловать")
        ContentList(items = listOf("Item1", "Item2"))
        Footer()
    }
}
```

    Здесь `Column`, `Header`, `ContentList`, `Footer` — все являются @Composable функциями. При выполнении `MyScreen`, Compose Runtime последовательно вызывает их для построения соответствующих узлов в UI дереве.

Ключевые участники процесса

• Compose Runtime (Композитор): Ядро системы. Он отслеживает:

    -   Позицию в дереве (`slot` или `group`).
    -   Состояние (State), используемое в функциях.
    -   Запоминает (кэширует) результаты предыдущих вызовов для интеллектуального рекомпозиции.
    Runtime сам вызывает функции в нужный момент, основываясь на изменении данных или структуры.

• Композиция (Composition): Это результат работы Runtime — зафиксированное дерево, описывающее UI на текущий момент. При изменении State, Compose Runtime сравнивает новое дерево с предыдущей Композицией и вызывает только те @Composable функции, чьи входные параметры изменились (процесс рекомпозиции).

• Пользовательский код (Разработчик): Мы пишем декларативные описания UI, используя @Composable функции и встраивая вызовы других composable функций в них. Мы не управляем временем или порядком вызова напрямую, но задаем логическую структуру. Compose Runtime интерпретирует эту структуру в процессе выполнения.

Пример процесса вызова при рекомпозиции

Рассмотрим пример с состоянием:

@Composable
fun Counter() {
    // State читается внутри composable функции. Compose Runtime отслеживает это.
    val count by remember { mutableStateOf(0) }

    Column {
        // Этот Text будет вызван (рекомпозирован) Compose Runtime при изменении count.
        Text(text = "Count: $count")
        Button(onClick = { count++ }) {
            Text("Increment")
        }
    }
}

1. Первоначальная композиция: При первом запуске Counter(), Compose Runtime вызывает функцию, создает состояние count=0, вызывает Column, Text, Button и строит дерево.
2. Рекомпозиция: Когда пользователь нажимает кнопку, count увеличивается. Compose Runtime видит изменение состояния, связанного с вызовом Text. Он повторно вызывает только Text (и возможно, родительские узлы, если нужно пересчитать структуру), потому что его параметр text теперь зависит от нового count. Button и часть Column могут быть пропущены, если их входные данные не изменились.

Резюме

@Composable функции вызываются автоматически системой Compose Runtime в процессе построения (композиции) и обновления (рекомпозиции) UI дерева. Разработчик декларативно описывает структуру, встраивая вызовы composable функций внутри других composable функций. Compose Runtime:

• Инициирует выполнение от корня (например, в setContent).
• Управляет рекурсивным выполнением всех внутренних composable вызовов.
• Интеллектуально рекомпозирует только необходимые части дерева при изменении состояния.

Таким образом, прямой "вызов" — это действие Runtime, основанное на декларативном описании, написанном разработчиком, и изменении данных приложения.