Sé que podemos establecer los siguientes valores en las propiedades android:gravityy android:layout_gravity:

1. center
2. center_vertical
3. center_horizontaletc.

Pero estoy confundido con respecto a ambos.

¿Cuál es la diferencia entre el uso de android:gravityy android:layout_gravity?

Sus nombres deberían ayudarte:

• android:gravityestablece la gravedad de los contenidos (es decir, sus subvistas) de los Viewque se utilizan.
• android:layout_gravityestablece la gravedad de la Viewo Layoutrelativa a su padre.

Y un ejemplo está aquí .

Dentro fuera

• gravityorganiza el contenido dentro de la vista.
• layout_gravityorganiza la posición de la vista fuera de sí misma.

A veces también ayuda ver una imagen. El verde y el azul son TextViewsy los otros dos colores de fondo son LinearLayouts.

Notas

• El layout_gravityno funciona para vistas en a RelativeLayout. Úselo para vistas en un LinearLayouto FrameLayout. Vea mi respuesta suplementaria para más detalles.
• El ancho (o alto) de la vista debe ser mayor que su contenido. De gravitylo contrario no tendrá ningún efecto. Por lo tanto, wrap_contenty no gravitytienen sentido juntos.
• El ancho (o alto) de la vista debe ser menor que el padre. De layout_gravitylo contrario no tendrá ningún efecto. Por lo tanto, match_parenty no layout_gravitytienen sentido juntos.
• Se layout_gravity=centerve igual que layout_gravity=center_horizontalaquí porque están en un diseño lineal vertical. No puede centrarse verticalmente en este caso, por lo que layout_gravity=centersolo se centra horizontalmente.
• Esta respuesta solo se refería a la configuración gravityy layout_gravitylas vistas dentro de un diseño. Para ver qué sucede cuando configura el gravitydiseño principal en sí, consulte la respuesta complementaria a la que me referí anteriormente. (Resumen: gravityno funciona bien en un RelativeLayoutpero puede ser útil con un LinearLayout.)

Recuerde, layout _gravity organiza una vista en su diseño . Gravity organiza el contenido dentro de la vista.

xml

Aquí está el xml de la imagen de arriba para su referencia:

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

• Diferencia entre el relleno y el margen de una vista
• Match_parent vs wrap_content
• Cómo configurar la gravedad y la gravedad del diseño de un LinearLayout mediante programación

La diferencia

android:layout_gravityes la gravedad exterior de la vista. Especifica la dirección en la que la Vista debe tocar el borde de su padre.

android:gravityes la gravedad interior de esa vista. Especifica en qué dirección debe alinearse su contenido.

Equivalentes HTML / CSS

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

Truco fácil para ayudarte a recordar

Tómelo layout-gravitycomo "Lay-outside-gravity".

Respuesta corta: use android:gravityo setGravity()para controlar la gravedad de todas las vistas secundarias de un contenedor; use android:layout_gravityo setLayoutParams()para controlar la gravedad de una vista individual en un contenedor.

Larga historia: para controlar la gravedad en un contenedor de diseño lineal como LinearLayouto RadioGroup, hay dos enfoques:

1) Para controlar la gravedad de TODAS las vistas secundarias de un LinearLayoutcontenedor (como lo hizo en su libro), use android:gravity(no android:layout_gravity) en el archivo XML de diseño o setGravity()método en código.

2) Para controlar la gravedad de una vista secundaria en su contenedor, use el android:layout_gravityatributo XML. En el código, uno necesita obtener LinearLayout.LayoutParamsla vista y establecer su gravedad. Aquí hay un ejemplo de código que establece un botón en la parte inferior de un contenedor orientado horizontalmente:

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 el LinearLayoutcontenedor horizontal , la gravedad horizontal de su vista secundaria está alineada a la izquierda una tras otra y no se puede cambiar. Establecer android:layout_gravityen center_horizontalno tiene ningún efecto. La gravedad vertical predeterminada es center (o center_vertical) y se puede cambiar a top o bottom. En realidad, el layout_gravityvalor predeterminado es -1pero Android lo coloca en el centro verticalmente.

Para cambiar las posiciones horizontales de las vistas secundarias en un contenedor lineal horizontal, se puede usar el layout_weightmargen y el relleno de la vista secundaria.

Del mismo modo, para el contenedor de grupo de vista vertical, la gravedad vertical de su vista secundaria está alineada uno debajo del otro y no se puede cambiar. La gravedad horizontal predeterminada es el centro (o center_horizontal) y se puede cambiar a izquierda o derecha.

En realidad, una vista secundaria, como un botón, también tiene un android:gravityatributo XML y el setGravity()método para controlar sus vistas secundarias: el texto que contiene . El Button.setGravity(int)está vinculado a esta entrada de developer.android.com .

De lo que puedo deducir layout_gravity es la gravedad de esa vista dentro de su padre, y la gravedad es la gravedad de los niños dentro de esa vista.

Creo que esto es correcto, pero la mejor manera de averiguarlo es jugar.

Mire la imagen para tener claridad sobre la gravedad.

Si queremos establecer la gravedad del contenido dentro de una vista, usaremos "android: gravity", y si queremos establecer la gravedad de esta vista (como un todo) dentro de su vista principal, usaremos "android: layout_gravity ".

Solo pensé en agregar mi propia explicación aquí: viniendo de un fondo en iOS, así es como he internalizado los dos en términos de iOS: "Layout Gravity" afecta su posición en la supervista. La "gravedad" afecta la posición de sus subvistas dentro de usted. Dicho de otra manera, Layout Gravity te posiciona a ti mismo mientras que la gravedad posiciona a tus hijos.

Hay muchas diferencias en el gravityy layout-gravity. Voy a explicar mi experiencia sobre estos 2 conceptos ( toda la información que obtuve debido a mi observación y algunos sitios web ).

Uso de la gravedad y la gravedad del diseño en FrameLayout.....

Nota:-

1. La gravedad se usa dentro de Ver contenido ya que algunos usuarios tienen una respuesta y es igual para todos ViewGroup Layout.

2. Layout-gravity se usa con la Vista principal ya que algunos Usuarios tienen respuesta.

3. Gravity and Layout-gravityEs el trabajo más útil con los FrameLayoutniños. We can't use Gravity and Layout-gravityen la etiqueta de FrameLayout ...

4. Podemos configurar Child View en cualquier lugar del FrameLayoutuso layout-gravity.

5. Podemos utilizar cada valor individual de gravedad dentro de la FrameLayout (por ejemplo: - center_vertical, center_horizontal, center, top, etc), pero no es posible con otros diseños de ViewGroup.

6. FrameLayoutplenamente a trabajar en Layout-gravity. Ejemplo: - Si trabaja, FrameLayoutentonces no necesita cambiar el diseño completo para agregar una nueva vista. Simplemente agrega Ver como último en el FrameLayouty darle Layout-gravityvalor ( esto es una ventaja de la gravedad de diseño con FrameLayout ).

mira el ejemplo ......

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

Salida:-

Uso de la gravedad y el diseño-gravedad en LinearLayout .....

Gravityfunciona igual que el anterior pero aquí la diferencia es que podemos usar Gravity dentro del LinearLayout Viewy RelativeLayout Viewque no es posible en FrameLayout View.

LinearLayout con orientación vertical ....

Nota: - Aquí podemos establecer solo 3 valores de layout_gravityeso es ( left| right| center(también llamado center_horizontal)).

tener ejemplo: -

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

Salida:-

LinearLayout con orientación horizontal ....

Nota: - Aquí también podemos establecer 3 valores de layout_gravityeso es ( top| bottom| center(también llamado center_vertical)).

tener ejemplo: -

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

salida:-

Nota: - No podemos usar layout_gravityen el RelativeLayout Viewspero podemos usar gravitypara establecer RelativeLayoutniños en la misma posición ...

Un truco fácil para recordar esto es que la gravedad se aplica a nosotros dentro de la tierra. Entonces, android:gravityes para dentro de la vista.

Rememeber al cabo de laico a cabo _gravity que le ayudaría a recordar que android:layout_gravityse referiría a las afueras de la vista

Algo que vi en el blog de Sandip que casi me perdí, solucionó mi problema. Dijo que layout_gravityNO FUNCIONA LinearLayout.

Si está utilizando LinearLayoutay la configuración de gravedad lo está volviendo loco (como yo), entonces cambie a otra cosa.

De hecho, cambié a un RelativeLayoutentonces usado layout_alignParentLefty layout_alignParentRighten los 2 contenidos TextViews para ponerlos en una línea para ir a la izquierda y a la derecha.

La diferencia básica entre los dos es que:

android: gravity se usa para elementos secundarios de la vista.

android: layout_gravity se usa para este elemento con respecto a la vista principal.

android:gravityse usa para especificar cómo colocar el contenido del objeto dentro del objeto mismo. En otras palabras, android: gravity se usa para especificar la gravedad del contenido de la vista.

android:layout_gravity es una atribución que el niño puede proporcionar a su padre, para especificar la gravedad de la vista dentro de sus padres.

Para más detalles puedes visitar

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

Gravedad: le permite mover el contenido dentro de un contenedor. (Cómo se colocarán las sub-vistas).

Importante: (MOVER a lo largo del eje X o el eje Y dentro del espacio disponible).

Ejemplo: Supongamos que si trabajara con LinearLayout (Altura: coincidencia_parente, Anchura: coincidencia_parente) como elemento de nivel raíz, entonces tendrá disponible el espacio de fotograma completo; y las vistas secundarias dicen que 2 TextViews (Altura: wrap_content, Ancho: wrap_content) dentro del LinearLayout se pueden mover a lo largo del eje x / y utilizando los valores correspondientes para la gravedad en el padre.

Layout_Gravity: le permite anular el comportamiento de la gravedad principal SOLAMENTE a lo largo del eje x.

Importante: (MOVER [anular] a lo largo del eje X dentro del espacio disponible).

Ejemplo: si tiene en cuenta el ejemplo anterior, sabemos que la gravedad nos permitió movernos a lo largo del eje x / y, es decir; el lugar TextViews dentro de LinearLayout. Digamos que LinearLayout especifica gravedad: centro; lo que significa que cada TextView debe estar centrado tanto vertical como horizontalmente. Ahora, si queremos que uno de los TextView vaya hacia la izquierda / derecha, podemos anular el comportamiento de gravedad especificado usando layout_gravity en TextView.

Bonificación: si profundiza, descubrirá que el texto dentro de TextView actúa como sub-vista; así que si aplica la gravedad en TextView, el texto dentro de TextView se moverá. (todo el concepto se aplica aquí también)

La gravedad se usa para establecer la alineación del texto en las vistas, pero layout_gravity se usa para establecer las vistas por sí mismo. Tomemos un ejemplo si desea alinear el texto escrito en editText y luego usar la gravedad y desea alinear este editText o cualquier botón o cualquier vista y luego usar layout_gravity, así que es muy simple.

gravedad : se usa para vistas simples como textview, edittext, etc.

layout_gravity : se usa para la vista actual solo la gravedad en el contexto de su vista principal relativa, como Layout lineal o FrameLayout para hacer que la vista en el centro o cualquier otra gravedad de su elemento primario.

android:gravity

se utiliza para ajustar el contenido de la vista en relación con su posición específica (área asignada). android:gravity="left" no haría nada si layout_widthes igual a la"wrap_content"

android:layout_gravity 

se utiliza para visualizarse en relación con el archivo principal o de diseño.

android:gravity -> Establece la gravedad del contenido de la Vista en la que se usa.

android:layout_gravity -> Establece la gravedad de la vista o diseño de sus padres

gravedad: se aplica a su propia vista.

layout-gravity --- Se aplica a la vista relacionada con su padre.

El android:gravityestablece la gravedad (posición) de los niños, mientras que los android:layout_gravityconjuntos de la posición de la vista en sí. Espero eso ayude