Por que eu devo ler este artigo:

Este artigo apresenta ao leitor o uso, vantagens e desvantagens da API de Fragmentos do Android. É importante saber que desenvolver para smartphones já não é o bastante hoje em dia. Criar aplicações que possam ser utilizadas em tablets e até mesmo em TVs é um desafio principalmente pelos diferentes tamanhos de tela. A API de Fragmentos se encaixa como uma luva para essas situações, nas quais existem dispositivos com telas de tamanhos variados, pois permite ajustes na interface gráfica possibilitando um melhor aproveitamento dos espaços disponíveis.

O aumento da procura por dispositivos portáteis, como smartphones e tablets, que auxiliam os usuários em suas atividades do cotidiano, tem motivado a indústria na produção de aparelhos com vários tamanhos de tela para diferentes finalidades. Esse fato despertou o interesse dos desenvolvedores a criar soluções que aproveitem ao máximo o espaço de tela disponível nesses aparelhos.

Entretanto, tem sido um enorme desafio para os programadores desenvolver aplicativos que se adaptem aos mais variados tamanhos de tela, pois um layout portável com uma boa interface visual e que ocupe todo o espaço da tela, tanto em smartphones quanto em tablets, exige um grande esforço.

Visando reduzir esse esforço foi criada a API de Fragmentos, que tem como objetivos principais a construção de layouts dinâmicos e o reuso de componentes. Os fragmentos são descritos como uma espécie de mini activities, que por sua vez podem ser adicionadas a uma Activity. Dessa forma é possível compor uma tela de diferentes maneiras, agrupando um ou vários fragmentos dentro de uma Activity.

A API de Fragmentos foi introduzida na plataforma Android a partir da versão 3.x (Honeycomb). Apesar disso, está disponível uma biblioteca de compatibilidade (android-support-v4) que permite que alguns recursos presentes no Honeycomb – entre eles, fragmentos – sejam suportados nas versões do Android 2.x para smartphones.

Neste contexto, o intuito deste artigo é apresentar as principais funcionalidades dessa API por meio de exemplos práticos, onde serão expostas suas vantagens e desvantagens. Além disso, também será apresentado ao leitor o ciclo de vida de um fragmento, o uso da biblioteca de compatibilidade e como manipular fragmentos dinamicamente. Ao final, será desenvolvida uma aplicação de leitura de notícias via RSS que utiliza os principais conceitos de fragmentos.

A API de Fragmentos

Um fragmento é um componente reutilizável que auxilia os programadores na criação de layouts para dispositivos com tamanhos de tela variados. Ele representa uma parte da interface gráfica em uma Activity que tem seu próprio ciclo de vida, recebe seus próprios eventos de entrada e pode ser adicionado ou removido enquanto a Activity está em execução.

Para utilizar um fragmento é preciso criar uma classe que estenda android.app.Fragment ou uma de suas subclasses, como ListFragment, DialogFragment ou PreferenceFragment. A Tabela 1 descreve essas classes.

Principais classes da API de Fragmentos
Tabela 1. Principais classes da API de Fragmentos

Com o intuito de demonstrar o uso de fragmentos na prática, criaremos uma aplicação de teste que exibe uma mensagem utilizando fragmentos e outra mensagem sem usar esse recurso. Para isso, codificamos a classe MeuFrament, que estende de Fragment. Veja o código desta classe na Listagem 1.

  1.  package labs.org.br;
  2.   
  3.  import org.cesar.br.R;
  4.  import android.app.Fragment;
  5.  import android.os.Bundle;
  6.  import android.view.LayoutInflater;
  7.  import android.view.View;
  8.  import android.view.ViewGroup;
  9.   
  10.  public class MeuFragment extends Fragment {
  11.   
  12.    @Override
  13.    public View onCreateView(LayoutInflater inflater, 
            ViewGroup container,
  14.    Bundle savedInstanceState) {
  15.       return inflater.inflate
             (R.layout.exemplo_fragmento, container, false);
  16.    }
  17.  }
Listagem 1. Exemplo de uma subclasse de Fragment

Conforme indicado na Listagem 1, devemos reimplementar o método onCreateView(). Este método é responsável por carregar o layout que será exibido na tela. Ele recebe como parâmetro, entre outros, um objeto do tipo LaytoutInflater, que transforma um layout definido em XML em uma classe View, procedimento feito pelo método inflate(), que possui três argumentos:

  1. O identificador do layout que será usado;
  2. Um objeto do tipo ViewGroup, que será o pai da View que está sendo gerada;
  3. Um parâmetro booleano que, se true, indica que a View carregada deve ser associada ao ViewGroup.

Como pode ser observado, um dos parâmetros do método inflate() é o identificador do layout que será carregado pelo fragmento. Esse identificador aponta para um arquivo XML onde o layout é especificado. A Listagem 2 apresenta um exemplo de como esse arquivo é definido.

  <?xml version="1.0" encoding="utf-8"?>
  <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
      android:layout_width="match_parent"
      android:layout_height="match_parent"
      android:orientation="vertical" >
      <TextView
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:text="@string/fragmento_str" />
  </LinearLayout>
Listagem 2. Exemplo do arquivo de layout que será carregado pelo fragmento

Como podemos observar, a Listagem 2 possui um layout que exibe um texto na tela do dispositivo quando a aplicação é carregada.

Até agora criamos um fragmento e definimos o seu layout. O próximo passo consiste em adicioná-lo à activity. Para isso, devemos declarar o fragmento no arquivo de layout da activity, como ilustra a Listagem 3.

  <?xml version="1.0" encoding="utf-8"?>
  <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
      android:layout_width="fill_parent"
      android:layout_height="fill_parent"
      android:orientation="vertical" >
      <TextView
          android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:text="@string/activity_str" />
      
      <fragment android:name="labs.org.br.ExemploFragmento"
              android:id="@+id/fragment"
              android:layout_width="wrap_content"
              android:layout_height="wrap_content" />
  </LinearLayout>
Listagem 3. Associando um fragmento a uma Activity

A tag <fragment> é usada para declarar um fragmento dentro de um arquivo de layout. Ela possui os atributos name, id e tag, descritos na Tabela 2.

Atributos da tag
Tabela 2. Atributos da tag

No exemplo demonstrado na Listagem 3, percebemos que por meio do atributo name instanciamos a classe de fragmento da Listagem 1 e exibimos o seu conteúdo junto com o layout da Activity. Vale lembrar que cada fragmento possui um identificador único definido pelo atributo id ou tag.

Podemos empregar qualquer um dos dois para obter a instância do fragmento que está em uso, sendo que o último recebe como parâmetro um texto e o primeiro um número. Assim, usa-se o método getFragmentManager() para obter o objeto da classe FragmentManage ...

Quer ler esse conteúdo completo? Seja um assinante e descubra as vantagens.
  • 473 Cursos
  • 10K Artigos
  • 100 DevCasts
  • 30 Projetos
  • 80 Guias
Tenha acesso completo