Eu sei que podemos definir os seguintes valores para as propriedades android:gravitye android:layout_gravity:

1. center
2. center_vertical
3. center_horizontaletc.

Mas estou confuso em relação a ambos.

Qual é a diferença entre o uso de android:gravitye android:layout_gravity?

Os nomes deles devem ajudá-lo:

• android:gravitydefine a gravidade do conteúdo (ou seja, suas subvisões) dos Viewquais é usado.
• android:layout_gravitydefine a gravidade de Viewou em Layoutrelação ao seu pai.

E um exemplo está aqui .

Dentro fora

• gravityorganiza o conteúdo dentro da visualização.
• layout_gravityorganiza a posição da vista fora de si mesma.

Às vezes, também ajuda ver uma foto. O verde e o azul são TextViewse as outras duas cores de fundo são LinearLayouts.

Notas

• O layout_gravitynão funciona para visualizações em a RelativeLayout. Use-o para visualizações em um LinearLayoutou FrameLayout. Veja minha resposta suplementar para mais detalhes.
• A largura (ou altura) da vista deve ser maior que o seu conteúdo. Caso contrário gravity, não terá nenhum efeito. Assim, wrap_contente gravitysão sem sentido juntos.
• A largura (ou altura) da vista deve ser menor que o pai. Caso contrário layout_gravity, não terá nenhum efeito. Assim, match_parente layout_gravitysão sem sentido juntos.
• A layout_gravity=centerparece o mesmo que layout_gravity=center_horizontalaqui, porque eles estão em um layout linear vertical. Você não pode centralizar verticalmente neste caso, portanto, layout_gravity=centercentralize apenas horizontalmente.
• Esta resposta tratou apenas da configuração gravitye layout_gravitydas visualizações em um layout. Para ver o que acontece quando você define o gravitypróprio layout pai, confira a resposta complementar a que me referi acima. (Resumo: gravitynão funciona bem em um, RelativeLayoutmas pode ser útil em um LinearLayout.)

Lembre-se, o layout _gravity organiza uma exibição em seu layout . A gravidade organiza o conteúdo dentro da visualização.

xml

Aqui está o xml da imagem acima para sua referência:

<?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" >

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"
        android:background="#e3e2ad"
        android:orientation="vertical" >

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center_horizontal"
            android:textSize="24sp"
            android:text="gravity=" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:background="#bcf5b1"
            android:gravity="left"
            android:text="left" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:background="#aacaff"
            android:gravity="center_horizontal"
            android:text="center_horizontal" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:background="#bcf5b1"
            android:gravity="right"
            android:text="right" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:background="#aacaff"
            android:gravity="center"
            android:text="center" />

    </LinearLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"
        android:background="#d6c6cd"
        android:orientation="vertical" >

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center_horizontal"
            android:textSize="24sp"
            android:text="layout_gravity=" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:layout_gravity="left"
            android:background="#bcf5b1"
            android:text="left" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:layout_gravity="center_horizontal"
            android:background="#aacaff"
            android:text="center_horizontal" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:layout_gravity="right"
            android:background="#bcf5b1"
            android:text="right" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:layout_gravity="center"
            android:background="#aacaff"
            android:text="center" />

    </LinearLayout>

</LinearLayout>

Relacionado

• Diferença entre o preenchimento e a margem de uma vista
• Match_parent vs wrap_content
• Como definir a gravidade e a gravidade do layout de um LinearLayout programaticamente

A diferença

android:layout_gravityé a gravidade externa da vista. Especifica a direção na qual a Visualização deve tocar na borda de seus pais.

android:gravityé a gravidade interna dessa vista. Especifica em qual direção seu conteúdo deve se alinhar.

Equivalentes HTML / CSS

Android                 | CSS
————————————————————————+————————————
android:layout_gravity  | float
android:gravity         | text-align

Truque fácil para ajudar você a se lembrar

Tome layout-gravitycomo "Lay-outside-gravity".

Resposta curta: use android:gravityou setGravity()para controlar a gravidade de todas as visualizações filho de um contêiner; use android:layout_gravityou setLayoutParams()para controlar a gravidade de uma vista individual em um contêiner.

Longa história: para controlar a gravidade em um contêiner de layout linear, como LinearLayoutou RadioGroup, existem duas abordagens:

1) Para controlar a gravidade de TODAS as visualizações filho de um LinearLayoutcontêiner (como você fez no seu livro), use android:gravity(não android:layout_gravity) no arquivo XML de layout ou setGravity()método no código.

2) Para controlar a gravidade de uma visão filho em seu contêiner, use o android:layout_gravityatributo XML. No código, é preciso obter LinearLayout.LayoutParamsa visão e definir sua gravidade. Aqui está um exemplo de código que define um botão para baixo em um contêiner horizontalmente orientado:

import android.widget.LinearLayout.LayoutParams;
import android.view.Gravity;
...

Button button = (Button) findViewById(R.id.MyButtonId);
// need to cast to LinearLayout.LayoutParams to access the gravity field
LayoutParams params = (LayoutParams)button.getLayoutParams(); 
params.gravity = Gravity.BOTTOM;
button.setLayoutParams(params);

Para LinearLayoutcontêiner horizontal , a gravidade horizontal de sua exibição filho é alinhada à esquerda uma após a outra e não pode ser alterada. Definir android:layout_gravitypara center_horizontalnão tem efeito. A gravidade vertical padrão é o centro (ou central_vertical) e pode ser alterada para cima ou para baixo. Na verdade, o layout_gravityvalor padrão é, -1mas o Android coloca-o no centro verticalmente.

Para alterar as posições horizontais das vistas filho em um contêiner linear horizontal, pode-se usar a layout_weightmargem e o preenchimento da vista filho.

Da mesma forma, para o contêiner vertical do Grupo de vistas, a gravidade vertical da vista secundária é alinhada superiormente abaixo da outra e não pode ser alterada. A gravidade horizontal padrão é o centro (ou center_horizontal) e pode ser alterada para esquerda ou direita.

Na verdade, uma exibição filho como um botão também possui android:gravityatributo XML e o setGravity()método para controlar suas exibições filho - o texto nele. O Button.setGravity(int)está vinculado a esta entrada developer.android.com .

Pelo que posso entender, layout_gravity é a gravidade dessa visão dentro de seu pai, e a gravidade é a gravidade das crianças dentro dessa visão.

Eu acho que isso é certo, mas a melhor maneira de descobrir é brincar.

Veja a imagem para ter uma ideia clara da gravidade

Se queremos definir a gravidade do conteúdo dentro de uma visualização, usaremos "android: gravity" e, se desejarmos definir a gravidade dessa visualização (como um todo) dentro da visualização pai, usaremos "android: layout_gravity ".

Apenas pensei em adicionar minha própria explicação aqui - vindo de um background no iOS, foi assim que internalizei os dois em termos do iOS: "Layout Gravity" afeta sua posição na superview. "Gravidade" afeta a posição de suas subvisões dentro de você. Dito de outra forma, o Layout Gravity posiciona você mesmo enquanto a gravidade posiciona seus filhos.

Há muitas diferenças no gravitye layout-gravity. Vou explicar minha experiência sobre esses dois conceitos ( todas as informações que recebi devido à minha observação e alguns sites ).

Uso de gravidade e gravidade de layout em FrameLayout.....

Nota:-

1. A gravidade é usada dentro do Exibir conteúdo, pois alguns usuários têm respostas e é o mesmo para todos ViewGroup Layout.

2. Layout-gravity é usado com a tela pai, pois alguns usuários têm resposta.

3. Gravity and Layout-gravityé um trabalho mais útil com as FrameLayoutcrianças. We can't use Gravity and Layout-gravityna tag FrameLayout ....

4. Podemos definir o Child View em qualquer lugar no FrameLayoutuso layout-gravity.

5. Podemos usar cada valor único de gravidade dentro do FrameLayout (por exemplo: - center_vertical, center_horizontal, center, top, etc), mas não é possível com outros Layouts ViewGroup.

6. FrameLayouttotalmente trabalhando Layout-gravity. Exemplo: - Se você trabalha FrameLayout, não precisa alterar o Layout inteiro para adicionar uma nova Visualização. Você apenas adiciona View como último no FrameLayoute fornece a ele Layout-gravityvalor ( isso é uma vantagem da gravidade do layout com o FrameLayout ).

dê uma olhada no exemplo ......

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

    <TextView
        android:layout_width="match_parent"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#264bd1"
        android:gravity="center"
        android:layout_gravity="center"
        android:text="Center Layout Gravity"/>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#1b64b9"
        android:gravity="bottom"
        android:layout_gravity="bottom|center"
        android:text="Bottom Layout Gravity" />

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#d75d1c"
        android:gravity="top"
        android:layout_gravity="top|center"
        android:text="Top Layout Gravity"/>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginTop="100dp"
        android:textColor="#d71f1c"
        android:gravity="top|right"
        android:layout_gravity="top|right"
        android:text="Top Right Layout Gravity"/>


    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginBottom="100dp"
        android:textColor="#d71cb2"
        android:layout_gravity="bottom"
        android:gravity="bottom"
        android:text="Top Left Layout Gravity"/>

</FrameLayout>

Resultado:-

Uso de gravidade e layout-gravidade em LinearLayout .....

Gravityfuncionando da mesma maneira que acima, mas aqui a diferença é que podemos usar a Gravidade dentro da LinearLayout Viewe RelativeLayout Viewque não é possível FrameLayout View.

LinearLayout com orientação vertical ....

Nota: - Aqui podemos definir apenas 3 valores layout_gravitydesse valor ( left| right| center(também chamado center_horizontal)).

veja o exemplo: -

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

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#264bd1"
        android:gravity="center"
        android:layout_gravity="center_horizontal"
        android:text="Center Layout Gravity \nor \nCenter_Horizontal"/>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginTop="20dp"
        android:textColor="#d75d1c"
        android:layout_gravity="right"
        android:text="Right Layout Gravity"/>


    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginBottom="100dp"
        android:textColor="#d71cb2"
        android:layout_gravity="left"
        android:layout_marginTop="20dp"
        android:gravity="bottom"
        android:text="Left Layout Gravity"/>

</LinearLayout>

Resultado:-

LinearLayout com orientação horizontal ....

Nota: - Aqui também podemos definir 3 valores layout_gravitydesse valor ( top| bottom| center(também chamado center_vertical)).

veja o exemplo: -

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

    <TextView
        android:layout_width="120dp"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#264bd1"
        android:gravity="center"
        android:layout_gravity="bottom"
        android:text="Bottom \nLayout \nGravity"/>

    <TextView
        android:layout_width="120dp"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginTop="20dp"
        android:textColor="#d75d1c"
        android:layout_gravity="center"
        android:text="Center \nLayout \nGravity"/>


    <TextView
        android:layout_width="150dp"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginBottom="100dp"
        android:textColor="#d71cb2"
        android:layout_gravity="left"
        android:layout_marginTop="20dp"
        android:text="Left \nLayout \nGravity"/>

</LinearLayout>

resultado:-

Nota: - Não podemos usar layout_gravityo RelativeLayout Viewsmas podemos usar gravitypara definir os RelativeLayoutfilhos na mesma posição ....

Um truque fácil de lembrar é que a gravidade se aplica a nós dentro da terra. Então, android:gravityé para dentro da vista.

Lembre-se do out in lay out _gravity que ajudaria você a lembrar que android:layout_gravityse referiria a fora da vista

Algo que vi no blog de Sandip que quase perdi, corrigiu meu problema. Ele disse: layout_gravityNÃO TRABALHA COMLinearLayout .

Se você estiver usando um LinearLayoute as configurações de gravidade o deixarem louco (como eu), mude para outra coisa.

Na verdade, eu mudei para um RelativeLayoutentão usado layout_alignParentLefte layout_alignParentRightnos 2 TextViews contidos para colocá-los em uma linha para ir à esquerda e à direita.

A diferença básica entre os dois é que

android: gravidade é usada para elementos filhos da vista.

android: layout_gravity é usado para este elemento em relação à visualização principal.

android:gravityé usado para especificar como colocar o conteúdo do objeto dentro do próprio objeto. Em outra palavra, android: gravity é usado para especificar a gravidade do conteúdo da visualização.

android:layout_gravity é uma atribuição que a criança pode fornecer a seus pais, para especificar a gravidade da visualização dentro de seus pais.

Para mais detalhes você pode visitar

http://developer.android.com/reference/android/widget/LinearLayout.LayoutParams.html

Gravidade: permite mover o conteúdo dentro de um contêiner. (Como as sub-visualizações serão colocadas).

Importante: (MOVE-SE no eixo X ou Y no espaço disponível).

Exemplo: Digamos que se você trabalha com LinearLayout (Altura: match_parent, Largura: match_parent) como elemento de nível raiz, então você terá espaço de quadro completo disponível; e as visualizações filho dizem que 2 TextViews (Altura: wrap_content, Largura: wrap_content) dentro do LinearLayout podem ser movidos ao longo do eixo x / y usando os valores correspondentes para a gravidade no pai.

Layout_Gravity: permite substituir SOMENTE o comportamento da gravidade pai ao longo do eixo x.

Importante: (MOVER [substituir] ao longo do eixo X no espaço disponível).

Exemplo: se você se lembrar do exemplo anterior, sabemos que a gravidade nos permitiu mover-se ao longo do eixo x / y, ou seja; o lugar TextViews dentro de LinearLayout. Digamos apenas que LinearLayout especifique gravidade: center; ou seja, todo TextView precisa estar centralizado tanto na vertical quanto na horizontal. Agora, se quisermos que um dos TextView vá para esquerda / direita, podemos substituir o comportamento da gravidade especificado usando layout_gravity no TextView.

Bônus: se você se aprofundar, descobrirá que o texto no TextView atua como sub-visualização; portanto, se você aplicar a gravidade no TextView, o texto dentro do TextView se moverá. (todo o conceito se aplica aqui também)

Gravidade é usada para definir o alinhamento do texto nas visualizações, mas layout_gravity é usado para definir as visualizações por si próprio. Vamos dar um exemplo, se você deseja alinhar o texto escrito em editText, use a gravidade e você deseja alinhar este editText ou qualquer botão ou qualquer visualização e, em seguida, use layout_gravity. Portanto, é muito simples.

gravidade : é usado para visualizações simples como textview, edittext etc.

layout_gravity : é usado para a gravidade atual da vista atual apenas no contexto de sua vista pai relativa, como Layout linear ou FrameLayout, para tornar a vista no centro ou qualquer outra gravidade do pai.

android:gravity

é usado para ajustar o conteúdo da visualização em relação à sua posição especificada (área alocada). android:gravity="left" não faria nada se layout_widthfor igual ao"wrap_content"

android:layout_gravity 

é usado para se visualizar em relação ao arquivo pai ou layout.

android:gravity -> Define a gravidade do conteúdo da tela em que é usado.

android:layout_gravity -> Define a gravidade da visualização ou layout dos pais

gravidade - aplica-se a sua própria visão.

layout-gravity --- Aplica-se à visualização relacionada ao seu pai.

O android:gravitydefine a gravidade (posição) das crianças, enquanto o android:layout_gravitydefine a posição da própria visão. Espero que ajude