В чем разница между "px", "dip", "dp" и "sp"?

В чем разница между единицами измерения андроида?

  • точек
  • падение
  • дп
  • зр
5202
задан capecrawler 08 янв. '10 в 6:23
источник поделиться

37 ответов

  • 1
  • 2

Из документации для разработчиков Android:

  1. ПВ
    Пиксели - соответствуют фактическим пикселям на экране.

  2. в
    Дюймы - на основе физического размера экрана.
    1 дюйм = 2,54 сантиметра

  3. мм
    Миллиметры - в зависимости от физических размеров экрана.

  4. пт
    Очки - 1/72 дюйма в зависимости от физического размера экрана.

  5. dp или dip
    Плотность -independent Пиксели - абстрактный блок, основанный на физической плотности экрана. Эти единицы относятся к экрану с разрешением 160 точек на дюйм, поэтому один пиксель составляет один пиксель на экране с разрешением 160 точек на дюйм. Отношение dp-to-pixel будет меняться с плотностью экрана, но не обязательно в прямой пропорции. Примечание. Компилятор принимает как "dip", так и "dp", хотя "dp" более соответствует "sp".

  6. зр
    Масштаб -independent Пиксели - это похоже на блок 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.

Чтобы вычислить размеры на реальном устройстве, это приложение можно использовать.

5230
ответ дан Alex Volovoy 08 янв. '10 в 7:41
источник поделиться

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

Размер экрана
Фактический физический размер, измеренный как диагональ экрана. Для простоты Android группирует все фактические размеры экрана в четыре обобщенные размеры: маленькие, нормальные, большие и очень большие.

Плотность экрана
Количество пикселей в пределах физической области экран; обычно называемый dpi (точек на дюйм). Например, "Низкий" экран плотности имеет меньше пикселей в заданной физической области, по сравнению с экраном "нормальной" или "высокой" плотности. Для простоты, Android объединяет все фактические плотности экрана в шесть обобщенных плотность: низкая, средняя, ​​высокая, сверхвысокая, сверхвысокая, и экстра-экстра-экстра-высокий.

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

Разрешение
Общее количество физических пикселей на экран. При добавлении поддержки нескольких экранов приложения не работают напрямую с разрешением; приложения должны быть только с размером и плотностью экрана, как указано обобщенным размера и плотности.

Независимый от плотности пиксель (dp)
Виртуальный пиксельный блок, который следует использовать при определении макета пользовательского интерфейса, чтобы выразить макетные размеры или положение не зависят от плотности. Независимый от плотности пиксель эквивалентен одному физическому пикселю на 160 экрана, который является базой плотности, принятой системой для" средний" экран плотности. Во время выполнения система прозрачно обрабатывает любое масштабирование блоков dp, если необходимо, на основе фактической плотности используемого экрана. Преобразование блоков dp ​​в пиксели экрана просто: px = dp * (dpi / 160). Например, на экране с разрешением 240 точек на дюйм 1 дп равно 1,5 физическим пикселям. Вы всегда должны использовать dp-единицы, когда определяя пользовательский интерфейс приложения, чтобы обеспечить правильное отображение вашего пользовательского интерфейса экраны с различной плотностью.

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

614
ответ дан Bruiser 25 февр. '11 в 15:56
источник поделиться

Я расскажу подробнее о том, как именно преобразование dp в px:

  • При запуске на устройстве mdpi изображение размером 150 x 150 px займет 150 * 150 dp экрана.
  • При запуске на устройстве hdpi изображение размером 150 x 150 px займет 100 * 100 dp пространства экрана.
  • Если вы работаете на устройстве xhdpi, изображение размером 150x150 px займет 75 * 75 dp экрана.

Другой способ: скажем, вы хотите добавить изображение в свое приложение, и вам нужно заполнить элемент управления 100 * 100 dp. Вам нужно будет создавать изображения разных размеров для поддерживаемых размеров экрана:

  • 100 * 100 px для mdpi
  • 150 * 150 px для hdpi
  • 200 * 200 px для xhdpi
288
ответ дан devmiles.com 02 авг. '12 в 17:15
источник поделиться

точек Пикселей - точка на шкале соответствует фактическим пикселям на экране.

в Дюймы - на основе физического размера экрана.

мм Миллиметры - на основе физического размера экрана.

пт Точки - 1/72 дюйма в зависимости от физического размера экрана.

дп Плотность - независимые пиксели - абстрактный блок, основанный на физической плотности экрана. Эти единицы относятся к экрану с разрешением 160 точек на дюйм, поэтому один dp - один пиксель на экране с разрешением 160 точек на дюйм. Отношение dp-to-pixel будет изменяться с плотностью экрана,  но не обязательно в прямой пропорции.  Примечание. Компилятор принимает как dip, так и dp, хотя dp более согласован с sp.

зр -Scale-independent Pixels - это похоже на блок dp  но он также масштабируется по предпочтению размера шрифта пользователя. Рекомендуется использовать этот аппарат при указании размеров шрифта,  поэтому они будут настроены как на плотность экрана, так и на пользовательские предпочтения.

Возьмем пример двух экранов с одинаковым размером, но каждый имеет плотность экрана 160 точек на дюйм (точек на дюйм, то есть пикселей на дюйм), а другой - 240 dpi.

                          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
238
ответ дан Amit Gajera 30 окт. '12 в 12:43
источник поделиться

Кроме того, у вас должно быть четкое понимание следующих концепций:

Размер экрана:

Фактический физический размер, измеренный как диагональ экрана. Для простоты Android группирует все фактические размеры экрана в четыре обобщенных размера: маленький, нормальный, большой и очень большой.

Плотность экрана:

Количество пикселей в физической области экрана; обычно называемый dpi (точек на дюйм). Например, "Низкий" экран плотности имеет меньше пикселей в заданной физической области, по сравнению с экраном "нормальной" или "высокой" плотности. Для простоты, Android объединяет все фактические плотности экрана в четыре обобщенных плотности: низкий, средний, высокий и очень высокий.

Ориентация:

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

Разрешение:

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

Не зависящий от плотности пиксель (dp):

Виртуальный пиксельный блок, который следует использовать при определении макета пользовательского интерфейса, для выражения размеров макета или положение не зависит от плотности. Не зависящий от плотности пиксель эквивалентно одному физическому пикселю на экране с разрешением 160 точек на дюйм, который является базовая плотность, принятая системой для экрана средней плотности. Во время выполнения система прозрачно обрабатывает любое масштабирование dp при необходимости, на основе фактической плотности используемого экрана. Преобразование единиц dp в пиксели экрана просто: px = dp * (dpi) /160). Например, на экране с разрешением 240 точек на дюйм 1 дп равен 1,5 физическим пиксели. Вы должны всегда использовать единицы измерения dp при определении пользовательский интерфейс приложения, чтобы обеспечить правильное отображение вашего пользовательского интерфейса на экранах с помощью различные плотности.

Ссылка: Сайт разработчиков Android

188
ответ дан Sazzad Hissain Khan 27 июля '13 в 0:19
источник поделиться

dp dip. Используйте его для всего (маржа, отступы и т.д.).

Используйте sp только для {text-size}.


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


См. разницу между px, dp и sp на разных размерах экрана.

Enter image description here

Источник: Android-программирование: руководство Big Nerd Ranch

173
ответ дан Mina Gabriel 17 окт. '14 в 15:47
источник поделиться

Я вычислил приведенную ниже формулу, чтобы сделать преобразования dpi равными dp и sp введите описание изображения здесь

122
ответ дан chaitanya 30 окт. '13 в 19:10
источник поделиться

Определения

px или точка - это пиксель на физическом экране.

dpi - это пиксели на дюйм на физическом экране и представляют плотность отображения.

Android дает псевдонимы для нескольких плотностей

  • ldpi (низкий) ~ 120dpi
  • mdpi (medium) ~ 160dpi
  • hdpi (высокий) ~ 240 точек на дюйм
    • большинство устройств в 2015 году здесь
  • xhdpi (extra-high) ~ 320dpi
    • Apple iPhone 4/5/6, Nexus 4
  • xxhdpi (extra-extra-high) ~ 480 точек на дюйм
    • Nexus 5
  • xxxhdpi (extra-extra-extra-high) ~ 640dpi

dip или dp являются пикселями с недостаточной плотностью, то есть они соответствуют более или менее пикселам в зависимости от физической плотности.

  • 1dp = 1px on mdpi

введите описание изображения здесь

sp или sip не зависит от масштаба. Они масштабируются, когда опция "Большой текст" включена в Settings > Accessibility

  • 1sp = 1dp
  • 1sp = 1.2dp с возможностью доступа Большой текст

Что использовать?

Используйте sp для размера текста.

Используйте dp для всего остального.

117
ответ дан rds 10 янв. '16 в 22:13
источник поделиться

Источник 1

Источник 2

Источник 3: (данные из источника 3 приведены ниже)

Это значения измерения, определенные в XML. Указано измерение с номером, за которым следует единица измерения. Например: 10px, 2in, 5SP. Android поддерживают следующие единицы измерения:

дп

Независимые от плотности пиксели - абстрактный блок, основанный на физическая плотность экрана. Эти единицы относятся к 160 dpi (точек на дюйм), на котором 1dp примерно равно 1px. когда работающий на экране с более высокой плотностью, количество пикселей, используемых для рисования 1dp масштабируется в соответствии с коэффициентом, соответствующим экрану dpi. Аналогично, когда на экране с более низкой плотностью используется количество пикселей для 1dp сокращается. Отношение dp-to-pixel будет изменяться с помощью плотность экрана, но не обязательно в прямой пропорции. Используя dp единицы (вместо единиц пикселей) - это простое решение для представления размеры в вашем макете правильно изменяются для разных экранов плотности. Другими словами, он обеспечивает согласованность для реального мира размеры элементов пользовательского интерфейса на разных устройствах.

зр

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

пт

Точки - 1/72 дюйма в зависимости от физического размера экрана.

точек

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

мм

Миллиметры - на основе физического размера экрана.

в

Дюймы - на основе физического размера экрана.

Примечание.. Измерение - это простой ресурс, на который ссылаются, используя значение, указанное в атрибуте name (а не имя файла XML). Таким образом, вы можете комбинировать ресурсы измерения с другими простыми ресурсами в одном XML файле под одним элементом.

109
ответ дан sms247 27 дек. '13 в 12:21
источник поделиться

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

На> 160 dpi вы можете получить 2-3 пикселя,

На> 120 точек на дюйм округляется до 0.

99
ответ дан Joe Plante 21 сент. '12 в 0:34
источник поделиться

точек

Пиксели - соответствуют фактическим пикселям на экране.

dp или dip

Не зависящие от плотности пиксели - абстрактный блок, основанный на физической плотности экрана. Эти единицы относятся к экрану с разрешением 160 точек на дюйм, поэтому один dp - один пиксель на экране с разрешением 160 точек на дюйм.

Использование dp:

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

зр

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

http://developer.android.com/guide/topics/resources/more-resources.html#Dimension

83
ответ дан Nirav Ranpara 02 апр. '13 в 9:35
источник поделиться

Где использовать что и отношения между px и dp?

Не зависящий от плотности пиксель (dp)

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

px = dp * (dpi/160).

Например, на экране с разрешением 240 точек на дюйм 1 дп равен 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
  • Попробуйте получить все значения пикселей в четных числах из творческой группы. В противном случае точность потери произойдет при умножении на 0,5.

ПВ

Это объяснено выше. Старайтесь избегать в файлах макетов. Но есть некоторые случаи, когда требуется рх. например, разделитель ListView. px лучше здесь для предоставления однопиксельной линии в качестве разделителя для всех разрешений по экрану.

зр

Используйте sp для размера шрифта. Тогда только шрифт внутри приложения будет меняться при изменении размера шрифта устройства (то есть Display → Fonts on Device). Если вы хотите сохранить шрифт статического размера внутри приложения, вы можете указать размер шрифта в dp. В таком случае он никогда не изменится. Разработчики могут получить такое требование для некоторых конкретных экранов, для этого разработчики могут использовать dp вместо sp. Во всех остальных случаях рекомендуется использовать sp.

83
ответ дан Arunjyothis 09 июля '14 в 8:46
источник поделиться

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

enter image description here

75
ответ дан Zephyr 13 февр. '15 в 21:50
источник поделиться

Все, что связано с размером текста и внешнего вида, должно использовать sp или pt. Принимая во внимание, что все, что связано с размером элементов управления, макетов и т.д., Должно использоваться с dp.

Вы можете использовать как dp, так и dip в своих местах.

68
ответ дан Atish Agrawal 09 авг. '13 в 16:38
источник поделиться

Я бы использовал только dp.

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

Кроме того, если вы возьмете приложение sp-font на планшете 160 dpi, вы обнаружите, что все масштабируется... но ваш шрифт, который будет выглядеть крошечным в сравнении. Это нехороший взгляд.

Хотя идея "sp" шрифтов имеет хорошее сердце, это плохая идея. Придерживайтесь dp для всего.

61
ответ дан bharal 22 нояб. '14 в 19:56
источник поделиться

sp = масштабный независимый пиксель

dp = dip = независимые от плотности пиксели

dpi = точек на дюйм

Мы не должны использовать sp.

Мы должны использовать dp для поддержки нескольких экранов.

Android поддерживает различные разрешения экрана

  • ldpi (низкий) ~ 120 dpi
  • mdpi (средний) ~ 160 dpi
  • hdpi (высокая) ~ 240 dpi
  • xhdpi (extra-high) ~ 320 dpi
  • xxhdpi (extra-extra-high) ~ 480 dpi
  • xxxhdpi (extra-extra-extra-high) ~ 640 dpi

Устройство 120dp ldpi имеет 120 пикселей в размере 1 дюйм.

То же самое для других плотностей...

Мы, как разработчики программного обеспечения, должны использовать эту формулу преобразования:

pixel = dp * (плотность/160)

Таким образом, устройство с разрешением 240 dpi 1 dp будет иметь = 1 * (240/160) = 3/2 = 1,5 пикселя.

И 480 dpi устройство 1 dp будет иметь = 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();
54
ответ дан Kushal 11 марта '15 в 9:33
источник поделиться

Разница между dp и sp единицами, указанными как "предпочтение размера пользовательских шрифтов" ответами, скопированными из официальной документации, можно увидеть во время выполнения, изменив опцию Settings->Accessibility->Large Text.

Large Text параметр заставляет текст становиться 1.3 раз больше.

private static final float LARGE_FONT_SCALE = 1.3f;

Это может быть, конечно, зависимым от поставщика, поскольку оно находится в packages/apps/Settings.

53
ответ дан auselen 14 окт. '13 в 11:44
источник поделиться

dpi -

  • Точки на дюйм
  • Измерение плотности пикселей экрана.

px - pixel

  • Для отображения пикселей экрана

pt - точки

  • Около 1/72 дюйма, в зависимости от размера физического экрана.

дюйм  - в отношении физического размера экрана (1 дюйм = 2,54 см).

мм-миллиметр  - в отношении физического размера экрана.

sp - масштабный независимый пиксель.

  • Исходя из предпочтений размера шрифта пользователя.
  • Шрифт должен находиться в 'sp'.

dip -

  • dip == dp
  • Независимый от плотности пиксель.
  • Он зависит от плотности экрана.
  • В окне с разрешением 160 точек на дюйм, 1 dp = 1 пиксель.
  • Используйте dp, кроме размера шрифта текста.

В стандарте используются 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  
46
ответ дан Arunendra 16 янв. '15 в 10:44
источник поделиться
  • px - один пиксель, то же, что и в CSS, JavaScript и т.д.
  • sp - независимые от масштаба пиксели
  • независимые от плотности пиксели пикселей

Обычно для размеров шрифта используется sp, а dip используется (также называемый dp) для других.

39
ответ дан DPC 13 нояб. '14 в 19:53
источник поделиться

Размер экрана в Android сгруппирован по категориям: small, medium, large, extra large, double-extra и triple-extra. Плотность экрана - это количество пикселей в пределах области (например, дюйма) экрана. Обычно он измеряется в точках на дюйм (dpi). Плотность экрана сгруппирована как низкая, средняя, высокая и сверхвысокая. Разрешение - общее количество пикселей на экране.

  • dp: Независимый от плотности пиксель, он зависит от плотности экрана. В 160 dpi экран, 1 dp = 1 пиксель. За исключением размера шрифта, всегда используйте dp.
  • dip: dip == dp. В предыдущих версиях Android dip использовался, а затем был изменен на dp.
  • sp: Масштабирование независимого пикселя, масштабируемое на основе предпочтений размера шрифта пользователей. Шрифты должны использовать sp.
  • px: наш обычный стандартный пиксель, который сопоставляется с пикселем экрана.
  • в дюймах, относительно физического размера экрана.
  • мм: миллиметры по размеру физического экрана.
  • pt: 1/72 дюйма, относительно физического размера экрана.

Формула для преобразования между единицами

 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: xxhdpi

Изображение размером 150 пикселей x 150 пикселей будет занимать,

  • 150 dp X 150 dp пространство экрана в mdpi
  • 100 dp X 100 dp экранное пространство в hdpi
  • 75 dp X 75 dp пространство экрана в xhdpi

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

Калькулятор DPI в Java

/*
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-between-dp-dip-sp-px-in-mm-pt-in-android/

38
ответ дан Ravi Vaghela 04 марта '16 в 8:36
источник поделиться

Здесь формула, используемая Android:

px = dp * (dpi/160)

Где dpi - одна из следующих плотностей экрана. Список всех возможных плотностей здесь

Он определяет константы "DENSITY_ *".

  • ldpi (низкий) ~ 120dpi
  • mdpi (средний) ~ 160dpi
  • hdpi (высокий) ~ 240dpi
  • xhdpi (extra-high) ~ 320dpi
  • xxhdpi (extra-extra-high) ~ 480dpi
  • xxxhdpi (extra-extra-extra-high) ~ 640dpi

Взято отсюда.

Это позволит решить много путаницы при переводе между px и dp, если вы знаете свой экранный dpi.

Итак, скажем, вы хотите изображение 60 dp для экрана hdpi, тогда размер физического пикселя 60 дп:

px = 60 * (240 / 160)
38
ответ дан Dan Borza 30 апр. '15 в 7:14
источник поделиться

Пожалуйста, прочитайте ответ из вики сообщества. Ниже приведена некоторая информация, которая будет рассмотрена в дополнение к вышеуказанным ответам.

sp = масштабный независимый пиксель

dp = независимые от плотности пиксели

dpi = плотность пикселей

Я прошел вышеупомянутые ответы... не нахожу их в точности. sp для размера текста, dp для границ макета - стандартный. Но sp для размера текста сломает макет, если он используется небрежно в большинстве устройств.

sp берет текст для устройства, тогда как dp принимает стандарт плотности устройства (никогда не меняйте устройство). Скажем, текст 100sp может занимать 80% экрана или 100% экрана в зависимости от размера шрифта, установленного в устройстве

enter image description here

Вы также можете использовать sp для ограничений макета, он будет работать :) Нет стандартного приложения sp для всего текста

Используйте sp и dp для размера текста, учитывая UX.

  • Не используйте sp для текста на панели инструментов (можете использовать доступные размеры android)
  • Не используйте sp для текста в маленьких ограниченных кнопках, очень маленьком тексте и т.д.

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

Аналогично, если у вас есть одно приложение, поддерживающее все размеры, добавление xxxhdpi-активов значительно увеличивает размер приложения. Но теперь телефоны xxxhdpi распространены, поэтому мы должны включать активы xxxhdpi по крайней мере для значков в боковой панели, панели инструментов и нижней панели. Его лучше перемещать в векторные изображения, чтобы иметь однородные и качественные изображения для всех размеров экрана.

30
ответ дан shijin 26 мая '16 в 8:32
источник поделиться

Я столкнулся с хорошей статьей о разработке пользовательского интерфейса Android для разных разрешений экрана, и я хотел бы оставить его здесь только для тех, кто ищет в этой области. Да, я знаю, что это как-то описано в документах Google (и упоминается в сообщениях выше), я читал это, но это было плохо для меня (да, я могу быть слишком глупым)). Мне осталось неясным, как создавать макеты, способные обрабатывать различные размеры экрана. Я ненавижу концепцию DP и т.д., Когда мне нужно реализовать "гибкий" макет интерфейса для разных экранов. (Привет, разработчики iOS - да, вы правы, это концепция раскадровки).

У Android неплохая концепция пользовательского интерфейса, но, к сожалению, не хватает функций раскадровки iOS. Разработка гибкого пользовательского интерфейса в Android - это не просто (в лучшем случае).

Вот статья, которая помогла мне понять, что делать в Android, чтобы сделать макеты для разных размеров экрана:

Блог JMSTUDIO: - Определите размер экрана приложения Android

Как создать интерфейс для Android-приложений для разных размеров экрана

Чтобы создать пользовательский интерфейс приложения для разных размеров экрана, наш первоначальный дизайн должен соответствовать минимально требуемому пространству для каждого размера экрана. Android определяет минимальный размер (в dp) для каждого обобщенного типа экрана. Ниже приведено руководство по размеру экрана Android. Minimum Screen Size for Android in dp Когда мы получаем размер экрана в формате dp, нам недостаточно разрабатывать пользовательский интерфейс приложения для Android. Для каждого размера экрана нам нужно подготовить графические и растровые изображения для каждой плотности. Вот ориентир на плотность экрана Android. Android Density Guideline (dpi)

Для удобства расчета мы можем следить за коэффициентом масштабирования 3: 4: 6: 8 между четырьмя обобщенными плотностями. Если мы создадим изображение размером 36 × 36 пикселей для устройства ldpi, размер снимков остальных размеров будет 48 × 48 для mdpi, 72 × 72 для hdpi и 96 × 96 для xhdpi.

Как создать интерфейс для Android-приложений в Photoshop

У многих дизайнеров есть проблемы для разработки пользовательского интерфейса Android-приложения в Photoshop или других графических инструментах, основанных на пикселях, из-за независимого от плотности модуля, дп. Дизайнеры не знают, как сопоставить dp с пикселем. Google также не дает четкого руководства по дизайну интерфейса Android для них, хотя они дают базовую формулу для перевода dp и пикселей.

Как определение андроидов, 1pd равно 1px при 160 dpi (mdpi). Поэтому мы хотим разработать Android-приложение для Android-устройства xlarge с плотностью mdpi, мы можем определить размер нашего пользовательского интерфейса в пикселях как 960 пикселей в ширину и 720 пикселей в высоту; Следуйте тому же правилу сопоставления, мы можем получить следующее руководство по дизайну интерфейса Android App:

Android App Screen Size in Pixel Guideline

ADDED: Если вы заинтересованы в "гибком" интерфейсе, посмотрите на эту библиотеку: Android SDK, который предоставляет новый размер - sdp (масштабируемый dp). Единица этого размера масштабируется с размером экрана (это также упоминается в ответе здесь, о SDP библиотеке)

ADDED2 Google наконец поняла полезность концепции пользовательского интерфейса iOS Storeboard, и здесь идет ConstraintLayout для Android мира: создайте отзывчивый интерфейс с ConstraintLayout (IMHO нужно читать для каждого Android-разработчика).

29
ответ дан Mixaz 17 мая '16 в 22:59
источник поделиться

Размер экрана в Android сгруппирован в категории ldpi, mdpi, hdpi, xhdpi, xxhdpi и xxxhdpi. Плотность экрана - это количество пикселей в пределах области (например, дюйма) экрана. Обычно он измеряется в точках на дюйм (dpi).

PX(Pixels):

  • наш обычный стандартный пиксель, который сопоставляется с пикселем экрана. px предназначен для абсолютных пикселей. Это используется, если вы хотите дать абсолютные пиксели для ширины или высоты. Не рекомендуется.

DP/DIP(Density pixels / Density independent pixels):

  • dip == dp. В предыдущих версиях Android использовался dip, а затем был изменен на dp. Это альтернатива px.

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

  • dp рекомендуется использовать вместо px. Используйте dp, если вы хотите указать ширину и высоту, чтобы расти и динамически уменьшаться на основе размеров экрана.

  • если мы дадим dp/dip, android автоматически вычислит размер пикселя на основе экрана размером 160 пикселей.

SP(Scale independent pixels):

  • масштабируется на основе предпочтений размера шрифта пользователей. Шрифты должны использовать sp.

  • указав размеры шрифта для разных размеров экрана, используйте sp. Это похоже на dp. Используйте sp, особенно для размеров шрифтов, которые растут и сжимаются динамически на основе размеров экрана.

Документация на Android говорит:

при указании размеров всегда используйте единицы dp или sp. A dp является не зависящий от плотности пиксель, который соответствует физическому размеру пиксель при 160 dpi. sp является одним и тем же базовым блоком, но масштабируется пользовательский размер шрифта (его независимый от масштаба пиксель), поэтому вы должен использовать этот блок измерения при определении размера текста

25
ответ дан Rajesh 07 окт. '15 в 11:47
источник поделиться

1) dp: (density independent pixels)

Количество пикселей, представленных в одном блоке dp, будет увеличиваться по мере увеличения разрешения экрана (когда у вас больше точек/пикселей на дюйм). И наоборот, на устройствах с более низким разрешением количество пикселей, представленных на единице измерения, уменьшится. Так как это относительная единица, она должна иметь базовый уровень для сравнения. Эта базовая линия - это экран с разрешением 160 точек на дюйм. Это уравнение: px = dp * (dpi/160).


2) sp: (scale independent pixels)

Этот блок масштабируется в соответствии с разрешением экрана (например, dp), а также предпочтением размера шрифта пользователя.


3) px: (pixels)

Фактические пиксели или точки на экране.


Более подробную информацию вы можете посетить

Руководство разработчика Android> Размер
Руководство разработчика Android> Экраны

24
ответ дан IntelliJ Amiya 10 мая '15 в 15:59
источник поделиться

Экран мобильного телефона состоит из тысяч крошечных точек, известных как пикселей (px). Пиксель - это самый маленький элемент, который позволяет сделать изображение. Чем больше пикселей для создания изображения или формулировки, тем он становится более резким, а экран смартфона становится более легко читаемым.

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

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

Независимый от плотности пиксель (dp или dip) равен одному пикселю при базовой плотности или 160 dpi (точек на дюйм).

1 px/1dp = 160 dpi/160 точек на дюйм

2 px/1dp = 320 dpi (2x)/160 dpi

где

dpi - точки на дюйм

Итак, при 320 dpi, 1 dp равно 2 px.

Формула

px/dp = dpi/160dpi

Точки на дюйм (dpi) - это показатель резкости (т.е. плотность освещенных точек) на экране дисплея. Точки на дюйм для заданного разрешения изображения будут отличаться в зависимости от общего размера экрана, так как одинаковое количество пикселей распределяется в другом пространстве.

Работа с независимыми от плотности пикселями помогает нам справляться с ситуацией, например, когда у вас есть два устройства с одинаковым разрешением пикселей, но с разным пространством. Предположим, что в случае планшет и телефон имеют одинаковое разрешение пикселей 1280 на 800 пикселей (160 точек на дюйм) и 800 на 1280 пикселей (320 точек на дюйм) соответственно.

Теперь, когда планшет имеет базовую плотность (160 dpi), его физические и плотности независимых размеров пикселей одинаковы, 1280 на 800. С другой стороны, телефон имеет более высокую плотность пикселей, поэтому он имеет вдвое меньше плотности пикселей в виде физических пикселей. Таким образом, телефон имеет 400 на 640 независимых пикселей. Таким образом, использование не зависящего от плотности пикселя облегчает мысленное изображение, что планшет имеет гораздо больше места, чем телефон.

Аналогичным образом, если у вас есть два устройства с аналогичным размером экрана, но различная плотность пикселей, скажем, одна на 800 на 1280 пикселей (320 точек на дюйм), а другая на 400 на 640 пикселей (160 точек на дюйм), нам не нужно для определения совершенно разных макетов для этих двух устройств, поскольку мы можем измерять активы с точки зрения плотности, независимой от пикселя, которая одинакова для обоих устройств.

800 на 1280 пикселей (320 точек на дюйм) = 400 на 640 пикселей с независимой от плотности (dp)

400 на 640 пикселей (160 точек на дюйм) = 400 на 640 пикселей с независимой от плотности (dp)

Масштабируемые независимые пиксели (sp) - предпочтительная единица для размера шрифта. В целях доступности Android позволяет пользователям настраивать размер шрифта своего устройства. Пользователи, у которых есть проблемы с чтением текста, могут увеличить размер шрифта своего устройства. Обычно этот параметр можно найти в настройках дисплея на вашем телефоне или планшете под размером шрифта. Он часто также доступен через настройки доступности.

С независимыми от масштаба пикселями 16 sp точно так же, как 16 dp, когда размер шрифта устройства нормальный или 100%. Но когда размер шрифта устройства большой, например 125%, 16 sp будут переведены на 20 dp или 1,25 раза 16.

Если вы используете dp в качестве единицы размера шрифта, тогда этот фрагмент текста имеет определенный физический размер независимо от того, настроен ли пользователь на размер шрифта устройства. Использование sp единиц сделает лучший опыт для людей с нарушенным зрением.

Ссылка: Udacity, Google

17
ответ дан Bhuvnesh Varma 29 янв. '17 в 13:00
источник поделиться

sp: масштабный независимый пиксель

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

px: элемент pixel или picture - это единственная точка на экране

13
ответ дан A.Saini 01 июля '16 в 19:37
источник поделиться

SDP - блок масштабируемого размера - в основном это не блок, а размерные ресурсы для разных размеров экрана.

Попробуйте библиотеку sdp из Intuit. Это очень удобно для решения проблем с блоком, и вы можете быстро поддерживать несколько экранов.

Использование

android:paddingBottom="@dimen/_15sdp" для положительного и android:layout_marginTop="@dimen/_minus10sdp" для отрицательного sdp sdp

Он имеет эквивалентное значение в dp для каждого размера в папках values-sw<N>dp (sw = smallestWidth).

Внимание

Используйте его осторожно! В большинстве случаев вам все равно нужно разработать другой макет для планшетов.

Пример

<LinearLayout
          android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:layout_marginTop="@dimen/_minus10sdp"
          android:paddingBottom="@dimen/_15sdp"
          android:orientation="horizontal" >

                <TextView
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:includeFontPadding="false"
                    android:text="♡"
                    android:textColor="#ED6C27"
                    android:textSize="@dimen/_70sdp"
                    android:textStyle="bold" />

                <TextView
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:includeFontPadding="false"
                    android:text="U"
                    android:textColor="@android:color/black"
                    android:textSize="@dimen/_70sdp" />
            </LinearLayout>

Вы можете использовать db для размера текста, но я предпочитаю ssp для размера текста.

Подробнее см. страницу GitHub библиотеки.

10
ответ дан Qamar 27 дек. '17 в 17:17
источник поделиться

Прежде чем ответить на этот вопрос, позвольте мне сначала уменьшить количество единиц. Итак, вы здесь: dp или dip - оба одинаковы и известны как пиксели, не зависящие от плотности.

1. px - обозначает пиксели. Пиксели - это одна точка, точка на экране. Обычно в мобильной индустрии он измеряется в ppi (пикселей на дюйм). Разрешение экрана прямо пропорционально ppi, чем больше пикселей на дюйм, тем выше разрешение экрана.

Например, если вы рисуете изображение размером 200 px * 200 px, то его внешний вид должен отличаться на устройстве с высоким разрешением и на устройстве с низким разрешением. Причина в том, что изображение на 200 пикселей на телефоне с низким разрешением будет выглядеть больше, чем на устройстве с высоким разрешением.

Ниже изображения показывают разрешение одного и того же изображения на разных телефонах -

  • Телефон с высоким разрешением экрана

    Введите описание изображения здесь

  • Телефон с низким разрешением экрана

    Введите описание изображения здесь

2. dip или dp - абстрактный блок, основанный на физической плотности экрана. Эти единицы относятся к экрану с разрешением 160 точек на дюйм, поэтому один пиксель составляет один пиксель на экране с разрешением 160 точек на дюйм. Отношение dp-to-pixel будет меняться с плотностью экрана, но не обязательно в прямой пропорции. "Независимость плотности" относится к равномерному отображению элементов пользовательского интерфейса на экранах с различной плотностью.

  • Изображение, показывающее 80px (изображение слева) и 80 dp (правое изображение). Разница в оплате.

Введите описание изображения здесь

A dp равен одному физическому пикселю на экране с плотностью 160. Для вычисления dp:

dp = (ширина в пикселях * 160)/плотность экрана

3. sp - означает масштабируемые пиксели. Обычно sp используется для текстов в пользовательском интерфейсе, а sp сохраняет настройки шрифта. Например, если пользователь выбрал более крупный шрифт, чем 30 sp, он будет автоматически масштабироваться, чтобы выглядеть большим в соответствии с предпочтениями пользователя.

10
ответ дан Rahul 21 июля '17 в 21:28
источник поделиться

Я хочу дать простой способ понять dp. На самом деле, я думаю, dp является самым простым для понимания. dp - это всего лишь единица физической длины. Он имеет тот же размер, что и mm или inch. Нам просто удобно писать 50dp, 60dp, а не 50/160 inch или 60/160 inch, потому что один dp - это просто 1/160 inch независимо от размера или разрешения экрана.

Единственная проблема заключается в том, что андроид-тэд некоторых экранов не является точным. Например, экран, классифицированный как 160dpi, может иметь действительно 170dpi. Таким образом, результат вычисления dp нечеткий. Он должен быть примерно таким же, как 1/160 inch.

10
ответ дан ProtossShuttle 02 апр. '16 в 6:19
источник поделиться
  • 1
  • 2

Другие вопросы по меткам