---
title: inflate() en Android – Inflar y adjuntar Views
url: https://jarroba.com/inflate-en-android-inflar-y-adjuntar-views/
author: Ramón Invarato
date: 2014-05-10
modified: 2026-10-23
language: es
license: CC BY-NC-SA 3.0 (https://creativecommons.org/licenses/by-nc-sa/3.0/) — attribution: "inflate() en Android – Inflar y adjuntar Views", Ramón Invarato, jarroba.com
categories: Aplicaciones Móviles
tags: Android, Inflate, LayoutInflater, Views, ViewsGroup
---
# inflate() en Android – Inflar y adjuntar Views
> Qué hace inflate() de LayoutInflater en Android: inflar frente a adjuntar Views, sus tres parámetros y su uso en Fragment, Dialog, Menu y Adapter.
Cuánta importancia y qué de misterio rodean al método **inflate()**, que pertenece al objeto de la clase**LayoutInflater**. Método que se utiliza para construir y añadir las Views a los diseños de:
- Fragment
- Menu o ActionBar
- Adapter
- Dialogs
- Para añadir una View a otra en cuando precisemos
- Entre otros muchos casos
- ¿Y Activity no lo utiliza? Claro que lo usa, pero Android nos lo facilita de otra manera. En vez del método inflate() -que es un inflado implícito- lo han llamado **setContentView()** -en un inflado explícito.
Suficiente argumento que hacen a este método de los más importantes en Android, por lo que requiere un artículo dedicado.
Antes de empezar, después de mucho tiempo buscando una explicación clara que parece no existir por ningún lado o un consenso de qué es lo que realmente hace el método inflate(), he de indicar que esta explicación es mi visión (después de años trabajando con ello, de haber investigado y deducido una explicación razonable). No es por criticar, pero casi ni los propios de Google parece que sepan lo que hace; debido a la falta de explicaciones en la documentación, y de darlo por dado o con una pobre descripción en las apariciones de las que tengo constancia. Sin embargo, aquí lo voy a explicar con detalle después de mucho trabajo de investigación y deducción. Ahora sí, comencemos.
Una cosa que hay que tener muy clara del método inflate() es –lo que lleva demasiado a confusión- que**inflar NO se refiere a insertar unas Views en un ViewGroup, sino a poner los atributos de diseño del que podría ser el ViewGroup padre**. Aquí seguramente surja la duda ¿Pero si cuando inflo se añaden las Views al ViewGroup? Y es que inflate() aparte de inflar, también tiene la opción de adjuntar (adjuntar es un valor añadido a la función inflate(), pero para nada adjuntar se refiere a inflar).
Aclarémoslo en un ejemplo, en el que vamos a tener la siguiente estructura de carpetas (el código de este ejemplo es un proyecto completo funcional, puedes crear un nuevo proyecto y probarlo):
[](https://jarroba.com/wp-content/uploads/2014/05/Estructura-proyecto-Inflate-de-Android-www.jarroba.com_.png)
Supongamos que tenemos un diseño que dibuja un texto como el siguiente diseño (Aquí no pondré capturas de pantalla del emulador de Android, sino abstracciones de lo que el usuario verá, con motivo de poder tomar lo importante de las imágenes):
[](https://jarroba.com/wp-content/uploads/2014/05/Layout-Abstracto-para-Ejemplo-Infalte-Android-1-www.jarroba.png)
Su fichero de diseño correspondiente en res/layout/**adjuntar_en_un_viewgroup.xml**:
```xml
```
Y lo que queremos es adjuntar el diseño anterior al RelativeLayout de este otro diseño:
[](https://jarroba.com/wp-content/uploads/2014/05/Layout-Abstracto-para-Ejemplo-Infalte-Android-2-www.jarroba.png)
Con el fichero res/layout/**fichero_de_disenio.xml**:
```xml
```
Como queremos es que la estructura del primer diseño se adjunte al ViewGroup del segundo diseño (se puede decir que es algo parecido a lo que se hace con las Views Merge e Include, pero en dinámico, desde Java). Para ello obtendremos el LayoutInflater del Context de la Activity y utilizaremos su método inflate() de esta manera:
```java
public class MainActivity extends Activity {
@Override
protectedvoid onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.fichero_de_disenio);
RelativeLayout contenedor = (RelativeLayout) findViewById(R.id.RelativeLayout_contenedor);
LayoutInflater inflater = LayoutInflater.from(this);
View laViewInflada = inflater.inflate(R.layout.adjuntar_en_un_viewgroup, contenedor, true);
}
}
```
Llegó el momento de tener muy clara la diferencia entre inflar y adjuntar:
#### **Inflar**
Por contra a la intuición, NO infla al ViewGroup contenedor con las Views que le pasamos (el fichero de diseño XML que queremos adjuntar al contenedor). **Lo que se infla es la nueva jerarquía de Views** (el diseño) que les pasamos con los atributos de diseño del padre (con los atributos del ViewGroup contenedor). Es decir, le decimos a las nuevas Views el tamaño que tienen que tener para que quepan en el padre, la gravedad, entre otros (dependerán del ViewGroup que usemos para inflar: LinearLayout, FrameLayout, Fragment, etc). Es por lo que se deduce que no dibuje en pantalla lo inflado y por tanto no pueda recibir eventos.
[](https://jarroba.com/wp-content/uploads/2014/05/Inflar-Views-con-Inflate-de-Android-www.jarroba.com_.png)
En el ejemplo, le pasaríamos al método inflate() el fichero de diseño de “adjuntar_en_un_viewgroup.xml” y el RelativeLayout del que será el contenedor (fíjate en los parámetros primero y segundo que se le pasa al método inflate() ). De este modo, se infla la estructura de views del fichero con los parámetros del contenedor que se le pasan del que será el padre y contenedor.
#### **Adjuntar**
Añade el nuevo diseño que se infló a la ViewGroup y ahora sí lo muestra en pantalla y podrá recibir eventos. El tercer parámetro del método inflate() indica si queremos que lo adjunte inmediatamente o no (por ejemplo, en Fragment no interesa, pues lo hará el propio Fragment en otro momento, por eso lo retornamos el objeto LayoutInflater en el método onCreateView() ).
[](https://jarroba.com/wp-content/uploads/2014/05/Adjuntar-Views-con-Inflate-de-Android-www.jarroba.png)
Volviendo al ejemplo. El tercer parámetro del método inflate() indica si queremos que la estructura que antes hinchamos se adjunte al contenedor (true) o no (false).
Por lo que después de adjuntar (que no de inflar), a nivel interno nos habrá generado la siguiente estructura de diseño que el usuario podrá ver y responderá a eventos:
[](https://jarroba.com/wp-content/uploads/2014/05/Layout-Abstracto-para-Ejemplo-Infalte-Android-3-www.jarroba.png)
Aunque no se ve, a nivel interno Android realizará la siguiente estructura de diseño XML:
```xml
```
## Parámetros de Inflate()
Ya hemos visto cómo funciona. Ahora definimos los tres parámetros que solicita el método inflate() (hay otras sobrecargas de este método, pero explicamos el de tres parámetros que se suele utilizar más y es el que se recomienda):
1. **Recurso de diseño (resource)**: La referencia de R del diseño que queramos inflar.
2. **Contenedor raíz (root de tipo ViewGroup)**: El contenedor cuyos parámetros de su diseño (todos sus “android:layout_xxxxx”) inflarán al anterior recurso de diseño indicado en el parámetro anterior. Y si el tercer parámetro lo permite con un true, se adjuntará el diseño anterior a este contenedor. Puede interesar pasar aquí un “null” si no queremos que se infle con ningún parámetro de ningún padre.
3. **Si adjuntar al contenedor que será la raíz (boolean):**Si es “true” indica si el diseño (primer parámetro) que es inflado por el ViewGroup contenedor (segundo parámetro) debe, además, adjuntar su jerarquía de Views a este contenedor. A veces interesa poner este parámetro a “false” porque nos interese solo inflar, debido a que se adjuntará lo inflado en otro momento diferente posterior (por eso devuelve una View inflada el método inflate() ); el motivo suele ser que no se cree dos veces el mismo conjunto de Views (Como en el método onCreateView() de Fragment, donde se encarga el Fragment de adjuntarlo cuando deba; si lo ponemos a “true” nos aparecerá dos veces lo mismo)
## Algunos sitios más donde utilizar inflate()
Hemos visto en el anterior ejemplo como aplicar inflate() directamente sobre una ViewGroup en cualquier momento. Ahora veamos unos ejemplos más:
#### Fragment
Lo utilizamos en la parte del ciclo de vida onCreateView() del Fragment. Este mismo método nos facilita un objeto de tipo LayoutInflater que podemos usar y el ViewGroup donde debe encajar. El inflate() nos devolverá la View que debemos retornar ([Caso de uso completo y ejemplo en el artículo sobre Fragments](https://jarroba.com/programar-fragments-fragmentos-en-android/)).
```java
public class MiFragment extends Fragment {
public MiFragment() {
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
View rootView = inflater.inflate(R.layout.adjuntar_en_un_viewgroup, container, false);
return rootView;
}
}
```
#### Dialog
De manera parecida los cuadros emergentes de diálogo también usan este método inflate(). Aquí podemos obtener el objeto de tipo LayoutInflater desde el mismo Context de la Activity que lo vaya a incorporar.
```java
public class MiCuadroDeDialogo extends DialogFragment {
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
View v = getActivity().getLayoutInflater().inflate(R.layout.mi_layout, null);
builder.setView(v);
return builder.create();
}
}
```
#### Menu o ActionBar
Aquí se emplea en el método onCreateOptionsMenu() para llenar de opciones el Menu o el ActionBar.
```java
public class MainActivity extends Activity {
@Override
protected void onCreate(BundlesavedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.elementos_menu_adjuntar_en_un_viewgroup, menu);
return true;
}
}
```
#### Adapter
Para un adaptador podremos obtener el LayoutInflater del servicio del sistema y luego utilizar inflate() (Tienes un [ejemplo completo en el artículo sobre listados](https://jarroba.com/listview-o-listado-en-android/)):
```java
public class MiAdaptador extends BaseAdapter{
private ArrayList entradas;
private Context contexto;
public Lista_adaptador(Context contexto, ArrayList entradas){
super();
this.contexto = contexto;
this.entradas = entradas;
}
@Override
public
View getView(int posicion,View view,ViewGroup pariente){
if(view == null){
LayoutInflater vi =(LayoutInflater) contexto.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
view = vi.inflate(R.layout.adjuntar_en_un_viewgroup, null);
}
return view;
}
@Override
public int getCount(){
return entradas.size();
}
@Override
public Object getItem(int posicion){
return entradas.get(posicion);
}
@Override
public long getItemId(int posicion){
return posicion;
}
}
```
Puede que me haya explayado un poco. Es necesario entender este concepto para no copiar y pegar código sin saber qué hace. Además, este método seguro que lo utilizarás en más de una ocasión 🙂
## Bibliografía
Como indiqué al principio del artículo, debido a la poca información existente sobre el tema, casi todo es de experiencia, recopilación y creación personal. No puedo quitar el prestigio y la merecida mención en las webs donde me inspiré:
- [Android Mobile App Developer Tools (Android Developers)](http://developer.android.com/)
- [http://stackoverflow.com/](http://stackoverflow.com/)
- [http://www.doubleencore.com/2013/05/layout-inflation-as-intended/](http://www.doubleencore.com/2013/05/layout-inflation-as-intended/)