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

Question

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

Answer 1

Según la documentación, android:weightSum define la suma de peso máxima, y ​​se calcula como la suma de layout_weight de todos los niños, si no se especifica explícitamente.

Consideremos un ejemplo con un LinearLayout con orientación horizontal y 3 ImageViews dentro de él. Ahora queremos que estos ImageViews siempre tomen el mismo espacio. Para lograr esto, puede configurar el layout_weight de cada ImageView en 1 y el weightSum se calculará para que sea 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 tener en el layout correctamente para cualquier dispositivo, lo que no ocurrirá si se establece la anchura y la altura directamente.

Answer 2

El documentation lo dice mejor e incluye un ejemplo, (resaltando el mío).

androide: weightSum

Define la suma máxima de peso. Si no se especifica, la suma se calcula en y se agrega el diseño_peso de todos los elementos secundarios. Esto se puede usar para la instancia para dar un solo niño el 50% del espacio total disponible por dándole un layout_weight de 0.5 y configurando weightSum en 1.0.

Así que para corregir el ejemplo de SUPERM, suponga que tiene un LinearLayout con orientación horizontal que contiene dos ImageViews y una TextView con. Define el TextView para tener un tamaño fijo, y desea que los dos ImageViews ocupen el espacio restante por igual.

Para lograr esto, se aplicaría a cada , ninguno en el TextView, y una weightSum de 2.0 en el LinearLayout.

Answer 3

la adición a la respuesta de Jeff SUPERM y de,

Si hay 2 puntos de vista en el LinearLayout, el primero con un layout_weight de 1, el segundo con una layout_weight de 2 y ninguna weightSum está especificado, por defecto, el weightSum se calcula que es 3 (suma de los pesos de los niños) y la primera vista ocupa 1/3 del espacio mientras que la segunda toma 2/3.

Sin embargo, si tuviéramos que especificar weightSum como 5, el primero tomaría 1/5th del espacio mientras que el segundo tomaría 2/5th. Por lo tanto, un total de 3/5 del espacio estaría ocupado por el diseño, manteniendo el resto vacío.

Answer 4

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 a un niño el 50% del espacio total disponible, dándole un diseño_peso de 0.5 y estableciendo el pesoSum 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> 

Answer 5

Después de algunos experimentos, creo que el algoritmo para LinearLayout es la siguiente:

Supongamos que weightSum se establece en el valor El caso de ausencia se discute más adelante

En primer lugar, dividir.. weightSum por el número de elementos con match_parent o fill_parent en la dimensión del LinearLayout (por ejemplo, layout_width para orientation="horizontal"). Llamaremos a este valor el multiplicador de peso para cada elemento. El valor predeterminado para weightSum es 1.0, por lo que el multiplicador de peso predeterminado es 1/n, donde n es el número de elementos fill_parent; wrap_content elementos no contribuyen a n.

P. ej 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, p. ej. layout_width si el atributo está ausente.

En segundo lugar, se calcula la expansión máxima posible de cada elemento. En primer lugar, los elementos wrap_content se calculan según sus contenidos. Su expansión se deduce de la expansión del contenedor padre. Llamaremos al remainer expansion_remainer. Este resto se distribuye entre los elementos fill_parent según su layout_weight.

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

Ejemplo:

Si weightSum es 60, y hay 3 fill_parent elementos con las ponderaciones de 10, 20 y 30 , su expansión en la 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ínimo está limitado a 0. La expansión máxima está limitada a tamaño padre, es decir, los pesos están limitadas a 0.

Si un elemento se establece en wrap_content, su expansión se calcula primero, y la expansión restante está sujeta a distribución entre los elementos fill_parent. Si se establece weightSum, esto lleva a layout_weight sin efecto en los elementos wrap_content. Sin embargo, los elementos wrap_content aún pueden ser expulsados ​​del área visible por elementos cuyo peso sea inferior a (por ejemplo, entre 0-1 para weightSum = 1 o entre 0-20 para el ejemplo anterior).

Si no se especifica weightSum, que se calcula como la suma de todos los valores layout_weight, incluyendo elementos con wrap_content conjunto! Así que teniendo layout_weight establecido en wrap_content elementos, puede influir en su expansión. P.ej. un peso negativo reducirá los otros fill_parent elementos. Antes de diseñar los elementos fill_parent, se aplicará la fórmula anterior a wrap_content elementos, con la expansión máxima posible siendo su expansión de acuerdo con el contenido envuelto. Los elementos wrap_content se reducirán y, a continuación, se calculará y distribuirá la expansión máxima posible para los elementos fill_parent restantes.

Esto puede conducir a resultados poco intuitivos.

Answer 6

Una cosa que parece como si nadie más ha dicho: Digamos que usted tiene una verticalesLinearLayout, así que para que las pesas de diseño/elemento/foto en su interior para trabajar 100% adecuadamente - todos ellos deben tener layout_height propiedad (que debe existir en su archivo xml) configurado en 0dp. Parece que cualquier otro valor arruinaría las cosas en algunos casos.

Answer 7

De desarrollador documentation

Esto se puede utilizar por ejemplo para dar un solo niño 50% del espacio total disponible, dándole un layout_weight de 0.5 y ajuste de la weightSum a 1.0.

adición a @Shubhayu responder

resto 3/5 puede ser utilizado para otros diseños de los niños que realmente no necesitan ninguna parte específica de la disposición que contiene.

este es el uso potencial de la propiedad android:weightSum.

Answer 8

Disposición El peso funciona como una relación. Por ejemplo, si hay un diseño vertical y hay dos elementos (como botones o vistas de texto), uno con un peso de diseño 2 y otro con un peso de diseño de 3, respectivamente. Luego, el primer elemento ocupará 2 de cada 5 porciones de la pantalla/diseño y el otro 3 de 5 porciones. Aquí 5 es la suma de peso. es decir, La suma de peso divide el diseño completo en porciones definidas. Y el peso del diseño define la cantidad de porción que ocupa el artículo en particular de la suma de peso total predefinida. La suma de peso también se puede declarar manualmente. Los botones, textviews, edittexts, etc. están organizados utilizando pesos y peso de diseño cuando se utilizan diseños lineales para el diseño de la interfaz de usuario.

Answer 9

La suma de pesos funciona exactamente como desee (como otras respuestas, no es necesario 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" 

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