Android relativelayout vs constraint layout

Relative Layout is Dead. Meet Constraint Layout — Part 1

There are 3.3 million apps on the Google Play store. For an app to be noticed you have to be the best. Building an Android UI that looks great on multiple devices can be frustrating. What if we made it easy?

Why Constraint Layout instead of other Layouts?

I see developers stick to RelativeLayout because it’s what they know, but they are missing out on great features that simplify advanced layouts. Features like view chaining, position bias, barriers and guidelines can make a layout that you previously had to break down into multiple sub views or xml files into a condensed layout. If that doesn’t convince you, Google has marked RelativeLayout as legacy code, and current documentation on it redirects to ConstraintLayout.

Constraining Views

There are four sides to a view: Start, End, Top, Bottom (Assuming api 19+).

To constrain or position a view, pick a side of the view. app:layout_constraint

Then pick a side of the view it should be relative to. app:layout_constraintTop_toOf=»«

For example, let’s put a TextView’s top to be to the bottom of a blue square view.

Centering Views

Previously, to center a view in a RelativeLayout you would write centerInParent=true. Constraint Layout instead allows centering in-between views and the parent. Constrain the start to the parent’s start and the end to the parent’s end. This will center the view horizontally.

Vertical and Horizontal Bias

Bias is the percentage of space on the Start/Top side of a view. All centered views actually have a bias of 0.5 by default. This can be adjusted to move the view from the start (horizontal bias of 0) to the end (horizontal bias of 1). The same can be done for a vertical center. A vertical bias of 0 will put the view below its top constraint and a bias of 1 will put the view above its bottom constraint.

Sizing Views

All child views need a size. There are three ways to size the child views.

1. match_parent — Match parent will be the same size as the ConstraintLayout. It will still use margins and padding.
2. wrap_content — Wrap content only uses the smallest space required. If there are no constraints, margins aren’t used. (Example: marginStart needs a constraintStart)
3. 0dp — Match constraint will make the view take up the entire space the constraints allow.

For an example, let’s use a text box in the top left corner with some margins and center a TextView Horizontally between the checkbox’s end and parent’s end. Now we can compare the different sizes using the TextView.

Chaining Views

Chaining views vertically or horizontally groups views and determines filling the space in one of four ways.

1. Spread ( Default) — Views are spaced equally between start/end or top/bottom constraints of the chain.
2. Spread Inside — Views are spread the furthest apart from each other as far as the start/end or top/bottom constraints allow.
3. Weighted — Like LinearLayout weight, each view has a weight in the chain to determine how much space each view gets. (Weight of a chain is defined by layout_constraintHorizontal_weight or layout_constraintVertical_weight.) Weighted is not a chainStyle.
4. Packed — All the views in the chain are squished together and the chain of views is spaced between the start/end or top/bottom constraints.

Weighted Chains

Weighted chains aren’t like the other three chain styles — they aren’t even a chain style. Instead, set the views in the chain to 0dp (match_constraint). Then set the horizontal or vertical weight for the views. Let’s use the previous example with the checkbox and textview. I’ve set both views to equal weights and removed the marginStart to show how a weight of 1:1 will give both views half the width of the parent.

Find out more

I’m in the process of writing a second part on the extra features of constraint layout! Follow us on medium to get updates! If you can’t wait that long, you can check out Android’s constraint layout guide.

Источник

Различия между ConstraintLayout и RelativeLayout

Я смущен различием между ConstraintLayout и RelativeLayout. Может кто-нибудь, пожалуйста, скажите мне, какие именно различия между ними?

11 ответов

Намерение ConstraintLayout состоит в том, чтобы оптимизировать и сгладить иерархию представлений ваших макетов, применив некоторые правила к каждому виду, чтобы избежать вложенности.

Правила напоминают вам о RelativeLayout , например, устанавливая левую часть слева от другого представления.

В отличие от RelativeLayout , ConstraintLayout предлагает значение bias , которое используется для позиционирования представления с точки зрения 0% и 100% горизонтального и вертикального смещения относительно ручек (помеченных кружком). Эти проценты (и фракции) предлагают бесшовное позиционирование вида по разным размерам экрана и размерам.

Исходная метка (длинная труба с закругленными углами ниже ручки круга) используется для выравнивания содержимого представления с другой ссылкой на вид.

Квадратные ручки (в каждом углу представления) используются для изменения размера представления в формате dps.

Это полностью основанное мнение, и мое впечатление от ConstraintLayout

Об этом сообщает @davidpbr ConstraintLayout performance

Я сделал два одинаковых 7-дочерних макета, по одному с родительским ConstraintLayout и RelativeLayout . Основанный на инструменте трассировки методов Android Studio, кажется, ConstraintLayout проводит больше времени в onMeasure и выполняет дополнительную работу в onFinishInflate .

Используемая библиотека ( support-v4 , appcompat-v7 …):

Версии устройств /Android воспроизводятся на: Samsung Galaxy S6 (SM-G920A. Извините, но нет Nexus Atm). Android 5.0.2

Быстрое сравнение методов отслеживания:

7 * 2 мс = 14 мс При измерении 60 мс + 52 мс

112 мс При макете всего 8 мс

141 мс Первая инициализация относительного макета почти в три раза быстрее, чем ограничение.

Эквивалентные свойства относительного макета и макета ограничения

(1) Относительная компоновка:

(1) Эквивалент макета ограничения:

(2) Относительная компоновка:

(2) Эквивалент макета ограничения:

(3) Относительная компоновка:

(3) Эквивалент макета ограничения:

(4) Относительная компоновка:

(4) Эквивалент макета ограничения:

(5) Относительная компоновка:

(5) Эквивалент макета ограничения:

(6) Относительная компоновка:

(6) Эквивалент макета ограничения:

(7) Относительная компоновка:

(7) Эквивалент макета ограничения:

(8) Относительная компоновка:

(8) Эквивалент макета ограничения:

(9) Относительная компоновка:

(9) Эквивалент макета ограничения:

(10) Относительная компоновка:

(10) Эквивалент макета ограничения:

(11) Относительная компоновка:

(11) Эквивалент макета ограничения:

(12) Относительная компоновка:

(12) Эквивалент макета ограничения:

(13) Относительная компоновка:

(13) Эквивалент макета ограничения:

(14) Относительная компоновка:

(14) Эквивалент макета ограничения:

(15) Относительная компоновка:

(15) Эквивалент макета ограничения:

(16) Относительная компоновка:

(16) Эквивалент макета ограничения:

(17) Относительная компоновка:

(17) Эквивалент макета ограничения:

(18) Относительная компоновка:

(18) Эквивалент макета ограничения:

(19) Относительная компоновка:

(19) Эквивалент макета ограничения:

(20) Относительная компоновка:

(20) Эквивалент макета ограничения:

(21) Относительная компоновка:

(21) Эквивалент макета ограничения:

(22) Относительная компоновка:

(22) Эквивалент макета ограничения:

Ниже приведены различия/преимущества:

1) Макет Constraint имеет двойную мощность как относительной компоновки, так и линейного макета: задайте относительные позиции просмотров (например, относительную компоновку), а также установите весы для динамического интерфейса (что было возможно только в линейной компоновке).

2) Очень мощное использование — группировка элементов путем формирования цепочки. Таким образом, мы можем сформировать группу представлений, которые в целом могут быть размещены желаемым образом без добавления другого уровня иерархии только для формирования другой группы представлений.

3) В дополнение к весам мы можем применять горизонтальное и вертикальное смещение, которое представляет собой не что иное, как процент перемещения из центра. (смещение 0,5 означает централизованное выравнивание. Любое значение меньше или больше означает соответствующее движение в соответствующем направлении).

4) Еще одна очень важная особенность заключается в том, что она уважает и предоставляет функциональные возможности для обработки представлений GONE, так что макеты не разбиваются, если какое-либо представление установлено в GONE через java-код. Подробнее можно найти здесь: https://developer.android.com/reference/android/support/constraint/ConstraintLayout.html#VisibilityBehavior

5) Обеспечивает автоматическое ограничение, применяемое с помощью инструмента Blue print и Visual Editor, что упрощает разработку страницы.

Все эти функции приводят к выравниванию иерархии представлений, что повышает производительность, а также помогает создавать гибкий и динамический интерфейс, который может более легко адаптироваться к разным размерам и плотности экрана.

Источник

Различия между ConstraintLayout и RelativeLayout

Я смущен различием между ConstraintLayout и RelativeLayout. Может кто-нибудь, пожалуйста, скажите мне точные различия между ними?

Намерение ConstraintLayout – оптимизировать и сгладить иерархию представлений ваших макетов, применив некоторые правила для каждого представления, чтобы избежать вложенности.

Правила напоминают вам RelativeLayout , например, устанавливая левый слева какой-либо другой вид.

В отличие от RelativeLayout , ConstraintLayout предлагает значение bias , которое используется для позиционирования вида с точки зрения 0% и 100% горизонтального и вертикального смещения относительно ручек (обозначенных кружком). Эти проценты (и фракции) предлагают бесшовное позиционирование вида с различной плотностью и размерами экрана.

Ручка базовой линии (длинная труба с закругленными углами, ниже ручки круга) используется для выравнивания содержимого представления с другой ссылкой на вид.

Квадратные ручки (на каждом углу обзора) используются для изменения размера представления в dps.

Это полностью основано на мнениях, и мое впечатление о ConstraintLayout

Сообщено командой @davidpbr ConstraintLayout

Я сделал два похожих 7-дочерних макета, по одному с родительским ConstraintLayout и RelativeLayout. На основе инструмента отслеживания методов Android Studio, похоже, ConstraintLayout проводит больше времени в onMeasure и выполняет дополнительную работу в onFinishInflate.

Используемая библиотека (поддержка-v4, appcompat-v7, …):

‘Com.android.support.constraint: ограничение-макет: 1.0.0-альфа1’

Устройства / версии для Android, воспроизводимые на: Samsung Galaxy S6 (SM-G920A. Извините, нет Nexus atm). Android 5.0.2

Быстрое сравнение трассировки метода:

Большая разница заключается в том, что ConstraintLayout уважает ограничения, даже если представление исчезло. Таким образом, он не сломает макет, если у вас есть цепочка, и вы хотите, чтобы представление исчезло посередине.

Реальный вопрос: есть ли какая-либо причина использовать какой-либо макет, кроме макета ограничения? Я считаю, что ответ может быть отрицательным.

Для тех, кто настаивает на том, что они нацелены на начинающих программистов и т. П., Они должны позаботиться о том, чтобы они уступали каким-либо другим макетам.

Конструкции ограничений лучше во всех отношениях (они стоят как 150k в размере APK). Они быстрее, они проще, они более гибкие, они лучше реагируют на изменения, устраняют проблемы, когда объекты уходят, они лучше подходят к радикально различным типам экранов, и они не используют кучу вложенного цикла с таким длинным Вытащил древовидную структуру для всего. Вы можете положить что угодно, в отношении чего угодно, где угодно.

Они были немного отвратительными в середине 2016 года, когда редактор визуальных макетов просто не был достаточно хорош, но они до такой степени, что если у вас есть макет вообще, вы можете серьезно подумать об использовании компоновки ограничений, даже Когда он делает то же самое, что RelativeLayout, или даже простой LinearLayout. У FrameLayouts явно есть свои цели. Но в этот момент я не могу ничего построить. Если бы они начали с этого, они бы ничего не добавили.

Единственное различие, которое я заметил, это то, что вещи, установленные в относительном макете с помощью перетаскивания, автоматически имеют свои размеры относительно других элементов, поэтому, когда вы запускаете приложение, то, что вы видите, это то, что вы получаете. Однако в макете ограничений, даже если вы перетаскиваете элемент в представлении дизайна, при запуске приложения вещи могут перемещаться. Это можно легко устранить, вручную установив ограничения или, более рискованным движением является щелчок правой кнопкой мыши по элементу в дереве компонентов, выбор подменю макета ограничения, а затем нажатие «infer constraints». Надеюсь это поможет

Образец дизайна RelativeLayout, который отображает элементы пользовательского интерфейса относительно друг друга. Это похоже на класс ConstraintLayout, но вы должны создать XML, тогда как ConstraintLayout использует Редактор визуального дизайна.

Источник