blocks|key|214855|text|定义父对象时，attachToRoot确定是否希望充气装置将其实际附加到父对象。在某些情况下，这会导致问题，比如在ListAdapter中，它会导致异常，因为list试图将视图添加到列表中，但它说它已经附加了。在其他情况下，您只是自己膨胀视图以添加到活动中，这可能会很方便，并为您节省一行代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|214856|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

When you define the parent the attachToRoot determines whether you want the inflater to actually attach it to the parent or not. In some cases this causes problems, like in a ListAdapter it will cause an exception because the list tries to add the view to the list but it says it's already attached. In other cased where you're just inflating the view yourself to add to an Activity it could be handy and save you a line of code.

blocks|key|212989|text|如果设置为true，则当您的布局膨胀时，它将作为子级自动添加到第二个参数中指定的ViewGroup的视图层次结构中。例如，如果根参数是一个LinearLayout，那么您的膨胀视图将自动添加为该视图的子视图。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|212990|如果设置为false，那么您的布局将被放大，但不会附加到任何其他布局(因此它将不会被绘制，接收触摸事件等)。|212991|entityMap^0|1X|C|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

If set to true then when your layout is inflated it will be automatically added to the view hierarchy of the ViewGroup specified in the 2nd parameter as a child. For example if the root parameter was a <code>LinearLayout</code> then your inflated view will be automatically added as a child of that view.

If it is set to false then your layout will be inflated but won't be attached to any other layout (so it won't be drawn, receive touch events etc).

blocks|key|210431|text|文档和前面的两个答案应该足够了，只是我的一些想法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|210432|inflate方法用于膨胀布局文件。对于这些膨胀的布局，您必须将它们直接附加到父ViewGroup，或者只是从该布局文件膨胀视图层次结构，并在正常视图层次结构之外使用它。|offset|length|style|CODE|210433|在第一种情况下，attachToRoot参数必须设置为true(或者更简单地使用接受布局文件和父根ViewGroup(非null)的inflate方法)。在本例中，返回的View只是方法中传递的ViewGroup，膨胀的视图层次结构将添加到该ViewGroup中。|210434|对于第二个选项，返回的View是布局文件中的根ViewGroup。如果你还记得我们上次讨论的include-merge+pair+question，这是merge限制的原因之一(当一个以merge为根的布局文件被膨胀时，你必须提供一个父文件，并且attachedToRoot必须设置为true)。如果您有一个以merge标记为根的布局文件，并且attachedToRoot被设置为false，那么inflate方法将不会返回任何内容，因为merge没有对应的内容。此外，正如文档所述，将attachToRoot设置为false的inflate版本很重要，因为您可以使用来自父级的正确LayoutParams创建视图层次结构。这在某些情况下很重要，最值得注意的是AdapterView的子类，它是ViewGroup的子类，不支持addView()方法集。我相信您还记得在getView()方法中使用过下面这一行：|210435|convertView+=+inflater.inflate(R.layout.row_layout,+parent,+false);|code-block|syntax|javascript|210436|这一行确保膨胀的R.layout.row_layout文件在其根LayoutParams上具有来自AdapterView子类的正确ViewGroup。如果您不这样做，如果根是一个RelativeLayout，那么布局文件可能会出现一些问题。TableLayout/TableRow还有一些特殊而重要的LayoutParams，您应该确保其中的视图具有正确的LayoutParams。|210437|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/q/12518446/403455^0|0|0|7|14|9|0|8|C|R|4|1D|9|1O|4|1U|7|2D|4|2P|9|3D|9|0|B|4|N|9|1A|D|24|5|2L|5|3F|E|3Y|4|4B|5|4S|E|5A|5|5I|7|63|5|6R|C|76|5|7C|7|83|C|96|B|9N|9|A3|9|AO|9|1A|R|0|0|0|8|J|W|C|1D|B|1T|9|2H|E|3C|K|46|C|4Y|C|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@$D|12|E|13|F|G]|$D|14|E|15|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|16|8|@$D|17|E|18|F|G]|$D|19|E|1A|F|G]|$D|1B|E|1C|F|G]|$D|1D|E|1E|F|G]|$D|1F|E|1G|F|G]|$D|1H|E|1I|F|G]|$D|1J|E|1K|F|G]|$D|1L|E|1M|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1N|8|@$D|1O|E|1P|F|G]|$D|1Q|E|1R|F|G]|$D|1S|E|1T|F|G]|$D|1U|E|1V|F|G]|$D|1W|E|1X|F|G]|$D|1Y|E|1Z|F|G]|$D|20|E|21|F|G]|$D|22|E|23|F|G]|$D|24|E|25|F|G]|$D|26|E|27|F|G]|$D|28|E|29|F|G]|$D|2A|E|2B|F|G]|$D|2C|E|2D|F|G]|$D|2E|E|2F|F|G]|$D|2G|E|2H|F|G]|$D|2I|E|2J|F|G]|$D|2K|E|2L|F|G]|$D|2M|E|2N|F|G]|$D|2O|E|2P|F|G]|$D|2Q|E|2R|F|G]]|9|@$D|2S|E|2T|1|2U]]|A|$]]|$1|L|3|M|5|N|7|2V|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|2W|8|@$D|2X|E|2Y|F|G]|$D|2Z|E|30|F|G]|$D|31|E|32|F|G]|$D|33|E|34|F|G]|$D|35|E|36|F|G]|$D|37|E|38|F|G]|$D|39|E|3A|F|G]|$D|3B|E|3C|F|G]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|3D|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

The documentation and the two previous answers should be enough, just some thoughts from me. 

The <code>inflate</code> method is used to inflate layout files. With those inflated layouts you have to possibility to attach them directly to a parent <code>ViewGroup</code> or just inflate the view hierarchy from that layout file and work with it outside of the normal view hierarchy. 

In the first case the <code>attachToRoot</code> parameter will have to be set to <code>true</code>(or much simple use the <code>inflate</code> method that takes a layout file and a parent root <code>ViewGroup</code>(non <code>null</code>)). In this case the <code>View</code> returned is simply the <code>ViewGroup</code> that was passed in the method, the <code>ViewGroup</code> to which the inflated view hierarchy will be added.

For the second option the returned <code>View</code> is the root <code>ViewGroup</code> from the layout file. If you remember our last discussion from the <a href="https://stackoverflow.com/q/12518446/403455"><code>include-merge</code> pair question</a> this is one of the reasons for the <code>merge</code>'s limitation(when a layout file with <code>merge</code> as root is inflated, you must supply a parent and <code>attachedToRoot</code> must be set to <code>true</code>). If you had a layout file with the root a <code>merge</code> tag and <code>attachedToRoot</code> was set to <code>false</code> then the <code>inflate</code> method will have nothing to return as <code>merge</code> doesn't have an equivalent.
Also, as the documentation says, the <code>inflate</code> version with <code>attachToRoot</code> set to <code>false</code> is important because you can create the view hierarchy with the correct <code>LayoutParams</code> from the parent. This is important in some cases, most notable with the children of <code>AdapterView</code>, a subclass of <code>ViewGroup</code>, for which the <code>addView()</code> methods set is not supported. I'm sure you recall using this line in the <code>getView()</code> method:

<pre><code>convertView = inflater.inflate(R.layout.row_layout, parent, false);
</code></pre>

This line ensures that the inflated <code>R.layout.row_layout</code> file has the correct <code>LayoutParams</code> from the <code>AdapterView</code> subclass set on its root <code>ViewGroup</code>. If you wouldn't be doing this you could have some problems with the layout file if the root was a <code>RelativeLayout</code>. The <code>TableLayout/TableRow</code> also have some special and important <code>LayoutParams</code> and you should make sure the views in them have the correct <code>LayoutParams</code>.

blocks|key|213476|text|在回复中似乎有很多文本，但没有代码，这就是为什么我决定用一个代码示例来重新提出这个老问题，在人们提到的几个回复中：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|213477|213478|如果设置为true，则当您的布局膨胀时，它将作为子级自动添加到第二个参数中指定的ViewGroup的视图层次结构中。|blockquote|213479|213480|213481|这在代码中的实际含义(大多数程序员都理解的)是：|213482|public+class+MyCustomLayout+extends+LinearLayout+{
++++public+MyCustomLayout(Context+context)+{
++++++++super(context);
++++++++//+Inflate+the+view+from+the+layout+resource+and+pass+it+as+child+of+mine+(Notice+I'm+a+LinearLayout+class).

++++++++LayoutInflater.from(context).inflate(R.layout.child_view,+this,+true);
++++}
}|code-block|syntax|javascript|213483|请注意，前面的代码将布局参数添加为MyCustomLayout的子级，因为attachToRoot参数为true，并以完全相同的方式分配父级的布局参数，就像我以编程方式使用addView一样，或者像我在xml中这样做：|offset|length|style|CODE|213484|213485|+<查看...+/>...|213486|213487|213488|以下代码解释了将attachRoot作为false传递时的场景|213489|LinearLayout+linearLayout+=+new+LinearLayout(context);
linearLayout.setLayoutParams(new+LayoutParams(
++++LayoutParams.MATCH_PARENT,+LayoutParams.WRAP_CONTENT));
linearLayout.setOrientation(LinearLayout.VERTICAL);
++++//+Create+a+stand-alone+view
View+myView+=+LayoutInflater.from(context)
++++.inflate(R.layout.ownRootView,+null,+false);
linearLayout.addView(myView);|213490|在前面的代码中，您指定希望myView成为它自己的根对象，并且不将其附加到任何父对象，后来我们将其添加为LinearLayout的一部分，但在一段时间内，它是一个独立(无父)视图。|213491|同样的事情也发生在片段上，你可以将它们添加到已经存在的组中，并成为其中的一部分，或者只是传递参数：|213492|213493|+inflater.inflate(R.layout.fragment，null，false)；|213494|213495|213496|来指定它将成为它自己的根。|213497|entityMap^0|0|0|0|0|0|0|0|H|E|11|C|1G|4|2E|7|0|0|0|0|0|8|A|K|5|0|0|D|6|1G|C|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1I|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1L|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1M|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1N|8|@$Q|1O|R|1P|S|T]|$Q|1Q|R|1R|S|T]|$Q|1S|R|1T|S|T]|$Q|1U|R|1V|S|T]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1W|8|@]|9|@]|A|$]]|$1|V|3|W|5|E|7|1X|8|@]|9|@]|A|$]]|$1|X|3|-4|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|20|8|@$Q|21|R|22|S|T]|$Q|23|R|24|S|T]]|9|@]|A|$]]|$1|11|3|12|5|L|7|25|8|@]|9|@]|A|$M|N]]|$1|13|3|14|5|6|7|26|8|@$Q|27|R|28|S|T]|$Q|29|R|2A|S|T]]|9|@]|A|$]]|$1|15|3|16|5|6|7|2B|8|@]|9|@]|A|$]]|$1|17|3|-4|5|6|7|2C|8|@]|9|@]|A|$]]|$1|18|3|19|5|E|7|2D|8|@]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|2E|8|@]|9|@]|A|$]]|$1|1B|3|-4|5|6|7|2F|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|2G|8|@]|9|@]|A|$]]|$1|1E|3|-4|5|6|7|2H|8|@]|9|@]|A|$]]]|1F|$]]

Seems like a lot of text in the responses but no code, that's why I decided to revive this old question with a code example, in several responses people mentioned:

<blockquote>
 If set to true then when your layout is inflated it will be automatically added to the view hierarchy of the ViewGroup specified in the 2nd parameter as a child.
</blockquote>

What that actually means in code(what most programmers understand) is:

<pre><code>public class MyCustomLayout extends LinearLayout {
 public MyCustomLayout(Context context) {
 super(context);
 // Inflate the view from the layout resource and pass it as child of mine (Notice I'm a LinearLayout class).

 LayoutInflater.from(context).inflate(R.layout.child_view, this, true);
 }
}
</code></pre>

Notice that previous code is adding the layout <code>R.layout.child_view</code> as child of <code>MyCustomLayout</code> because of <code>attachToRoot</code> param is <code>true</code> and assigns the layout params of the parent exactly in the same way as if I would be using <code>addView</code> programmatically, or as if I did this in xml:

<blockquote>
<pre><code>&lt;LinearLayout&gt;
 &lt;View.../&gt;
 ...
&lt;/LinearLayout&gt;
</code></pre>
</blockquote>

The following code explains the scenario when passing <code>attachRoot</code> as <code>false</code>:

<pre><code>LinearLayout linearLayout = new LinearLayout(context);
linearLayout.setLayoutParams(new LayoutParams(
 LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT));
linearLayout.setOrientation(LinearLayout.VERTICAL);
 // Create a stand-alone view
View myView = LayoutInflater.from(context)
 .inflate(R.layout.ownRootView, null, false);
linearLayout.addView(myView);
</code></pre>

In the previous code you specify that you wanted <code>myView</code> to be it's own root object and do not attach it to any parent, later on we added it as part of the <code>LinearLayout</code> but for a moment it was a stand-alone (no parent) view.

Same thing happens with Fragments, you could add them to an already existing group and be part of it, or just pass the parameters:

<blockquote>
 inflater.inflate(R.layout.fragment, null, false);
</blockquote>

To specify that it will be it's own root.

blocks|key|3069041|text|我自己也不清楚inflate方法中attachToRoot的真正目的是什么。经过对UI的研究，我终于得到了答案：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3069042|父级：|BOLD|3069043|在本例中，是您想要使用findViewById()膨胀的视图对象周围的小部件/布局。|3069044|attachToRoot:|3069045|将视图附加到其父视图(包括它们在父层次中)，因此视图接收到的任何触摸事件也将传输到父视图。如果设置为false，则它们不会被添加为父对象的直接子对象，并且父对象不会从视图接收任何触摸事件。|3069046|希望这能澄清你的困惑|3069047|entityMap^0|7|7|H|C|0|0|3|0|0|0|D|0|O|L|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|H]]|D|@]|E|$]]|$1|I|3|J|5|6|7|10|8|@]|D|@]|E|$]]|$1|K|3|L|5|6|7|11|8|@$9|12|A|13|B|H]]|D|@]|E|$]]|$1|M|3|N|5|6|7|14|8|@$9|15|A|16|B|H]]|D|@]|E|$]]|$1|O|3|P|5|6|7|17|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|R|$]]

I myself was also confused about what was the real purpose of <code>attachToRoot</code> in <code>inflate</code> method. After a bit of UI study, I finally got the answer:

parent: 

in this case is the widget/layout that is surrounding the view objects that you want to inflate using findViewById().

attachToRoot: 

attaches the views to their parent (includes them in the parent hierarchy), so any touch event that the views recieve will also be transfered to parent view. Now it's upto the parent whether it wants to entertain those events or ignore them. if set to false, they are not added as direct children of the parent and the parent doesn't recieve any touch events from the views.

Hope this clears the confusion

blocks|key|3069063|text|attachToRoot设置为true意味着inflatedView将被添加到父视图的层次结构中。因此，用户可能“看到”并感测触摸事件(或任何其他UI操作)。否则，它是刚刚创建的，没有被添加到任何视图层次结构中，因此无法看到或处理触摸事件。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3069064|对于刚接触安卓系统的iOS开发人员来说，attachToRoot设置为true意味着你需要调用这个方法：|3069065|[parent+addSubview:inflatedView];|code-block|syntax|javascript|3069066|如果继续下去，您可能会问:如果我将attachToRoot设置为false，为什么要传递父视图？这是因为XML树中的根元素需要父视图来计算一些LayoutParams+(如match+parent)。|3069067|entityMap^0|0|C|M|C|0|K|C|0|0|H|C|W|5|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|P|$]]

<code>attachToRoot</code> set to true means the <code>inflatedView</code> will be added to the parent view's hierarchy. Thus can possibly be "seen" and sense touch events (or any other UI operations) by users. Otherwise, it is just been created, not been added to any view hierarchy and thus cannot be seen or handle touch events.

For iOS developers new to Android, <code>attachToRoot</code> set to true means you call this method:

<pre><code>[parent addSubview:inflatedView];
</code></pre>

If going further you might ask: Why should I pass parent view if I set <code>attachToRoot</code> to <code>false</code>? It is because the root element in your XML tree needs the parent view to calculate some LayoutParams (like match parent).

blocks|key|213512|text|由于inflate()方法的文档，在这个主题上有很多混淆。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|213513|通常，如果attachToRoot设置为true，则在该时刻，第一个参数中指定的布局文件将被膨胀并附加到第二个参数中指定的ViewGroup。当attachToRoot为false时，来自第一个参数的布局文件将被放大并作为视图返回，并且任何视图附件都会在其他时间发生。|213514|除非您看到很多示例，否则这可能没有多大意义。当在片段的onCreateView方法内调用LayoutInflater.inflate()时，您可能希望为attachToRoot传入false，因为与该片段相关联的活动实际上负责添加该片段的视图。如果您要手动扩展视图并在稍后的某个时间点将其添加到另一个视图中，例如使用addView()方法，您将希望为attachToRoot传递false，因为附件是在稍后的时间点出现的。|213515|你可以在我写的一篇关于这个主题的博客文章中读到关于对话框和自定义视图的其他几个独特的例子。|213516|https://www.bignerdranch.com/blog/understanding-androids-layoutinflater-inflate/|offset|length|213517|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|0|28|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|V|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|W|8|@]|9|@$J|X|K|Y|1|Z]]|A|$]]|$1|L|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|I]]]]

There is a lot of confusion on this topic due to the documentation for the inflate() method.

In general, if attachToRoot is set to true, then the layout file specified in the first parameter is inflated and attached to the ViewGroup specified in the second parameter at that moment in time. When attachToRoot is false, the layout file from the first parameter is inflated and returned as a View and any View attachment happens at some other time.

This probably doesn't mean much unless you see a lot of examples. When calling LayoutInflater.inflate() inside of the onCreateView method of a Fragment, you will want to pass in false for attachToRoot because the Activity associated with that Fragment is actually responsible for adding that Fragment's view. If you are manually inflating and adding a View to another View at some later point in time, such as with the addView() method, you will want to pass in false for attachToRoot because the attachment comes at a later point in time.

You can read about several other unique examples concerning Dialogs and custom Views on a blog post I wrote about this very topic.

<a href="https://www.bignerdranch.com/blog/understanding-androids-layoutinflater-inflate/" rel="noreferrer">https://www.bignerdranch.com/blog/understanding-androids-layoutinflater-inflate/</a>

blocks|key|2855715|text|例如，我们有一个ImageView、一个LinearLayout和一个RelativeLayout。LinearLayout是RelativeLayout的子类。视图层次结构将是。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2855716|RelativeLayout
+++++++++++------->LinearLayout|code-block|syntax|javascript|2855717|我们有一个单独的ImageView布局文件|2855718|image_view_layout.xml|BOLD|2855719|附加到根目录的：|2855720|//here+container+is+the+LinearLayout

++++View+v+=+Inflater.Inflate(R.layout.image_view_layout,container,true);|2855721|这里的v包含容器布局的引用，即|2855722|如果你想设置参数，如LinearLayout.and+of+ImageView，你必须通过引用父元素来找到它，即v的view.findById()|ordered-list-item|2855723|Parent将是FrameLayout.|2855724|LayoutParams+be+of+FrameLayout.|2855725|2855726|未连接到根目录：|2855727|//here+container+is+the+LinearLayout
++++View+v+=+Inflater.Inflate(R.layout.image_view_layout,container,false);|2855728|2855729|这里的v包含了没有引用的容器布局，但是直接引用了膨胀的ImageView，所以你可以像view.setImageResource(R.drawable.np);一样设置它的参数，而不像findViewById那样引用。但是指定了容器，以便容器获得容器的引用，所以您可以说，容器的引用只是为了容器，没有其他的东西。ImageView将是LayoutParams，在特定情况下，LayoutParams将是|2855730|。|2855731|2855732|entityMap^0|8|9|K|C|Z|E|0|0|0|0|L|0|7|1|0|0|0|1M|F|0|0|0|0|0|8|0|0|0|17|11|2K|C|0|0|0^^$0|@$1|2|3|4|5|6|7|1F|8|@$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1M|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1N|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|1O|8|@$9|1P|A|1Q|B|O]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1R|8|@$9|1S|A|1T|B|O]]|D|@]|E|$]]|$1|R|3|S|5|H|7|1U|8|@]|D|@]|E|$I|J]]|$1|T|3|U|5|6|7|1V|8|@]|D|@]|E|$]]|$1|V|3|W|5|X|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|X|7|1Z|8|@]|D|@]|E|$]]|$1|10|3|11|5|X|7|20|8|@]|D|@]|E|$]]|$1|12|3|-4|5|6|7|21|8|@]|D|@]|E|$]]|$1|13|3|14|5|6|7|22|8|@$9|23|A|24|B|O]]|D|@]|E|$]]|$1|15|3|16|5|H|7|25|8|@]|D|@]|E|$I|J]]|$1|17|3|-4|5|6|7|26|8|@]|D|@]|E|$]]|$1|18|3|19|5|X|7|27|8|@$9|28|A|29|B|C]|$9|2A|A|2B|B|C]]|D|@]|E|$]]|$1|1A|3|1B|5|X|7|2C|8|@]|D|@]|E|$]]|$1|1C|3|-4|5|6|7|2D|8|@]|D|@]|E|$]]|$1|1D|3|-4|5|6|7|2E|8|@]|D|@]|E|$]]]|1E|$]]

For example we have an <code>ImageView</code> , a <code>LinearLayout</code> and a <code>RelativeLayout</code>. LinearLayout is the child of RelativeLayout.
the View Hierarchy will be.

<pre><code>RelativeLayout
 -------&gt;LinearLayout
</code></pre>

and we have a separate layout file for ImageView

image_view_layout.xml
 

Attach to root:

<pre><code>//here container is the LinearLayout

 View v = Inflater.Inflate(R.layout.image_view_layout,container,true);
</code></pre>

<ol>
<li>Here v contains the reference of the container layout i.e the
LinearLayout.and if you want to set the parameters like <code>setImageResource(R.drawable.np);</code> of ImageView you will have to find it by the reference of parent i.e <code>view.findById()</code></li>
<li>Parent of v will be the FrameLayout.</li>
<li>LayoutParams will be of FrameLayout.</li>
</ol>

Not attach to root:

<pre><code>//here container is the LinearLayout
 View v = Inflater.Inflate(R.layout.image_view_layout,container,false);
</code></pre>

<ol>
<li>Here v contains the no reference container layout but direct
reference to the ImageView that is inflated so you can set its
parameters like <code>view.setImageResource(R.drawable.np);</code> without
refereing like <code>findViewById</code>. But container is specified so that
ImageView gets the LayoutParams of the container so you can say
that the reference of container is just for LayoutParams nothing
else.</li>
<li>so in particular case Parent will be null.</li>
<li>LayoutParams will be of LinearLayout.</li>
</ol>

blocks|key|2855765|text|attachToRoot设置为true:|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2855766|2855767|如果attachToRoot设置为true，则第一个参数中指定的布局文件将被膨胀并附加到第二个参数中指定的ViewGroup。|blockquote|2855768|2855769|2855770|假设我们在XML布局文件中指定了一个按钮，并将其布局宽度和布局高度设置为match_parent。|2855771|<Button+xmlns:android="http://schemas.android.com/apk/res/android"
++++++++++++android:layout_width="match_parent"
++++++++++++android:layout_height="match_parent"
++++++++++++android:id="@%2Bid/custom_button">
</Button>|code-block|syntax|javascript|2855772|现在，我们希望以编程方式将此按钮添加到片段或活动中的LinearLayout中。如果我们的LinearLayout已经是一个成员变量mLinearLayout，我们可以简单地添加如下按钮：|2855773|inflater.inflate(R.layout.custom_button,+mLinearLayout,+true);|2855774|我们指定要从其布局资源文件中膨胀按钮；然后告诉LayoutInflater我们希望将其附加到mLinearLayout。我们的布局参数是有效的，因为我们知道按钮会被添加到LinearLayout中。按钮的布局参数类型应为LinearLayout.LayoutParams。|2855775|attachToRoot设置为false+(使用false时不需要)|2855776|2855777|如果attachToRoot设置为false，则对第一个参数中指定的布局文件进行膨胀，并且不会将附加到第二个参数中指定的ViewGroup，但膨胀后的视图将获取父视图的LayoutParams，从而使该视图能够正确地适合父视图。|2855778|2855779|2855780|让我们来看看什么时候需要将attachToRoot设置为false。在此场景中，在inflate()的第一个参数中指定的视图此时不会附加到第二个参数中的ViewGroup。|2855781|回想一下前面的按钮示例，我们希望将布局文件中的自定义按钮附加到mLinearLayout。我们仍然可以通过为attachToRoot传入false来将我们的Button附加到mLinearLayout+--我们只是在之后手动添加它。|2855782|Button+button+=+(Button)+inflater.inflate(R.layout.custom_button,++++mLinearLayout,+false);
mLinearLayout.addView(button);|2855783|当我们为attachToRoot传入true时，这两行代码等同于我们之前在一行代码中编写的代码。通过传入false，我们表示还不想将视图附加到根ViewGroup。我们说的是，它将在其他某个时间点发生。在本例中，另一个时间点是紧接在通货膨胀之后使用的addView()方法。|2855784|当我们手动将视图添加到ViewGroup时，false+attachToRoot示例需要做更多的工作。|2855785|attachToRoot设置为false(需要false)|2855786|在onCreateView()中膨胀和返回片段的视图时，一定要为attachToRoot传入false。如果传入true，则会得到一个IllegalStateException，因为指定的子级已经有了父级。您应该已经指定了将片段视图放回活动中的位置。FragmentManager的工作是添加、删除和替换片段。|2855787|FragmentManager+fragmentManager+=+getSupportFragmentManager();
Fragment+fragment+=++fragmentManager.findFragmentById(R.id.root_viewGroup);

if+(fragment+==+null)+{
fragment+=+new+MainFragment();
fragmentManager.beginTransaction()
++++.add(R.id.root_viewGroup,+fragment)
++++.commit();
}|2855788|将在活动中保存片段的root_viewGroup容器是在片段的onCreateView()中给出的ViewGroup参数。它也是传递给LayoutInflater.inflate()的ViewGroup。但是，FragmentManager将处理将片段的视图附加到此ViewGroup。您不希望将其附加两次。将attachToRoot设置为false。|2855789|public+View+onCreateView(LayoutInflater+inflater,+ViewGroup++parentViewGroup,+Bundle+savedInstanceState)+{
View+view+=+inflater.inflate(R.layout.fragment_layout,+++++parentViewGroup,+false);
…
return+view;
}|2855790|如果我们不想把片段附加到onCreateView()中，为什么我们首先要给出片段的父ViewGroup呢？为什么inflate()方法请求一个根ViewGroup？|2855791|事实证明，即使我们没有立即将新膨胀的视图添加到其父ViewGroup中，我们仍然应该使用父视图的LayoutParams，以便新视图在最终附加时确定其大小和位置。|2855792|链接：https://youtu.be/1Y0LlmTCOkM?t=409|2855793|entityMap|0|LINK|mutability|MUTABLE|url|https://youtu.be/1Y0LlmTCOkM?t=409^0|0|K|0|0|0|0|0|0|0|0|0|0|0|Y|0|0|23|L|0|0|0|0|0|0|0|0|0|T|0|0|0|0|0|0|0|3|Y|0|0^^$0|@$1|2|3|4|5|6|7|23|8|@$9|24|A|25|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|26|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|27|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|28|8|@]|D|@]|E|$]]|$1|K|3|-4|5|6|7|29|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|2A|8|@]|D|@]|E|$]]|$1|N|3|O|5|P|7|2B|8|@]|D|@]|E|$Q|R]]|$1|S|3|T|5|6|7|2C|8|@]|D|@]|E|$]]|$1|U|3|V|5|P|7|2D|8|@]|D|@]|E|$Q|R]]|$1|W|3|X|5|6|7|2E|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|2F|8|@$9|2G|A|2H|B|C]]|D|@]|E|$]]|$1|10|3|-4|5|6|7|2I|8|@]|D|@]|E|$]]|$1|11|3|12|5|I|7|2J|8|@$9|2K|A|2L|B|C]]|D|@]|E|$]]|$1|13|3|-4|5|6|7|2M|8|@]|D|@]|E|$]]|$1|14|3|-4|5|6|7|2N|8|@]|D|@]|E|$]]|$1|15|3|16|5|6|7|2O|8|@]|D|@]|E|$]]|$1|17|3|18|5|6|7|2P|8|@]|D|@]|E|$]]|$1|19|3|1A|5|P|7|2Q|8|@]|D|@]|E|$Q|R]]|$1|1B|3|1C|5|6|7|2R|8|@]|D|@]|E|$]]|$1|1D|3|1E|5|6|7|2S|8|@]|D|@]|E|$]]|$1|1F|3|1G|5|6|7|2T|8|@$9|2U|A|2V|B|C]]|D|@]|E|$]]|$1|1H|3|1I|5|6|7|2W|8|@]|D|@]|E|$]]|$1|1J|3|1K|5|P|7|2X|8|@]|D|@]|E|$Q|R]]|$1|1L|3|1M|5|6|7|2Y|8|@]|D|@]|E|$]]|$1|1N|3|1O|5|P|7|2Z|8|@]|D|@]|E|$Q|R]]|$1|1P|3|1Q|5|6|7|30|8|@]|D|@]|E|$]]|$1|1R|3|1S|5|6|7|31|8|@]|D|@]|E|$]]|$1|1T|3|1U|5|6|7|32|8|@]|D|@$9|33|A|34|1|35]]|E|$]]|$1|1V|3|-4|5|6|7|36|8|@]|D|@]|E|$]]]|1W|$1X|$5|1Y|1Z|20|E|$21|22]]]]

attachToRoot Set to true:

<blockquote>
 If attachToRoot is set to true, then the layout file specified in the first parameter is inflated and attached to the ViewGroup specified in the second parameter.
</blockquote>

Imagine we specified a button in an XML layout file with its layout width and layout height set to match_parent.

<pre><code>&lt;Button xmlns:android="http://schemas.android.com/apk/res/android"
 android:layout_width="match_parent"
 android:layout_height="match_parent"
 android:id="@+id/custom_button"&gt;
&lt;/Button&gt;
</code></pre>

We now want to programmatically add this Button to a LinearLayout inside of a Fragment or Activity. If our LinearLayout is already a member variable, mLinearLayout, we can simply add the button with the following:

<pre><code>inflater.inflate(R.layout.custom_button, mLinearLayout, true);
</code></pre>

We specified that we want to inflate the Button from its layout resource file; we then tell the LayoutInflater that we want to attach it to mLinearLayout. Our layout parameters are honored because we know the Button gets added to a LinearLayout. The Button’s layout params type should be LinearLayout.LayoutParams. 

attachToRoot Set to false (not required to use false) 

<blockquote>
 If attachToRoot is set to false, then the layout file specified in the first parameter is inflated and not attached to the ViewGroup specified in the second parameter but that inflated view acquires parent's LayoutParams which enables that view to fit correctly in the parent.
</blockquote>

 

Let’s take a look at when you would want to set attachToRoot to false. In this scenario, the View specified in the first parameter of inflate() is not attached to the ViewGroup in the second parameter at this point in time.

Recall our Button example from earlier, where we want to attach a custom Button from a layout file to mLinearLayout. We can still attach our Button to mLinearLayout by passing in false for attachToRoot—we just manually add it ourselves afterward.

<pre><code>Button button = (Button) inflater.inflate(R.layout.custom_button, mLinearLayout, false);
mLinearLayout.addView(button);
</code></pre>

These two lines of code are equivalent to what we wrote earlier in one line of code when we passed in true for attachToRoot. By passing in false, we say that we do not want to attach our View to the root ViewGroup just yet. We are saying that it will happen at some other point in time. In this example, the other point in time is simply the addView() method used immediately below inflation.

The false attachToRoot example requires a bit more work when we manually add the View to a ViewGroup.

attachToRoot Set to false(false is Required) 
When inflating and returning a Fragment’s View in onCreateView(), be sure to pass in false for attachToRoot. If you pass in true, you will get an IllegalStateException because the specified child already has a parent. You should have specified where your Fragment’s view will be placed back in your Activity. It is the FragmentManager’s job to add, remove and replace Fragments.

<pre><code>FragmentManager fragmentManager = getSupportFragmentManager();
Fragment fragment = fragmentManager.findFragmentById(R.id.root_viewGroup);

if (fragment == null) {
fragment = new MainFragment();
fragmentManager.beginTransaction()
 .add(R.id.root_viewGroup, fragment)
 .commit();
}
</code></pre>

The root_viewGroup container that will hold your Fragment in your Activity is the ViewGroup parameter given to you in onCreateView() in your Fragment. It’s also the ViewGroup you pass into LayoutInflater.inflate(). The FragmentManager will handle attaching your Fragment’s View to this ViewGroup, however. You do not want to attach it twice. Set attachToRoot to false.

<pre><code>public View onCreateView(LayoutInflater inflater, ViewGroup parentViewGroup, Bundle savedInstanceState) {
View view = inflater.inflate(R.layout.fragment_layout, parentViewGroup, false);
…
return view;
}
</code></pre>

Why are we given our Fragment’s parent ViewGroup in the first place if we don’t want to attach it in onCreateView()? Why does the inflate() method request a root ViewGroup? 
It turns out that even when we are not immediately adding our newly inflated View to its parent ViewGroup, we should still use the parent’s LayoutParams in order for the new View to determine its size and position whenever it is eventually attached. 

Link: <a href="https://youtu.be/1Y0LlmTCOkM?t=409" rel="nofollow noreferrer">https://youtu.be/1Y0LlmTCOkM?t=409</a>

blocks|key|2855822|text|现在或不是现在|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2855823|“第三个”参数attachToRoot是真还是假之间的主要区别在于。|2855824|当您将attachToRoot设置为|2855825|2855826|true+:立即将子视图添加到父|offset|length|style|BOLD|2855827|false:将子视图添加到父，而不是现在的。|2855828|稍后再添加。`|2855829|2855830|+是什么时候更新的？|blockquote|2855831|2855832|2855833|后面就是你使用for例如parent.addView(childView)的时候。|CODE|2855834|一个常见的误解是，如果attachToRoot参数为false，那么子视图将不会被添加到父视图中。错误的|2855835|在这两种情况下，子视图都将添加到parentView中。这只是time的问题。|2855836|inflater.inflate(child,parent,false);
parent.addView(child);+++|code-block|syntax|javascript|2855837|等同于|2855838|inflater.inflate(child,parent,true);|2855839|是一个大禁忌|2855840|如果您不负责将子视图添加到父视图中，则不应将attachToRoot作为true传递。|2855841|例如添加分片时|2855842|public+View+onCreateView(LayoutInflater+inflater,ViewGroup+parent,Bundle+bundle)
++{
++++++++super.onCreateView(inflater,parent,bundle);
++++++++View+view+=+inflater.inflate(R.layout.image_fragment,parent,false);
++++++++.....
++++++++return+view;
++}|2855843|如果你将第三个参数作为true传递，你会因为这个家伙而得到IllegalStateException。|2855844|getSupportFragmentManager()
++++++.beginTransaction()
++++++.add(parent,+childFragment)
++++++.commit();|2855845|因为您已经错误地在onCreateView()中添加子片段。调用add会告诉您，子视图已添加到父视图中，因此为IllegalStateException.|2855846|这里你不负责添加childView，FragmentManager负责。所以在这种情况下总是传递false。|2855847|注意：我也读到过，如果attachToRoot为false，parentView将不会获得childView+touchEvents。但是我还没有测试过它。|2855848|entityMap^0|0|0|0|0|0|6|0|0|6|E|7|0|0|0|0|0|0|C|P|0|0|7|1D|3|0|V|4|0|0|0|3|0|0|0|6|0|0|0|0|0|0|1J|L|0|0|0|3|0^^$0|@$1|2|3|4|5|6|7|1W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|20|8|@$I|21|J|22|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|23|8|@$I|24|J|25|K|L]|$I|26|J|27|K|L]]|9|@]|A|$]]|$1|O|3|P|5|6|7|28|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|29|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|2A|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|2B|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|2C|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|2D|8|@$I|2E|J|2F|K|Y]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|2G|8|@$I|2H|J|2I|K|L]|$I|2J|J|2K|K|L]]|9|@]|A|$]]|$1|11|3|12|5|6|7|2L|8|@$I|2M|J|2N|K|L]]|9|@]|A|$]]|$1|13|3|14|5|15|7|2O|8|@]|9|@]|A|$16|17]]|$1|18|3|19|5|6|7|2P|8|@$I|2Q|J|2R|K|L]]|9|@]|A|$]]|$1|1A|3|1B|5|15|7|2S|8|@]|9|@]|A|$16|17]]|$1|1C|3|1D|5|6|7|2T|8|@$I|2U|J|2V|K|L]]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|2W|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|2X|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|15|7|2Y|8|@]|9|@]|A|$16|17]]|$1|1K|3|1L|5|6|7|2Z|8|@]|9|@]|A|$]]|$1|1M|3|1N|5|15|7|30|8|@]|9|@]|A|$16|17]]|$1|1O|3|1P|5|6|7|31|8|@$I|32|J|33|K|L]]|9|@]|A|$]]|$1|1Q|3|1R|5|6|7|34|8|@]|9|@]|A|$]]|$1|1S|3|1T|5|6|7|35|8|@$I|36|J|37|K|L]]|9|@]|A|$]]|$1|1U|3|-4|5|6|7|38|8|@]|9|@]|A|$]]]|1V|$]]

<h1>NOW OR NOT NOW</h1>

The main difference between the "third" parameter attachToRoot being true or false is this. 

<blockquote>
 When you put attachToRoot
</blockquote>

true : add the child view to parent RIGHT NOW 
false: add the child view to parent NOT NOW. 
Add it later. `

<blockquote>
 When is that later?
</blockquote>

That later is when you use for eg <code>parent.addView(childView)</code> 

A common misconception is, if attachToRoot parameter is false then the child view will not be added to parent. WRONG 
In both cases, child view will be added to parentView. It is just the matter of time.

<pre><code>inflater.inflate(child,parent,false);
parent.addView(child); 
</code></pre>

is equivalent to 

<pre><code>inflater.inflate(child,parent,true);
</code></pre>

A BIG NO-NO 
You should never pass attachToRoot as true when you are not responsible for adding the child view to parent. 
Eg When adding Fragment

<pre><code>public View onCreateView(LayoutInflater inflater,ViewGroup parent,Bundle bundle)
 {
 super.onCreateView(inflater,parent,bundle);
 View view = inflater.inflate(R.layout.image_fragment,parent,false);
 .....
 return view;
 }
</code></pre>

if you pass third parameter as true you will get IllegalStateException because of this guy.

<pre><code>getSupportFragmentManager()
 .beginTransaction()
 .add(parent, childFragment)
 .commit();
</code></pre>

Since you have already added the child fragment in onCreateView() by mistake. Calling add will tell you that child view is already added to parent Hence IllegalStateException. 
Here you are not responsible for adding childView, FragmentManager is responsible. So always pass false in this case. 

NOTE: I have also read that parentView will not get childView touchEvents if attachToRoot is false. But I have not tested it though.

blocks|key|3069283|text|我之所以写这个答案，是因为即使在浏览了几个StackOverflow页面之后，我也不能清楚地理解attachToRoot的意思。下面是LayoutInflater类中的inflate()方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3069284|View+inflate+(int+resource,+ViewGroup+root,+boolean+attachToRoot)|code-block|syntax|javascript|3069285|看看我创建的activity_main.xml文件、button.xml布局和MainActivity.java文件。|3069286|activity_main.xml|3069287|<LinearLayout+xmlns:android="http://schemas.android.com/apk/res/android"
++++android:id="@%2Bid/root"
++++android:layout_width="match_parent"
++++android:layout_height="match_parent"
++++android:orientation="vertical">

</LinearLayout>|3069288|button.xml|3069289|<Button+xmlns:android="http://schemas.android.com/apk/res/android"
++++android:layout_width="match_parent"
++++android:layout_height="wrap_content"+/>|3069290|MainActivity.java|3069291|@Override
protected+void+onCreate(Bundle+savedInstanceState)+{
++++super.onCreate(savedInstanceState);
++++setContentView(R.layout.activity_main);

++++LayoutInflater+inflater+=+getLayoutInflater();
++++LinearLayout+root+=+(LinearLayout)+findViewById(R.id.root);
++++View+view+=+inflater.inflate(R.layout.button,+root,+false);
}|3069292|当我们运行代码时，我们在布局中看不到按钮。这是因为我们的按钮布局没有添加到主活动布局中，因为attachToRoot设置为false。|3069293|LinearLayout有一个addView(视图视图)方法，可以用来向LinearLayout添加视图。这会将按钮布局添加到主活动布局中，并使按钮在运行代码时可见。|3069294|root.addView(view);|3069295|让我们删除前一行，看看当我们将attachToRoot设置为true时会发生什么。|3069296|View+view+=+inflater.inflate(R.layout.button,+root,+true);|3069297|我们再次看到按钮布局是可见的。这是因为attachToRoot直接将膨胀的布局附加到指定的父级。在本例中是根LinearLayout。在这里，我们不必像在前面的addView(View+view)方法中那样手动添加视图。|3069298|为什么人们在将片段的attachToRoot设置为true时会得到IllegalStateException。|offset|length|style|BOLD|3069299|这是因为对于一个片段，您已经指定了在活动文件中放置片段布局的位置。|3069300|FragmentManager+fragmentManager+=+getSupportFragmentManager();
fragmentManager.beginTransaction()
++++.add(R.id.root,+fragment)
++++.commit();|3069301|add(int+parent，fragment)将具有其布局的片段添加到父布局中。如果我们将attachToRoot设置为true，您将得到IllegalStateException:指定的子对象已经有了父对象。因为片段布局已经在add()方法中添加到了父布局中。|3069302|当你膨胀片段时，你应该总是为attachToRoot传递false。添加、删除和替换片段是FragmentManager的工作。|3069303|回到我的例子。如果我们两个都做呢。|3069304|View+view+=+inflater.inflate(R.layout.button,+root,+true);
root.addView(view);|3069305|在第一行中，LayoutInflater将按钮布局附加到根布局，并返回一个包含相同按钮布局的视图对象。在第二行中，我们将相同的View对象添加到父根布局中。这会产生与我们在片段中看到的相同的IllegalStateException+(指定的子对象已经有了父对象)。|3069306|请记住，还有另一个重载的inflate()方法，它在默认情况下将attachToRoot设置为true。|3069307|View+inflate+(int+resource,+ViewGroup+root)|3069308|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|1J|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|20|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|21|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|22|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|23|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|24|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|25|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|26|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|27|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|28|8|@]|9|@]|A|$]]|$1|12|3|13|5|D|7|29|8|@]|9|@]|A|$E|F]]|$1|14|3|15|5|6|7|2A|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|2B|8|@$18|2C|19|2D|1A|1B]]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|2E|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|D|7|2F|8|@]|9|@]|A|$E|F]]|$1|1G|3|1H|5|6|7|2G|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|2H|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|6|7|2I|8|@]|9|@]|A|$]]|$1|1M|3|1N|5|D|7|2J|8|@]|9|@]|A|$E|F]]|$1|1O|3|1P|5|6|7|2K|8|@]|9|@]|A|$]]|$1|1Q|3|1R|5|6|7|2L|8|@]|9|@]|A|$]]|$1|1S|3|1T|5|D|7|2M|8|@]|9|@]|A|$E|F]]|$1|1U|3|-4|5|6|7|2N|8|@]|9|@]|A|$]]]|1V|$]]

I wrote this answer because even after going through several StackOverflow pages I wasn't able to clearly grasp what attachToRoot meant. Below is inflate() method in the LayoutInflater class.

<pre><code>View inflate (int resource, ViewGroup root, boolean attachToRoot)
</code></pre>

Take a look at activity_main.xml file, button.xml layout and the MainActivity.java file I created.

activity_main.xml

<pre><code>&lt;LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 android:id="@+id/root"
 android:layout_width="match_parent"
 android:layout_height="match_parent"
 android:orientation="vertical"&gt;

&lt;/LinearLayout&gt;
</code></pre>

button.xml

<pre><code>&lt;Button xmlns:android="http://schemas.android.com/apk/res/android"
 android:layout_width="match_parent"
 android:layout_height="wrap_content" /&gt;
</code></pre>

MainActivity.java

<pre><code>@Override
protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_main);

 LayoutInflater inflater = getLayoutInflater();
 LinearLayout root = (LinearLayout) findViewById(R.id.root);
 View view = inflater.inflate(R.layout.button, root, false);
}
</code></pre>

When we run the code, we won't see the button in the layout. This is because our button layout is not added into the main activity layout since attachToRoot is set to false.

LinearLayout has an addView(View view) method which can be used to add Views to LinearLayout. This will add the button layout into the main activity layout, and make the button visible when you run the code.

<pre><code>root.addView(view);
</code></pre>

Let's remove the previous line, and see what happens when we set attachToRoot as true.

<pre><code>View view = inflater.inflate(R.layout.button, root, true);
</code></pre>

Again we see that the button layout is visible. This is because attachToRoot directly attaches the inflated layout to the parent specified. Which in this case is root LinearLayout. Here we don't have to add the views manually like we did in the previous case with addView(View view) method.

Why are people getting IllegalStateException when setting attachToRoot as true for a Fragment.

This is because for a fragment you have already specified where to place your fragment layout in your activity file.

<pre><code>FragmentManager fragmentManager = getSupportFragmentManager();
fragmentManager.beginTransaction()
 .add(R.id.root, fragment)
 .commit();
</code></pre>

The add(int parent, Fragment fragment) adds the fragment which has it's layout to the parent layout. If we set attachToRoot as true, you will get IllegalStateException: The specified child already has a parent. Since fragment layout is already added to the parent layout in the add() method.

You should always pass false for attachToRoot when you're inflating Fragments. It is the FragmentManager’s job to add, remove and replace Fragments.

Back to my example. What if we do both.

<pre><code>View view = inflater.inflate(R.layout.button, root, true);
root.addView(view);
</code></pre>

In the first line, LayoutInflater attaches the button layout to the root layout and returns a View object which holds the same button layout. In the second line, we add the same View object to the parent root layout. This results in the same IllegalStateException we saw with Fragments (The specified child already has a parent).

Keep in mind that there is another overloaded inflate() method, which sets attachToRoot as true by default.

<pre><code>View inflate (int resource, ViewGroup root)
</code></pre>

blocks|key|210560|text|我只是分享我在这个话题上遇到的一些观点，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|210561|除了公认的答案之外，我还想提出一些观点，这可能会有所帮助。|210562|因此，当我使用attachToRoot作为true时，返回的视图类型是+ViewGroup+，即作为参数传递给inflate(layoutResource，ViewGroup，attachToRoot)方法的父级根代码，而不是传递的布局类型，但在attachToRoot上为false。我们获得该布局资源的根视图组<代码>E29的函数返回类型。|offset|length|style|BOLD|210563|让我举个例子来解释一下：|210564|如果我们有一个LinearLayout作为根布局，然后我们想要通过膨胀函数在其中添加TextView。|210565|然后，在使用attachToRoot作为视图时，true+inflate函数将返回类型为LinearLayout的|210566|在将attachToRoot用作false时，+inflate函数返回TextView类型的视图|210567|希望这个发现能对你有所帮助。|210568|entityMap^0|0|0|7|C|Z|B|1J|1A|3F|C|4A|I|0|0|C|0|0|1F|0|0|S|18|C|0|0|1C|0|0|E|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|X|8|@$F|Y|G|Z|H|I]|$F|10|G|11|H|I]|$F|12|G|13|H|I]|$F|14|G|15|H|I]|$F|16|G|17|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|18|8|@$F|19|G|1A|H|I]]|9|@]|A|$]]|$1|L|3|M|5|6|7|1B|8|@$F|1C|G|1D|H|I]]|9|@]|A|$]]|$1|N|3|O|5|6|7|1E|8|@$F|1F|G|1G|H|I]|$F|1H|G|1I|H|I]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1J|8|@$F|1K|G|1L|H|I]]|9|@]|A|$]]|$1|R|3|S|5|6|7|1M|8|@$F|1N|G|1O|H|I]]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]]|U|$]]

Just sharing some points that i encountered while working on this topic,

In addition to the accepted answer i want to some points which could be of some help.

So, when i used attachToRoot as true, the view which was returned was of type ViewGroup i.e. parent's root ViewGroup which was passed as parameter for the inflate(layoutResource,ViewGroup,attachToRoot) method, not of type the layout which was passed but on attachToRoot as false we get the function return type of that layoutResource's root ViewGroup. 

Let me explain with an example:

If we have a LinearLayout as the root layout and then we want to add TextView in it through inflate function.

then on using attachToRoot as true inflate function returns a View of type LinearLayout

while on using attachToRoot as false inflate function returns a View of type TextView

Hope this finding would be of some help...

The <a href="http://developer.android.com/reference/android/view/LayoutInflater.html#inflate%28org.xmlpull.v1.XmlPullParser,%20android.view.ViewGroup,%20boolean%29" rel="noreferrer"><code>LayoutInflater.inflate</code></a> documentation isn't exactly clear to me about the purpose of the <code>attachToRoot</code> parameter. 

<blockquote>
 attachToRoot: whether the inflated hierarchy should be attached to the root parameter? If false, root is only used to create the correct
 subclass of LayoutParams for the root view in the XML.
</blockquote>

Could someone please explain in more detail, specifically what the root view is, and maybe show an example of a change in behavior between <code>true</code> and <code>false</code> values?

What does the LayoutInflater attachToRoot parameter mean?

容器

对于attachToRoot参数的用途，我在文档中并不是很清楚。 attachToRoot:是否应该将膨胀的层次结构附加到根参数？如果为false，则root仅用于为XML中的根视图创建正确的LayoutParams子类。有没有人可以更详细地解释一下根视图是什么，或许可以给出一个true和false值之间行为变化的例子...

问LayoutInflater attachToRoot参数是什么意思？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问LayoutInflater attachToRoot参数是什么意思？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问LayoutInflater attachToRoot参数是什么意思？
EN