Como alinhar as vistas na parte inferior da tela?

Aqui está o meu código de layout;

<?xml version="1.0" encoding="utf-8"?>
<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:text="@string/welcome"
        android:id="@+id/TextView"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content">
    </TextView>

    <LinearLayout android:id="@+id/LinearLayout"
        android:orientation="horizontal"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:gravity="bottom">

            <EditText android:id="@+id/EditText"
                android:layout_width="fill_parent"
                android:layout_height="wrap_content">
            </EditText>

            <Button android:text="@string/label_submit_button"
                android:id="@+id/Button"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content">
            </Button>

    </LinearLayout>

</LinearLayout>

O que parece está à esquerda e o que eu quero que esteja à direita.

A resposta óbvia é definir o TextView como fill_parent na height, mas isso não deixa espaço para o botão ou campo de entrada.

Essencialmente, o problema é que eu quero que o botão enviar e a entrada de texto tenham uma altura fixa na parte inferior e a exibição de texto para preencher o restante do espaço. Da mesma forma, no layout linear horizontal, desejo que o botão enviar envolva seu conteúdo e que a entrada de texto preencha o restante do espaço.

Se o primeiro item em um layout linear é solicitado a fill_parent, ele faz exatamente isso, não deixando espaço para outros itens. Como obtenho um item que é o primeiro em um layout linear para preencher todo o espaço além do mínimo exigido pelo restante dos itens no layout?

Layouts relativos foram de fato a resposta:

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">

    <TextView
        android:text="@string/welcome"
        android:id="@+id/TextView"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true">
    </TextView>

    <RelativeLayout
        android:id="@+id/InnerRelativeLayout"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true" >

        <Button
            android:text="@string/label_submit_button"
            android:id="@+id/Button"
            android:layout_alignParentRight="true"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content">
        </Button>

        <EditText
            android:id="@+id/EditText"
            android:layout_width="fill_parent"
            android:layout_toLeftOf="@id/Button"
            android:layout_height="wrap_content">
        </EditText>

    </RelativeLayout>

</RelativeLayout>

A maneira moderna de fazer isso é ter um ConstraintLayout e restringir a parte inferior da visualização à parte inferior do ConstraintLayout comapp:layout_constraintBottom_toBottomOf="parent"

O exemplo abaixo cria um FloatingActionButton que será alinhado ao final e à parte inferior da tela.

<android.support.constraint.ConstraintLayout
   xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:app="http://schemas.android.com/apk/res-auto"
   xmlns:tools="http://schemas.android.com/tools"
   android:layout_height="match_parent"
   android:layout_width="match_parent">

<android.support.design.widget.FloatingActionButton
    android:layout_height="wrap_content"
    android:layout_width="wrap_content"

    app:layout_constraintBottom_toBottomOf="parent"

    app:layout_constraintEnd_toEndOf="parent" />

</android.support.constraint.ConstraintLayout>

Para referência, vou manter minha antiga resposta.

Antes da introdução do ConstraintLayout, a resposta era um layout relativo .

Se você tiver um layout relativo que preencha a tela inteira, poderá usar android:layout_alignParentBottomo botão para mover o botão para a parte inferior da tela.

Se suas vistas na parte inferior não forem mostradas em um layout relativo, talvez o layout acima ocupe todo o espaço. Nesse caso, você pode colocar a visualização, que deve estar na parte inferior, primeiro no arquivo de layout e posicionar o restante do layout acima das visualizações android:layout_above. Isso permite que a visualização inferior ocupe o espaço necessário e o restante do layout pode preencher todo o restante da tela.

Em um exemplo, ScrollViewisso não funciona, pois o RelativeLayoutarquivo se sobrepõe ao que está na ScrollViewparte inferior da página.

Corrigi-o usando um alongamento dinâmico FrameLayout:

<ScrollView 
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_height="match_parent" 
    android:layout_width="match_parent"
    android:fillViewport="true">
    <LinearLayout 
        android:id="@+id/LinearLayout01"
        android:layout_width="match_parent" 
        android:layout_height="match_parent"
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:orientation="vertical">

                <!-- content goes here -->

                <!-- stretching frame layout, using layout_weight -->
        <FrameLayout
            android:layout_width="match_parent" 
            android:layout_height="0dp"
            android:layout_weight="1">
        </FrameLayout>

                <!-- content fixated to the bottom of the screen -->
        <LinearLayout 
            android:layout_width="match_parent" 
            android:layout_height="wrap_content"
            android:orientation="horizontal">
                                   <!-- your bottom content -->
        </LinearLayout>
    </LinearLayout>
</ScrollView>

Você pode manter seu layout linear inicial, aninhando o layout relativo no layout linear:

<LinearLayout
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">

    <TextView android:text="welcome" 
        android:id="@+id/TextView" 
        android:layout_width="fill_parent" 
        android:layout_height="wrap_content">
    </TextView>

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent">
        <Button android:text="submit" 
            android:id="@+id/Button" 
            android:layout_width="wrap_content" 
            android:layout_height="wrap_content"
            android:layout_alignParentBottom="true"
            android:layout_alignParentRight="true">
        </Button>
        <EditText android:id="@+id/EditText" 
            android:layout_width="match_parent" 
            android:layout_height="wrap_content"
            android:layout_toLeftOf="@id/Button"
            android:layout_alignParentBottom="true">
        </EditText>
    </RelativeLayout>
</LinearLayout>

A resposta acima (de Janusz) é bastante correta, mas eu pessoalmente não me sinto 100% confortável com RelativeLayouts, por isso prefiro introduzir um TextView vazio 'preenchedor', assim:

<!-- filler -->
<TextView android:layout_height="0dip" 
          android:layout_width="fill_parent"
          android:layout_weight="1" />

antes do elemento que deve estar na parte inferior da tela.

Você pode fazer isso com um LinearLayout ou um ScrollView também. Às vezes, é mais fácil de implementar do que um RelativeLayout. A única coisa que você precisa fazer é adicionar a seguinte exibição antes das exibições que você deseja alinhar na parte inferior da tela:

<View
    android:layout_width="wrap_content"
    android:layout_height="0dp"
    android:layout_weight="1" />

Isso cria uma vista vazia, preenchendo o espaço vazio e empurrando as próximas vistas para a parte inferior da tela.

Isso também funciona.

<LinearLayout 
    android:id="@+id/linearLayout4"
    android:layout_width="wrap_content"
    android:layout_height="fill_parent"
    android:layout_below="@+id/linearLayout3"
    android:layout_centerHorizontal="true"
    android:orientation="horizontal" 
    android:gravity="bottom"
    android:layout_alignParentBottom="true"
    android:layout_marginTop="20dp"
>

    <Button
        android:id="@+id/button1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Button" 

    />

    <Button
        android:id="@+id/button2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Button" 


    />

</LinearLayout>

1. Use ConstraintLayoutem seu layout raiz

E defina app:layout_constraintBottom_toBottomOf="parent"para deixar o Layout na parte inferior da tela:

<LinearLayout
    android:id="@+id/LinearLayout"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal"
    app:layout_constraintBottom_toBottomOf="parent">
</LinearLayout>

2. Use FrameLayoutem seu layout raiz

Basta definir android:layout_gravity="bottom"no seu layout

<LinearLayout
    android:id="@+id/LinearLayout"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_gravity="bottom"
    android:orientation="horizontal">
</LinearLayout>

3. Use LinearLayoutem seu layout raiz ( android:orientation="vertical")

(1) Defina um layout android:layout_weight="1"na parte superior do seu Layout

<TextView
    android:id="@+id/TextView"
    android:layout_width="match_parent"
    android:layout_height="0dp"
    android:layout_weight="1"
    android:text="welcome" />

(2) Defina a criança LinearLayoutparaandroid:layout_width="match_parent" android:layout_height="match_parent" android:gravity="bottom"

O principal atributo é ndroid:gravity="bottom", deixe o filho Visualizar na parte inferior do Layout.

<LinearLayout
    android:id="@+id/LinearLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="bottom"
    android:orientation="horizontal">
</LinearLayout>

4. Use RelativeLayoutno layout raiz

E defina android:layout_alignParentBottom="true"para deixar o Layout na parte inferior da tela

<LinearLayout
    android:id="@+id/LinearLayout"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_alignParentBottom="true"
    android:orientation="horizontal">
</LinearLayout>

Resultado

Seguindo a solução elegante de Timores , descobri que o seguinte cria um preenchimento vertical em um LinearLayout vertical e um preenchimento horizontal em um LinearLayout horizontal:

<Space
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_weight="1" />

Você nem precisa aninhar o segundo relativelayout dentro do primeiro. Basta usar o android:layout_alignParentBottom="true"no botão e EditText .

Se você não deseja fazer muitas alterações, basta colocar:

android:layout_weight="1"

para o TextView com ID como @+id/TextViewie

<TextView android:text="@string/welcome" 
    android:id="@+id/TextView" 
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content"
    android:layout_weight="1">
</TextView>

Criando cabeçalho e rodapé , aqui está um exemplo:

XML de layout

<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:background="@color/backgroundcolor"
    tools:context=".MainActivity">

    <RelativeLayout
        android:layout_width="fill_parent"
        android:layout_height="40dp"
        android:background="#FF0000">
    </RelativeLayout>

    <RelativeLayout
        android:layout_width="fill_parent"
        android:layout_height="40dp"
        android:layout_alignParentBottom="true"
        android:background="#FFFF00">
    </RelativeLayout>

</RelativeLayout>

Captura de tela

Use o código abaixo. Alinhe o botão ao botão. Está funcionando.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <Button
        android:id="@+id/btn_back"
        android:layout_width="100dp"
        android:layout_height="80dp"
        android:text="Back" />

    <TextView
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="0.97"
        android:gravity="center"
        android:text="Payment Page" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content" >

        <EditText
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_weight="1"/>

        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Submit"/>
    </LinearLayout>

</LinearLayout>

Para um caso como esse, sempre use RelativeLayouts. Um LinearLayout não se destina a esse uso.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/db1_root"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">

        <!-- Place your layout here -->

    </LinearLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true"
        android:layout_gravity="bottom"
        android:orientation="horizontal"
        android:paddingLeft="20dp"
        android:paddingRight="20dp" >

        <Button
            android:id="@+id/setup_macroSavebtn"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="Save" />

        <Button
            android:id="@+id/setup_macroCancelbtn"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="Cancel" />

        </LinearLayout>

</RelativeLayout>

Use android:layout_alignParentBottom="true" no seu <RelativeLayout>.

Isso definitivamente vai ajudar.

Caso você tenha uma hierarquia como esta:

<ScrollView> 
  |-- <RelativeLayout> 
    |-- <LinearLayout>

Primeiro, aplique android:fillViewport="true"ao ScrollViewe depois android:layout_alignParentBottom="true"ao LinearLayout.

Isso funcionou para mim perfeitamente.

<ScrollView
    android:layout_height="match_parent"
    android:layout_width="match_parent"
    android:scrollbars="none"
    android:fillViewport="true">
    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content">
        <LinearLayout
            android:orientation="horizontal"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:gravity="center"
            android:id="@+id/linearLayoutHorizontal"
            android:layout_alignParentBottom="true">
        </LinearLayout>
    </RelativeLayout>
</ScrollView>

Você pode apenas dar a sua visão superior da criança (o TextView @ + id / TextView ) um atributo: android:layout_weight="1".

Isso forçará todos os outros elementos abaixo para baixo.

Isso também pode ser feito com um layout linear.

Basta fornecer Altura = 0dp e peso = 1 para o layout acima e o desejado na parte inferior. Basta escrever a altura = conteúdo do invólucro e sem peso.

Ele fornece conteúdo de quebra automática para o layout (aquele que contém o texto e o botão de edição) e, em seguida, aquele que tem peso ocupa o restante do layout.

Eu descobri isso por acidente.

Usei a solução que Janusz postou, mas adicionei preenchimento à última visualização, pois a parte superior do meu layout era um ScrollView.

O ScrollView ficará parcialmente oculto à medida que cresce com o conteúdo. O uso android:paddingBottomda última visualização ajuda a mostrar todo o conteúdo no ScrollView.