What Does Layoutinflater in Android Do

What does LayoutInflater in Android do?

When you use a custom view in a ListView you must define the row layout.
You create an xml where you place android widgets and then in the adapter's code you have to do something like this:

public MyAdapter(Context context, List<MyObject> objects) extends ArrayAdapter {
  super(context, 1, objects);
  /* We get the inflator in the constructor */
  mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
}

@Override
public View getView(int position, View convertView, ViewGroup parent) {
  View view;
  /* We inflate the xml which gives us a view */
  view = mInflater.inflate(R.layout.my_list_custom_row, parent, false);

  /* Get the item in the adapter */
  MyObject myObject = getItem(position);

  /* Get the widget with id name which is defined in the xml of the row */
  TextView name = (TextView) view.findViewById(R.id.name);

  /* Populate the row's xml with info from the item */
  name.setText(myObject.getName());

  /* Return the generated view */
  return view;
}

Read more in the official documentation.

What does LayoutInflater class do? (in Android)

What is Layoutinflater ?

LayoutInflater is a class (wrapper of some implementation or service), you can get one:

LayoutInflater li = LayoutInflater.from(context);

---

How to use Layoutinflater ?

You feed it an XML layout file. You need not give full file address, just its resource id, generated for you automatically in R class. For example, a layout file which look like:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="fill_parent"
              android:layout_height="fill_parent">

    <TextView
            android:id="@+id/text_view"
            android:layout_width="fill_parent"
            android:layout_height="fill_parent"/>

</LinearLayout>

saved as /res/layout/my_layout.xml.

You give it to LayoutInflater like:

  View v = li.inflate(R.layout.my_layout,null,false);

---

What did Layout Inflater do ?

That v is now a LinearLayout object ^{(LinearLayout extends View)} , and contains a TextView object, arranged in exact order and with all properties set, as we described in the XML above.

---

TL;DR: A LayoutInflater reads an XML in which we describe how we want a UI layout to be. It then creates actual Viewobjects for UI from that XML.

What is LayoutInflater and how do I use it properly?

What is a LayoutInflater?

LayoutInflater is a class used to create views from a layout resource (xml) file or a node of it (XmlPullParser objects).

These can be a representation of either a single view or a view hierarchy.

Creating LayoutInflater object

To inflate a view, we need a LayoutInflater object. Instead of creating new object, we use one of these methods normally to get an existing object with the context.

• LayoutInflater#from(Context context)
• Activity#getLayoutInflater()
• Context#getSystemService(Class<T> serviceClass)
• Context#getSystemService(String name)

The first one is most commonly used because of its simplicity.

Here are sample usages of the last two methods.

LayoutInflater inflater = (LayoutInflater)getSystemService(Context.LAYOUT_INFLATER_SERVICE)
LayoutInflater inflater = (LayoutInflater)getSystemService(LayoutInflater.class)

Inflating views

To inflate views, LayoutInflater#inflate() method can be used. It has four forms as listed below. One of the first two methods can be used if the source is a layout resource. Last two methods are used if the source is a layout resource node.

1. View inflate(int resource, ViewGroup root)

2. View inflate(int resource, ViewGroup root, boolean attachToRoot)

3. View inflate(XmlPullParser parser, ViewGroup root)

4. View inflate(XmlPullParser parser, ViewGroup root, boolean attachToRoot)

root: It is a ViewGroup to which the newly created view hierarchy is about to attached.

attachToRoot: The first and third methods attaches the newly created view hierarchy to the root once it is created. However if you choose manually add it by ViewGroup#addView() or attaching should be taken place at somewhere else, then you can choose the second or last method and set attachToRoot as false.
For instance, inside Fragment’s onCreateView() and when creating a view as RecyclerView’s itemView. You should set attachToRoot as false in these two places because the attaching will be done somewhere else. If we set it as true or use the first or third method in such places, it will throw an error.

java.lang.IllegalStateException: The specified child already has a parent. You must call removeView() on the child's parent first.

Using the result

If attachToRoot is true, the result will be the root view. Otherwise it will be the newly created view hierarchy.

Theoretically all these methods returns the same thing - the root view. However, to us, they are not the same. Are they?

Some common mistakes

It is seen that setting root as null even if it is known. Root can be null if attachToRoot is false. However, it should be given if possible because it is used to create the correct subclass of LayoutParams.

What does it mean to inflate a view from an xml file?

When you write an XML layout, it will be inflated by the Android OS which basically means that it will be rendered by creating view object in memory. Let's call that implicit inflation (the OS will inflate the view for you). For instance:

class Name extends Activity{
    public void onCreate(){
         // the OS will inflate the your_layout.xml
         // file and use it for this activity
         setContentView(R.layout.your_layout);
    }
}

You can also inflate views explicitly by using the LayoutInflater. In that case you have to:

1. Get an instance of the LayoutInflater
2. Specify the XML to inflate
3. Use the returned View
4. Set the content view with returned view (above)

For instance:

LayoutInflater inflater = LayoutInflater.from(YourActivity.this); // 1
View theInflatedView = inflater.inflate(R.layout.your_layout, null); // 2 and 3
setContentView(theInflatedView) // 4

Can't able to understand layout inflater?What it does? and why we use it?

You can go through the Android Official Documentation.

LayoutInflater (which coverts an XML layout file into corresponding ViewGroups and Widgets) and the way it inflates Views inside Fragment’s onCreateView() method.

LayoutInflater is a class used to instantiate layout XML file into its corresponding view objects which can be used in java programs.

Why to use Inflater in listview

What is an Inflater ?

To summarize what the LayoutInflater Documentation says... A LayoutInflater is one of the Android System Services that is responsible for taking your XML files that define a layout, and converting them into View objects. The OS then uses these view objects to draw the screen.

I always had ambiguity on why we need to use inflater in android, Why
are they used in android ListView for a custom layout ?

Typically, you don't ever need to directly use a LayoutInflater. Android does most of the layout inflation for you when you call setContentView() in the onCreate() method of your activity. So you, as the programmer, are responsible for making sure the views are inflated. Now you want to inflate views in the context of a ListView. The Adapter class can do the inflation for you if you do not want to customize each item. But if you want to customize the views shown in a list, you will have to manually inflate each view with the LayoutInflater, since there is no other existing method you can use.

What is the advantage of using Inflater ?

There is no advantage to using it. You are required to use a LayoutInflater in some shape or form to inflate your static XML layouts.

Alternatively, you could create views dynamically with java code. However, you would need to call methods to set each property for the view by hand. In my opinion, it is easier to use the XML/inflation process. In addition, Android pre-processes your XML files at build time, so this results in a faster execution time.

What does inflater.inflate() do?

You have a View defined in your xml file. E.g. you have a layout for a list row.

You want to create a View from that xml. E.g. your ListAdapter requires you to create a View for a list row in ListAdapter.getView();

So by using inflater.inflate() you create your View from your XML file.

There's also a static method View.inflate() which does the same.

When is the LayoutInflater used in Android

Basically it is needed to create (or fill) View based on XML file in runtime. For example if you need to generate views dynamically for your ListView items and that's all about it.

How does LayoutInflater work?

It basically is the term used for instantiating an xml Layout file into an object to be used in the java code. You can do this by calling setContentView(R.layout.file name minus xml extension) or by using LayoutInflater. Only after inflating can you call its child Views. This is important to know because I have seen many questions on SO in which people have an app that crashes and it turns out that they are trying to reference a view like

EditText et = (EditText) findViewById(R.id.someID);

and they haven't called setContentView() to obtain the Layout which holds that EditText which results in a NPE since the EditText doesn't actually exist until the Layout is inflated.

I'm sure you have seen the docs on it but Here they are anyway

---

Related Topics