Fragment: o que é, fragmentos e FragmentManager no Android

O que é Fragment?

Fragment é um componente de interface de usuário modular do Android que representa uma parte da tela dentro de uma Activity. Fragment pode gerenciar seu próprio layout, lidar com eventos do ciclo de vida e salvar seu estado. Graças à modularidade, um mesmo fragmento pode ser usado em diferentes Activities e em diferentes dispositivos.

A API Fragment surgiu no Android 3.0 (Honeycomb, API 11) em 2011 para suportar tablets. Antes disso, os desenvolvedores precisavam criar Activities separadas para celular e tablet. Fragment permitiu montar uma tela a partir de blocos independentes. Em 2019, o Google lançou a biblioteca Jetpack Fragment com compatibilidade retroativa até API 4.

Segundo o Google (2026), 80% dos aplicativos na Google Play usam Fragment de alguma forma. A biblioteca Jetpack Fragment foi baixada mais de 10 bilhões de vezes através do Google Play Services. Fragment continua sendo um componente chave da arquitetura Android mesmo na era do Jetpack Compose.

Ciclo de vida do Fragment

O ciclo de vida do Fragment é mais complexo que o da Activity porque depende do estado da Activity hospedeira. Fragment passa pelos mesmos estados que a Activity, mas adiciona seus próprios callbacks: onAttach, onCreateView, onViewCreated, onActivityCreated, onDestroyView, onDetach.

Comparação do ciclo de vida Fragment e Activity

A principal diferença do ciclo de vida do Fragment é a invocação de onCreateView e onDestroyView entre onCreate e onDestroy. Fragment pode existir sem UI (se onCreateView retornar null). Após a recriação da Activity, o FragmentManager restaura os fragmentos automaticamente.

FragmentManager e transações

FragmentManager é a classe central para gerenciar fragmentos em uma Activity. Ele é responsável por adicionar, remover, substituir fragmentos, gerenciar a pilha de retorno e restaurar o estado. FragmentManager está disponível através de supportFragmentManager (AndroidX) ou fragmentManager (API antiga).

class MainActivity : AppCompatActivity() {

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

        // Fragmento ainda não adicionado — criando
        if (savedInstanceState == null) {
            val transaction = this.supportFragmentManager
                .beginTransaction()
            transaction.add(R.id.fragment_container, ListFragment())
            transaction.addToBackStack(null)
            transaction.commit()
        }
    }

    fun replaceFragment(fragment: Fragment) {
        supportFragmentManager.beginTransaction()
            .replace(R.id.fragment_container, fragment)
            .addToBackStack(null)
            .commit()
    }
}

As transações FragmentTransaction são atômicas. commit() agenda a execução para o próximo ciclo do Looper. Para execução imediata use commitNow(). addToBackStack(null) adiciona a transação à pilha de retorno — o botão de voltar desfará a operação.

Métodos do ciclo de vida do Fragment

Vamos examinar os principais métodos do ciclo de vida do Fragment com um exemplo em Kotlin. onCreateView cria um layout — diferentemente da Activity, o método deve retornar uma View. onViewCreated é chamado imediatamente depois, aqui é seguro encontrar elementos por id. onDestroyView é o último momento para limpar referências de view.

class DetailFragment : Fragment() {

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

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

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        binding.textTitle.setText("Detalhes")
    }

    override fun onDestroyView() {
        super.onDestroyView()
        _binding = null
    }
}

O padrão View Binding com _binding/binding garante que após onDestroyView a referência ao layout seja anulada. Acessar binding após a destruição da view causará NullPointerException. Este padrão é recomendado pelo Google para todos os fragmentos.

Transferência de dados entre fragmentos

Para transferência de dados entre fragmentos, o Android oferece vários mecanismos. O mais confiável é um ViewModel compartilhado entre fragmentos de uma mesma Activity. Fragment Result API é adequado para eventos únicos. Argumentos Bundle são para dados ao criar um fragmento.

// ViewModel compartilhado para dois fragmentos
class SharedViewModel : ViewModel() {
    private val _selectedItem = MutableLiveData<Item>()
    val selectedItem: LiveData<Item> = _selectedItem

    fun select(item: Item) { _selectedItem.setValue(item) }
}

// Fragmento A: envia evento via Fragment Result API
setFragmentResult("request_key", bundleOf("key" to "value"))

// Fragmento B: recebe evento
childFragmentManager.setFragmentResultListener("request_key", this) { requestKey, bundle ->
    val value = bundle.getString("key")
}

Fragment Result API (adicionado no Fragment 1.3.0) substitui os obsoletos setTargetFragment/onActivityResult. A API é type-safe, usa Bundle e não requer conhecimento do receptor. Parent FragmentManager atua como intermediário entre fragmentos.

Fragment vs Activity: quando escolher o quê

A escolha entre Fragment e Activity depende da arquitetura do aplicativo. Fragment é obrigatório para layouts adaptativos (telefone + tablet), para animações de transição personalizadas e para usar Jetpack Navigation. Activity é preferível para aplicativos simples com uma ou duas telas.

Jetpack Fragment e Jetpack Navigation

A abordagem moderna para trabalhar com Fragment é o Jetpack Navigation Component, que substitui o gerenciamento manual do FragmentManager. A biblioteca fornece NavGraph (grafo de navegação XML), NavHostFragment e Safe Args para transferência de dados type-safe.

Jetpack Fragment library (androidx.fragment:fragment-ktx) inclui FragmentResult API, DialogFragment, BottomSheetDialogFragment e integração com componentes Lifecycle-aware. Desde 2026, o Google recomenda usar Fragment apenas através do Jetpack Navigation, não diretamente.

<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    app:startDestination="@+id/listFragment">

    <fragment
        android:id="@+id/listFragment"
        android:name=".ListFragment"
        android:label="Lista">
        <action
            android:id="@+id/action_list_to_detail"
            app:destination="@+id/detailFragment" />
    </fragment>

    <fragment
        android:id="@+id/detailFragment"
        android:name=".DetailFragment"
        android:label="Detalhes" />
</navigation>