Guest list layout

<LinearLayout
    android:orientation="vertical"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content">
 
    <TextView
        android:text="Guest List"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
 
    <TextView
        android:text="Kunal"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
 
</LinearLayout>

linear layout vertical
wrap content for the vertical layout
2 TextViews in the LinearLayout

1. The view group is a linear layout.
2. There are 2 children TextView in this layout.

1. View group is a LinearLayout
2. LinearLayout have orientation
3. LinearLayout have heigth and width

View group is a LinearLayout
LinearLayout have orientation
LinearLayout have heigth and width
both textview are inside this LinearLayout view group

1. There is a Linear Layout ViewGroup
2. The Linear Layout has two TextView Child
3. The Linear Layout has a vertical orientation

the Linear Layout is Vertical
there are 2 text views
the child views are indented inwards from the parent for easy viewing of child/parent

The layout is vertical.
There are two TextViews.
And wrap content is used throughout.

1. viewGroup is a Linear layout
2. Linear layout has orientation
3. Linear layout has height and width

• ViewGroup is a LinearLayout (Parent)
• It has 2 child Views, 2 TextViews
• The linearLayout uses vertical layout.

• This code has a root view called of LinearLayout with the vertical orientation;
• This code has two TextView sibling;
• This code are just one parent

• LinearLayout has an orientation. It has width and height like any other views.
• LinearLayout contains two children, which are sibligns

1. LinearLayout has orientation "vertical"
2. LinearLayout has attribute android:layout_width="wrap_content" and
   android:layout_height="wrap_content"
3. the LinearLayout has to children TextView

Has parent GroupView of LinearLayout
Has children of 2 TextView
Linear Orientation is vertical
All views wrap_content

• 3 views are used,
• The LinearLayout parent view group has a vertical orientation,
• 2 child TextViews.

The LinearLayout contains two TextViews
Each of the TextView has the attribute of layout_height and layout_width with the value of wrap_content
The orientation of the LinearLayout is vertical

1. View group has a LinearLayout
2. LinearLayout's orientation is set on vertical
3. each view has width and height set to wrap the content
4. the text in the TextViews is hard coded

1. ViewGroup is a LinearLayout with orientation "vertical".
2. Linear Layout ViewGroup have same basic attributes common for every view like Height and Width.
3. The two textview are siblings.
4. ViewGroup is a LinearLayout is the parent of the two textview

1. it's a linear layout.
2. the orientation of the view group is horizontal.
3. all have wrap_content.
4. The TextView's are siblings.

Orientation vertical
all are wrap_content

The parent and child seem somewhat similar in the way that they are structured.
The linear layout tag does not close like the text view tag.
Linear layout still uses the android::

linear layout vertical
wrap content for the vertical layout
2 TextViews in the LinearLayout

linear layout is vertical
There are 2 TextView in linear layout
linear layout has orientation

The colors match.
The child code is inside the parent code.
The Parent could be a child of another parent ;)

3 times this:
android:layout_width="wrap_content"
android:layout_height="wrap_content"

suggest it can be inheritted?

3 times this:
android:layout_width="wrap_content"
android:layout_height="wrap_content"

can the child inherit this from the parent?

1. 3 times this:
   android:layout_width="wrap_content
   android:layout_height="wrap_content
   can the child not inherit this?
2. no slash in end of LinearLayout
3. Kunal is there again

1. Use Two TextView
2. TextView layout_width="match_parent"
3. android:orientation="vertical"

The LinearLayout is the parent
The LinearLayout has vertical orientation
The size of the LinearLayot depends on his children

1. LinearLayout
2. 2 TextView
3. TextView layout_width="match_parent"

Linear Layout.
Vertical Orientation.
2 child TextViews with wrap_content

1. Red view is LinearLayout.
2. The view is vertical.
3. Red view has two TextView.
4. each TextView's size is wrap_content

The child code is contained within the parent element LinearLayout.
The type of view group is classified by the element tag.

1. Linear layout vertical
2. Wrap content for the vertical layout
3. Two TextViews in the LinearLayout

1. The parent is a linear layout whose width and height extend across the entire screen [wrap content].
2. There is the child, text view, reading "Guest List" also wrapped across the entire screen.
3. There is a sibling to that child, another text view, reading "Kunis" also wrapped across the entire screen.

Has Linear Layout
Children are oriented vertically inside the parent
and there are two siblings

Ding -> Hoosh
Pew Pew
plup BOOM

used wrap content
linearlayout needs extra closing tag
parent-child

Use wrap_content for adapt the size to its childs
its a linear layout with vertical orientation

1. It's using LinearLayout
2. The parent have 2 TextView
3. And using vertical orientation parent

linear layout vertical
wrap content for the vertical layout
2 TextViews in the LinearLayout

1. It is a linear layout
2. All are warp content
3. They are vertical

Linear layout is the parent view.
It has two sibling TextView's.
All the three Views have height & width value as "wrap_content"

1. There is a vertical linear layout called parent(Mother) layout.
2. Two textViews are there as children of parent view.
3. Relative Layout(Father) is hidden from user.

• It's a linear layout.
• It has vertical orientation.
• It has two child textViews: Guest List and Kunal.
• All of the views have wrap_content for height and width, so the view only occupies the top portion of the screen.
• As written, the code would not produce the two colors shown in the image because the background color is not set in any of the views.
• This quiz is very irritating because it won't accept a valid answer!

It is a linear layout with a vertical orientation and has two children

The view group is a vertical orientation LinearLayout.
The parent has 2 TextView, Guest List and Kunal

1. Linear Layout with the vertical orientation.
2. 2 children Text View
3. Text view has width and height set to wrap the content

The view group has a linear layout and a vertical orientation. Both text views are children of the parent view. The attributes are all set to wrap_content.

LinearLayout is the parent, and the View Group.
TextView's are the two children, and the views inside the View Group.
All of the views shares a common Attribute Value "wrap_content" for their Attribute names : layout_width and layout_height.

ViewGroup is of type LinearLayout
Its child views will be arranged vertically.
The size of the view group is wrap able or even dp's are provided as unit of height and width.

The ViewGroup has two child views...and both of their height and width are wrappable. The text views are siblings.

linear layout vertical
wrap content for the vertical layout
2 TextViews in the LinearLayout

In total there are 3 views (1 parent view & 2 child views)
child views are of type TextView under the parent LinearLayout view
All views have layout_height & layout_width

LayoutLinear is the parent View Groups
LinearLayout has two TextView with different text vertically
LinearLayout and the two TextView occupy the minimum required content: wrap_content

dice la orientacion del view
hay dos textview en layoutlinear
y el linearlayout se abre y cierra individual en la ultima linea

LayoutLinear es el padre Ver grupos
LinearLayout cuenta con dos TextView con diferente texto verticalmente
LinearLayout y los dos TextView ocupar el mínimo contenido requerido: wrap_content

1- This is a ViewGroup of type LinearLayout
2- It contains two TextViews
3- They are positioned vertically

1 - Linear Layout is the parent view. With the orientation proproti we can specify if the children vews will be are fixed vertically or horizontally.

2- The Text Views are the children views.
3- The children views must be declared between the parent views marked

1. Hay un ViewGroup, que es parent
2. Hay 3 View
3. 2 views están de manera vertical

1 . Have a ViewGroup is LinearLayout with orientation vertical property.
2 Have 2 child views is TexView is sibling
3 All View is on a couple of angle bracket, <> .

linearLayout is the parent view group and set to display the child views vertically

linearLayout has two textView children

all views have width and height set to wrap the content

1. LinearLayout is the parent which displays the children vertically
2. TextView "Guest List" is a child of LinearLayout above that displays text "Guest List"
3. TextView "Kunal" is a child of LinearLayout above that displays text "Kunal"

1. There is a parent LinearLayout ViewGroup
2. Parent ViewGroup LinearLayout Orinetation is Vertical
3. There are two child TextView within parent LinearLayout ViewGroup

• The parent view group is a LinearLayout.
• This parent has two childs: TextView views.
• The orientation of the above childs inside the parent is vertical.

Linear layout is the father, kunal is the son and listguest the daugther.

1. The ViewGroup is LinearLayout
2. There are three Views
3. LinearLayout is the parent View
4. There are two TextViews that are children of the LinearLayout
5. The two Views are placed vertically, one above the other

The view group is a linear layout.
There are 2 children TextView in this layout.

1. the order of child follows order of code
2. sizes of the boxes are equal even though the length are different
3. ...

1. LinearLayout is a Viewgroup
2. LinearLayout have attribute orientation
3. the orientation is vertical

1.The Parent Layout is Linear
2. The LinearLayout orientation is vertical
2. There are two Children Text Views

• Linear layout has vertical orientation.
• Linear layout has 2 TextViews.
• Linear layout's layout width and height is set to wrap_content.

We have written two TextViews in one parent view.
Parent view opens with <LinearLayout and closes with .
Two TextViews have vertical orientation.

We have two textView inside one parent linear layout
All textView are close by a />
Parent view has a vertical layout

Linear Layout
A parent view with 2 child views
Orientation is Vertical
width and height of both parent and child are wrap_content

Linear Layout with linear orientation is the parent element
The two textviews are the child elements.

It starts and ends with Linear Layout
Two TextView children
Linear Layout is Parent

1 Linear Layout and Two Text Views
Linear Layout is oriented vertically
Width and height is set to wrap content

This is a linear layout with two textViews:
my observation: Linear layout encloses children views, it has three angle brackets, two in the last, with a backward angle and forward slash, the linear layout has an attribute that shows the children orientation.

linear layout
two textViews
linear layout wraps children inside and shows how they should be viewed or seen orientation wise

Attribute: pew, pew, pew!

Two textviews in a linearlayout

A lineal layout with two textviews

Two textviews inside a LinearLayout ViewGroup verticaly oriented

1. What does orientation = vertical means? May be how child widgets are arranged.
2. layout width and height is for the height and width of the parent widget.
3. 2 TextView in one LayoutView.

1. TextViews are aligned vertically.
2. 2 TextViews
3. 1 LinearLayout housing the TextViews

linear layout orientation is vertical
wrap content in linear layout
two text views inside linear layout

1.Linear layout : android:orientation="vertical",android:layout_width and android:layout_height
2. 2 text view one is guest list and Kunal ,and both of that is in warp_content
3. This 2 text view are children

Linear Layout with the vertical orientation.
2 children Text View
Text view has width and height set to wrap the content

1. The view group is LinearLayout
2. Inside LinearLayout has two TextView
3. LinearLayout has vertical orientation

There is nesting in the for the TextView
2. There is 2 children TextViews
3. There is vertical orientation

The ViewGroups is LinearLayout
LinearLayout has 2 children (TextView)
LinearLayout arrange children view Vertical column

View Group is a Linear Layout in vertical orientation parent to
TextView Guest List with wrapped content(width and height)
TextView Kunal with wrapped content(width and height)

1 View Group is LinearLayout
2 children TextView
LinearLayout with vertical orientation

-LinearLayout orientation is vertical
-Parent and it's child having a wrap content for height and width
-LinearLayout is not a self closing group

1. The Linear Layout with be a vertical column.
2. There are two child Views (both TextViews).
3. The two child Views will also be arranged vertically.

the linear layout orientation is vertical
all of the parent and children using wrap_content for the layout
there'ra two children with 1 parent

1. The LinearLayout is going to be vertical
2. The two TextViews are also going to be oriented vertically
3. LinearLayout is not a self closing tag

The viewgroup is linear layout.
In the group have 2 children of type TextView.
The viewgroup have height and width too.

We have a LinearLayout the parente using vertical orientation that contains two children TextViews

1. LinearLayout contiene dos hijos que son TextView.
2. LinearLayout organiza sus hijos en forma vertical.
   3.TextView se ajusta de tamaño a su padre LinearLayout
   4 LinearLayout es primero y finaliza o cierra debajo de los TextView

1. Layout is Linear
2. Layout orientation is vertical
3. 2 textViews are used

1. Layout is Linear
2. Layout orientation is vertical
3. 2 textViews are used

1- The ViewGroup is LinearLayoutand it is vertical layout
2- There are three Views
3- LinearLayout is the parent View and 2 other views is the children

The parent is the ViewGroup LinearLayout and its orientation is vertical. That means all its child views are going to be arranged vertically.

The two child views are both TextViews and their height and width are wrapped around content. Also, the parent's (LinearLayout's) height and width are wrapped around its two children.

The XML code for the children is written inside the tag for the parent View. The Parent view has some of its own attributes.

1- use lineatlayout
2- 2 textview
3- 1 groupview

1. verticle linearlayout
2. 2 TextView
3. 1 parent view with 2 child view

1. - Specifies a linear vertical layout
2. - No colors or fonts specified
3. - The parent view Has 2 child views
4. - The child views are textviews

1. View Group is a Linear layout
2. 2 TextViews a)GuestList TextView b) Kunal TextView
3. No formattings like background color or Text color
4. Font size is not set.

It is a parent vertical linear layout view with 2 children textViews
Each of the 3 view would wrap around the content it has .

1. LinearLayout (Parent View)
   2.TextView (Child View)
   3.TextView (Child View)

Pew, shuosh, ploc, bum!

1. Parent View is the LinearLayout. 2. There are two TextViews. 3. Orientation is set to vertical.

One GroupView that is LinearLayout which is parent view.
Two TextViews which are the child views.

There is a Linear Layout ViewGroup and the Linear Layout has two TextView Child, Linear Layout has a vertical orientation view

The view group is LinearLayout
Inside LinearLayout has two TextView
LinearLayout has vertical orientation

• children views are set to match_parent
• Linearlayout is set to wrap_content
• the view group is linear layout

The parent layout is linear
The linear layout is vertical
Linear layout contains child text views

1. The parent view contains two children TextView.
2. All views are arranged in vertical column.
3. The children views need to be enclosed between Layout Opening and Closing tags.

The linear layout(parent) is having two children TextView.
Linear layout has arranged the TextView vertically.
Linear Layout is not a self closing tag.It requires its closing pair.

1. Linear Layout uses the attribute android:orientation to specify whether vertical or horizontal alignment.
2. Linear Layout uses a complete closing tag.
3. Children views are positioned according to precedence.

• 3 View groups in total
• All 3 use wrap_content
• Linear layout is the parent with two children

1. android:orientation="vertical" in the parent view
2. May have some of the same attributes of the child views
3. Ends with instead of /> like the child views do.

1. View group is LinearLayout
2. The two children are TextView
3. The attributes for width and height are all wrap_content

android:orientation is the attribute of the ViewGroup (LinearLayout)

open LinearLayout- vertical orientation
TextView-GuestList
TextView-Kamal
end LinearLayout

One linear layout
Contains two textviews
Arranged in vertical orientation

• Linear viewgroup got an orientation.
• Linear viewgroup has width and height.
  Linear viewgroup is vertical

• The Linear viewgroup has a vertical layout
• There are 2 children (textviews) of the parent layout
• The root view tag is not self ending since there are sub viewgroups.

1.The view group is a linear layout.
2.There are 2 children TextView in this layout.
3.arranged in vertical manner

1. There is one LinearLayout.
2. There are two TextView
3. The attribute layout_height & width has the value wrap_content

A linear vertical oriented layout having 3 types of views i.e linear group, image view and text view. Am I right?

HaHa!

1.There is a Vertical linear layout.
2.Have two textviews Inside.
3.The 2 textViews are sons of the Linear layout

• This code has a root view called of LinearLayout with the vertical orientation
• This code has two TextView sibling
• This code are just one parent
• Two TextView are inside this LinearLayout view group
• This code is XML

1. LinearLayout view (One parent)
2. LinearLayout has two child TextView's
3. Two TextView's are siblings of each other
4. Both LinearLayout and TextView's are wrapped
5. One TextView has value = Guest List
6. Other TextView has value = Kunal

1. Why doesn't the have a prefixed namespace?
2. Why doesn't the have a prefixed namespace?
3. Why doesn't the attributes layout_height, layout_width follow the same humpy camel as textColor, etc... ?

1. all the XML elements use wrap content.
2. linear vertical layout
3. group 2 TextView

1. There's a vertical linear layout with wrapped content for height and width
2. The layout has 2 child text views
3. Both text views also have wrapped content for height and width

1. 2 Child text views
2. Linear layout parent view
3. height and width wrapped

-The view Group is a LinealLayout in orientation vertical.

• The parent (LinearLayout) contains 2 children (TextView and another TextView).
• The android:orientation is vertical.
• All the views including the viewgroup have wrap_content as attributevalue for the attributesnames layout_width and layout_height.

One parent view containing two vertically-aligned child views.
The three view elements containing repeating lines about layout.
The children align vertically, the alignment is specified in the parent attribute called "orientation"

Viewgroup being used is Linearlayout
Orientantion used is vertical
height and width ViewGroup is wrap content

there is one viewgroup (parent) as a root = linear layout with vertical orientation
there are two textviews as children :)

It's title is LinearLayout opening & closing
the children Views are indented
Each children view is opened and closed individually

A vertical Linear Layout View Group
Enclosed two text views
Text Views are 1 Guest List
2 Kunal

All views are opened and closed ie <..../>
All content is wraped

1- there is three views (2 child is text view) and (1 parent is linearlayout view group)
2- child inside parent
3- child is self closing tag but parent not

1- a Linear Layout group, children oriented vertically.
2- has two children both are text view tag.
3- children tahs : self closing tags, parent (linear layout) : closes after children close their self closing tags.

3 views - 1 parent (as view group) and 2 child views
Child views are vertically oriented
Content is wrapped

ViewGroup is a LinearLayout (Parent)
It has 2 child Views, 2 TextViews
The linearLayout uses vertical layout.

LinearLayout en posición vertical
2 TextView en orientación vertical

LinearLayout is a view groups or as a father and had two children: TextView

ViewGroup is LinearLayout
Child view are TextViews
orienation of the LinearLayout is vertical

Parent ViewGroup LinearLayout with vertical orientation
2 Child TextView

View group is a LinearLayout
LinearLayout has orientation
LinearLayout has heigth and width

1- LinearLayout is a type of Groupview.
2- LinearLayout is a vertical.
3- GoupView have 2 child (2 TextView).

1. Linear Layout is vertical.
2. Two text views.
3. Linear layout contains the two text views.

linear layout vertical
wrap content for the vertical layout
2 TextViews in the LinearLayout

1. the ViewGroup is LinearLayout.
2. the ViewGroup isn't self-closing tag.
3. the LinearLayout orientation is set to be vertical
4. children views are contained inside the ViewGroup.

1. The width and height attributes for the parent and children are set to wrap content so as the children adapt to the content so does the parent view group.
2. The Parent ViewGroup is a LinearLayout
3. The LinearLayout is set to display content in a vertical orientation.

The view group is a linear layout.
There are 2 children TextView in this layout

linear layout vertical
wrap content for the vertical layout
2 TextViews in the LinearLayout

Se trata de un LinearLayout con orientación vertical que agrupa dos TextView

LinearLayout view group is used, which has vertical orientation.
Two child TextViews will be placed in vertical one below the other inside the parent view.
Linear layout has its own attributes.
LinearLayout has opening and closing tags.

1.Linear layout is vertical.
2.There are 2 children TextViews are there.
3.In this layout width and height are in "Wrap_content".

1. Two TextView are group in one LinearLayout
2. The layout orientation is in vertical.
3. layout width and height are the same for the LinearLayout and the other two TextView as well.

1. LinearLayout
2. android:orientation
3. 2 TextViews in the LinearLayout

1. 2 children TextViews
2. Vertical LinearLayout
3. Wrap content on both the parent and child

Boring

Linear layout, orientation, and wrap content

1.Two TextViews
2.Vertical LinearLayout
3.TextView is wrapped inside LinearLayout

two text views.
Linear layout.
orientation is vertical.

1.android:orientation is there
2.both textviews are within linearlayout
3.linearlayout width and height

There two siblings TextViews [1] inside a LinearLayout parent view [2] and they will lay out vertically on the screen. [3]

the Layout is linear
there is 2 textview children in the code
the LinearLayout fisished is </

1. There are 2 TextViews within a parent LinearLayout.
2. The LinearLayout has the TextViews organized inside in a vertical position.
3. They will expand/grow as big as their contents (All childs and parent has wrap_content as their width&height).

The View Groups:

1. Linear Layout: Vertical
2. Two vertical child views
3. layout_width and layout_height are both wrap_content

linear layout vertical
wrap content for the vertical layout
2 TextViews in the LinearLayout

It is a linear layout with a vertical orientation and it has a width and a height.
It contains two siblings, which are two TextViews.
The wrap_content is always used.

Linear Layou is Vertical
Two vertical child views
layout_width and layout_height are both wrap_content

ther is one parent and two children both text

Linear Layout for Vertical
wrap content for Linear Layout
2 TextView in Linear Layout

The ViewGroup is LinearLayout
LinearLayout is the parent View
There are two TextViews that are children of the LinearLayout
The two Views are placed vertically, one above the other

1. The orientation is vertical ie, the linear view arranges its child view in vertical column
2. It has two child views both are textviews
3. The parent view only wraps the content not any other spaces

1.The orientation of the view group (i.e.,Linear Layout) is vertical
2.The view group contains two TextViews
3.Due to wrap content,view group wraps only the two TextViews and not the whole screen.
4.in linear layout no slash to close

view group is linear view group
two children view group
in linear layout no slash to close

1.Layout tag is not self closing tag
2.Two child views are TextView.
3.line 2:to positioning the view accordingly.

There are a one parent Linear Layout, and two children texview.
The lineal layout is ordening his children vertical.

There are 3 views: 1 parent, 2 children.
The parent one is Linear Layout. 2 children are texts
they are sorted vertically.

1. the View Group is linear layout type
2. the linear layout is set in a vertical orientation
3. the dimensions of the layout is set as wrap_content
4. the 2 view groups are vertically aligned with dimensions set as wrap content

The view group is a linear layout.
There are 2 children TextView in this layout.
everything is vertically aligned

The parent layout is LinearLayout
The orientation of the parent layout is vertical
The two child views are TextViews

Both TextView blocks are entirely contained within the view group block.
The view group attributes are expressed before the contained views are established.
The order in which the TextView blocks are written determines their positioning withing the group block.

All elements use wrap content
Linear Layout has a vertical orientation
The TextViews have self closing tags

1.The linear layout tag is not a self closing tag.
2.Thsi is a vertical layout view group.
3.The 2 textViews are wriiten in continity to come top and bottom rlatiely to each other.

One and only observation: HOP IN THE CONSTRAINTLAYOUT TRAIN GUYS!

I was struggling making RelativeView do whatever I wanted but now it's so much simpler.

Doing the Android Basics with Udacity Scholarship right now.

1. It's a Lineral layout
2. 2 TextView (children) in Linear Layout (parent)
3. LinearLayout and both TexView have a "wrap_content" heigth and width

1. It is Linear Layout with vertical orientation
2. The ViewGroup (LinearLayout) contains 2 children (TextViews)
3. All views has "wrap_content" and take as much space as they need

XML tags use CamelCase while attributes use snake_case ; )

Linear layout with vertical orientation.
The ViewGroup has two childrens.
"wrap_content" for the text.

1. linear layout is vertical
2. wrap content for the vertical layout
3. Two TextViews are in the LinearLayout as children.

Parent view LinearLayout sets a vertical arrangement of its children views.
"Guest List" child view should be represented on the top, as it's the first child view into the vertically orientated LinearLayout parent view, and "Kunal" TextView should be represented bellow.
Values such as background color, text size, etc. of the views are not specified, so they will be take default values.

Linear Layout is Parent
Two child that are TextViews
wrap_content for every view

LinearLayout is the ViewGroup
forward slash
"android:orientation="vertical"

1. The two TextView tags are placed within the LinearLayout tag.
2. The LinearLayout has a vertical orientation.
3. The indentation of the code seems to matter.

1. Linear layout with vertical orientation
2. 3 Views
3. 1 parent 2 children

1. Linear layout with vertical orientation
2. 2 child views
3. 2 children are textViews

1. The groupview called LinearLayout wrap 2 children TextViews
2. It wraps horizontally
3. Text view has property set to "wrap_content"

1. LinearLayout as parent
2. Two TextViews as children
   3.TextViews are relative to each other

1. 2 textview (children)
   2, LinearLayout consist of 2 textviews
2. vertical orientation of LinearLayout

1. ViewGroup is a LinearLayout
2. Parent LinearLayout have 2 TextView children
3. LinearLayout have vertical orientation

1. It's vertical orientated LinearLayout
2. It has width and height based on content
3. It has 2 siblings - 2 TextViews

Do we really have to write things here or someone posted something and now everyone is posting? :) I think ill skip it in next tasks

The layout used is LinearLayout with vertical orientation specified by "android:orientation" attribute
This layout has two child of TextView type.
All Layouts (LinearLayout and TextView) was defined by wrap_content

1. GroupView: one parent view, 2 children
2. LinearLayout which contain two TextViews between specific tags(<LinearLayout and )
3. Two siblings TextView

There is a group view LinearLayout with two children TextViews. All of the three views with WrapContent

The Viewgroup is a LinearLayout with two children who are TextViews. Orientation is vertical and all of the views has wrap_content.

LinearLayout is vertical and wrap_content (widht&height)
2 TextView are wrap_content(widht&height)

1. Parent orientation is set to vertical
2. Children use the same with and height as the parent
3. The parent view has 2 children

this is a linearLayout, with vertical orientation so the child will stack over each other, there are 2 child views, they are all set to wrap on content.

1. LinearLayout is the Parent and it has 2 children (TextViews)
2. Width & height of the View Group, is adapted to the device (wrap_content).
3. Width & height of both TextViews, are adapted to the View Group (wrap_content).
4. There is a vertical orientation