В чем разница между единицами измерения Android?
Из Документация разработчика Android:
px Пиксели - соответствует фактическим пикселям на экране.
в Дюймы - в зависимости от физического размера экрана. 1 дюйм = 2,54 сантиметра
мм Миллиметры - в зависимости от физического размера экрана.
пт Точки - 1/72 дюйма в зависимости от физического размера экрана.
dp или dip Плотность - независимые пиксели - абстрактная единица, основанная на физической плотности экрана. Эти единицы относительно 160 экран dpi, поэтому один dp - один пиксель на экране с разрешением 160 точек на дюйм. Соотношение dp-to-pixel изменится с плотностью экрана, но не обязательно в прямой пропорции. Примечание. Компилятор принимает и «dip», и «dp», хотя «dp» больше соответствует «sp».
sp Масштаб - независимые пиксели - это похоже на устройство dp, но оно также масштабируется по предпочтению размера шрифта пользователя. Рекомендуется вам используйте этот блок при указании размеров шрифта, чтобы они были скорректированы как по плотности экрана, так и по предпочтениям пользователя.
Из Понимание независимости плотности в Android:
& Лт;!- язык: нет - >
+----------------+----------------+---------------+-------------------------------+
| Density Bucket | Screen Density | Physical Size | Pixel Size |
+----------------+----------------+---------------+-------------------------------+
| ldpi | 120 dpi | 0.5 x 0.5 in | 0.5 in * 120 dpi = 60x60 px |
+----------------+----------------+---------------+-------------------------------+
| mdpi | 160 dpi | 0.5 x 0.5 in | 0.5 in * 160 dpi = 80x80 px |
+----------------+----------------+---------------+-------------------------------+
| hdpi | 240 dpi | 0.5 x 0.5 in | 0.5 in * 240 dpi = 120x120 px |
+----------------+----------------+---------------+-------------------------------+
| xhdpi | 320 dpi | 0.5 x 0.5 in | 0.5 in * 320 dpi = 160x160 px |
+----------------+----------------+---------------+-------------------------------+
| xxhdpi | 480 dpi | 0.5 x 0.5 in | 0.5 in * 480 dpi = 240x240 px |
+----------------+----------------+---------------+-------------------------------+
| xxxhdpi | 640 dpi | 0.5 x 0.5 in | 0.5 in * 640 dpi = 320x320 px |
+----------------+----------------+---------------+-------------------------------+
& Лт;!- язык: нет - >
+---------+-------------+---------------+-------------+--------------------+
| Unit | Description | Units Per | Density | Same Physical Size |
| | | Physical Inch | Independent | On Every Screen |
+---------+-------------+---------------+-------------+--------------------+
| px | Pixels | Varies | No | No |
+---------+-------------+---------------+-------------+--------------------+
| in | Inches | 1 | Yes | Yes |
+---------+-------------+---------------+-------------+--------------------+
| mm | Millimeters | 25.4 | Yes | Yes |
+---------+-------------+---------------+-------------+--------------------+
| pt | Points | 72 | Yes | Yes |
+---------+-------------+---------------+-------------+--------------------+
| dp | Density | ~160 | Yes | No |
| | Independent | | | |
| | Pixels | | | |
+---------+-------------+---------------+-------------+--------------------+
| sp | Scale | ~160 | Yes | No |
| | Independent | | | |
| | Pixels | | | |
+---------+-------------+---------------+-------------+--------------------+
Дополнительную информацию можно также найти в Документации Google Design.
Практически все об этом и о том, как добиться наилучшей поддержки нескольких экранов разных размеров и плотностей, здесь очень хорошо документировано:
Размер экрана < br / > Фактический физический размер, измеренный по диагонали экрана. Для простоты Android объединяет все фактические размеры экрана в четыре обобщенные размеры: маленькие, нормальные, большие и очень большие.
Плотность экрана < br / > Количество пикселей в физической области экран; обычно упоминается как dpi (точки на дюйм). Например, а Экран «низкой плотности» имеет меньше пикселей в данной физической области по сравнению с «нормальным» или «высоким» экраном плотности. Для простоты Android объединяет все фактические плотности экрана в шесть обобщенных плотности: низкие, средние, высокие, сверхвысокие, сверх-сверх-высокие и экстра-экстра-экстра-высокий.
Ориентация < br / > Ориентация экрана с точки пользователя просмотр. Это либо пейзаж, либо портрет, что означает, что экран соотношение сторон является широким или высоким соответственно. Знай, что нет только разные устройства работают в разных направлениях по умолчанию, но ориентация может меняться во время выполнения, когда пользователь вращает устройство.
Разрешение < br / > Общее количество физических пикселей на экран. При добавлении поддержки для нескольких экранов приложения делают не работать напрямую с разрешением; приложения должны быть обеспокоены только с размером и плотностью экрана, как указано обобщенным размер и плотность групп.
Независимый от плотности пиксель (dp) < br / > Виртуальный пиксельная единица, которую вы должны использовать при определении макета пользовательского интерфейса для выражения размеры макета или положение не зависящим от плотности способом. Независимый от плотности пиксель эквивалентен одному физическому пикселю на 160 dpi экран, который является базовой плотностью, принятой системой для a Экран средней плотности. Во время работы система прозрачно обрабатывает любое масштабирование единиц dp, при необходимости, на основе фактической плотности экрана в использовании. Преобразование единиц dp в пиксели экрана просто:
px = dp * (dpi / 160)
. Например, на экране 240 точек на дюйм, 1 dp равно 1,5 физических пикселей. Вы всегда должны использовать единицы измерения dp, когда определение пользовательского интерфейса вашего приложения, чтобы обеспечить правильное отображение вашего пользовательского интерфейса экраны с различной плотностью.
Если вы серьезно относитесь к разработке приложения для Android для более чем одного типа устройства, вам следует хотя бы один раз прочитать документ по разработке поддержки экранов. Кроме того, всегда полезно знать фактическое количество активных устройств, имеющих определенную конфигурацию экрана.
Я подробно остановлюсь на том, как именно dp преобразуется в px:
150 * 150 dp
экранного пространства.100 * 100 dp
экранного пространства.150x150 px
займет 75 * 75 dp
экранного пространства.Наоборот, скажем, вы хотите добавить изображение в приложение, и оно вам нужно для заполнения элемента управления 100 * 100 dp
. Вам нужно будет создавать изображения разного размера для поддерживаемых размеров экрана:
100 * 100 px
изображение для mdpi150 * 150 px
изображение для hdpi200 * 200 px
изображение для xhdpipx Пиксели - точка на шкалу соответствует фактическим пикселям на экране.
в Дюймы - в зависимости от физического размера экрана.
мм Миллиметры - в зависимости от физического размера экрана.
pt Точки - 1/72 дюйма в зависимости от физического размера экрана.
dp
Плотность - независимые пиксели - абстрактная единица, основанная на физической плотности экрана.
Эти единицы относятся к экрану с разрешением 160 точек на дюйм, поэтому один dp
- это один пиксель на экране с разрешением 160 точек на дюйм. Соотношение dp-к-пикселю изменится с плотностью экрана
но не обязательно в прямой пропорции.
Примечание. Компилятор принимает dip
и dp
, хотя dp
больше соответствует sp
.
Sp
-Независимые от масштаба пиксели - это как dp
unit,
но он также масштабируется по предпочтению размера шрифта пользователя.
Рекомендуется использовать этот блок при указании размеров шрифта
поэтому они будут скорректированы как по плотности экрана, так и по предпочтениям пользователя.
Возьмите пример двух экранов одинакового размера, но один имеет плотность экрана 160 точек на дюйм (точек на дюйм, т.е. пиксели на дюйм), а другой - 240 точек на дюйм.
Lower resolution screen Higher resolution, same size
Physical Width 1.5 inches 1.5 inches
Dots Per Inch (“dpi”) 160 240
Pixels (=width*dpi) 240 360
Density (factor of baseline 160) 1.0 1.5
Density-independent Pixels 240 240
(“dip” or “dp” or “dps”)
Scale-independent pixels
(“sip” or “sp”) Depends on user font size settings same
Более того, вы должны иметь четкое понимание следующих понятий:
Размер экрана:
Фактический физический размер, измеренный по диагонали экрана. Для простоты Android группирует все реальные размеры экрана четыре обобщенных размера: маленький, нормальный, большой и очень большой.
Плотность экрана:
количество пикселей в физической области экрана; обычно упоминается как dpi (точки на дюйм). Например, а Экран «низкой плотности» имеет меньше пикселей в данной физической области по сравнению с «нормальным» или «высоким» экраном плотности. Для простоты Android объединяет все фактические плотности экрана в четыре обобщенных плотности: низкие, средние, высокие и очень высокие.
Ориентация:
Ориентация экрана с точки зрения пользователя. Это либо пейзаж, либо портрет, что означает, что соотношение сторон экрана является широким или высоким соответственно. Быть в курсе что не только разные устройства работают в разных направлениях по умолчанию, но ориентация может меняться во время выполнения, когда пользователь вращает устройство.
Разрешение:
Общее количество физических пикселей на экране. При добавлении поддержки для нескольких экранов приложения не работают напрямую с разрешением; приложения должны касаться только экрана размер и плотность, как указано обобщенным размером и плотностью группы.
Не зависящий от плотности пиксель (дп):
Виртуальный пиксельный блок, который вы должны использовать при определении макета пользовательского интерфейса, чтобы выразить размеры макета или положение в зависимости от плотности. Независимый от плотности пиксель эквивалентно одному физическому пикселю на экране с разрешением 160 точек на дюйм, который является базовая плотность, принятая системой для экрана «средней» плотности. Во время выполнения система прозрачно обрабатывает любое масштабирование dp единицы, при необходимости, основаны на фактической плотности используемого экрана. Преобразование единиц dp в пиксели экрана простое: px = dp * (dpi / 160). Например, на экране с разрешением 240 точек на дюйм 1 dp равен 1,5 физическим пиксели. Вы всегда должны использовать единицы измерения dp при определении вашего пользовательский интерфейс приложения, чтобы обеспечить правильное отображение вашего пользовательского интерфейса на экранах разные плотности.
Ссылка: сайт разработчиков Android
dp
- это dip
. Используйте его для всего (маржа, набивка и т. Д.).).
Используйте sp
только для {text-size}.
Чтобы получить одинаковый размер при разных плотностях экрана, Android переводит эти единицы в пиксели во время выполнения, поэтому вам не нужно делать сложную математику.
См. Разницу между px
, dp
и sp
на разных размерах экрана.
Введите описание изображения здесь! Источник: Android Programming: Руководство по ранчо Big Nerd
px или точка - это пиксель на физическом экране.
dpi - это пиксели на дюйм на физическом экране, которые представляют плотность дисплея.
Android дает псевдоним имен нескольким плотностям
dip или dp являются непендентными по плотности пикселями , т.е. они соответствуют более или менее пикселям в зависимости от физической плотности.
sp или sip является зависимым от масштаба пикселем . Они масштабируются, когда опция Большой текст включена в Настройки < / kbd > > Доступность < / kbd >
Используйте sp для размера текста.
Используйте dp для всего остального.
Источник 3: (данные из источника 3 приведены ниже)
Это значения размеров, определенные в XML. Измерение указано с номером, за которым следует единица измерения. Например: 10px, 2in, 5sp. Следующие единицы измерения поддерживаются Android:
дп
Независимые от плотности пиксели - абстрактная единица, основанная на физическая плотность экрана. Эти единицы относительно 160 точек на дюйм (точки на дюйм) экран, на котором 1dp примерно равен 1px. Когда работает на экране с более высокой плотностью, количество пикселей используется для рисования 1dp масштабируется с помощью фактора, подходящего для dpi экрана. Аналогично, когда на экране с более низкой плотностью используется количество пикселей для 1dp уменьшено. Соотношение dp-к-пикселю изменится с плотность экрана, но не обязательно в прямой пропорции. Использование дп единицы измерения (вместо единиц px) - это простое решение для создания представления размеры в вашем макете правильно изменяются для другого экрана плотности. Другими словами, это обеспечивает последовательность для реального мира размеры ваших элементов пользовательского интерфейса на разных устройствах.
sp
Независимые от масштаба пиксели - это как блок dp, но это также так масштабируется по предпочтению размера шрифта пользователя. Рекомендуется использовать это устройство при указании размеров шрифта, поэтому они будут скорректированы и плотность экрана, и предпочтения пользователя.
пт
Точки - 1/72 дюйма в зависимости от физического размера экрана.
px
Пиксели - соответствует фактическим пикселям на экране. Это устройство мера не рекомендуется, потому что фактическое представление может варьироваться через устройства; каждое устройство может иметь разное количество пикселей на дюйм и может иметь больше или меньше общего количества пикселей на экране.
мм
Миллиметры - в зависимости от физического размера экрана.
в
Дюймы - в зависимости от физического размера экрана.
Примечание: Измерение - это простой ресурс, на который ссылаются, используя значение, указанное в атрибуте name (а не имя файла XML). Таким образом, вы можете комбинировать ресурсы измерений с другими простыми ресурсами в одном файле XML под одним < resources > элемент.
По сути, единственный раз, когда применяется px, это один px, и это если вы хотите ровно один пиксель на экране, как в случае с делителем:
На > 160 dpi вы можете получить 2-3 пикселя
На > 120 dpi, он округляется до 0.
px
Пиксели - соответствует фактическим пикселям на экране.
dp или dip
Независимые от плотности пиксели - абстрактная единица, основанная на физической плотности экрана. Эти единицы измерения относятся к экрану с разрешением 160 точек на дюйм, поэтому один dp - это один пиксель на экране с разрешением 160 точек на дюйм.
Использование dp:
Плотность независимости - Ваше приложение достигает «независимости от плотности», когда оно сохраняет физический размер (с точки зрения пользователя) элементов пользовательского интерфейса при отображении на экранах с различной плотностью. (т. е.) Изображение должно выглядеть одинакового размера (не увеличено или уменьшено) на разных типах экранов.
sp
Независимые от масштаба пиксели - это похоже на устройство dp, но оно также масштабируется по предпочтению размера шрифта пользователя.
http://developer.android.com/guide/topics/resources/more-resources.html#Dimension
Виртуальный пиксельный блок, который вы должны использовать при определении макета пользовательского интерфейса, чтобы выразить размеры макета или положение независимо от плотности. Как описано выше, пиксель, не зависящий от плотности, эквивалентен одному физическому пикселю на экране с разрешением 160 точек на дюйм, который представляет собой базовую плотность, принятую системой для экрана с «средней» плотностью. Во время выполнения система прозрачно обрабатывает любое масштабирование блоков dp, по мере необходимости, в зависимости от фактической плотности используемого экрана. Преобразование единиц dp в пиксели экрана просто:
px = dp * (dpi / 160).
Например, на экране с разрешением 240 точек на дюйм 1 dp равен 1,5 физическим пикселям. Вы всегда должны использовать единицы измерения dp при определении пользовательского интерфейса вашего приложения, чтобы убедиться правильное отображение вашего пользовательского интерфейса на экранах с различной плотностью.
Понимание пикселя к dp и наоборот очень важно (особенно для предоставления точных значений dp творческой команде)
dp = px * 160 / dpi
MDPI = 160 dpi || Therefore, on MDPI 1 px = 1 dp
For example, if you want to convert 20 pixel to dp, use the above formula,
dp = 20 * 160 / 160 = 20.
So, 20 pixel = 20 dp.
HDPI = 240 dpi - So, on HDPI 1.5 px = 1 dp
XHDPI = 320 dpi - So, on XHDPI 2 px = 1 dp
XXHDPI = 480 dpi - So, on XXHDPI 3 px = 1 dp
For example, let us consider Nexus 4.
If 24 pixels to be converted to dp and if it is a Nexus 4 screen, developers can
convert it to dp easily by the following calculation :
dp = 24 * 160 / 320 = 12 dp
Screen dimension:
768 x 1280 pixel resolution (320 ppi or 320dpi)
Optional (screen size):
4.7" diagonal
Это объясняется выше. Старайтесь избегать в макетах файлов. Но есть некоторые случаи, когда требуется px. например, разделительная линия ListView. px лучше здесь для предоставления однопиксельной линии в качестве делителя для всех разрешений экрана.
Используйте sp для размеров шрифта. Тогда только шрифт внутри приложения будет меняться при изменении размера шрифта устройства (то есть Display -> Fonts on Device). Если вы хотите сохранить шрифт статического размера внутри приложения, вы можете указать размер шрифта в dp. В таком случае это никогда не изменится. Разработчики могут получить такое требование для некоторых конкретных экранов, для этого разработчики могут использовать dp вместо sp. Во всех остальных случаях рекомендуется sp.
Вы можете увидеть разницу между px
и dp
на рисунке ниже, а также обнаружите, что px
и dp
не могут гарантировать одинаковые физические размеры на разных экранах.
Все, что связано с размером текста и внешнего вида, должно использовать sp
или pt
. Принимая во внимание, что все, что связано с размером элементов управления, макетов и т. Д. должен использоваться с dp
.
Вы можете использовать как dp
, так и dip
на своих местах.
Я бы использовал только дп.
Существует много разговоров об использовании «sp» для размеров шрифта, и хотя я ценю это, я не думаю, что это правильно с точки зрения дизайна. Вы можете в конечном итоге сломать свой дизайн, если у пользователя есть какой-то шаткий выбор размера шрифта, и пользователь в конечном итоге будет обвинять приложение , а не свой собственный жизненный выбор.
Кроме того, если вы возьмете приложение sp-font на планшете 160 & nbsp; dpi, вы обнаружите, что все масштабируется... но ваш шрифт, который будет выглядеть крошечным по сравнению. Это не очень хорошо выглядит.
Хотя идея шрифтов "sp" имеет доброе сердце, это плохая идея. Придерживайтесь dp для всего.
sp = масштабный независимый пиксель
dp = dip = независимые от плотности пиксели
dpi = точки на дюйм
Мы должны избегать использования sp .
Мы должны использовать dp для поддержки нескольких экранов.
Android поддерживает разные разрешения экрана
Устройство ldpi 120 dp имеет размер 120 пикселей в 1 дюйм.
То же самое для других плотностей...
Мы, как разработчики программного обеспечения, должны использовать эту формулу преобразования
пиксель = dp * (плотность / 160)
Таким образом, 1 dp устройства 240 dpi будет иметь = 1 * (240/160) = 3/2 = 1,5 пикселей.
И 1 dp устройства 480 dpi будет иметь = 1 * (480/160) = 3 пикселя.
Используя эти знания 1,5 и 3 пикселей, инженер-программист может создавать макеты различной плотности.
Чтобы проверить параметры экрана любого устройства:
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
Toast.makeText(
this,
"4:" + metrics.heightPixels + "," + metrics.density + ","
+ metrics.densityDpi, Toast.LENGTH_LONG).show();
Разница между единицами dp
и sp
, упомянутыми как " предпочтение размера шрифта пользователя ", с помощью ответов, скопированных из официальной документации, можно увидеть во время выполнения, изменив Settings- > Accessibility- > Большой текст
опция.
Опция «Большой текст» заставляет текст становиться в 1,3 раза больше.
private static final float LARGE_FONT_SCALE = 1.3f;
Это может быть, конечно, зависит от поставщика, поскольку оно находится в пакетах / приложениях / настройках.
dpi -
px - пиксель
pt - баллы
в дюйме
мм-миллиметр
sp - независимый от масштаба пиксель.
окунуть -
В стандарте используются dp и sp. sp для размера шрифта и dp для всего остального.
Формула для преобразования единиц:
px = dp * (dpi / 160) ;
Density Bucket -> Screen Display => Physical Size => Pixel Size
ldpi -> 120 dpi => 0.5 x 0.5 in => 0.5 in * 120 dpi = 60x60 px
mdpi -> 160 dpi => 0.5 x 0.5 in => 0.5 in * 160 dpi = 80x80 px
hdpi -> 240 dpi => 0.5 x 0.5 in => 0.5 in * 240 dpi = 120x120 px
xhdpi -> 320 dpi => 0.5 x 0.5 in => 0.5 in * 320 dpi = 160x160 px
xxhdpi -> 480 dpi => 0.5 x 0.5 in => 0.5 in * 480 dpi = 240x240 px
xxxhdpi -> 640 dpi => 0.5 x 0.5 in => 0.5 in * 640 dpi = 320x320 px
Размер экрана в Android
сгруппирован в категории small
, medium
, large
, extra large
, double-extra
и triple-extra
. Плотность экрана - это количество пикселей в области (например, дюйм) экрана. Обычно его измеряют в точках на дюйм (dpi). Плотность экрана группируется как низкая, средняя, высокая и сверхвысокая. Разрешение - это общее количество пикселей на экране.
Формула для преобразования между единицами
px = dp * (dpi / 160)
dp to px в устройстве
Следующий пример может помочь лучше понять. Масштабирование происходит на основе размера ведра 120 (ldpi), 160 (mdpi), 240 (hdpi), 320 (xhdpi), 480 (xxhdpi) и 640 (xxxhdpi). Предлагаемое Google соотношение для проектирования составляет 3: 4: 6: 8: 12 для ldpi: mdpi: hdpi: xhdpi: xxxdpi
Изображение 150px X 150px будет занимать
- 150 dp X 150 dp экранное пространство в mdpi
- 100 dp X 100 dp экранное пространство в HDPI
- 75 dp X 75 dp экранное пространство в xhdpi
Вы можете использовать следующий калькулятор DPI, чтобы исправить размеры вашего изображения и другие размеры, если вы хотите иметь единый дизайн пользовательского интерфейса на всех устройствах Android.
Калькулятор DPI < H1 > в Java < / H1 >
/*
Program output
LDPI: 165.0 X 60.0
MDPI: 220.0 X 80.0
HDPI: 330.0 X 120.0
XHDPI: 440.0 X 160.0
XXHDPI: 660.0 X 240.0
XXXHDPI: 880.0 X 320.0
*/
public class DPICalculator {
private final float LDPI = 120;
private final float MDPI = 160;
private final float HDPI = 240;
private final float XHDPI = 320;
private final float XXHDPI = 480;
private final float XXXHDPI = 640;
private float forDeviceDensity;
private float width;
private float height;
public DPICalculator(float forDeviceDensity, float width, float height){
this.forDeviceDensity = forDeviceDensity;
this.width = width;
this.height = height;
}
public static void main(String... args) {
DPICalculator dpiCalculator = new DPICalculator(240,330,120);
dpiCalculator.calculateDPI();
}
private float getPx(float dp, float value) {
float px = dp * (value / forDeviceDensity );
return px;
}
private void calculateDPI() {
float ldpiW = getPx(LDPI,width);
float ldpiH = getPx(LDPI,height);
float mdpiW = getPx(MDPI,width);
float mdpiH = getPx(MDPI,height);
float hdpiW = getPx(HDPI,width);
float hdpiH = getPx(HDPI,height);
float xdpiW = getPx(XHDPI,width);
float xdpiH = getPx(XHDPI,height);
float xxdpiW = getPx(XXHDPI,width);
float xxdpiH = getPx(XXHDPI,height);
float xxxdpiW = getPx(XXXHDPI,width);
float xxxdpiH = getPx(XXXHDPI,height);
System.out.println("LDPI: " + ldpiW + " X " + ldpiH);
System.out.println("MDPI: " + mdpiW + " X " + mdpiH);
System.out.println("HDPI: " + hdpiW + " X " + hdpiH);
System.out.println("XHDPI: " + xdpiW + " X " + xdpiH);
System.out.println("XXHDPI: " + xxdpiW + " X " + xxdpiH);
System.out.println("XXXHDPI: " + xxxdpiW + " X " + xxxdpiH);
}
}
Дополнительная информация см. По следующей ссылке.
http://javapapers.com/android/difference-между-dp-dip-sp-px-in-mm-pt-in-android/
Вот формула, используемая Android:
px = dp * (dpi / 160)
Где dpi - одна из следующих плотностей экрана. Для списка всех возможных плотностей перейдите сюда
Он определяет константы "DENSITY_ *".
Взято из здесь.
Это решит большую путаницу при переводе между px и dp, если вы знаете свой экран dpi.
Итак, допустим, вам нужно изображение 60 dp для экрана HDPI, тогда физический размер пикселя 60 dp равен:
px = 60 * (240 / 160)