¿Qué es android:weightSum en android y cómo funciona?

8 minutos de lectura

¿Que es androidweightSum en android y como funciona
Dhiral Pandya

Quiero saber: ¿Qué es android:weightSum y el peso del diseño, y cómo funcionan?

Agregando a la respuesta de superM y Jeff,

Si hay 2 vistas en LinearLayout, la primera con un layout_weight de 1, la segunda con un layout_weight de 2 y no se especifica ninguna suma de peso, de forma predeterminada, la suma de peso se calcula en 3 (suma de los pesos de los niños) y la primera vista ocupa 1/3 del espacio mientras que la segunda ocupa 2/3.

Sin embargo, si tuviéramos que especificar la suma de peso como 5, la primera ocuparía 1/5 del espacio mientras que la segunda ocuparía 2/5. Entonces, un total de 3/5 del espacio estaría ocupado por el diseño dejando el resto vacío.

  • Estaba buscando lo mismo, que pasa si la suma de pesos no está definida y los pesos se proporcionan a las vistas secundarias. Tu respuesta que calcula lo suyo propio lo aclaró todo

    – DeltaCap019

    2 de septiembre de 2014 a las 11:23

  • ¿Es cierto que se recomienda usar RelativeLayout que Layouts con weightSum?

    – Roberto

    25 de julio de 2015 a las 17:07

¿Que es androidweightSum en android y como funciona
SuperM

Por documentación, android:weightSum define la suma del peso máximo, y se calcula como la suma de los layout_weight de todos los hijos si no se especifica explícitamente.

Consideremos un ejemplo con un LinearLayout con orientación horizontal y 3 ImageViews dentro de eso. Ahora queremos estos ImageViews siempre para ocupar el mismo espacio. Para lograr esto, puede configurar el layout_weight de cada ImageView a 1 y el weightSum se calculará para ser igual a 3 como se muestra en el comentario.

<LinearLayout
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    <!-- android:weightSum="3" -->
    android:orientation="horizontal"
    android:layout_gravity="center">

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

weightSum es útil para que el diseño se represente correctamente para cualquier dispositivo, lo que no sucederá si establece el ancho y la altura directamente.

  • Esto no es una explicación del propósito de weightSum. El comportamiento en su ejemplo sería idéntico a weightSum se omite y, de hecho, weightSum no debe especificarse en ese escenario. los documentación dice, weightSum Defines the maximum weight sum. If unspecified, the sum is computed by adding the layout_weight of all of the children.

    –Jeff Axelrod

    4 de octubre de 2012 a las 3:26


  • @JeffAxelrod: ¿”No debería” especificarse? ¿Por qué? No veo ninguna razón para eso. Así que solo diría que no es necesario especificarlo.

    – graznido

    1 de febrero de 2013 a las 11:03

  • @MarcoW.: No debe especificarse debido a la mantenibilidad. Como dijo Jeff, establecer la suma de peso para que sea igual a la suma de los pesos dentro del diseño no logra nada, pero si alguien lo cambia en el futuro, podría causar dolores de cabeza, ya que ahora hay un modificador innecesario en el diseño que tendría que ser encontrado. y cambiado Esta respuesta es incorrecta y no debería ser la respuesta aceptada.

    – d370urn3ur

    11 de septiembre de 2013 a las 12:33

  • No veo una buena explicación del parámetro weightSum, así que de docs: “Esto se puede usar, por ejemplo, para darle a un solo niño el 50% del espacio total disponible dándole un layout_weight de 0.5 y configurando el weightSum a 1.0”. Ver desarrollador.android.com/reference/android/widget/…

    – Profundo desprecio

    13 de marzo de 2015 a las 14:06

  • La idea es que puede establecer la suma de peso en un número mayor que la suma de los niños. Esto hace que los niños reciban parte del espacio extra disponible, pero no todo. En el ejemplo anterior, su hijo único heredaría la mitad del espacio disponible en lugar de todo.

    –Edward Falk

    26/10/2015 a las 23:52

1646956210 235 ¿Que es androidweightSum en android y como funciona
zumbido

La suma de peso funciona exactamente como lo desea (al igual que otras respuestas, no tiene que sumar todos los pesos en el diseño principal). En la vista infantil, especifique el peso que desea que tome. No olvide especificar

android:layout_width="0dp" 

El siguiente es un ejemplo

    <LinearLayout
                android:layout_width="500dp"
                android:layout_height="20dp" >

                <TextView
                    android:layout_width="0dp"
                    android:layout_height="match_parent"
                    android:layout_weight="3"
                    android:background="@android:color/holo_green_light"
                    android:gravity="center"
                    android:text="30%"
                    android:textColor="@android:color/white" >
                </TextView>

                <TextView
                    android:layout_width="0dp"
                    android:layout_height="match_parent"
                    android:layout_weight="2"
                    android:background="@android:color/holo_blue_bright"
                    android:gravity="center"
                    android:text="20%"
                    android:textColor="@android:color/white" >
                </TextView>

                <TextView
                    android:layout_width="0dp"
                    android:layout_height="match_parent"
                    android:layout_weight="5"
                    android:background="@android:color/holo_orange_dark"
                    android:gravity="center"
                    android:text="50%"
                    android:textColor="@android:color/white" >
                </TextView>
 </LinearLayout>

esto se verá como

ingrese la descripción de la imagen aquí

los documentación lo dice mejor e incluye un ejemplo, (resaltando el mío).

android:pesoSuma

Define la suma máxima de peso. Si no se especifica, la suma se calcula sumando el layout_weight de todos los elementos secundarios. Esto se puede utilizar, por ejemplo, para dar una único child el 50 % del espacio total disponible dándole un layout_weight de 0,5 y configurando la suma de peso en 1,0.

Entonces, para corregir el ejemplo de superM, suponga que tiene un LinearLayout con orientación horizontal que contiene dos ImageViews y un TextView con. Tú defines el TextView tener un tamaño fijo, y te gustaría que los dos ImageViews para ocupar el espacio restante por igual.

Para lograr esto, usted aplicaría layout_weight 1 a cada uno ImageViewninguno en el TextViewy un weightSum de 2.0 en el LinearLayout.

Después de experimentar un poco, creo que el algoritmo para LinearLayout es este:

Asumir que weightSum se establece en un valor. El caso de ausencia se discute más adelante.

Primero, divida el weightSum por el número de elementos con match_parent o fill_parent en la dimensión del LinearLayout (p. ej. layout_width por orientation="horizontal"). Llamaremos a este valor el multiplicador de peso w_m para cada elemento. El valor predeterminado para weightSum es 1,0, por lo que el multiplicador de peso predeterminado es 1/ndonde n es el numero de fill_parent elementos; wrap_content elementos no contribuyen a n.

w_m = sumapeso / #fill_parent

por ejemplo, cuando weightSum es 60, y hay 3 fill_parent elementos, el multiplicador de peso es 20. El multiplicador de peso es el valor predeterminado para, por ejemplo, layout_width si el atributo está ausente.

En segundo lugar, se calcula la expansión máxima posible de cada elemento. Primero el wrap_content los elementos se calculan de acuerdo con su contenido. Su expansión se deduce de la expansión del contenedor principal. Llamaremos al resto expansion_remainer. Este resto se distribuye entre fill_parent elementos según su layout_weight.

En tercer lugar, la expansión de cada fill_parent elemento se calcula como:

w_m - ( diseño_peso / w_m ) * máxima_posible_expansión

Ejemplo:

Si weightSum es 60, y hay 3 fill_parent elementos con los pesos 10, 20 y 30, su expansión en pantalla es 2/3, 1/3 y 0/3 del contenedor padre.

weight | expansion
     0 | 3/3
    10 | 2/3
    20 | 1/3
    30 | 0/3
    40 | 0/3

La expansión mínima tiene un tope de 0. La expansión máxima tiene un tope de tamaño principal, es decir, los pesos tienen un tope de 0.

Si un elemento se establece en wrap_contentsu expansión se calcula primero, y la expansión restante está sujeta a distribución entre los fill_parent elementos. Si weightSum se establece, esto conduce a layout_weight sin tener efecto sobre wrap_content elementos. Sin embargo, wrap_content los elementos aún pueden ser empujados fuera del área visible por elementos cuyo peso es inferior a multiplicador de peso (por ejemplo, entre 0-1 para weightSum= 1 o entre 0-20 para el ejemplo anterior).

Si no weightSum se especifica, se calcula como la suma de todos layout_weight valores, incluso elementos con wrap_content ¡colocar! así que tener layout_weight establecer en wrap_content elementos, lata influir en su expansión. Por ejemplo, un peso negativo encogerá el otro fill_parent elementos. Antes de fill_parent se presentan los elementos, ¿se aplicará la fórmula anterior a wrap_content elementos, siendo la máxima expansión posible su expansión según el contenido envuelto. los wrap_content elementos se encogerán, y luego la máxima expansión posible para el resto fill_parent los elementos se calculan y distribuyen.

Esto puede conducir a resultados poco intuitivos.

1646956212 699 ¿Que es androidweightSum en android y como funciona
Faakhir

Si no se especifica, la suma se calcula sumando el layout_weight de todos los elementos secundarios. Esto se puede usar, por ejemplo, para darle a un solo niño el 50% del espacio total disponible dándole un layout_weight de 0.5 y configurando la suma de peso en 1.0. Debe ser un valor de punto flotante, como “1.2”

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/main_rel"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="horizontal"
        android:weightSum="2.0" >

        <RelativeLayout
            android:id="@+id/child_one"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_weight="1.0"
            android:background="#0000FF" >
        </RelativeLayout>

        <RelativeLayout
            android:id="@+id/child_two"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_weight="1.0"
            android:background="#00FF00" >
        </RelativeLayout>

    </LinearLayout>

1646956213 166 ¿Que es androidweightSum en android y como funciona
yoav feuerstein

Una cosa que parece que nadie más mencionó: digamos que tienes un vertical LinearLayoutpor lo que para que los pesos en el diseño/elemento/vista interior funcionen al 100% correctamente, todos deben tener layout_height propiedad (que debe existir en su archivo xml) establecida en 0dp. Parece que cualquier otro valor estropearía las cosas en algunos casos.

  • android:layout_width=”match_parent” generalmente se usa en lugar de 0dp

    – kc ochibili

    17 de abril de 2015 a las 16:16

  • ¿por qué es así? Quiero decir que tienes razón, está estropeando, pero establecer la altura en 0 dp solucionó mi problema. quisiera saber el motivo

    – Abdul Wahid

    19 de noviembre de 2016 a las 7:14

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad