android-layout android:layout_gravity setlayoutparams - Diferencia entre gravedad y layout_gravity en Android





9 Answers

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

center_horizontal example layout_weight

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 ?




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 .




Mira la imagen para ser claro 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 ".




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




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




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.




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.




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.




Related