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


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

  • px
  • dip
  • dp
  • sp
30   5250   2010-01-08 06:23:46

30 ответов:

С Документация Для Разработчиков Android:

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

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

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

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

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

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

С Понимание Независимости Плотности В Android:

+----------------+----------------+---------------+-------------------------------+
| Density Bucket | Screen Density | Physical Size | Pixel Size                    | 
+----------------+----------------+---------------+-------------------------------+
| ldpi           | 120 dpi        | 0.5 x 0.5 in  | 0.5 in * 120 dpi = 60x60 px   | 
+----------------+----------------+---------------+-------------------------------+
| mdpi           | 160 dpi        | 0.5 x 0.5 in  | 0.5 in * 160 dpi = 80x80 px   | 
+----------------+----------------+---------------+-------------------------------+
| hdpi           | 240 dpi        | 0.5 x 0.5 in  | 0.5 in * 240 dpi = 120x120 px | 
+----------------+----------------+---------------+-------------------------------+
| xhdpi          | 320 dpi        | 0.5 x 0.5 in  | 0.5 in * 320 dpi = 160x160 px | 
+----------------+----------------+---------------+-------------------------------+
| xxhdpi         | 480 dpi        | 0.5 x 0.5 in  | 0.5 in * 480 dpi = 240x240 px | 
+----------------+----------------+---------------+-------------------------------+
| xxxhdpi        | 640 dpi        | 0.5 x 0.5 in  | 0.5 in * 640 dpi = 320x320 px | 
+----------------+----------------+---------------+-------------------------------+
+---------+-------------+---------------+-------------+--------------------+
| Unit    | Description | Units Per     | Density     | Same Physical Size | 
|         |             | Physical Inch | Independent | On Every Screen    | 
+---------+-------------+---------------+-------------+--------------------+
| px      | Pixels      | Varies        | No          | No                 | 
+---------+-------------+---------------+-------------+--------------------+
| in      | Inches      | 1             | Yes         | Yes                | 
+---------+-------------+---------------+-------------+--------------------+
| mm      | Millimeters | 25.4          | Yes         | Yes                | 
+---------+-------------+---------------+-------------+--------------------+
| pt      | Points      | 72            | Yes         | Yes                | 
+---------+-------------+---------------+-------------+--------------------+
| dp      | Density     | ~160          | Yes         | No                 | 
|         | Independent |               |             |                    | 
|         | Pixels      |               |             |                    | 
+---------+-------------+---------------+-------------+--------------------+
| sp      | Scale       | ~160          | Yes         | No                 | 
|         | Independent |               |             |                    | 
|         | Pixels      |               |             |                    | 
+---------+-------------+---------------+-------------+--------------------+

дополнительную информацию можно также найти в Проектная Документация Google.

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

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

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

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

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

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

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

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

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

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

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

  • 100 * 100 px изображение для mdpi
  • 150 * 150 px изображение для hdpi
  • 200 * 200 px изображение для xhdpi

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

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

вы должны иметь четкое представление о следующих понятиях:

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

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

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

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

ориентация:

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

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

использовать sp для {размер шрифта} только.


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


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

Enter image description here

источник: Android Программирование: The Big Nerd Ranch Guide

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

определения

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

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

Андроид псевдонимы с несколькими плотностями

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

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

  • 1dp = 1px на mdpi

enter image description here

sp или sip это масштаб-независимый пиксель. Они масштабируются, когда Большой Текст на настройки>доступность

  • 1sp = 1dp
  • 1sp = 1.2 dp с доступом большой текст

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

использовать sp размер текста.

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

Источник 1

Источник 2

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

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

dp

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

sp

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

pt

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

px

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

мм

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

на

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

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

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

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

On > 120 dpi, он округляется до 0.

px

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

dp или dip

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

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

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

sp

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

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

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

плотность-независимый пиксел (dp)

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

px = dp * (dpi / 160).

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

понимание пикселя в dp и наоборот очень важно (особенно для предоставления точных значений dp творческой команде)

dp = px * 160 / dpi

MDPI = 160 dpi || Therefore, on MDPI 1 px = 1 dp
For example, if you want to convert 20 pixel to dp, use the above formula,
dp = 20 * 160 / 160 = 20.
So, 20 pixel = 20 dp.

HDPI = 240 dpi - So, on HDPI 1.5 px = 1 dp
XHDPI = 320 dpi - So, on XHDPI 2 px = 1 dp
XXHDPI = 480 dpi - So, on XXHDPI 3 px = 1 dp

For example, let us consider Nexus 4.
If 24 pixels to be converted to dp and if it is a Nexus 4 screen, developers can
convert it to dp easily by the following calculation :
dp = 24 * 160 / 320 = 12 dp
Screen dimension:
768 x 1280 pixel resolution (320 ppi or 320dpi)
Optional (screen size):
 4.7" diagonal
  • попробуйте получить все значения пикселей в четных числах от творческой команды. В противном случае потеря точности произойдет при умножении на 0,5.

px

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

sp

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

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

enter image description here

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

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

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

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

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

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

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

DP = dip = плотность независимых пикселей

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

мы должны избегать, чтобы использовать sp.

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

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

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

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

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

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

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

таким образом, 1 dp устройства 240 dpi будет иметь = 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();

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

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

private static final float LARGE_FONT_SCALE = 1.3f;

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

dpi -

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

px-pixel

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

pt-points

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

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

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

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

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

dip -

  • dip == dp
  • плотность независимых пикселей.
  • Он варьируется в зависимости от плотности экрана.
  • в экране 160 dpi, 1 DP = 1 пиксель.
  • используйте dp, кроме размера шрифта текста.

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

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

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 и т. д.
  • СП - масштабно-независимые пиксели
  • dip - плотность-независимые пиксели

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

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

px = dp * (dpi / 160)

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

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

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

принято от здесь.

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

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

px = 60 * (240 / 160)

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

  • "ДП": плотность независимых пикселей, это зависит от экрана плотность. На экране 160 dpi, 1 dp = 1 пиксель. За исключением размера шрифта, всегда используйте dp.
  • dip: dip == dp. В более ранних версиях Android dip использовался, а затем был изменен на dp.
  • sp: масштабировать независимый пиксель, масштабируемый на основе предпочтения размера шрифта пользователя. Шрифты должны использовать sp.
  • px: наш обычный стандартный пиксель, который сопоставляется с пикселем экрана.
  • in: дюймов, по отношению к физический размер экрана.
  • мм: миллиметров, по отношению к физическому размеру экрана.
  • 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 пикселей на 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/

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

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

ДП = плотность независимых пикселей

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

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

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

enter image description here

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

использовать sp и dp для размера текста с учетом УБ.

  • не используйте sp для текста на панели инструментов (можно использовать Android dimens available или dp)
  • не использовать СП для текста в небольших ограниченных кнопки, очень мелкий текст и т. д.

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

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

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

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

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

блог JMSTUDIO : - решите Размер экрана приложения для 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 Приложения UI в Photoshop

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

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

Android App Screen Size in Pixel Guideline

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

ADDED2 Google, наконец, понял полезность концепции iOS Storeboard UI, и здесь идет ConstraintLayout для Android world:создайте отзывчивый пользовательский интерфейс с ConstraintLayout

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

1) dp: (density independent pixels)

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


Два) sp: (scale independent pixels)

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


3) px: (pixels)

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


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

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

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

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

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

пиксел плотности независимый (ДП или погружение) равен До один пиксел на плотности базиса или 160 ДПИ (точек в дюйм.)

1 px / 1dp = 160 dpi / 160 dpi

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

здесь

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

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

Формула

px / dp = dpi / 160dpi

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

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

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

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

800 на 1280 пикселей (320dpi)=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

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

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

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

Я хочу обеспечить простой способ понять 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 = 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>

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

для получения более подробной информации, проверьте страница библиотеки GitHub.

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

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

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

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

  • телефон с Высокое разрешение экрана

    Enter image description here

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

    Enter image description here

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

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

Enter image description here

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

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

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