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 delDialog
. Consulta Cómo mostrar diálogos conDialogFragment
para obtener más información. PreferenceFragmentCompat
- Muestra una jerarquía de objetos
Preference
en forma de lista. Puedes usarPreferenceFragmentCompat
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
.
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(); } } }
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.