Что такое android gravity

Полный список

На этом уроке мы:

— разбираемся в характеристиках экрана
— рассматриваем layout параметры (высота, ширина, отступ, гравитация, вес)

Экраны

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

Возьмем в качестве примера экран смартфона HTC Desire. Диагональ = 3,7 дюйма, разрешение = 800х480 пикселей.

Кол-во пикселей в одном дюйме называется dpi (dot per inch). Узнаем чему равно dpi в данном случае, вспомнив классику: c 2 = a 2 + b 2 , где с – кол-во пикселей по диагонали, т.е. вмещаемое в 3,7 дюйма. a и b – стороны экрана.

c = 3,7 * dpi
(3,7 * dpi) 2 = 480 2 + 800 2
dpi 2 = 870400 / 13,69 = 63579
dpi = 252. Т.е. в одном дюйме экрана помещается ряд из 252 пикселей.

Возвращаемся к теме урока. Рассмотрим подробно следующие параметры View элементов

Layout width и Layout height

Про ширину (layout_width) и высоту (layout_height) мы уже немного говорили на прошлом уроке. Мы можем указывать для них абсолютные значения, а можем использовать константы. Разберем подробнее эти возможности.

Абсолютные значения:

Используются следующие единицы измерения (ЕИ):

dp или dip — Density-independent Pixels. Абстрактная ЕИ, позволяющая приложениям выглядеть одинаково на различных экранах и разрешениях.

sp — Scale-independent Pixels. То же, что и dp, только используется для размеров шрифта в View элементах

pt — 1/72 дюйма, определяется по физическому размеру экрана. Эта ЕИ из типографии.

px – пиксел, не рекомендуется использовать т.к. на разных экранах приложение будет выглядеть по-разному.

mm – миллиметр, определяется по физическому размеру экрана

in – дюйм, определяется по физическому размеру экрана

Подробней о различиях и соотношениях между этими ЕИ вы можете прочесть в этом материале сайта.

Константы

match_parent (fill_parent) – означает, что элемент займет всю доступную ему в родительском элементе ширину/высоту.

wrap_content – ширина/высота элемента будет определяться его содержимым

Project name: P0072_LayoutProp
Build Target: Android 2.3.3
Application name: LayoutProp
Package name: ru.startandroid.develop.layoutprop
Create Activity: MainActivity

Открываем main.xml. Настроим корневой LinearLayout на горизонтальную ориентацию, удалим TextView, и добавим Button с шириной и высотой равной wrap_content. Она отображается на экране и ее ширина соответствует тексту на ней.

Изменим текст с «Button» на «Button with text», сохраним и посмотрим на экран.

Кнопка стала шире, т.к. ширина определяется по содержимому. Если же мы сейчас явно укажем ей ширину 250 dp, то кнопка растянется независимо от содержимого.

Теперь сделаем ширину равной match_parent. Кнопка растянулась на всю ширину родителя, т.е. LinearLayout. А LinearLayout в свою очередь занимет всю ширину экрана.

Если у нас родитель содержит несколько элементов и мы хотим, чтобы они заняли все пространство необходимо использовать параметр Layout weight – вес. Свободное пространство распределяется между элементами пропорционально их weight-значениям.

Изменим текст нашей кнопки на B1 и добавим ей соседа по LinearLayout – вторую кнопку с текстом B2. Ширину для обоих поставьте wrap_content

Займемся дележом. Если мы хотим, чтобы кнопки поделили пространство родителя поровну – то для обеих укажем weight = 1. В этом случае кнопки равны по ширине.

Обратите внимание, что не используются единицы измерения, указываются просто числа.

Если нужно, чтобы B1 занимала четверть, а B2 три четверти свободного пространства, то проставляем weight = 1 для B1 и weight = 3 для B2.

Кол-во элементов может быть любым. Добавим еще кнопку с текстом B3, weight = 2 и width = wrap_content.

xml-код получившегося экрана:

Теперь для B2 и B3 укажите weight = 0. Они больше не претендуют на свободное пространство и занимают ширину по содержимому, а B1 забирает все себе.

Разумеется, все выше сказанное применимо и для параметра высоты — height.

При использовании weight вы можете указать значение height или width = 0dp. В этом случае не будет учитываться содержимое элементов и результат будет более соответствующий коэффициентам веса.

Layout gravity

Параметр layout_gravity аналогичен выравниванию из Word или Excel. Удобнее всего продемонстрировать его с использованием FrameLayout. Я не описывал этот Layout на прошлом уроке, т.к. он совсем простой. Все помещаемые в него элементы он по умолчанию помещает в левый верхний угол и никак их не выстраивает. Нам это очень подходит для демонстрации настроек выравнивания.

Создадим grlayout.xml:

На экране видим:

Для наглядности текст кнопки отображает ее свойства. Все очевидно и несложно.

Я честно пытался понять зачем нужны значения gravity fill_* и clip_*, но так и не понял. То, что написано про них в хелпе у меня не работает. Если у вас есть сведения по этому поводу – пишите в каменты.

Layout margin

Параметры margin полностью аналогичны margin из html. Это отступ. Он может быть со всех сторон сразу, либо только с необходимых сторон. Продемонстрируем это на примере TableLayout. Создадим marginlayout.xml и нарисуем таблицу три на три с кнопками.

И на кнопке в центре будем экспериментировать.

margin = 50 dp
Вокруг кнопки со всех сторон образовался отступ = 50 dp.

margin left = 10 dp
margin top = 20 dp
Отступ слева и сверху.

margin right = 30 dp
margin bottom = 40 dp
Отступ справа и снизу.

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

Стили

Если кто использовал HTML, то наверняка слышали про каскадные стили — CSS. Стили позволяют вам группировать атрибуты элементов (кнопок, таблиц, параграфов и т.д.). Далее вы просто применяете к элементам стили, и элемент рисуется с учетом всех атрибутов стиля. И нет необходимости повторять несколько раз один и тот же код для элементов, которые должны выглядеть одинаково. Особенно это удобно в случае изменения атрибутов. Вы просто меняете один раз стиль и все элементы с этим стилем меняются.

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

На следующем уроке:

— научимся обращаться к View-элементам из кода и менять их свойства

Присоединяйтесь к нам в Telegram:

— в канале StartAndroid публикуются ссылки на новые статьи с сайта startandroid.ru и интересные материалы с хабра, medium.com и т.п.

— в чатах решаем возникающие вопросы и проблемы по различным темам: Android, Kotlin, RxJava, Dagger, Тестирование

— ну и если просто хочется поговорить с коллегами по разработке, то есть чат Флудильня

— новый чат Performance для обсуждения проблем производительности и для ваших пожеланий по содержанию курса по этой теме

Источник

В чем разница между гравитацией и layout_gravity в Android?

Я знаю, что мы можем установить следующие значения для свойств android:gravity и android:layout_gravity :

1. center
2. center_vertical
3. center_horizontal и т. Д.

Но меня это смущает.

В чем разница между использованием android:gravity и android:layout_gravity ?

19 ответов

Их имена должны вам помочь:

• android:gravity устанавливает степень тяжести содержимого (т. Е. Его подпредставлений) View , в котором оно используется.
• android:layout_gravity устанавливает гравитацию View или Layout относительно его родителя.

Пример можно найти здесь .

Краткий ответ: используйте android:gravity или setGravity() для управления гравитацией всех дочерних представлений контейнера; используйте android:layout_gravity или setLayoutParams() для управления силой тяжести отдельного вида в контейнере.

Длинная история: для управления гравитацией в контейнере с линейной компоновкой, таком как LinearLayout или RadioGroup , есть два подхода:

1) Чтобы контролировать степень тяжести ВСЕХ дочерних представлений контейнера LinearLayout (как вы это делали в своей книге), используйте android:gravity (не android:layout_gravity ) в XML-файле макета или setGravity() в коде.

2) Чтобы управлять плотностью дочернего представления в его контейнере, используйте атрибут XML android:layout_gravity . В коде нужно получить LinearLayout.LayoutParams представления и установить его гравитацию. Вот пример кода, который устанавливает кнопку внизу в горизонтально ориентированном контейнере:

Для горизонтального контейнера LinearLayout горизонтальная сила тяжести его дочернего представления выравнивается по левому краю один за другим и не может быть изменена. Установка android:layout_gravity на center_horizontal не имеет никакого эффекта. Вертикальная гравитация по умолчанию — center (или center_vertical) и может быть изменена на верхнюю или нижнюю. На самом деле значение по умолчанию layout_gravity равно -1 , но Android помещает его по центру по вертикали.

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

Точно так же для контейнера вертикальной группы представлений вертикальная сила тяжести его дочернего представления выровнена по верхнему краю один под другим и не может быть изменена. Горизонтальная гравитация по умолчанию — центр (или center_horizontal ), и ее можно изменить влево или вправо.

Фактически, дочернее представление, такое как кнопка, также имеет атрибут XML android:gravity и метод setGravity() для управления его дочерними представлениями — текстом в нем. Button.setGravity(int) связан с этой записью developer.android.com .

Из того, что я могу понять, layout_gravity — это сила тяжести этого представления внутри его родительского объекта, а gravity — это сила тяжести дочерних элементов внутри этого представления.

Я думаю, что это правильно, но лучший способ узнать это — поиграться.

Посмотрите на изображение, чтобы понять гравитацию

Если мы хотим установить гравитацию содержимого внутри представления, мы будем использовать «android: gravity», а если мы хотим установить гравитацию этого представления (в целом) в его родительском представлении, мы будем использовать «android: layout_gravity «.

Легко запомнить, что гравитация применяется к нам внутри Земли. Итак, android:gravity для внутри представления.

Запомните out в layout out _gravity , который поможет вам запомнить, что android:layout_gravity будет относиться к внешнему вид

Просто подумал, что добавлю здесь свое собственное объяснение — исходя из фона iOS, вот как я усвоил их в терминах iOS: «Гравитация макета» влияет на вашу позицию в супервизоре. «Гравитация» влияет на положение ваших подвидов внутри вас. Другими словами, Layout Gravity позиционирует вас, а гравитацию — ваших детей.

Есть много различий в gravity и layout-gravity . Я собираюсь объяснить свой опыт использования этих двух концепций ( Вся информация, которую я получил благодаря своим наблюдениям и некоторым веб-сайтам ).

Использование гравитации и макетной гравитации в FrameLayout .

Примечание: —

Гравитация используется внутри Просмотр содержания , поскольку у некоторых пользователей есть ответ, и он одинаков для всех ViewGroup Layout .

Layout-gravity используется с родительским представлением, поскольку у некоторого пользователя есть ответ.

Gravity and Layout-gravity работать более полезно с дочерними элементами FrameLayout . We can’t use Gravity and Layout-gravity в теге FrameLayout .

Мы можем установить Детский просмотр в любом месте FrameLayout , используя layout-gravity .

Мы можем использовать каждое значение силы тяжести внутри FrameLayout (например: — center_vertical , center_horizontal , center , top и т. Д.), Но это невозможно с другими ViewGroup Макеты.

FrameLayout полностью работает над Layout-gravity . Пример: — Если вы работаете над FrameLayout , вам не нужно менять весь макет для добавления нового представления. Вы просто добавляете View последним в FrameLayout и присваиваете ему Layout-gravity значение ( Это преимущество макета-гравитации с FrameLayout ).

Использование Gravity и Layout-Gravity в LinearLayout .

Gravity работает так же, как указано выше, но здесь отличие состоит в том, что мы можем использовать гравитацию внутри LinearLayout View и RelativeLayout View , что невозможно в FrameLayout View .

LinearLayout с вертикальной ориентацией .

Примечание. — Здесь мы можем установить только 3 значения layout_gravity , то есть ( left | right | center (также называется center_horizontal )).

LinearLayout с горизонтальной ориентацией .

Примечание: — Здесь мы также можем установить 3 значения layout_gravity , то есть ( top | bottom | center (также называется center_vertical )).

Читайте также:  Плавающая клавиатура для андроид

Примечание: — Мы не можем использовать layout_gravity в RelativeLayout Views , но мы можем использовать gravity , чтобы установить дочерние элементы RelativeLayout в ту же позицию .

То, что я увидел в блоге Сандипа, что я почти пропустил, решило мою проблему. Он сказал, что layout_gravity НЕ РАБОТАЕТ С LinearLayout .

Если вы используете LinearLayout и настройки гравитации сводят вас с ума (как и я), переключитесь на что-нибудь другое.

Я фактически переключился на RelativeLayout , а затем использовал layout_alignParentLeft и layout_alignParentRight для двух содержащихся TextView , чтобы поместить их в одну строку, чтобы они шли далеко влево и вправо.

Основное различие между ними в том, что —

android: gravity используется для дочерних элементов представления.

android: layout_gravity используется для этого элемента относительно родительского представления.

android:gravity используется для указания того, как разместить содержимое объекта внутри самого объекта. Другими словами, android: gravity используется для указания степени тяжести содержимого представления.

android:layout_gravity — это атрибут, который дочерний элемент может предоставить своему родителю, чтобы указать серьезность взгляда в пределах его родителей.

Для более подробной информации вы можете посетить

Гравитация: позволяет перемещать содержимое внутри контейнера. (Как будут размещаться подвиды).

Важно: (ДВИГАЙТЕСЬ по оси X или Y в пределах доступного пространства).

Пример: Допустим, если вы работали с LinearLayout (Height: match_parent, Width: match_parent) в качестве элемента корневого уровня, тогда у вас будет доступное пространство для всего кадра; а дочерние представления говорят, что 2 TextView (Height: wrap_content, Width: wrap_content) внутри LinearLayout можно перемещать по оси x / y, используя соответствующие значения для силы тяжести на родительском элементе.

Layout_Gravity: позволяет переопределить поведение родительской силы тяжести ТОЛЬКО вдоль оси x.

Важно: (ПЕРЕМЕСТИТЕ [переопределить] по оси X в пределах доступного пространства).

Пример. Если вы помните предыдущий пример, мы знаем, что гравитация позволяет нам перемещаться по осям x / y, т. е. место TextViews внутри LinearLayout. Скажем так, LinearLayout определяет гравитацию: center; это означает, что каждый TextView должен быть центрирован как по вертикали, так и по горизонтали. Теперь, если мы хотим, чтобы один из TextView перемещался влево / вправо, мы можем переопределить указанное поведение гравитации с помощью layout_gravity в TextView.

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

Гравитация используется для установки выравнивания текста в представлениях, но layout_gravity используется для установки самих представлений. Давайте рассмотрим пример, если вы хотите выровнять текст, написанный в editText, затем использовать гравитацию, и вы хотите выровнять этот editText или любую кнопку или любое представление, а затем используйте layout_gravity, так что это очень просто.

гравитация : используется для простых представлений, таких как просмотр текста, редактирование текста и т. д.

layout_gravity : используется для текущего вида только гравитации в контексте его относительного родительского вида, такого как линейный макет или FrameLayout, чтобы сделать вид в центре или любой другой гравитацией его родительского вида.

android:gravity устанавливает гравитацию (положение) дочерних элементов, тогда как android:layout_gravity устанавливает положение самого представления. Надеюсь, поможет

Используется для настройки содержимого представления относительно его указанной позиции (выделенной области). android:gravity=»left» ничего не сделает, если layout_width равно «wrap_content»

Используется для самого представления относительно родительского файла или файла макета.

android:gravity -> Устанавливает степень тяжести содержимого представления, в котором оно используется.

android:layout_gravity -> Устанавливает степень тяжести родительского вида или макета

Гравитация — применяется к собственному виду.

Layout-gravity — Применяется к представлению, относящемуся к его родительскому объекту.

Различия

android:layout_gravity — это внешняя сила тяжести обзора. Определяет направление, в котором представление должно касаться границы своего родителя.

android:gravity — это внутренняя гравитация этого обзора. Указывает, в каком направлении должно выровняться его содержимое.

Эквиваленты HTML / CSS

(если вы работаете в сфере веб-разработки)

Простой трюк, который поможет вам запомнить

Возьмите layout-gravity как «Укладка вне гравитации».

Источник