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

StackOverflow https://stackoverflow.com/questions/2025282

Вопрос

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

  • пиксель
  • погружение
  • дп
  • сп
Это было полезно?

Решение

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

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

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

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

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

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

  6. сп
    Масштаб-независимые пиксели - это похоже на единицу измерения 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.

Другие советы

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

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

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

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

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

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

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

Я подробнее расскажу о том, как именно 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

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

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

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

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

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

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

Возьмем пример двух экранов одинакового размера, но один из них имеет плотность экрана 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 группирует все фактические плотности экрана в четыре обобщенных плотности:низкий, средний, высокий и сверхвысокий.

Ориентация:

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

Разрешение:

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

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

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

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

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

Использование sp только для {text-size}.

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

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

Enter image description here

Источник: Программирование для Android:Руководство по ранчо Большого Ботаника

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

Определения

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

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

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

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

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

  • 1dp = 1px в mdpi

enter image description here

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

  • 1sp = 1dp
  • 1sp = 1.2dp с доступным крупным текстом

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

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

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

Источник 1

Источник 2

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

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

дп

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

сп

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

Очки

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

пиксель

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

мм

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

в

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

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

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

При разрешении > 160 точек на дюйм вы можете получить 2-3 пикселя,

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

пиксель

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

dp или погружение

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

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

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

сп

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

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

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

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

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

px = dp * (точек надюйм / 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
  • Попробуйте получить все значения пикселей в четных числах от творческой команды.В противном случае при умножении на 0.5 произойдет потеря точности.

пиксель

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

сп

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

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

enter image description here

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

Вы можете использовать оба варианта dp и dip на своих местах.

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

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

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

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

sp = пиксель, не зависящий от масштаба.

dp = dip = пиксели , не зависящие от плотности

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

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

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

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

  • ldpi (низкий) ~ 120 точек на дюйм
  • mdpi (средний) ~ 160 точек на дюйм
  • hdpi (высокий) ~ 240 точек на дюйм
  • разрешение xhdpi (сверхвысокое) ~ 320 точек на дюйм
  • xxhdpi (сверхвысокий) ~ 480 точек на дюйм
  • xxxhdpi (очень-очень-очень-высокий) ~ 640 точек на дюйм

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

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

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

пиксель = dp * (плотность / 160)

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

А 1 dp устройства с разрешением 480 точек на дюйм будет иметь = 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->Large Text вариант.

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

private static final float LARGE_FONT_SCALE = 1.3f;

Это, конечно, может зависеть от поставщика, поскольку оно заключается в пакеты / приложения / Настройки.

точек на дюйм -

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

px - пиксель

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

pt - точки

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

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

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

пиксель, не зависящий от sp-масштаба.

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

погружение -

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

В стандарте используются dp и sp.sp для размера шрифта и dp для всего остального.

Формула для пересчета единиц измерения:

px = dp * ( точек на дюйм / 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:

px = dp * (точек на дюйм / 160)

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

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

  • ldpi (низкий) ~ 120 точек на дюйм
  • mdpi (средний) ~ 160 точек на дюйм
  • hdpi (высокий) ~ 240 точек на дюйм
  • xhdpi (сверхвысокий) ~ 320 точек на дюйм
  • xxhdpi (сверхвысокий) ~ 480 точек на дюйм
  • xxxhdpi (очень-очень-очень-высокий) ~ 640 точек на дюйм

Взято из здесь.

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

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

px = 60 * (240 / 160)

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

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

Формула для пересчета между Единицами измерения

 px = dp * (dpi / 160)

dp в 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/

  • px - один пиксель, такой же, как тот, что используется в CSS, JavaScript и т.д.
  • пиксели, не зависящие от sp -масштаба
  • пиксели, не зависящие от плотности погружения

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

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

sp = пиксель, не зависящий от масштаба.

dp = пиксели, не зависящие от плотности

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

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

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

enter image description here

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

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

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

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

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

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

Обратитесь к сайту разработчика Google для получения подробной информации о чувствительности экрана и базовой плотности для Android.https://developer.android.com/training/multiscreen/screendensities

Я наткнулся на хорошую статью о разработке пользовательского интерфейса приложений Android для разных разрешений экрана, и я хотел бы оставить ее здесь только для тех, кто ищет в этой области.Да, я знаю, что это каким-то образом описано в Google docs (и упомянуто в постах выше), я читал это, но мне это не понравилось (да, возможно, я слишком глуп)).Для меня оставалось неясным, как создавать макеты, способные работать с различными размерами экрана.Я ненавижу концепцию 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 из-за не зависящей от плотности единицы измерения.Дизайнеры не знают, как сопоставить dp с пикселем.Google также не предоставляет четкого руководства по дизайну пользовательского интерфейса Android для них, хотя они дают базовую формулу для dp и пиксельного перевода.

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

Android App Screen Size in Pixel Guideline

ДОБАВЛЕННЫЙ:Если вас тоже интересует "гибкий" пользовательский интерфейс, взгляните на эту библиотеку: Android SDK, который предоставляет новую единицу измерения размера - sdp (scalable dp).Эта единица измерения размера масштабируется в соответствии с размером экрана (это также упоминается в ответе здесь, о SDP библиотека)

ДОБАВЛЕНО 2 Google наконец-то понял полезность концепции пользовательского интерфейса iOS Storeboard, и вот что происходит ConstraintLayout для мира Android: Создайте адаптивный пользовательский интерфейс с помощью ConstraintLayout

1) dp: (density independent pixels)

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


2) sp: (scale independent pixels)

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


3) px: (pixels)

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


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

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

Размер экрана в 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 является той же базовой единицей, но масштабируется по предпочитаемому пользователем размеру текста (это пиксель, не зависящий от масштаба), поэтому вам следует использовать эту единицу измерения при определении размера текста

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

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

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

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

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

2 пикселя /1dp = 320 точек на дюйм (2x)/160 точек на дюйм

где,

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

Таким образом, при разрешении 320 точек на дюйм 1 dp равен 2 пикселям.

Формула

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

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

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

Теперь, поскольку планшет имеет базовую плотность (160 точек на дюйм), его физические размеры пикселей, не зависящие от плотности, остаются прежними - 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 улучшит работу людей с ослабленным зрением.

Ссылка: Удача, Google

сп:пиксель, не зависящий от масштаба

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

пиксель:пиксель или элемент изображения - это единственная точка на экране

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

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

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

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

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

    Enter image description here

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

    Enter image description here

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

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

Enter image description here

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

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

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

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

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

СДП - масштабируемая единица измерения размера - по сути, это не единица измерения, а размерные ресурсы для разных размеров экрана.

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

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

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

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

Внимание

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

Пример

<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.

Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top