Qu'est-ce qu'Android: weightSum in Android et comment fonctionne-t-il?
Je veux savoir: Qu'est-ce qu'Android: weightSum et poids de mise en page, et comment fonctionnent-ils?
Par documentation, Android:weightSum définit le poids maximal pondéré et correspond à la somme du layout_weight de tous les enfants, sauf indication explicite.
Considérons un exemple avec un LinearLayout avec une orientation horizontale et 3 ImageViews à l'intérieur. Maintenant, nous voulons que ces ImageViews prennent toujours le même espace. Pour ce faire, vous pouvez définir le layout_weight de chaque ImageView sur 1 et le weightSum sera égal à 3, comme indiqué dans le commentaire.
<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 est utile pour que la mise en page soit restituée correctement pour tout périphérique, ce qui ne se produira pas si vous définissez directement la largeur et la hauteur.
Ajoutant à la réponse de superM et Jeff,
S'il existe deux vues dans LinearLayout, la première avec un layout_weight de 1, la seconde avec un layout_weight de 2 et aucun weightSum n'est spécifiée, par défaut, le weightSum est égal à 3 (somme des poids des enfants) et la première vue occupe 1/3 de l'espace tandis que la seconde occupe les 2/3.
Cependant, si nous devions spécifier weightSum à 5, le premier occuperait 1/5ème de l'espace tandis que le second prendrait 2/5ème. Donc, un total de 3/5ème de l'espace serait occupé par la mise en page en gardant le reste vide.
La somme de poids fonctionne exactement comme vous le souhaitez (comme pour les autres réponses, vous n'avez pas à additionner tous les poids de la mise en page parent). Dans la vue enfant, spécifiez le poids que vous souhaitez prendre. N'oubliez pas de spécifier
Android:layout_width="0dp"
Voici un exemple
<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>
Cela ressemblera à
Le documentation le dit mieux et comprend un exemple (en soulignant le mien).
Android: weightSum
Définit la somme de poids maximale. Si non spécifié, la somme est calculée en ajoutant le poids layout_weight de tous les enfants. Ceci peut être utilisé par exemple pour donner à un enfant unique 50% de l'espace total disponible en lui attribuant un layout_weight de 0.5 et en fixant le weightSum à 1.0.
Donc, pour corriger l'exemple de superM, supposons que vous avez une LinearLayout à orientation horizontale qui contient deux ImageViews et une TextView avec. Vous définissez la TextView pour qu'elle ait une taille fixe et vous souhaitez que les deux ImageViews occupent également l’espace restant.
Pour ce faire, vous appliqueriez layout_weight 1 à chaque ImageView, aucun sur le TextView et un weightSum de 2,0 sur le LinearLayout.
Après quelques expériences, je pense que l'algorithme pour LinearLayout est le suivant:
Supposons que weightSum soit défini sur une valeur. Le cas d'absence est discuté plus tard.
Commencez par diviser la weightSum par le nombre d’éléments avec match_parent ou fill_parent dans la dimension de LinearLayout (par exemple layout_width pour orientation="horizontal"). Nous appellerons cette valeur le multiplicateur de poids 
pour chaque élément. La valeur par défaut de weightSum étant de 1,0, le multiplicateur de pondération par défaut est 1/n, où n représente le nombre d'éléments fill_parent; Les éléments wrap_content ne contribuent pas à n.
Par exemple. Lorsque weightSum vaut 60 et qu'il y a 3 fill_parent éléments, le multiplicateur de pondération est 20. Le multiplicateur de pondération est la valeur par défaut pour ex. layout_width si l'attribut est absent.
Deuxièmement, l'expansion maximale possible de chaque élément est calculée. Tout d'abord, les éléments wrap_content sont calculés en fonction de leur contenu. Leur expansion est déduite de celle du conteneur parent. Nous appellerons le reste expansion_remainer. Ce reste est réparti entre les éléments fill_parent en fonction de leur layout_weight.
Troisièmement, le développement de chaque élément fill_parent est calculé comme suit:
layout_weight / w_m ) * maximum_possible_expansion">
Exemple:
Si weightSum vaut 60 et qu'il y a 3 fill_parent éléments correspondant aux poids 10, 20 et 30, leur extension à l'écran correspond aux 2/3, 1/3 et 0/3 du conteneur parent.
weight | expansion
0 | 3/3
10 | 2/3
20 | 1/3
30 | 0/3
40 | 0/3
L’extension minimale est plafonnée à 0. L’extension maximale est plafonnée à la taille parent, c’est-à-dire que les poids sont plafonnés à 0.
Si un élément est défini sur wrap_content, son développement est calculé en premier, et le développement restant est sujet à une distribution entre les éléments fill_parent. Si weightSum est défini, cela signifie que layout_weight n'a aucun effet sur les éléments wrap_content. Cependant, wrap_content éléments peuvent toujours être poussés hors de la zone visible par des éléments dont le poids est inférieur à (par exemple, entre 0-1 pour weightSum = 1 ou entre 0 et 20 pour l'exemple ci-dessus).
Si aucun weightSum n'est spécifié, il est calculé comme la somme de toutes les valeurs de layout_weight, --- (y compris avec wrap_content défini! Donc, avoir layout_weight défini sur wrap_content éléments, peut influencer leur développement. Par exemple. un poids négatif réduira les autres fill_parent éléments. Avant que les éléments fill_parent ne soient disposés, la formule ci-dessus sera appliquée aux éléments wrap_content, l'expansion maximale étant leur expansion en fonction du contenu encapsulé. Les éléments wrap_content seront rétrécis, puis le développement maximal possible pour les éléments fill_parent restants est calculé et distribué.
Cela peut conduire à des résultats non intuitifs.
Si non spécifié, la somme est calculée en ajoutant le poids layout_weight de tous les enfants. Ceci peut être utilisé par exemple pour donner à un seul enfant 50% de l'espace total disponible en lui attribuant un layout_weight de 0.5 et en fixant le weightSum à 1.0. Doit être une valeur à virgule flottante, telle que "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>
Une chose qui semble ne pas être mentionnée: disons que vous avez un verticalLinearLayout, donc pour que les poids dans layout/element/view à l'intérieur fonctionnent à 100% correctement - tous La propriété layout_height (qui doit exister dans votre fichier xml) doit être définie sur _0dp_. On dirait que toute autre valeur pourrait gâcher les choses dans certains cas.
Le poids de la présentation fonctionne comme un rapport. Par exemple, s'il existe une disposition verticale et qu'il y a deux éléments (tels que des boutons ou des vues de texte), l'un ayant le poids 2 et l'autre 3. Ensuite, le premier élément occupera 2 parties sur 5 de l’écran/la présentation et l’autre 3 sur 5 parties. Ici 5 est la somme du poids. C'est-à-dire la somme du poids divise la mise en page entière en portions définies.Et la pondération de la mise en page définit la portion occupée par l'élément par rapport à la somme totale prédéfinie. La somme pondérée peut être déclaré manuellement aussi. Les boutons, les vues de texte, les éditions, etc. sont tous organisés en fonction de la pondération et de l'épaisseur de la présentation lors de l'utilisation de dispositions linéaires pour la conception d'interface utilisateur.
De développeur documentation
Cela peut être utilisé par exemple pour donner à un seul enfant 50% de l'espace total disponible en lui attribuant un layout_weight de 0.5 et en lui affectant la valeur 1.0.
Ajout à la réponse @Shubhayu
rest 3/5 peut être utilisé pour d'autres mises en page enfants qui n'ont vraiment pas besoin de portion spécifique de mise en page contenant.
c'est l'utilisation potentielle de la propriété Android:weightSum.