O que é Jetpack Compose?

Question

Accepted Answer

**Jetpack Compose** é o moderno **toolkit de UI declarativo** do Android — construindo UIs com funções Kotlin compostas em vez de layouts XML. É a abordagem recomendada pelo Google para novas UIs Android, oferecendo uma forma reativa, concisa e mais produtiva de construir interfaces.

## O que é Compose

```text
JETPACK COMPOSE = a declarative UI toolkit (Kotlin code, no XML):
  → describe the UI as COMPOSABLE FUNCTIONS (annotated @Composable)
  → DECLARATIVE + REACTIVE — describe UI for a given state; it updates when state changes
  → Google's RECOMMENDED modern approach (similar philosophy to Flutter, React, SwiftUI)
```

## Uma função composável

```kotlin
@Composable
fun Greeting(name: String) {
  Column {                            // layout composable
    Text("Hello, $name")              // text composable
    Button(onClick = { /* ... */ }) {
      Text("Click me")
    }
  }
}
// → compose UI by CALLING composable functions (composition); no XML, no findViewById
```

## Estado e recomposição

```kotlin
@Composable
fun Counter() {
  var count by remember { mutableStateOf(0) }   // STATE
  Button(onClick = { count++ }) {                // change state
    Text("Count: $count")                         // UI reads state
  }
  // → when state changes, Compose RECOMPOSES (re-runs affected composables) → UI updates
}
```

Mudanças de estado desencadeiam **recomposição** (Compose re-executa as funções composáveis afetadas para atualizar a UI) — o modelo reativo.

## Compose vs o sistema de View tradicional

```text
TRADITIONAL → XML layouts + imperative view manipulation (findViewById, setText, etc.)
COMPOSE → declarative Kotlin; less boilerplate; reactive state; more productive;
  the modern, recommended direction (new apps; interop with existing Views possible)
```

## Por que isso importa

Entender Jetpack Compose é importante porque é a **abordagem moderna recomendada pelo Google para UI Android** e a direção do desenvolvimento de UI Android, portanto é conhecimento cada vez mais essencial.

Compose é um **toolkit de UI declarativo** que constrói UIs com funções Kotlin composáveis em vez de layouts XML — representando uma mudança fundamental em como as UIs Android são construídas, alinhada com a filosofia declarativa moderna compartilhada por Flutter, React e SwiftUI.

Entender o **modelo declarativo e reativo** — descrevendo a UI como funções composáveis para um dado estado, com a UI atualizando automaticamente (via **recomposição**) quando o estado muda — é o conceito central, contrastando com a abordagem imperativa tradicional (manipulação manual de views com findViewById e setters).

Entender **composables** (construindo UIs ao compor funções, sem XML ou findViewById) e **estado com recomposição** (mudanças de estado desencadeando re-execuções de composables afetados para atualizar a UI) é necessário para construir UIs em Compose.

Entender o **contraste com o sistema de View tradicional** (XML + manipulação imperativa vs Kotlin declarativo com menos boilerplate, estado reativo e maior produtividade) esclarece por que Compose é preferido e como difere.

Como Compose é a abordagem recomendada pelo Google para novas UIs Android (com novos aplicativos adotando-o cada vez mais e sendo a direção clara do desenvolvimento de UI Android), e como entender seu modelo declarativo, reativo e como difere do sistema tradicional é cada vez mais essencial para o trabalho Android moderno, entender Jetpack Compose é conhecimento Android importante e cada vez mais essencial — a forma moderna e recomendada de construir UIs Android, representando a direção da plataforma e conhecimento cada vez mais esperado para desenvolvedores Android que constroem novos aplicativos, uma evolução significativa do sistema de views baseado em XML tradicional.