Fragmentos

Un Fragment representa un comportamiento o una parte de la interfaz de usuario

en una Activity. Puedes combinar múltiples fragmentos en una sola actividad
para crear una IU multipanel y volver a usar un fragmento en múltiples
actividades.
Un fragmento siempre debe estar integrado a una actividad y el ciclo de vida
del fragmento se ve directamente afectado por el ciclo de vida de la actividad
anfitriona. Cuando realizas una transacción de fragmentos como esta, también
puedes agregarlos a una pila de actividades administrada por la actividad; cada
entrada de la pila de actividades en la actividad es un registro de la
transacción de fragmentos realizada. La pila de actividades le permite al
usuario invertir una transacción de fragmentos (navegar hacia atrás) al
presionar el botón Atrás.
Cuando agregas un fragmento como parte del diseño de tu actividad, este se
ubica en ViewGroup, dentro de la jerarquía de vistas de la actividad y el
fragmento define su propio diseño de vista. Puedes insertar un fragmento en el
diseño de tu actividad declarando el fragmento en el archivo de diseño de la
actividad como elemento <fragment> o agregándolo a un ViewGroup existente desde
el código de la actividad; también puedes usar un fragmento con su IU propia,
como un trabajador invisible para la actividad.
Se debe diseñar cada fragmento como un componente modular y reutilizable de la
actividad. Como cada fragmento define su propio diseño y su propio
comportamiento con sus propio callbacks del ciclo de vida, puedes incluir un
fragmento en múltiples actividades; por lo tanto, debes diseñarlo para volver a
utilizarlo y evitar la manipulación directa de un fragmento desde otro
fragmento. Un fragmento modular te permite cambiar tus combinaciones de
fragmentos para diferentes tamaños de pantalla.
Crear un fragmento
Para crear un fragmento debes crear una subclase Fragment. La clase Fragment
tiene un código que se asemeja a un Activity. Contiene métodos callback
similares a los de una actividad, como onCreate(), onStart(), onPause() y
onStop().
Generalmente, debes implementar al menos los siguientes métodos del ciclo de
vida:
onCreate()
El sistema lo llama cuando crea el fragmento. En la implementación, se
debe inicializar componentes esenciales del fragmento que quieres
conservar cuando el fragmento se pause o se detenga y luego se reanude.
onCreateView()
El sistema lo llama cuando el fragmento debe diseñar su interfaz de
usuario por primera vez. Para diseñar una IU para tu fragmento, debes
devolver una View desde este método que será la raíz del diseño de tu
fragmento. Puede devolver nulo si el fragmento no proporciona una IU.
onPause()
El sistema llama a este método como el primer indicador de que el usuario
está abandonando el fragmento. Este es el momento en el que debes
confirmar los cambios que deban conservarse más allá de la sesión de
usuario actual.
Existen también algunas subclases que quizá desees extender, en lugar de la
clase de base Fragment:
DialogFragment

2
 Muestra un diálogo flotante. Usar esta clase para crear un diálogo es una
buena alternativa al uso de métodos del asistente de diálogos en la clase
Activity, ya que puedes incorporar un diálogo del fragmento en la pila de
actividades de fragmentos administrados por la actividad, lo que le
permite al usuario volver a un fragmento descartado.
ListFragment
Muestra una lista de elementos administrados por un adaptador como un
SimpleCursorAdapter, al igual que ListActivity. Proporciona varios
métodos para administrar una vista de lista, como el callback
onListItemClick() para manipular eventos de clic.
PreferenceFragment
Muestra una jerarquía de objetos Preference en forma de lista, al igual
que PreferenceActivity. Esto resulta útil para crear una actividad
“configuración” para tu aplicación.

Agregar una interfaz de usuario

Un fragmento se usa como parte de la interfaz de usuario de una actividad y
aporta su propio diseño a la actividad.
Para proporcionar un diseño para un fragmento, debes implementar el método de
callback onCreateView(), al cual el sistema Android llama cuando llega el
momento de que el fragmento defina su diseño. Tu implementación de este método
debe devolver una View que es la raíz del diseño de tu fragmento.
SI TU FRAGMENTO ES UNA SUBCLASE DE ListFragment, LA IMPLEMENTACIÓN
PREDETERMINADA MUESTRA UNA ListView DESDE onCreateView(), DE MODO QUE NO
NECESITAS IMPLEMENTARLA
Para mostrar un diseño desde onCreateView(), puedes agrandarlo desde un recurso
de diseño definido en XML. Este proporciona un objeto LayoutInflater.
public static class ExampleFragment extends Fragment {
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        return inflater.inflate(R.layout.example_fragment, container, false);
  }
}
El parámetro container que se pasa a onCreateView() es el ViewGroup principal
en el cual se insertará el diseño de tu fragmento. El parámetro
saveInstanceState es un Bundle que proporciona datos acerca de la instancia
previa del fragmento, si el fragmento se está reanudando.
El método inflate() adopta tres argumentos:
- La ID de recurso del diseño que quieres agrandar
- El ViewGroup que será el elemento principal del diseño agrandado. Es
importante pasar container par aque el sistema aplique parámetros de

3
 diseño a la vista de raíz del diseño agrandado, especificada por la vista
principal a la que se integra.
- Un valor booleano que indica si se debe anexar el diseño aumentado al
ViewGroup (el segundo parámetro) durante el agrandamiento.
Agregar un fragmento a una actividad
Un fragmento aporta una parte de la IU a la actividad anfitriona, que se
integra como parte de la jerarquía de vistas general de la actividad. Existen
dos maneras de agregar un fragmento al diseño de una actividad.
- DECLARAR EL FRAGMENTO EN EL ARCHIVO DE DISEÑO DE LA ACTIVIDAD
En este caso, puedes especificar propiedades de diseño para el fragmento
como si fueran una vista
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="horizontal"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <fragment android:name="com.example.news.ArticleListFragment"
            android:id="@+id/list"
            android:layout_weight="1"
            android:layout_width="0dp"
            android:layout_height="match_parent" />
    <fragment android:name="com.example.news.ArticleReaderFragment"
            android:id="@+id/viewer"
            android:layout_weight="2"
            android:layout_width="0dp"
            android:layout_height="match_parent" />
</LinearLayout>

El atributo android:name en el <fragment> especifica la clase Fragment

para crear una instancia en el diseño.
Cuando el sistema crea el diseño de esta actividad, crea una instancia
para cada fragmento especificado en el diseño y llama al método
onCreateView() para cada uno, con el objetivo de recuperar el diseño de
cada fragmento. El sistema inserta la View mostrada por el fragmento
directamente en lugar del elemento <fragment>.

Cada fragmento requiere un identificador único que el sistema puede usar

para restaurar el fragmento si se reinicia la actividad. Hay tres formas
de proporcionar un ID a un fragmento:
o Proporciona el atributo android:id con un ID único.
o Proporciona el atributo android:tag con una string única.
o Si proporcionas los dos atributos anteriores, el sistema usa el ID del
objeto View contenedor.
- O GUARDA EL FRAGMENTO DE FORMA PROGRAMÁTICA EN UN VIEWGROUP EXISTENTE
En cualquier momento mientras tu actividad se esté ejecutando, puedes
agregar fragmentos al diseño de la actividad. Solo necesitas especificar
un ViewGroup en el cual dispondrá colocar el fragmento.

4
 Para realizar transacciones de fragmentos en tu actividad se debe usar
las API de FragmentTransaction. Puedes obtener una instancia de
FragmentTransaction de tu Activity como esta:
FragmentManager fragmentManager = getFragmentManager();
FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

Luego puedes agregar un fragmento usando el método add() y especificando

el fragmento que se agregará y la vista en la que se insertará.
ExampleFragment fragment = new ExampleFragment();
fragmentTransaction.add(R.id.fragment_container, fragment);
fragmentTransaction.commit();

El primer argumento que se pasa a add() es ViewGroup, en el que se debe

colocar el fragmento especificado por ID de recurso, y el segundo
parámetro es el fragmento que quieras agregar.
Una vez que realices los cambios con FragmentTransaction, debes llamar a
commit() para que se apliquen esos cambios.