Cómo crear un fragmento

Un fragmento representa una parte modular de la interfaz de usuario dentro de una actividad. Un fragmento tiene su propio ciclo de vida, recibe sus propios eventos de entrada, y tú puedes agregar o quitar fragmentos mientras se ejecuta la actividad que lo contiene.

En este documento, se describe cómo crear un fragmento e incluirlo en una actividad.

Cómo configurar tu entorno

Los fragmentos requieren una dependencia en la biblioteca de fragmentos de AndroidX. Para incluir esta dependencia, debes agregar el repositorio de Maven de Google al archivo settings.gradle de tu proyecto.

Groovy

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        ...
    }
}

Kotlin

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        ...
    }
}

Para incluir la biblioteca de AndroidX Fragment a tu proyecto, agrega las siguientes dependencias al archivo build.gradle de tu app:

Groovy

dependencies {
    def fragment_version = "1.8.3"

    // Java language implementation
    implementation "androidx.fragment:fragment:$fragment_version"
    // Kotlin
    implementation "androidx.fragment:fragment-ktx:$fragment_version"
}

Kotlin

dependencies {
    val fragment_version = "1.8.3"

    // Java language implementation
    implementation("androidx.fragment:fragment:$fragment_version")
    // Kotlin
    implementation("androidx.fragment:fragment-ktx:$fragment_version")
}

Cómo crear una clase de fragmento

Si deseas crear un fragmento, extiende la clase Fragment de AndroidX y anula sus métodos para insertar la lógica de tu app, de manera similar a cómo crearías una clase Activity. Para crear un fragmento mínimo que defina su propio diseño, proporciona el recurso de diseño de tu fragmento en el constructor básico, como se muestra en el siguiente ejemplo:

Kotlin

class ExampleFragment : Fragment(R.layout.example_fragment)

Java

class ExampleFragment extends Fragment {
    public ExampleFragment() {
        super(R.layout.example_fragment);
    }
}

La biblioteca de fragmentos también proporciona clases básicas de fragmentos más especializadas:

DialogFragment

Muestra un diálogo flotante. Usar esta clase a fin de crear un diálogo es una buena alternativa al uso de los métodos auxiliares de diálogo en la clase Activity, ya que los fragmentos administran automáticamente la creación y la limpieza del Dialog. Consulta Cómo mostrar diálogos con DialogFragment para obtener más información.

PreferenceFragmentCompat

Muestra una jerarquía de objetos Preference en forma de lista. Puedes usar PreferenceFragmentCompat a fin de crear una pantalla de configuración para tu app.

Cómo agregar un fragmento a una actividad

En general, tu fragmento debe estar incorporado dentro de una FragmentActivity de AndroidX para contribuir con una parte de la IU al diseño de esa actividad. FragmentActivity es la clase básica de AppCompatActivity, de modo que si ya creas una subclase de AppCompatActivity a fin de proporcionar retrocompatibilidad en tu app, no es necesario que cambies la clase básica de tu actividad.

Puedes agregar tu fragmento a la jerarquía de vistas de la actividad; para ello, define el fragmento en el archivo de diseño de tu actividad, o bien define un contenedor de fragmentos en el archivo de diseño de la actividad y, luego, agrega el fragmento de forma programática desde tu actividad. En cualquier caso, debes agregar una FragmentContainerView que defina la ubicación donde se debería colocar el fragmento dentro de la jerarquía de vistas de la actividad. Te recomendamos que siempre uses una FragmentContainerView como contenedor de fragmentos, ya que FragmentContainerView incluye correcciones específicas para fragmentos que no proporcionan otros grupos de vistas, como FrameLayout.

Cómo agregar un fragmento a través de XML

Para agregar un fragmento de forma declarativa al XML de diseño de tu actividad, usa un elemento FragmentContainerView.

A continuación, puedes ver un ejemplo de diseño de actividad que contiene un único FragmentContainerView:

<!-- res/layout/example_activity.xml -->
<androidx.fragment.app.FragmentContainerView
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/fragment_container_view"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:name="com.example.ExampleFragment" />

El atributo android:name especifica el nombre de clase del Fragment cuya instancia se creará. Cuando el diseño de la actividad aumenta, se crea una instancia del fragmento especificado, se llama a onInflate() en el fragmento cuya instancia se acaba de crear y se crea una FragmentTransaction para agregar el fragmento al FragmentManager.

Nota: Puedes usar el atributo class en lugar de android:name como una forma alternativa de especificar el Fragment cuya instancia se creará.

Cómo agregar un fragmento de manera programática

Para agregar un fragmento de manera programática al diseño de tu actividad, debes incluir una FragmentContainerView que funcione como un contenedor de fragmentos, como se muestra en el siguiente ejemplo:

<!-- res/layout/example_activity.xml -->
<androidx.fragment.app.FragmentContainerView
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/fragment_container_view"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

A diferencia del enfoque XML, el atributo android:name no se usa en esta FragmentContainerView, por lo que no se crea automáticamente una instancia de ningún fragmento específico. En su lugar, se usa una FragmentTransaction a fin de crear una instancia de un fragmento y agregarlo al diseño de la actividad.

Mientras tu actividad se está ejecutando, puedes realizar transacciones de fragmentos, como agregar, quitar o reemplazar un fragmento. En tu FragmentActivity, puedes obtener una instancia del FragmentManager, que se puede usar para crear una FragmentTransaction. Luego, puedes crear una instancia de tu fragmento en el método onCreate() de tu actividad usando FragmentTransaction.add() y pasando el ID de ViewGroup del contenedor de tu diseño y la clase del fragmento que quieras agregar. A continuación, confirma la transacción, como se muestra en el siguiente ejemplo:

Kotlin

class ExampleActivity : AppCompatActivity(R.layout.example_activity) {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        if (savedInstanceState == null) {
            supportFragmentManager.commit {
                setReorderingAllowed(true)
                add<ExampleFragment>(R.id.fragment_container_view)
            }
        }
    }
}

Java

public class ExampleActivity extends AppCompatActivity {
    public ExampleActivity() {
        super(R.layout.example_activity);
    }
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (savedInstanceState == null) {
            getSupportFragmentManager().beginTransaction()
                .setReorderingAllowed(true)
                .add(R.id.fragment_container_view, ExampleFragment.class, null)
                .commit();
        }
    }
}

Nota: Siempre debes usar setReorderingAllowed(true) cuando realices una FragmentTransaction. Para obtener más información sobre las transacciones reordenadas, consulta Transacciones de fragmentos.

En el ejemplo anterior, ten en cuenta que la transacción de fragmentos solo se crea cuando savedInstanceState es null. Esto garantiza que el fragmento se agregue solo una vez, cuando se crea la actividad por primera vez. Cuando se produce un cambio de configuración y se vuelve a crear la actividad, savedInstanceState ya no es null, y no es necesario agregar el fragmento por segunda vez, ya que este se restablecerá automáticamente desde el savedInstanceState.

Si tu fragmento requiere algunos datos iniciales, puedes pasarle argumentos proporcionando un Bundle en la llamada a FragmentTransaction.add(), como se muestra a continuación:

Kotlin

class ExampleActivity : AppCompatActivity(R.layout.example_activity) {
      override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        if (savedInstanceState == null) {
            val bundle = bundleOf("some_int" to 0)
            supportFragmentManager.commit {
                setReorderingAllowed(true)
                add<ExampleFragment>(R.id.fragment_container_view, args = bundle)
            }
        }
    }
}

Java

public class ExampleActivity extends AppCompatActivity {
    public ExampleActivity() {
        super(R.layout.example_activity);
    }
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (savedInstanceState == null) {
            Bundle bundle = new Bundle();
            bundle.putInt("some_int", 0);

            getSupportFragmentManager().beginTransaction()
                .setReorderingAllowed(true)
                .add(R.id.fragment_container_view, ExampleFragment.class, bundle)
                .commit();
        }
    }
}

Los argumentos Bundle se pueden recuperar desde tu fragmento llamando a requireArguments(), y se pueden usar los métodos get Bundle apropiados para recuperar cada argumento.

Kotlin

class ExampleFragment : Fragment(R.layout.example_fragment) {
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        val someInt = requireArguments().getInt("some_int")
        ...
    }
}

Java

class ExampleFragment extends Fragment {
    public ExampleFragment() {
        super(R.layout.example_fragment);
    }

    @Override
    public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
        int someInt = requireArguments().getInt("some_int");
        ...
    }
}

Consulta también

Las transacciones de fragmentos y el FragmentManager se abordan con más detalle en la guía para administradores de fragmentos.