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

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.

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.

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

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

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:

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

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>

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.