Activity — o que é, tela de aplicativo no Android e seu Lifecycle

O que é Activity?

Activity — um componente chave de aplicativo Android que fornece uma janela para interação com o usuário. Cada Activity gerencia uma tela separada: lista de tarefas, formulário de login, visualizador de fotos. O sistema Android cria uma Activity quando solicitado e a destrói quando outros aplicativos precisam de memória.

Activity apareceu pela primeira vez no Android 1.0 (2008) e continua sendo o principal bloco de construção da interface. De acordo com o Google (2026), 98% dos aplicativos na Google Play contêm pelo menos uma Activity. Na arquitetura moderna, o Google recomenda uma Activity com múltiplos Fragments, no entanto o aplicativo clássico de múltiplas telas continua sendo uma prática comum.

Activity stack (back stack) — uma pilha de tarefas que armazena o histórico de navegação. Quando o usuário pressiona "Voltar", a Activity atual é destruída e a anterior é restaurada. O sistema gerencia a pilha automaticamente, mas o desenvolvedor pode controlar o comportamento através de launchMode e flags de Intent.

Ciclo de vida da Activity

O ciclo de vida da Activity é um conjunto de estados e callbacks pelos quais uma tela passa desde a criação até a destruição. Compreender o Lifecycle é criticamente importante: o manuseio incorreto de estados leva a vazamentos de memória, perda de dados e falhas do aplicativo.

O sistema Android chama os callbacks em uma ordem rigorosa. O desenvolvedor sobrescreve os métodos necessários para inicializar recursos, salvar dados e liberar memória. Cada callback tem um par correspondente: onCreate ↔ onDestroy, onStart ↔ onStop, onResume ↔ onPause.

Estados da Activity

Existem quatro estados de Activity: Running (onResume ativo), Paused (visível mas sem foco), Stopped (não visível), Destroyed (destruído). O sistema pode matar uma Activity no estado Stopped quando falta memória — os dados devem ser salvos em onSaveInstanceState.

Métodos do ciclo de vida: onCreate, onStart, onResume

Vamos examinar três métodos principais do ciclo de vida da Activity com um exemplo em Kotlin. onCreate — o ponto de entrada, chamado uma vez. Aqui ocorrem a vinculação do layout via setContentView, a inicialização do RecyclerView, a inscrição no LiveData. onStart — a Activity se torna visível para o usuário. onResume — a Activity obtém foco e está pronta para interação.

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val recyclerView = findViewById<RecyclerView>(R.id.rv_items)
        recyclerView.layoutManager = LinearLayoutManager(this)
        loadItems()
    }

    override fun onStart() {
        super.onStart()
        startLocationUpdates()
    }

    override fun onResume() {
        super.onResume()
        resumeVideoPlayer()
    }
}

No exemplo, onCreate inicializa RecyclerView e carrega dados. onStart inicia atualizações de geolocalização — um recurso que deve funcionar apenas quando a tela está visível. onResume retoma o vídeo que foi pausado em onPause. Essa separação evita trabalho desnecessário em segundo plano.

Declaração de Activity no AndroidManifest.xml

Cada Activity deve ser declarada no arquivo AndroidManifest.xml. Sem registro, o sistema não encontrará a tela e lançará uma exceção ActivityNotFoundException. O manifesto especifica o nome da classe, tema, orientação, launchMode e filtros de Intent.

<application
    android:allowBackup="true"
    android:label="@string/app_name"
    android:theme="@style/Theme.MyApp">

    <activity
        android:name=".MainActivity"
        android:exported="true">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>

    <activity
        android:name=".DetailActivity"
        android:parentActivityName=".MainActivity" />
</application>

A flag exported determina se outros aplicativos podem iniciar a Activity. Para a tela principal exported=true, para telas internas — false. O atributo parentActivityName habilita a navegação padrão "Para cima" (Up Navigation).

Iniciar Activity via Intent

Intent — um objeto que descreve uma ação a ser executada. No contexto da Activity, Intent é usado para iniciar outra tela com transferência de dados. Intent pode ser explícito (especifica uma classe concreta) e implícito (especifica uma ação, o sistema seleciona um componente adequado).

// Intent explícito — iniciar DetailActivity com dados
val intent = Intent(this, DetailActivity::class.java).apply {
    putExtra("item_id", itemId)
    putExtra("item_name", itemName)
}
startActivity(intent)

// Obter dados no DetailActivity
val itemId = intent.getLongExtra("item_id", 0L)
val itemName = intent.getStringExtra("item_name") ?: ""

Para obter um resultado de uma Activity iniciada, utiliza-se a Activity Result API, que substituiu o obsoleto startActivityForResult. A nova API é type-safe, declarativa e funciona com Jetpack Compose.

private val getResult = registerForActivityResult(
    ActivityResultContracts.StartActivityForResult()
) { result ->
    if (result.resultCode == Activity.RESULT_OK) {
        val data = result.data?.getStringExtra("result_key")
    }
}

fun openPicker() {
    val intent = Intent(this, PickerActivity::class.java)
    getResult.launch(intent)
}

Salvar estado ao recriar

Ao girar a tela ou alterar a configuração, o Android recria a Activity — chama sequencialmente onDestroy e onCreate. Sem salvar o estado, o usuário perde dados inseridos, posição de rolagem e itens selecionados. O Android fornece dois mecanismos para resolver este problema: onSaveInstanceState e ViewModel.

onSaveInstanceState salva dados simples no Bundle antes de chamar onDestroy. O ViewModel do Jetpack sobrevive à recriação da Activity e armazena dados na memória, o que é mais eficiente para objetos complexos e requisições de rede.

class MainActivity : AppCompatActivity() {

    private val viewModel: MainViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // ViewModel salva dados automaticamente
        viewModel.items.observe(this) { items ->
            updateAdapter(items)
        }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putInt("scroll_position", recyclerView.computeVerticalScrollOffset())
    }
}

Arquitetura Single Activity e Jetpack

A abordagem moderna do Google é a arquitetura Single Activity com uma Activity e múltiplos Fragments. O aplicativo usa uma MainActivity, e toda a navegação é gerenciada pelo Navigation Component através do NavHostFragment. Vantagens: navegação centralizada, ViewModel compartilhado por tela, manipulação correta de Deep Links.

O Jetpack Navigation Component automatiza o gerenciamento da back stack, animações de transição e passagem de argumentos. O NavHostFragment é colocado no layout da Activity, e o grafo de navegação (NavGraph) descreve todas as telas e conexões entre elas. Esta abordagem é recomendada pelo Google para novos projetos e segue os princípios do Material Design.

class MainActivity : AppCompatActivity() {

    private val navController by lazy {
        findViewById<NavHostFragment>(R.id.nav_host_fragment)
            .navController
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Configuração do NavigationUI para AppBar
        setupActionBarWithNavController(navController)
    }

    override fun onSupportNavigateUp() = 
        navController.navigateUp() || super.onSupportNavigateUp()
}