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

В чем разница между:

  • px
  • dip
  • dp и
  • sp

На Android?

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

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

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

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

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

  5. Dp или dip
    Плотно-независимые пиксели – абстрактный блок, основанный на физической плотности экрана. Эти единицы относятся к экрану с разрешением 160 точек на дюйм, поэтому один пиксель – один пиксель на экране с разрешением 160 точек на дюйм. Отношение dp-to-pixel будет меняться с плотностью экрана, но не обязательно в прямой пропорции. Примечание. Компилятор принимает как «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 дп равен 1,5 физическим пикселям. Вы всегда должны использовать модули dp при определении пользовательского интерфейса вашего приложения, чтобы обеспечить правильное отображение вашего интерфейса на экранах с различной плотностью.

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

  • Размеры экрана и плотность

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

  • При запуске на устройстве mdpi изображение размером 150×150 пикселей займет 150 * 150 дп пространства на экране.
  • При запуске на устройстве hdpi изображение размером 150×150 пикселей займет 100 * 100 дп пространства на экране.
  • При работе на устройстве xhdpi изображение размером 150×150 пикселей займет 75 * 75 дп пространства на экране.

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

  • 100 * 100 px для mdpi
  • 150 * 150 px для hdpi
  • 200 * 200 px для xhdpi

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

В дюймах – на основе физического размера экрана.

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

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

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

Sp Scale – независимые пиксели – это похоже на блок 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 * (dpi / 160). Например, на экране с разрешением 240 точек на дюйм 1 дп равен 1,5 физическим пикселям. Вы всегда должны использовать модули dp при определении пользовательского интерфейса вашего приложения, чтобы обеспечить правильное отображение вашего интерфейса на экранах с различной плотностью.

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

dpdip . Используйте его для всех (маржа, прокладка и т. Д.).

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


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


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

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

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

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

Источник 1

Источник 2

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

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

дп

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

зр

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

пт

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

ПВ

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

мм

Миллиметры – Исходя из физического размера экрана.

в

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

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

В основном единственный раз, когда px применяется, равен одному px, и это, если вы хотите, чтобы на экране был ровно один пиксель, как в случае делителя. Вкл.> 160 вы можете получить 2-3 пикселя, а на 120dpi округлите до 0.

Определения

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

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

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

  • Ldpi (низкий) ~ 120dpi
  • Mdpi (средний) ~ 160dpi
  • Hdpi (высокий) ~ 240dpi
    • Большинство устройств в 2015 году здесь
  • Xhdpi (extra-high) ~ 320dpi
    • Apple iPhone 4/5/6, Nexus 4
  • Xxhdpi (extra-extra-high) ~ 480 точек на дюйм
    • Нексус 5
  • Xxxhdpi (extra-extra-extra-high) ~ 640dpi

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

  • 1dp = 1px на mdpi

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

Sp или sip – это не зависящий от масштаба пиксель пиксель . Они масштабируются, когда параметр « Большой текст» включен в « Настройки» > « Доступность»

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

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

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

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

Где использовать что & отношения между 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.

ПВ

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

зр

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

ПВ

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

Dp или dip

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

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

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

зр

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

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

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

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

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

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

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

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

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

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

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

Опция « Large Text заставляет текст увеличиваться в 1.3 раза.

 private static final float LARGE_FONT_SCALE = 1.3f; 

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

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

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

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

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

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

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

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

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

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

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

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

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

И 480 точек на дюйм устройства 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(); 

Dpi –

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

Px – пиксель

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

Pt – точки

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

Дюйм – по размеру физического экрана (1 дюйм = 2,54 см).

Мм-миллиметр – по отношению к размеру физического экрана.

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

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

Dip –

  • Dip == dp
  • Независимый от плотности пиксель.
  • Он варьируется в зависимости от плотности экрана.
  • На экране с разрешением 160 точек на дюйм 1 дп = 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 
  • Px – один пиксель, то же, что и в CSS, JavaScript и т. Д.
  • Sp – независимые от масштаба пиксели пикселей
  • Независимые от плотности пиксели пиксели

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

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

Px = dp * (dpi / 160)

Где dpi – одна из следующих плотности экрана. Список всех возможных плотностей можно найти на странице http://developer.android.com/reference/android/util/DisplayMetrics.html . Он определяет константы «DENSITY_ *».

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

Взято из http://developer.android.com/guide/practices/screens_support.html .

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

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

Px = 60 * (240/160)

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

  • Dp: Независимый от плотности пиксель, он зависит от плотности экрана. На экране с разрешением 160 точек на дюйм 1 дп = 1 пиксель. За исключением размера шрифта, всегда используйте dp.
  • Dip: dip == dp. В предыдущих версиях Android использовался dip, а затем был изменен на dp.
  • Sp: Scale Independent Pixel, масштабируется в зависимости от предпочтения размера шрифта пользователя. Шрифты должны использовать 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(){ } 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); } } 

More Information refer following link.

http://javapapers.com/android/difference-between-dp-dip-sp-px-in-mm-pt-in-android/

sp = scale independent pixel

dp = density independent pixels

dpi = density pixels

I have gone through the above answers…not finding them exactly correct. sp for text size, dp for layout bounds – standard. But sp for text size will break the layout if used carelessly in most of the devices.

sp take the textsize of the device, whereas dp take that of device density standard( never change in a device) Say 100sp text can occupies 80% of screen or 100% of screen depending on the font size set in device

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

You can use sp for layout bounds also, it will work 🙂 No standard app use sp for whole text

Use sp and dp for text size considering UX.

  • Dont use sp for text in toolbar( can use android dimens available or dp)
  • Dont use sp for text in small bounded buttons, very smaller text, etc

Some people use huge FONT in their phone for more readability, giving them small hardcoded sized text will be an UX issue. Put sp for text where necessary, but make sure it won't break the layout.

I've come across a good article about designing Android apps UI for different screen resolutions, and I'd like to leave it here just for somebody searching in this area. Yes, I know that it's somehow described in Google docs (and mentioned in the posts above), I read that but it was not good for me (yeah, I may be too stupid)). It remained unclear for me how to design layouts capable to handle different screen size. I hate DP concept and so on, when I need to implement a "flexible" UI layout for different screens. (Hey iOS developers – yes, you're right it's Storyboard concept).

Android has not bad UI concept, but lacks iOS Storyboard features, unfortunately. Designing flexible UI in Android is not easy thing (at the best).

Here goes the article that helped me to understand what to do in Android to make layouts for different screen sizes:

http://jmsliu.com/1718/decide-android-app-screen-size.html

How to Design UI for Android Apps for Different Screen Size

To design an app UI for different screen sizes, our initial design has to meet a minimum required space for each screen size. Android defines a minimum size (in dp) for each generalized screen type. Here is an Android screen size guideline. Minimum Screen Size for Android in dp When we get the screen size in dp, it is not enough for us to design the Android app UI. For each screen size, we need to prepare graphics and bitmap images for each density. Here is an Android screen density guideline. Android Density Guideline (dpi)

For easy calculation, we can follow the 3:4:6:8 scaling ratio between the four generalized densities. If we create a 36×36 pixel picture for ldpi device, the rest densities pictures size will be 48×48 for mdpi, 72×72 for hdpi, and 96×96 for xhdpi.

How to Design Android Apps UI in Photoshop

Many designers have problems for designing Android app UI in photoshop or other pixel based graphic design tools because of density-independent unit, dp. Designers don't know how to map dp to pixel. Google also doesn't give a clear Android UI design guide for them, though they give a basic formula for dp and pixel translation.

As Android's definition, 1pd equal to 1px under 160 dpi device (mdpi). So we want to design an Android app for xlarge Android device with mdpi density, we can define our UI size in pixel as 960 pixel in width and 720px in height; Follow the same mapping rule, we can get following Android App screen size UI design guideline:

Android App Screen Size in Pixel Guideline

ADDED : If you interested in "flexible" UI too, have a look at this library: An Android SDK that provides a new size unit – sdp (scalable dp). This size unit scales with the screen size (this also mentioned in an answer here, about SDP library)

ADDED2 Google has finally understood usefulness of iOS Storeboard UI concept, and here goes ConstraintLayout for Android world: Build a Responsive UI with ConstraintLayout (IMHO a must to read for every Android dev).

Screen size in Android is grouped into categories ldpi , mdpi , hdpi , xhdpi , xxhdpi and xxxhdpi . Screen density is the amount of pixels within an area (like inch) of the screen. Generally it is measured in dots-per-inch ( dpi ).

PX(Pixels):

  • our usual standard pixel which maps to the screen pixel. px is meant for absolute pixels. This is used if you want to give in terms of absolute pixels for width or height. Не рекомендуется.

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

  • dip == dp . In earlier Android versions dip was used and later changed to dp . This is alternative of px .

  • Generally we never use px because it is absolute value. If you use px to set width or height, and if that application is being downloaded into different screen sized devices, then that view will not stretch as per the screen original size.

  • dp is highly recommended to use in place of px . Use dp if you want to mention width and height to grow & shrink dynamically based on screen sizes.

  • if we give dp/dip , android will automatically calculate the pixel size on the basis of 160 pixel sized screen.

SP(Scale independent pixels):

  • scaled based on user's font size preference. Fonts should use sp .

  • when mentioning the font sizes to fit for various screen sizes, use sp . This is similar to dp .Use sp especially for font sizes to grow & shrink dynamically based on screen sizes

Android Documentation says:

when specifying dimensions, always use either dp or sp units. A dp is a density-independent pixel that corresponds to the physical size of a pixel at 160 dpi . An sp is the same base unit, but is scaled by the user's preferred text size (it's a scale-independent pixel), so you should use this measurement unit when defining text size

dp: (density independent pixels) The number of pixels represented in one unit of dp will increase as the screen resolution increases (when you have more dots/pixels per inch). Conversely on devices with lower resolution, the number of pixels represented in on unit of dp will decrease. Since this is a relative unit, it needs to have a baseline to be compared with. This baseline is a 160 dpi screen. This is the equation: px = dp * (dpi / 160).

sp: (scale independent pixels) This unit scales according to the screen dpi (similar to dp) as well as the user's font size preference.

px (Pixels) – Actual pixels or dots on the screen.

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

http://developer.android.com/guide/topics/resources/more-resources.html#Dimension And http://developer.android.com/about/dashboards/index.html#Screens

The screen of a mobile phone is made up of thousands of tiny dots known as Pixels(px) .A Pixel is the smallest element which goes to make the picture.The more the number of pixels to make a picture or wording, the sharper it becomes and makes the smartphone screen more easily readable.Screen resolution is measured in terms of number of pixels on the screen.Screen resolution is commonly used spec when buying a device,but it's actually not that useful when designing for android because thinking of screens in terms of pixels ignores the notion of physical size,which for touch device is really really important.

Density independent pixel(dp or dip) allow the designer to create assets that appear in a expected way,no matter the resolution or density of target device. A density independent pixel(dp or dip) is equal to one pixel at the baseline density or 160 dpi(dots per inch)

1 px/1dp = 160 dpi/160 dpi

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

где,

dpi is dots per inch

So, At 320 dpi, 1dp is equal to 2 px.

формула

px/dp=dpi/160dpi

dots per inch (dpi) is a measure of the sharpness (that is, the density of illuminated points) on a display screen .The dots per inch for a given picture resolution will differ based on the overall screen size since the same number of pixels are being spread out over a different space.

Working with density independent pixels help us to deal with situation like where you have two devices with same pixel resolution but differing amount of space.Suppose in a case,a tablet and phone has same pixel resolution 1280 by 800 pixels(160 dpi) and 800 by 1280 pixels(320 dpi) respectively. Now because tablet is at baseline density(160 dpi) its physical and density independent pixels sizes are the same,1280 by 800.The phone on the other hand has a higher pixel density so it has half as many density independent pixels as physical pixels.So phone has 400 by 640 density independent pixels.So using density independent pixel makes it easier to mentally picture that tablet has much more space than the phone.

Similarly,if you have two devices with similar screen size but different pixel density,say one is,800 by 1280 pixels(320 dpi), and the other is 400 by 640 pixels(160 dpi),we don't need to define totally different layouts for these two devices as we can measure assets in terms of density independent pixel which is same for both devices.

800 by 1280 pixels(320dpi)=400 by 640 density independent pixel(dp)

400 by 640 pixels(160 dpi)=400 by 640 density independent pixel(dp)

Scale independent pixels(sp) is the preferred unit for font size. For accessibility purposes Android allows users to customize their device's font size.Users that have trouble reading text can increase their device's font size.You can normally find this option in the display setting on your phone or tablet under font size.It's often also available through the accessibility settings. With scale independent pixels,16 sp is exactly the same as 16 dp when the device's font size is normal or 100%.But when device's font size is large,for example 125%, 16 sp will translate to 20 dp or 1.25 times 16. If you use dp as unit for font size,than that piece of text has specific physical size no matter if the user has customize device's font size.Using sp units will make a better experience for people with impaired eyesight.

Reference : Udacity ,Google

sp: scale independent pixel. You should use it with texts because it is automatically scaled according to the font size that is being used by the user in his device. px: pixel or picture element is the single point on the screen

SDP – a scalable size unit – basically it is not a unit but dimension resources for different screen size.

Try sdp library from intuit, it's very handy to solve unit problem and you can quickly support to multiple screens .

Применение

android:paddingBottom="@dimen/_15sdp" for positive and android:layout_marginTop="@dimen/_minus10sdp" for negative sdp sdp

It has equivalent value in dp for each size in values-sw<N>dp folders (sw = smallestWidth)

Внимание

Use it carefully! in most cases you still need to design a different layout for tablets.

пример

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

You can use db for text size but I prefer ssp for text size.

For more details check library git link

I want to provide an easy way to understand dp . In fact, I think dp is the easiest one to understand. dp is just a physical length unit. It's of the same dimension as mm or inch . It's just convenient for us to write 50dp , 60dp rather than 50/160 inch or 60/160 inch , because one dp is just 1/160 inch whatever the screen size or resolution is.

The only problem is that, the android dpi of some screens are not accurate. For example, a screen classified to 160dpi may have 170dpi indeed. So the computation result of dp is fuzzy. It should be approximately the same as 1/160 inch .

The ratio of dp-to-pixel will change with the screen density, but not necessarily in direct proportion.

Note : The compiler accepts both " dip " and " dp ", though " dp " is more consistent with " sp ".

Scale-independent Pixels – this is like the dp unit, but it is also scaled by the user's font size preference.

Intereting Posts