studio - layoutparams android example

Diferencia entre gravedad y layout_gravity en Android

Question

Sé que podemos establecer los siguientes valores para las propiedades de android:gravity y android:layout_gravity :

1. center
2. center_vertical
3. center_horizontal , etc.

Pero estoy confundido con respecto a ambos.

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

Answer 1

La diferencia

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

android:gravity es la gravedad interior de esa vista. Especifica en qué dirección deben alinearse sus contenidos.

Equivalentes HTML / CSS

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

Truco fácil para ayudarte a recordar

Tomar el layout-gravity como "Lay-outside-gravity".

Answer 2

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

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

De hecho, layout_alignParentLeft a un RelativeLayout luego utilicé layout_alignParentLeft y layout_alignParentRight en los 2 TextView contenían para TextView en una línea para ir a la izquierda y a la derecha.

Answer 3

Aunque la pregunta ya está respondida, tengo algunos ejemplos que demuestran el uso de gravedad, layout_gravity y layout_weight.

Puede encontrar los ejemplos en http://juanpickselov.com/LayoutExamples.zip

Creé los archivos en Eclipse, eliminé las subcarpetas .svn y he incluido estilos, cadenas, colores, etc. Los archivos de diseño son el punto principal de las demostraciones. Como soy un principiante de desarrollo de Java y Android, uno puede encontrar el ineficiente de Java. Los archivos se pueden copiar en un Proyecto Eclipse o también los he usado en Netbeans con el complemento de desarrollo de Android disponible para ese IDE.

Answer 4

De lo que puedo reunir 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.

Answer 5

Hay mucha diferencia en la gravity y la gravity 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 el diseño de la gravedad en FrameLayout .....

Nota:-

1. La gravedad se utiliza dentro del Contenido de la vista ya que algunos usuarios tienen respuesta y es la misma para todo el ViewGroup Layout .

2. Layout-gravity se utiliza con la vista principal ya que algunos usuarios tienen respuesta.

3. Gravity and Layout-gravity son más útiles para los niños de FrameLayout . We can''t use Gravity and Layout-gravity en la etiqueta de FrameLayout ...

4. Podemos configurar la Vista del niño en cualquier lugar del FrameLayout usando layout-gravity .

5. Podemos usar todos los valores de gravedad dentro del FrameLayout (por ejemplo: center_vertical , center_horizontal , center , top , etc.), pero no es posible con otros diseños de ViewGroup.

6. FrameLayout trabajando completamente en Layout-gravity . Ejemplo: - Si trabaja en FrameLayout , no necesita cambiar el diseño completo para agregar una nueva vista. Simplemente agregue Vista como último en el FrameLayout y le FrameLayout valor Layout-gravity . ( 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 de la gravedad en LinearLayout .....

Gravity funciona igual que la anterior, pero aquí la diferencia es que podemos utilizar la gravedad dentro de la LinearLayout View y la RelativeLayout View que no es posible en la FrameLayout View .

LinearLayout con orientación vertical ....

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

Mira el 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_gravity que son ( top | bottom | center (también llamado center_vertical )).

Mira el 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_gravity en las RelativeLayout Views pero podemos usar la gravity para establecer a los niños RelativeLayout en la misma posición ...

Answer 6

La diferencia básica entre los dos es que

Android: la gravedad se utiliza para elementos secundarios de la vista.

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

Answer 7

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

Answer 8

Respuesta corta: use android:gravity o setGravity() para controlar la gravedad de todas las vistas de niños de un contenedor; use android:layout_gravity o setLayoutParams() para controlar la gravedad de una vista individual en un contenedor.

Historia larga: para controlar la gravedad en un contenedor de diseño lineal como LinearLayout o RadioGroup , hay dos enfoques:

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

2) Para controlar la gravedad de una vista secundaria en su contenedor, use el atributo XML android:layout_gravity . En el código, uno necesita obtener el LinearLayout.LayoutParams de la vista y establecer su gravedad. Aquí hay un ejemplo de código que establece que un botón está 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 contenedor LinearLayout horizontal, la gravedad horizontal de su vista secundaria se alinea a la izquierda una tras otra y no se puede cambiar. Configurar android:layout_gravity a center_horizontal no tiene ningún efecto. La gravedad vertical predeterminada es center (o center_vertical) y se puede cambiar a la parte superior o inferior. En realidad, el valor predeterminado de layout_gravity es -1 pero Android lo coloca en el centro verticalmente.

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

De manera similar, para el contenedor del Grupo de vistas vertical, la gravedad vertical de su vista secundaria se alinea en la parte superior una debajo de otra y no se puede cambiar. La gravedad horizontal predeterminada es center (o center_horizontal ) y se puede cambiar a izquierda o derecha.

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

Answer 9

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

Answer 10

Simplemente pensé que agregaría mi propia explicación aquí: proveniente de un fondo en iOS, así es como he internalizado los dos en términos de iOS: "Gravedad de diseño" afecta su posición en la vista de supervisión. "Gravedad" afecta la posición de tus subvistas dentro de ti. Dicho de otra manera, Layout Gravity lo posiciona usted mismo mientras que la gravedad posiciona a sus hijos.

Answer 11

Sus nombres deberían ayudarte:

• android:gravity establece la gravedad de los contenidos (es decir, subvistas) de la View en la que se usa.
• android:layout_gravity establece la gravedad de la View o el Layout relación con su padre.

Y un ejemplo está here .

Answer 12

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

Recuerde la disposición en _gravity que le ayudaría a recordar que android:layout_gravity se referiría a fuera de la vista

Answer 13

Dentro fuera

• gravity organiza el contenido dentro de la vista.
• lay out _gravity arregla la posición de la vista fuera de sí misma.

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

Notas

• La layout_gravity no funciona para las vistas en un RelativeLayout . Úselo para las vistas en un LinearLayout o FrameLayout . Ver mi respuesta complementaria para más detalles.
• El ancho de la vista (o altura) tiene que ser mayor que su contenido. De lo contrario, la gravity no tendrá ningún efecto. Por lo tanto, wrap_content y la gravity tienen sentido juntos.
• El ancho (o altura) de la vista debe ser menor que el principal. De layout_gravity contrario, layout_gravity no tendrá ningún efecto. Por lo tanto, match_parent y layout_gravity tienen sentido juntos.
• El layout_gravity=center ve igual que layout_gravity=center_horizontal aquí porque están en un diseño lineal vertical. No puede centrarse verticalmente en este caso, por lo que layout_gravity=center solo se centra horizontalmente.
• Esta respuesta solo trata con la configuración de la gravity y la gravity layout_gravity en las vistas dentro de un diseño. Para ver qué sucede cuando configura la gravity del propio diseño principal, consulte la respuesta complementaria a la que me he referido anteriormente. (Resumen: la gravity no funciona bien en un RelativeLayout pero puede ser útil con un LinearLayout .)

Así que recuerda, layout _gravity organiza una vista en su diseño . Gravedad 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 programáticamente

Answer 14

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

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

Answer 15

android:gravity se utiliza para especificar cómo colocar el contenido del objeto dentro del propio objeto. En otra palabra, 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

Answer 16

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 eje Y dentro del espacio disponible).

Ejemplo: Digamos que si tuviera que trabajar con LinearLayout (Altura: match_parent, Width: match_parent) como elemento de nivel raíz, entonces tendrá espacio de fotograma completo disponible; y la vista secundaria dice 2 TextViews (Altura: wrap_content, Width: wrap_content) dentro de LinearLayout se puede mover a lo largo del eje x / y usando los valores correspondientes de la gravedad en el padre.

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

Importante: (MOVE [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ó avanzar a lo largo del eje x / y, es decir; El lugar TextViews dentro de LinearLayout. Digamos que LinearLayout especifica la gravedad: centro; lo que significa que cada TextView debe estar centrado tanto vertical como horizontalmente. Ahora, si queremos que uno de los TextView vaya a la izquierda / derecha, podemos anular el comportamiento de la gravedad especificada utilizando layout_gravity en el TextView.

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

Answer 17

gravedad : se utiliza para vistas simples como vista de texto, texto de edición, etc.

layout_gravity : se usa para la vista actual solo la gravedad en el contexto de su vista primaria relativa, como el Diseño lineal o FrameLayout, para hacer una vista en el centro o cualquier otra gravedad de su padre.

Answer 18

Mira la imagen para ser claro sobre la gravedad.

Answer 19

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_width sea ​​igual a "wrap_content"

android:layout_gravity 

se utiliza para la vista en sí misma en relación con el archivo principal o de diseño.