Android Academy · Aula

Fragments

Fragments é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 6 de 7. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Android Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Android Academy inclui 7 aulas no total.

O que são Fragments?

Um Fragment é um módulo de interface reutilizável que vive dentro de uma Activity. Pense nele como uma subatividade com seu próprio layout, ciclo de vida e lógica.

Por que usar Fragments?

Reutilizar a interface em várias Activities
Lidar com layouts diferentes para celular e tablet
Criar fluxos com várias telas sem várias Activities
Trabalhar naturalmente com o Navigation Component

Ciclo de vida do Fragment

Os Fragments têm seu próprio ciclo de vida, que ocorre paralelamente ao ciclo de vida da Activity. Principais funções de retorno de chamada:

onAttach — fragmento anexado à Activity
onCreate — fragmento criado (ainda sem visualização)
onCreateView — infla o layout
onViewCreated — visualização pronta; configure a interface aqui
onDestroyView — visualização destruída (limpe as referências à visualização)
onDetach — fragmento desanexado

Criando um Fragment

Crie uma classe que estenda Fragment e substitua onCreateView para inflar o layout:

import androidx.fragment.app.Fragment
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup

class HomeFragment : Fragment() {

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        return inflater.inflate(R.layout.fragment_home, container, false)
    }
}

ViewBinding em Fragments

Use ViewBinding em fragments, mas libere a vinculação em onDestroyView para evitar vazamentos de memória:

class HomeFragment : Fragment() {

    private var _binding: FragmentHomeBinding? = null
    private val binding get() = _binding!!

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
        _binding = FragmentHomeBinding.inflate(inflater, container, false)
        return binding.root
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        binding.tvTitle.text = "Welcome!"
    }

    override fun onDestroyView() {
        super.onDestroyView()
        _binding = null   // prevent memory leak
    }
}

XML de layout do Fragment

Crie res/layout/fragment_home.xml assim como criaria um layout de Activity. A visualização raiz se torna a visualização do Fragment:

<!-- res/layout/fragment_home.xml -->
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <TextView
        android:id="@+id/tvTitle"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="24sp"
        android:text="Home" />

</LinearLayout>

Adicionando um Fragment a uma Activity

Há duas maneiras de adicionar um Fragment a uma Activity:

Estática (XML) — declare-o no layout com a tag <fragment>. Fica fixa durante a execução.
Dinâmica (código) — use FragmentManager e transações. Pode ser substituído durante a execução.

<!-- Static: in activity_main.xml -->
<fragment
    android:id="@+id/homeFragment"
    android:name="com.example.HomeFragment"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

Transações dinâmicas de Fragments

Use supportFragmentManager para adicionar, substituir ou remover fragments durante a execução:

// In Activity:
class MainActivity : AppCompatActivity(R.layout.activity_main) {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        if (savedInstanceState == null) {
            supportFragmentManager.beginTransaction()
                .add(R.id.fragmentContainer, HomeFragment())
                .commit()
        }
    }

    fun showDetail(id: Int) {
        supportFragmentManager.beginTransaction()
            .replace(R.id.fragmentContainer, DetailFragment.newInstance(id))
            .addToBackStack(null)  // allow back navigation
            .commit()
    }
}

Passando argumentos para Fragments

Passe dados por meio de um Bundle, usando o padrão de fábrica do objeto companion. Nunca use um construtor de Fragment com parâmetros — o Android recria os fragments com um construtor sem argumentos após alterações de configuração:

class DetailFragment : Fragment() {

    companion object {
        private const val ARG_ID = "item_id"

        fun newInstance(itemId: Int): DetailFragment {
            return DetailFragment().apply {
                arguments = Bundle().apply {
                    putInt(ARG_ID, itemId)
                }
            }
        }
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val itemId = requireArguments().getInt(ARG_ID)
        // use itemId to load data
    }
}

Comunicação entre Fragment e Activity

Use uma interface definida no Fragment e implementada pela Activity. O Fragment obtém uma referência por meio de onAttach:

class ListFragment : Fragment() {

    interface OnItemSelected {
        fun onItemSelected(id: Int)
    }

    private var listener: OnItemSelected? = null

    override fun onAttach(context: Context) {
        super.onAttach(context)
        listener = context as? OnItemSelected
    }

    private fun handleClick(id: Int) {
        listener?.onItemSelected(id)
    }

    override fun onDetach() {
        super.onDetach()
        listener = null
    }
}

Pilha de retorno

Quando você chama addToBackStack(null) em uma transação, pressionar Voltar remove o fragmento da pilha:

Sem addToBackStack — Voltar encerra a Activity
Com addToBackStack — Voltar retorna ao fragmento anterior
Use popBackStack() programaticamente para voltar

Fragment em um contêiner

O layout da Activity precisa apenas de uma visualização contêiner — normalmente um FrameLayout com um ID. O Fragment preenche esse contêiner:

<!-- activity_main.xml -->
<FrameLayout
    android:id="@+id/fragmentContainer"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

Verificação rápida

Por que você nunca deve passar argumentos ao construtor de um Fragment e deve usar um Bundle por meio de uma fábrica companion?

Recapitulação: Fragments

Os Fragments são os blocos de construção das interfaces modernas do Android:

Estenda Fragment e infle o layout em onCreateView
Configure a interface em onViewCreated
Libere o ViewBinding em onDestroyView
Passe dados por meio de Bundle + fábrica companion (newInstance)
Use addToBackStack para a navegação de retorno
Comunique-se com a Activity por meio de uma interface

Próximo passo: solicite permissões perigosas durante a execução.

Perguntas Frequentes

A aula “Fragments” é grátis?

Sim — o texto completo de “Fragments” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Android Academy, atualize para CoddyKit PRO. O curso de Android Academy inclui 7 aulas no total.

O que vou aprender em “Fragments”?

Crie interfaces de usuário modulares com Fragments. Aprenda o ciclo de vida de fragments, o ViewBinding em fragments, a passagem de argumentos, o gerenciamento da pilha de retorno e a comunicação ent… Você pratica Android Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Android Academy?

Nenhuma experiência prévia é necessária. Android Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 6 de 7.

Quanto tempo leva a aula “Fragments”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Android Academy?

Sim. Cada aula de Android Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Android Academy