Je ne sais pas quelle est la différence entre ConstraintLayout y RelativeLayout . Quelqu'un pourrait-il me dire quelles sont les différences exactes entre les deux ?
Intention de ConstraintLayout consiste à optimiser et à aplatir la hiérarchie des vues de vos mises en page en appliquant certaines règles à chaque vue pour éviter l'imbrication.
Les règles vous rappellent RelativeLayout par exemple en plaçant la gauche à la gauche d'une autre vue.
app:layout_constraintBottom_toBottomOf="@+id/view1"Contrairement à RelativeLayout , ConstraintLayout offre bias valeur utilisée pour positionner une vue en termes de décalage horizontal et vertical de 0 % et 100 % par rapport aux poignées (marquées d'un cercle). Ces pourcentages (et fractions) permettent un positionnement transparent de la vue sur différentes densités et tailles d'écran.
app:layout_constraintHorizontal_bias="0.33" <!-- from 0.0 to 1.0 -->
app:layout_constraintVertical_bias="0.53" <!-- from 0.0 to 1.0 -->Manche de base (long tube aux coins arrondis, sous la poignée du cercle) est utilisé pour aligner le contenu de la vue avec une autre référence de vue.
Poignées carrées (sur chaque coin de la vue) sont utilisés pour redimensionner la vue en dps.
Il s'agit d'une opinion totalement fondée et de mon impression de ConstraintLayout
Nous pouvons toujours créer une mise en page aplatie en utilisant RelativeLayout, c'est pourquoi je ne comprends pas où ConstraintLayout prend en charge ce que RelativeLayout ne peut pas faire ?
RelativeLayout est une mise en page à deux passages, qui souffre d'une double imposition. Elle doit mesurer et mettre en page au moins deux fois. ConstraintLayout ne souffre pas de cette pénalité de performance.
Oui, nous pouvons toujours créer une mise en page plate en utilisant RelativeLayout. Mais en plus de tous ceux mentionnés ici, ConstraintLayout vous permet d'utiliser marges négatives y dimensionner les sous-vues dans un rapport prédéfini . La dernière est la manière la plus robuste de conserver le rapport 16:9 pour votre ImageView dans CardView, conformément à la norme de l'UE. Conception matérielle
Propriétés équivalentes de la mise en page relative et de la mise en page contrainte
(1) Disposition relative :
android:layout_centerInParent="true" (1) Disposition des contraintes équivalente :
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintTop_toTopOf="parent"(2) Disposition relative :
android:layout_centerHorizontal="true"(2) Contrainte équivalente à la mise en page :
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintEnd_toEndOf="parent"(3) Disposition relative :
android:layout_centerVertical="true" (3) Équivalent de la mise en page des contraintes :
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintTop_toTopOf="parent"(4) Disposition relative :
android:layout_alignParentLeft="true" (4) Contrainte équivalente à la mise en page :
app:layout_constraintLeft_toLeftOf="parent"(5) Disposition relative :
android:layout_alignParentStart="true"(5) Contrainte équivalente à la mise en page :
app:layout_constraintStart_toStartOf="parent"(6) Disposition relative :
android:layout_alignParentRight="true"(6) Contrainte équivalente à la mise en page :
app:layout_constraintRight_toRightOf="parent"(7) Disposition relative :
android:layout_alignParentEnd="true" (7) Contrainte équivalente à la mise en page :
app:layout_constraintEnd_toEndOf="parent"(8) Disposition relative :
android:layout_alignParentTop="true"(8) Contrainte équivalente à la mise en page :
app:layout_constraintTop_toTopOf="parent"(9) Disposition relative :
android:layout_alignParentBottom="true" (9) Contrainte équivalente à la mise en page :
app:layout_constraintBottom_toBottomOf="parent"(10) Disposition relative :
android:layout_alignStart="@id/view"(10) Contrainte équivalente à la mise en page :
app:layout_constraintStart_toStartOf="@id/view"(11) Disposition relative :
android:layout_alignLeft="@id/view" (11) Contrainte équivalente à la mise en page :
app:layout_constraintLeft_toLeftOf="@id/view"(12) Disposition relative :
android:layout_alignEnd="@id/view" (12) Contrainte équivalente à la mise en page :
app:layout_constraintEnd_toEndOf="@id/view"(13) Disposition relative :
android:layout_alignRight="@id/view"(13) Contrainte équivalente à la mise en page :
app:layout_constraintRight_toRightOf="@id/view"(14) Disposition relative :
android:layout_alignTop="@id/view" (14) Contrainte équivalente à la mise en page :
app:layout_constraintTop_toTopOf="@id/view"(15) Disposition relative :
android:layout_alignBaseline="@id/view" (15) Contrainte équivalente à la mise en page :
app:layout_constraintBaseline_toBaselineOf="@id/view"(16) Disposition relative :
android:layout_alignBottom="@id/view"(16) Contrainte équivalente à la mise en page :
app:layout_constraintBottom_toBottomOf="@id/view"(17) Mise en page relative :
android:layout_toStartOf="@id/view"(17) Contrainte équivalente à la mise en page :
app:layout_constraintEnd_toStartOf="@id/view"(18) Disposition relative :
android:layout_toLeftOf="@id/view" (18) Contrainte équivalente à la mise en page :
app:layout_constraintRight_toLeftOf="@id/view"(19) Mise en page relative :
android:layout_toEndOf="@id/view"(19) Contrainte équivalente à la mise en page :
app:layout_constraintStart_toEndOf="@id/view"(20) Disposition relative :
android:layout_toRightOf="@id/view"(20) Contrainte équivalente à la mise en page :
app:layout_constraintLeft_toRightOf="@id/view"(21) Disposition relative :
android:layout_above="@id/view" (21) Contrainte équivalente à la mise en page :
app:layout_constraintBottom_toTopOf="@id/view"(22) Mise en page relative :
android:layout_below="@id/view" (22) Contrainte équivalente à la mise en page :
app:layout_constraintTop_toBottomOf="@id/view"
Pouvez-vous poster un texte au lieu d'une image ? Pour que ce soit très utile pour moi et pour d'autres à l'avenir.
Ces informations sont utiles, mais il s'agit simplement d'un dépotoir de documentation qui n'explique en rien la différence entre les deux.
Rapporté par @davidpbr ConstraintLayout performance
J'ai créé deux mises en page similaires à 7 enfants, chacune ayant un parent ConstraintLayout y RelativeLayout . Sur la base de l'outil de traçage des méthodes d'Android Studio, il semble que la ConstraintLayout passe plus de temps en onMeasure et effectue des travaux supplémentaires en onMeasure. onFinishInflate .
Bibliothèque utilisée ( support-v4 , appcompat-v7 ) :
com.android.support.constraint:constraint-layout:1.0.0-alpha1
Appareils/Versions Android reproduits sur : Samsung Galaxy S6 (SM-G920A. Désolé, pas de Nexus pour le moment). Android 5.0.2
Comparaison rapide des méthodes de traçage :
Exemple de dépôt Github : https://github.com/OnlyInAmerica/ConstraintLayoutPerf
Du même problème : Je vais clore cette question pour l'instant. L'alpha 4/5 a permis d'améliorer considérablement les performances. Nous serons probablement en mesure de l'améliorer davantage, mais cela pourrait attendre la version 1.0.
Pouvez-vous s'il vous plaît expliquer dans quel outil vous avez utilisé afin de créer cette grande comparaison ?
Voici les différences/avantages :
La mise en page par contrainte possède la double puissance de la mise en page relative et de la mise en page linéaire : Définissez les positions relatives des vues (comme dans le cas de la disposition relative) et définissez également les pondérations pour une interface utilisateur dynamique (ce qui n'était possible qu'avec la disposition linéaire).
Une utilisation très puissante est le regroupement d'éléments en formant une chaîne. De cette façon, nous pouvons former un groupe de vues qui, dans leur ensemble, peuvent être placées de la manière souhaitée sans ajouter une autre couche de hiérarchie juste pour former un autre groupe de vues.
En plus des poids, nous pouvons appliquer un biais horizontal et vertical qui n'est rien d'autre que le pourcentage de décalage par rapport au centre. ( un biais de 0,5 signifie un alignement central. Toute valeur inférieure ou supérieure signifie un mouvement correspondant dans la direction respective) .
Une autre caractéristique très importante est qu'il respecte et fournit la fonctionnalité pour gérer les vues GONE afin que les mises en page ne se brisent pas si une vue est définie comme GONE par le code Java. Vous trouverez plus d'informations ici : https://developer.Android.com/reference/Android/support/constraint/ConstraintLayout.html#VisibilityBehavior
Offre la possibilité d'appliquer automatiquement des contraintes grâce à l'utilisation de l'outil Blue print et de l'éditeur visuel, ce qui facilite la conception d'une page.
Toutes ces fonctionnalités permettent d'aplatir la hiérarchie des vues, ce qui améliore les performances et contribue à la création d'une interface utilisateur dynamique et réactive qui s'adapte plus facilement aux différentes tailles et densités d'écran.
C'est le meilleur endroit pour apprendre rapidement : https://codelabs.developers.google.com/codelabs/constraint-layout/#0
6) ConstraintLayout permet de dimensionner les sous-vues selon des ratios prédéfinis. medium.com/google-developers/ . C'est utile par exemple lorsque vous voulez garder votre ImageView en 16:9.
Pouvez-vous me donner un exemple ? Supposons qu'il y ait 3 boutons. Je vais cacher le 2ème bouton et le 3ème bouton est attaché au 2ème bouton avec l'identifiant btn2. Supposons que je cache le 2ème bouton, comment le 3ème bouton pourrait-il trouver l'identifiant du 2ème bouton ?
Ce n'est pas vrai. Si vous définissez la visibilité d'un bouton comme "INVISIBLE" au lieu de "GONE", vous ne briserez pas les contraintes. En ce qui me concerne, la plus grande différence, comme l'a dit @Nikola, est le biais qui vous aide à créer des vues plus "réactives".
Supposons que les boutons se trouvent l'un en dessous de l'autre. Même si vous cachez le bouton 2, il est toujours présent dans le "contrat de vue", soit dans votre xml, soit dans votre code. Le ConstraintLayout le respectera et le bouton 3 sera sous le bouton 1. Dans un RelativeLayout, le bouton 2 n'existe plus, la contrainte disparaît avec lui, et le bouton 3 se retrouvera à la position par défaut, c'est-à-dire en haut à gauche de l'écran.
Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.
11 votes
ConstraintLayout est principalement conçu pour les nouveaux programmeurs, afin qu'ils puissent facilement concevoir la mise en page à l'aide de l'éditeur visuel au lieu de construire la mise en page à la main via XML.
1 votes
@Jack sans aucun doute, il a aussi un but plus profond pour les développeurs experts et chevronnés.
0 votes
@MosesAprico vous avez raison, il a cela. Mais je pense que les développeurs experts et chevronnés ont déjà beaucoup d'autres moyens (ils connaissent déjà comme
RealtiveLayout,LinearLayout,GridLayoutetc.) pour obtenir la hiérarchie de vues qu'ils souhaitent.10 votes
@CopsOnRoad En fait, vous avez tort. Apple fait des mises en page avec contraintes depuis plus de 5 ans. Vous obtenez un design réactif à n'importe quelle taille et vous n'avez pas besoin d'écrire une tonne de mises en page complexes. Lorsque vous commencez à lier plusieurs vues, vous n'avez besoin que de 3 contrôles de base pour créer un design entièrement réactif.