Was ist der Unterschied zwischen Android-Maßeinheiten?

• px
• tauchen
• dp
• sp

Aus der Android Developer-Dokumentation :

1. px
   Pixel - entspricht den tatsächlichen Pixeln auf dem Bildschirm.

2. in
   Zoll - basierend auf der physischen Größe des Bildschirms.
   1 Zoll = 2,54 Zentimeter

3. mm
   Millimeter - basierend auf der physischen Größe des Bildschirms.

4. pt
   Punkte - 1/72 Zoll basierend auf der physischen Größe des Bildschirms.

5. dp oder dip
   Dichteunabhängige Pixel - eine abstrakte Einheit, die auf der physikalischen Dichte des Bildschirms basiert. Diese Einheiten beziehen sich auf einen Bildschirm mit 160 dpi, sodass ein dp ein Pixel auf einem Bildschirm mit 160 dpi ist. Das Verhältnis von dp zu Pixel ändert sich mit der Bildschirmdichte, jedoch nicht unbedingt in direktem Verhältnis. Hinweis: Der Compiler akzeptiert sowohl "dip" als auch "dp", obwohl "dp" konsistenter mit "sp" ist.

6. sp
   Skalierungsunabhängige Pixel - Dies entspricht der dp-Einheit, wird jedoch auch anhand der bevorzugten Schriftgröße des Benutzers skaliert. Es wird empfohlen, dieses Gerät bei der Angabe von Schriftgrößen zu verwenden, damit diese sowohl an die Bildschirmdichte als auch an die Vorlieben des Benutzers angepasst werden.

Vom Verständnis der Dichteunabhängigkeit in 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      |               |             |                    | 
+---------+-------------+---------------+-------------+--------------------+

Weitere Informationen finden Sie auch in der Google Design-Dokumentation .

So ziemlich alles darüber und wie man die beste Unterstützung für mehrere Bildschirme unterschiedlicher Größe und Dichte erzielt, ist hier sehr gut dokumentiert:

• Unterstützung mehrerer Bildschirme

Bildschirmgröße
Tatsächliche physische Größe, gemessen als Diagonale des Bildschirms. Der Einfachheit halber gruppiert Android alle tatsächlichen Bildschirmgrößen in vier allgemeine Größen: klein, normal, groß und extragroß.

Bildschirmdichte
Die Anzahl der Pixel in einem physischen Bereich des Bildschirms. normalerweise als dpi (Punkte pro Zoll) bezeichnet. Beispielsweise hat ein Bildschirm mit "niedriger" Dichte weniger Pixel innerhalb eines gegebenen physikalischen Bereichs im Vergleich zu einem Bildschirm mit "normaler" oder "hoher" Dichte. Der Einfachheit halber gruppiert Android alle tatsächlichen Bildschirmdichten in sechs allgemeine Dichten: niedrig, mittel, hoch, extra hoch, extra extra hoch und extra extra extra hoch.

Ausrichtung
Die Ausrichtung des Bildschirms aus Sicht des Benutzers. Dies ist entweder Querformat oder Hochformat, was bedeutet, dass das Seitenverhältnis des Bildschirms entweder breit oder hoch ist. Beachten Sie, dass nicht nur verschiedene Geräte standardmäßig in unterschiedlichen Ausrichtungen arbeiten, sondern dass sich die Ausrichtung zur Laufzeit ändern kann, wenn der Benutzer das Gerät dreht.

Auflösung
Die Gesamtzahl der physischen Pixel auf einem Bildschirm. Wenn Sie Unterstützung für mehrere Bildschirme hinzufügen, arbeiten Anwendungen nicht direkt mit Auflösung. Anwendungen sollten sich nur mit Bildschirmgröße und -dichte befassen, wie in den allgemeinen Größen- und Dichtegruppen angegeben.

Dichteunabhängiges Pixel (dp)
Eine virtuelle Pixeleinheit, die Sie beim Definieren des UI-Layouts verwenden sollten, um Layoutdimensionen oder -positionen dichteunabhängig auszudrücken. Das dichteunabhängige Pixel entspricht einem physikalischen Pixel auf einem 160-dpi-Bildschirm. Dies ist die Basisliniendichte, die vom System für einen Bildschirm mit "mittlerer" Dichte angenommen wird. Zur Laufzeit übernimmt das System die Skalierung der dp-Einheiten nach Bedarf transparent, basierend auf der tatsächlichen Dichte des verwendeten Bildschirms. Die Umrechnung von dp-Einheiten in Bildschirmpixel ist einfach : px = dp * (dpi / 160). Auf einem 240-dpi-Bildschirm entspricht 1 dp beispielsweise 1,5 physischen Pixeln. Sie sollten beim Definieren der Benutzeroberfläche Ihrer Anwendung immer dp-Einheiten verwenden, um eine ordnungsgemäße Anzeige Ihrer Benutzeroberfläche auf Bildschirmen mit unterschiedlichen Dichten sicherzustellen.

Wenn Sie ernsthaft eine Android-App für mehr als einen Gerätetyp entwickeln möchten, sollten Sie das Entwicklungsdokument für Bildschirme mindestens einmal gelesen haben. Darüber hinaus ist es immer gut, die tatsächliche Anzahl der aktiven Geräte mit einer bestimmten Bildschirmkonfiguration zu kennen.

• Bildschirmgrößen und -dichten

Ich werde näher darauf eingehen, wie genau dp in px konvertiert:

• Wenn es auf einem mdpi-Gerät ausgeführt wird, nimmt ein 150 x 150 pxBild Platz auf dem 150 * 150 dpBildschirm ein.
• Wenn es auf einem HDPI-Gerät ausgeführt wird, nimmt ein 150 x 150 pxBild Platz auf dem 100 * 100 dpBildschirm ein.
• Wenn es auf einem xhdpi-Gerät ausgeführt wird, nimmt ein 150x150 pxBild Platz auf dem 75 * 75 dpBildschirm ein.

Umgekehrt: Angenommen, Sie möchten Ihrer Anwendung ein Bild hinzufügen und benötigen es, um ein 100 * 100 dpSteuerelement zu füllen . Sie müssen Bilder unterschiedlicher Größe für unterstützte Bildschirmgrößen erstellen:

• 100 * 100 px Bild für mdpi
• 150 * 150 px Bild für HDPI
• 200 * 200 px Bild für xhdpi

px - Pixel - Punkt pro Skala entspricht den tatsächlichen Pixeln auf dem Bildschirm.

i - Zoll - basierend auf der physischen Größe des Bildschirms.

mm - Millimeter - basierend auf der physischen Größe des Bildschirms.

pt - Punkte - 1/72 Zoll basierend auf der physischen Größe des Bildschirms.

dp - Dichteunabhängige Pixel - eine abstrakte Einheit, die auf der physikalischen Dichte des Bildschirms basiert. Diese Einheiten beziehen sich auf einen Bildschirm mit 160 dpi, sodass eines dpauf einem Bildschirm mit 160 dpi ein Pixel ist. Das Verhältnis von dp zu Pixel ändert sich mit der Bildschirmdichte, jedoch nicht unbedingt in direktem Verhältnis. Hinweis: Der Compiler akzeptiert sowohl dipund dp, wenn auch dpmehr im Einklang mit ist sp.

sp - Skalierungsunabhängige Pixel - Dies entspricht dem dpGerät, wird jedoch auch anhand der bevorzugten Schriftgröße des Benutzers skaliert. Es wird empfohlen, dieses Gerät bei der Angabe der Schriftgrößen zu verwenden, damit diese sowohl an die Bildschirmdichte als auch an die Vorlieben des Benutzers angepasst werden.

Nehmen wir das Beispiel von zwei Bildschirmen mit derselben Größe, aber einer Bildschirmdichte von 160 dpi (Punkte pro Zoll, dh Pixel pro Zoll) und einer von 240 dpi.

                          Lower resolution screen     Higher resolution, same size
Physical Width                      1.5 inches                        1.5 inches
Dots Per Inch (“dpi”)               160                               240
Pixels (=width*dpi)                 240                               360
Density (factor of baseline 160)    1.0                               1.5

Density-independent pixels          240                               240
(“dip” or “dp” or “dps”)

Scale-independent pixels 
 (“sip” or “sp”)                  Depends on user font size settings    same

Darüber hinaus sollten Sie ein klares Verständnis für die folgenden Konzepte haben:

Bildschirmgröße:

Tatsächliche physische Größe, gemessen als Bildschirmdiagonale. Der Einfachheit halber gruppiert Android alle tatsächlichen Bildschirmgrößen in vier allgemeine Größen: klein, normal, groß und extra groß.

Bildschirmdichte:

Die Anzahl der Pixel in einem physischen Bereich des Bildschirms; normalerweise als dpi (Punkte pro Zoll) bezeichnet. Beispielsweise hat ein Bildschirm mit "niedriger" Dichte weniger Pixel innerhalb eines gegebenen physikalischen Bereichs im Vergleich zu einem Bildschirm mit "normaler" oder "hoher" Dichte. Der Einfachheit halber gruppiert Android alle tatsächlichen Bildschirmdichten in vier allgemeine Dichten: niedrig, mittel, hoch und extra hoch.

Orientierung:

Die Ausrichtung des Bildschirms aus Sicht des Benutzers. Dies ist entweder Querformat oder Hochformat, was bedeutet, dass das Seitenverhältnis des Bildschirms entweder breit oder hoch ist. Beachten Sie, dass nicht nur verschiedene Geräte standardmäßig in unterschiedlichen Ausrichtungen arbeiten, sondern dass sich die Ausrichtung zur Laufzeit ändern kann, wenn der Benutzer das Gerät dreht.

Auflösung:

Die Gesamtzahl der physischen Pixel auf einem Bildschirm. Wenn Sie Unterstützung für mehrere Bildschirme hinzufügen, arbeiten Anwendungen nicht direkt mit Auflösung. Anwendungen sollten sich nur mit Bildschirmgröße und -dichte befassen, wie in den allgemeinen Größen- und Dichtegruppen angegeben.

Dichteunabhängiges Pixel (dp):

Eine virtuelle Pixeleinheit, die Sie beim Definieren des UI-Layouts verwenden sollten, um Layoutdimensionen oder -positionen dichteunabhängig auszudrücken. Das dichteunabhängige Pixel entspricht einem physikalischen Pixel auf einem 160-dpi-Bildschirm. Dies ist die Basisliniendichte, die vom System für einen Bildschirm mit "mittlerer" Dichte angenommen wird. Zur Laufzeit übernimmt das System die Skalierung der dp-Einheiten nach Bedarf transparent, basierend auf der tatsächlichen Dichte des verwendeten Bildschirms. Die Konvertierung von dp-Einheiten in Bildschirmpixel ist einfach: px = dp * (dpi / 160). Auf einem 240-dpi-Bildschirm entspricht 1 dp beispielsweise 1,5 physischen Pixeln. Sie sollten beim Definieren der Benutzeroberfläche Ihrer Anwendung immer dp-Einheiten verwenden, um eine ordnungsgemäße Anzeige Ihrer Benutzeroberfläche auf Bildschirmen mit unterschiedlichen Dichten sicherzustellen.

Referenz: Android-Entwicklerseite

dpist dip. Verwenden Sie es für alles (Rand, Polsterung usw.).

Verwenden Sie spfür {text-size} nur.

Um die gleiche Größe bei unterschiedlichen Bildschirmdichten zu erzielen, übersetzt Android diese Einheiten zur Laufzeit in Pixel, sodass Sie keine kniffligen Berechnungen durchführen müssen.

Sehen Sie den Unterschied zwischen px, dpund spauf unterschiedlichen Bildschirmgrößen.

Quelle: Android-Programmierung: The Big Nerd Ranch Guide

Ich habe die folgende Formel berechnet, um die Umrechnungen dpizu dpund vorzunehmensp

Definitionen

px oder Punkt ist ein Pixel auf dem physischen Bildschirm.

dpi sind Pixel pro Zoll auf dem physischen Bildschirm und repräsentieren die Dichte der Anzeige.

Android gibt Aliasnamen für mehrere Dichten

• ldpi (niedrig) ~ 120 dpi
• mdpi (mittel) ~ 160 dpi
• hdpi (hoch) ~ 240 dpi
  • Die meisten Geräte im Jahr 2015 sind hier
• xhdpi (extra hoch) ~ 320 dpi
  • Apple iPhone 4/5/6, Nexus 4
• xxhdpi (extra-extra-hoch) ~ 480dpi
  • Nexus 5
• xxxhdpi (extra-extra-extra-hoch) ~ 640dpi

dip oder dp sind dichteunabhängige Pixel , dh sie entsprechen je nach physikalischer Dichte mehr oder weniger Pixeln.

• 1dp = 1px auf mdpi

sp oder sip ist ein skalierungsunabhängiges Pixel . Sie werden skaliert, wenn die Option Großer Text in Settings> aktiviert istAccessibility

• 1sp = 1dp
• 1sp = 1.2dp mit Barrierefreiheit Großer Text

Was ist zu verwenden?

Verwenden Sie sp für die Textgröße.

Verwenden Sie dp für alles andere.

Quelle 1

Quelle 2

Quelle 3 : (Daten aus Quelle 3 sind unten angegeben)

Dies sind in XML definierte Dimensionswerte. Eine Dimension wird mit einer Zahl gefolgt von einer Maßeinheit angegeben. Zum Beispiel: 10px, 2in, 5sp. Folgende Maßeinheiten werden von Android unterstützt:

dp

Dichteunabhängige Pixel - Eine abstrakte Einheit, die auf der physischen Dichte des Bildschirms basiert. Diese Einheiten beziehen sich auf einen Bildschirm mit 160 dpi (Punkte pro Zoll), auf dem 1 dp ungefähr 1 Pixel entspricht. Wenn Sie auf einem Bildschirm mit höherer Dichte arbeiten, wird die Anzahl der Pixel, die zum Zeichnen von 1 dp verwendet werden, um einen Faktor vergrößert, der für die dpi des Bildschirms geeignet ist. Ebenso wird auf einem Bildschirm mit geringerer Dichte die Anzahl der für 1 dp verwendeten Pixel verkleinert. Das Verhältnis von dp zu Pixel ändert sich mit der Bildschirmdichte, jedoch nicht unbedingt in direktem Verhältnis. Die Verwendung von dp-Einheiten (anstelle von px-Einheiten) ist eine einfache Lösung, um die Größe der Ansichtsabmessungen in Ihrem Layout für unterschiedliche Bildschirmdichten richtig anzupassen. Mit anderen Worten, es bietet Konsistenz für die realen Größen Ihrer UI-Elemente auf verschiedenen Geräten.

sp

Skalierungsunabhängige Pixel - Dies entspricht der dp-Einheit, wird jedoch auch anhand der bevorzugten Schriftgröße des Benutzers skaliert. Es wird empfohlen, dieses Gerät bei der Angabe der Schriftgrößen zu verwenden, damit diese sowohl an die Bildschirmdichte als auch an die Vorlieben des Benutzers angepasst werden.

pt

Punkte - 1/72 Zoll basierend auf der physischen Größe des Bildschirms.

px

Pixel - Entspricht den tatsächlichen Pixeln auf dem Bildschirm. Diese Maßeinheit wird nicht empfohlen, da die tatsächliche Darstellung von Gerät zu Gerät unterschiedlich sein kann. Jedes Gerät hat möglicherweise eine andere Anzahl von Pixeln pro Zoll und möglicherweise mehr oder weniger Gesamtpixel auf dem Bildschirm.

mm

Millimeter - Basierend auf der physischen Größe des Bildschirms.

im

Zoll - Basierend auf der physischen Größe des Bildschirms.

Hinweis: Eine Dimension ist eine einfache Ressource, auf die mit dem im Attribut name angegebenen Wert verwiesen wird (nicht mit dem Namen der XML-Datei). Daher können Sie Dimensionsressourcen mit anderen einfachen Ressourcen in einer XML-Datei unter einem Element kombinieren.

Grundsätzlich gilt px nur für einen px, und das ist, wenn Sie genau ein Pixel auf dem Bildschirm haben möchten, wie im Fall eines Teilers:

Bei> 160 dpi erhalten Sie möglicherweise 2-3 Pixel.

Bei> 120 dpi wird auf 0 gerundet.

px

Pixel - entspricht den tatsächlichen Pixeln auf dem Bildschirm.

dp oder dip

Dichteunabhängige Pixel - eine abstrakte Einheit, die auf der physischen Dichte des Bildschirms basiert. Diese Einheiten beziehen sich auf einen Bildschirm mit 160 dpi, sodass ein dp ein Pixel auf einem Bildschirm mit 160 dpi ist.

Verwendung von dp:

Dichteunabhängigkeit - Ihre Anwendung erreicht eine „Dichteunabhängigkeit“, wenn die physische Größe (aus Sicht des Benutzers) von Benutzeroberflächenelementen beibehalten wird, wenn sie auf Bildschirmen mit unterschiedlicher Dichte angezeigt wird. (dh) Das Bild sollte auf verschiedenen Bildschirmtypen gleich groß (nicht vergrößert oder verkleinert) sein.

sp

Skalierungsunabhängige Pixel - Dies entspricht der dp-Einheit, wird jedoch auch anhand der bevorzugten Schriftgröße des Benutzers skaliert.

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

Wo soll was & Beziehung zwischen px & dp verwendet werden?

Dichteunabhängiges Pixel (dp)

Eine virtuelle Pixeleinheit, die Sie beim Definieren des UI-Layouts verwenden sollten, um Layoutdimensionen oder -positionen dichteunabhängig auszudrücken. Wie oben beschrieben, entspricht das dichteunabhängige Pixel einem physikalischen Pixel auf einem 160-dpi-Bildschirm, was die vom System für einen Bildschirm mit "mittlerer" Dichte angenommene Basisliniendichte ist. Zur Laufzeit übernimmt das System die Skalierung der dp-Einheiten nach Bedarf transparent, basierend auf der tatsächlichen Dichte des verwendeten Bildschirms. Die Konvertierung von dp-Einheiten in Bildschirmpixel ist einfach:

px = dp * (dpi / 160).

Auf einem 240-dpi-Bildschirm entspricht 1 dp beispielsweise 1,5 physischen Pixeln. Sie sollten beim Definieren der Benutzeroberfläche Ihrer Anwendung immer dp-Einheiten verwenden, um eine ordnungsgemäße Anzeige Ihrer Benutzeroberfläche auf Bildschirmen mit unterschiedlichen Dichten sicherzustellen.

Das Verständnis von Pixel zu dp und umgekehrt ist sehr wichtig (insbesondere, um dem Kreativteam genaue dp-Werte zu geben).

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

• Versuchen Sie, alle Pixelwerte in geraden Zahlen vom Kreativteam zu erhalten. Andernfalls kommt es beim Multiplizieren mit 0,5 zu Präzisionsverlusten.

px

Es ist oben erklärt. Versuchen Sie, in Layout-Dateien zu vermeiden. Es gibt jedoch einige Fälle, in denen px erforderlich ist. Zum Beispiel ListView-Trennlinie. px ist hier besser geeignet, um eine Ein-Pixel-Linie als Teiler für alle Bildschirmauflösungen anzugeben.

sp

Verwenden Sie sp für Schriftgrößen. Dann ändert sich nur die Schriftart in der Anwendung, während sich die Schriftgröße des Geräts ändert (dh Anzeige -> Schriftarten auf dem Gerät). Wenn Sie eine Schrift mit statischer Größe in der App behalten möchten, können Sie die Schriftgröße in dp angeben. In einem solchen Fall wird es sich nie ändern. Entwickler erhalten möglicherweise eine solche Anforderung für bestimmte Bildschirme. Dafür können Entwickler dp anstelle von sp verwenden. In allen anderen Fällen wird sp empfohlen.

Sie können den Unterschied zwischen pxund dpvon dem folgenden Bild sehen, und Sie können auch feststellen, dass die pxund dpnicht die gleichen physischen Größen auf den verschiedenen Bildschirmen garantieren konnten.

Alles, was mit der Größe des Textes und dem Erscheinungsbild zusammenhängt, muss spoder verwenden pt. Alles, was mit der Größe der Steuerelemente, den Layouts usw. zu tun hat, muss mit verwendet werden dp.

Sie können beide dpund dipan seinen Stellen verwenden.

Ich würde nur dp verwenden.

Es wird viel über die Verwendung von "sp" für Schriftgrößen gesprochen, und obwohl ich den Punkt schätze, denke ich nicht, dass es aus gestalterischer Sicht das Richtige ist. Sie können am Ende Ihr Design brechen, wenn der Benutzer eine wackelige Schriftgrößenauswahl hat und der Benutzer am Ende die App beschuldigt und nicht seine eigenen Lebensentscheidungen.

Wenn Sie eine Sp-Font-App auf einem 160-dpi-Tablet verwenden, werden Sie feststellen, dass sich alles vergrößert ... aber Ihre Schrift, die im Vergleich winzig aussehen wird. Es sieht nicht gut aus.

Während die Idee von "sp" -Schriften ein gutes Herz hat, ist es eine schlechte Idee. Bleib bei dp für alles.

sp = skalierungsunabhängiges Pixel

dp = dip = dichteunabhängige Pixel

dpi = Punkte pro Zoll

Wir sollten vermeiden, sp zu verwenden .

Wir sollten dp verwenden , um mehrere Bildschirme zu unterstützen.

Android unterstützt verschiedene Bildschirmauflösungen

• ldpi (niedrig) ~ 120 dpi
• mdpi (mittel) ~ 160 dpi
• hdpi (hoch) ~ 240 dpi
• xhdpi (extra hoch) ~ 320 dpi
• xxhdpi (extra-extra-hoch) ~ 480 dpi
• xxxhdpi (extra-extra-extra-hoch) ~ 640 dpi

Ein 120-dp-ldpi-Gerät hat 120 Pixel in einer Größe von 1 Zoll.

Das gleiche gilt für andere Dichten ...

Wir als Softwareentwickler sollten diese Konvertierungsformel verwenden:

Pixel = dp * (Dichte / 160)

Die 1 dp des 240-dpi-Geräts hat also = 1 * (240/160) = 3/2 = 1,5 Pixel.

Und 1 dp des 480-dpi-Geräts hat = 1 * (480/160) = 3 Pixel.

Mit diesem Wissen über 1,5 und 3 Pixel kann ein Softwareentwickler Layouts für verschiedene Dichten entwerfen.

So überprüfen Sie die Bildschirmparameter eines Geräts:

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);

Toast.makeText(
    this,
    "4:" + metrics.heightPixels + "," + metrics.density + ","
    + metrics.densityDpi, Toast.LENGTH_LONG).show();

Der Unterschied zwischen dpund spEinheiten, die in den aus der offiziellen Dokumentation kopierten Antworten als " Schriftgrößeneinstellung des Benutzers " angegeben sind, kann zur Laufzeit durch Ändern der Settings->Accessibility->Large TextOption angezeigt werden.

Large TextOption erzwingt, dass Text 1.3mal größer wird.

private static final float LARGE_FONT_SCALE = 1.3f;

Dies kann natürlich vom Hersteller abhängig sein, da es in Paketen / Apps / Einstellungen liegt .

dpi -

• Punkte pro Zoll
• Messung der Pixeldichte des Bildschirms.

px - Pixel

• Zum Zuordnen von Bildschirmpixeln

pt - Punkte

• Etwa 1/72 Zoll, bezogen auf die physische Bildschirmgröße.

in - Zoll - in Bezug auf die physische Bildschirmgröße (1 Zoll = 2,54 cm).

mm-Millimeter - in Bezug auf die physische Bildschirmgröße.

sp - skalierungsunabhängiges Pixel.

• Basierend auf der bevorzugten Schriftgröße des Benutzers.
• Die Schriftart sollte in 'sp' sein.

dip -

• dip == dp
• Dichteunabhängiges Pixel.
• Sie variiert je nach Bildschirmdichte.
• Bei einem Bildschirm mit 160 dpi ist 1 dp = 1 Pixel.
• Verwenden Sie dp mit Ausnahme der Textschriftgröße.

Im Standard werden dp und sp verwendet. sp für Schriftgröße und dp für alles andere.

Formel für die Umrechnung von Einheiten:

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  

Hier ist die von Android verwendete Formel:

px = dp * (dpi / 160)

Wobei dpi eine der folgenden Bildschirmdichten ist. Eine Liste aller möglichen Dichten finden Sie hier

Es definiert die Konstanten "DENSITY_ *".

• ldpi (niedrig) ~ 120 dpi
• mdpi (mittel) ~ 160 dpi
• hdpi (hoch) ~ 240 dpi
• xhdpi (extra hoch) ~ 320 dpi
• xxhdpi (extra-extra-hoch) ~ 480dpi
• xxxhdpi (extra-extra-extra-hoch) ~ 640dpi

Von hier genommen .

Dies wird viel Verwirrung bei der Übersetzung zwischen px und dp beseitigen, wenn Sie Ihre Bildschirm-dpi kennen.

Angenommen, Sie möchten ein Bild mit 60 dp für einen HDPI-Bildschirm, dann beträgt die physische Pixelgröße von 60 dp:

px = 60 * (240 / 160)

Bildschirmgröße in Androidist in Kategorien gruppiert small, medium, large, extra large, double-extraund triple-extra. Die Bildschirmdichte ist die Anzahl der Pixel in einem Bereich (z. B. Zoll) des Bildschirms. Im Allgemeinen wird es in Punkten pro Zoll (dpi) gemessen. Die Bildschirmdichte wird in niedrig, mittel, hoch und extra hoch eingeteilt. Die Auflösung ist die Gesamtzahl der Pixel auf dem Bildschirm.

• dp: Dichteunabhängiges Pixel, das je nach Bildschirmdichte variiert. Bei einem Bildschirm mit 160 dpi ist 1 dp = 1 Pixel. Verwenden Sie mit Ausnahme der Schriftgröße immer dp.
• dip: dip == dp. In früheren Android-Versionen wurde dip verwendet und später in dp geändert.
• sp: Unabhängiges Pixel skalieren, skaliert basierend auf der bevorzugten Schriftgröße des Benutzers. Schriftarten sollten sp verwenden.
• px: unser übliches Standardpixel, das dem Bildschirmpixel zugeordnet ist.
• in: Zoll, in Bezug auf die physische Bildschirmgröße.
• mm: Millimeter, bezogen auf die physikalische Bildschirmgröße.
• pt: 1/72 Zoll, bezogen auf die physische Bildschirmgröße.

Formel für die Umrechnung zwischen Einheiten

 px = dp * (dpi / 160)

dp bis px im Gerät

Das folgende Beispiel kann helfen, besser zu verstehen. Die Skalierung erfolgt basierend auf der Bucket-Größe von 120 (ldpi), 160 (mdpi), 240 (hdpi), 320 (xhdpi), 480 (xxhdpi) und 640 (xxxhdpi). Das von Google vorgeschlagene Verhältnis für das Entwerfen beträgt 3: 4: 6: 8: 12 für ldpi: mdpi: hdpi: xhdpi: xxhdpi

Ein Bild mit einer Größe von 150 x 150 Pixel belegt Folgendes:

• 150 dp x 150 dp Bildschirmfläche in mdpi
• 100 dp x 100 dp Bildschirmfläche in HDPI
• 75 dp x 75 dp Bildschirmfläche in xhdpi

Sie können den folgenden DPI-Rechner verwenden, um Ihre Bildgrößen und andere Abmessungen festzulegen, wenn Sie auf allen Android-Geräten ein einheitliches UI-Design wünschen.

DPI-Rechner in 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);        
   }
}

Weitere Informationen finden Sie unter folgendem Link.

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

Bitte lesen Sie die Antwort aus dem Community-Wiki. Nachstehend sind einige Informationen aufgeführt, die zusätzlich zu den obigen Antworten zu berücksichtigen sind. Die meisten Android-Entwickler vermissen dies bei der Entwicklung von Apps, daher füge ich diese Punkte hinzu.

sp = skalierungsunabhängiges Pixel

dp = dichteunabhängige Pixel

dpi = Dichtepixel

Ich habe die obigen Antworten durchgesehen ... und sie nicht genau richtig gefunden. sp für Textgröße, dp für Layoutgrenzen - Standard. Aber sp für die Textgröße bricht das Layout, wenn es in den meisten Geräten unachtsam verwendet wird.

sp Nehmen Sie die Textgröße des Geräts, während dp die Größe des Gerätedichtestandards übernimmt (niemals in einem Gerät ändern). Angenommen, 100sp-Text kann 80% des Bildschirms oder 100% des Bildschirms einnehmen, abhängig von der im Gerät eingestellten Schriftgröße

Sie können sp auch für Layoutgrenzen verwenden, es wird funktionieren :) Keine Standard-App verwendet sp für ganzen Text

Verwenden Sie sp und dp für die Textgröße unter Berücksichtigung von UX.

• Verwenden Sie sp nicht für Text in der Symbolleiste (kann Android-Dimensionen verwenden, die für verschiedene Bildschirmgrößen mit dp verfügbar sind)
• Verwenden Sie sp nicht für Text in kleinen, begrenzten Schaltflächen, sehr kleinem Text usw.

Einige Benutzer verwenden eine große FONT-Größe in ihrem Telefon, um die Lesbarkeit zu verbessern. Daher ist es ein UX-Problem, ihnen kleinen, fest codierten Text zu geben. Geben Sie bei Bedarf sp für Text ein, aber stellen Sie sicher, dass das Layout nicht beschädigt wird, wenn der Benutzer seine Einstellungen ändert.

Wenn Sie eine einzige App haben, die alle Dimensionen unterstützt, erhöht das Hinzufügen von xxxhdpi-Assets die App-Größe erheblich. Aber jetzt sind xxxhdpi-Telefone üblich, daher müssen wir xxxhdpi-Assets mindestens für Symbole in die Seitenleiste, Symbolleiste und untere Leiste aufnehmen. Es ist besser, zu Vektorbildern zu wechseln, um einheitliche und qualitativ bessere Bilder für alle Bildschirmgrößen zu erhalten.

Beachten Sie auch, dass Benutzer in ihrem Telefon benutzerdefinierte Schriftarten verwenden. Das Fehlen einer Schriftart kann also zu Problemen hinsichtlich des Abstands und allem führen. Angenommen, die Textgröße 12sp für eine benutzerdefinierte Schriftart benötigt möglicherweise einige Pixel mehr als die Standardschriftart.

Informationen zu Screendensities und Basedensity für Android finden Sie auf der Google Developer Site. https://developer.android.com/training/multiscreen/screendensities

• px - ein Pixel, genau wie bei CSS, JavaScript usw.
• sp - skalierungsunabhängige Pixel
• dip - dichteunabhängige Pixel

Normalerweise wird sp für Schriftgrößen verwendet, während dip (auch als dp bezeichnet) für andere verwendet wird.

Ich habe einen guten Artikel über das Entwerfen der Benutzeroberfläche von Android-Apps für verschiedene Bildschirmauflösungen gefunden und möchte ihn hier nur für jemanden belassen, der in diesem Bereich sucht. Ja, ich weiß, dass es irgendwie in Google Docs beschrieben ist (und in den obigen Beiträgen erwähnt wurde). Ich habe das gelesen, aber es war nicht gut für mich (ja, ich bin vielleicht zu dumm). Es blieb mir unklar, wie ich Layouts entwerfen sollte, die für unterschiedliche Bildschirmgrößen geeignet sind. Ich hasse das DP-Konzept und so weiter, wenn ich ein "flexibles" UI-Layout für verschiedene Bildschirme implementieren muss. (Hey iOS-Entwickler - ja, Sie haben Recht, es ist das Storyboard-Konzept).

Android hat kein schlechtes UI-Konzept, aber leider fehlen iOS Storyboard-Funktionen. Das Entwerfen einer flexiblen Benutzeroberfläche in Android ist (bestenfalls) nicht einfach.

Hier ist der Artikel, der mir geholfen hat zu verstehen, was in Android zu tun ist, um Layouts für verschiedene Bildschirmgrößen zu erstellen:

JMSTUDIO Blog: - Legen Sie die Bildschirmgröße für die Android-App fest

So gestalten Sie die Benutzeroberfläche für Android-Apps für unterschiedliche Bildschirmgrößen

Um eine App-Benutzeroberfläche für verschiedene Bildschirmgrößen zu entwerfen, muss unser ursprüngliches Design einen Mindestplatz für jede Bildschirmgröße erfüllen. Android definiert eine Mindestgröße (in dp) für jeden verallgemeinerten Bildschirmtyp. Hier ist eine Richtlinie zur Bildschirmgröße für Android. Wenn wir die Bildschirmgröße in dp erhalten, reicht es uns nicht aus, die Benutzeroberfläche der Android-App zu entwerfen. Für jede Bildschirmgröße müssen wir Grafiken und Bitmap-Bilder für jede Dichte vorbereiten. Hier ist eine Richtlinie zur Bildschirmdichte für Android.

Zur einfachen Berechnung können wir das Skalierungsverhältnis von 3: 4: 6: 8 zwischen den vier verallgemeinerten Dichten befolgen. Wenn wir ein 36 × 36-Pixel-Bild für ein ldpi-Gerät erstellen, beträgt die Bildgröße für Restdichten 48 × 48 für mdpi, 72 × 72 für hdpi und 96 × 96 für xhdpi.

So gestalten Sie die Benutzeroberfläche von Android Apps in Photoshop

Viele Designer haben Probleme beim Entwerfen der Android-App-Benutzeroberfläche in Photoshop oder anderen pixelbasierten Grafikdesign-Tools aufgrund der dichteunabhängigen Einheit dp. Designer wissen nicht, wie man dp auf Pixel abbildet. Google gibt ihnen auch keinen klaren Leitfaden für das Design der Android-Benutzeroberfläche, obwohl sie eine Grundformel für die Übersetzung von dp und Pixeln enthalten.

Nach Android-Definition entspricht 1pd 1px unter einem Gerät mit 160 dpi (mdpi). Um eine Android-App für ein großes Android-Gerät mit mdpi-Dichte zu entwerfen, können wir unsere UI-Größe in Pixel als 960 Pixel in der Breite und 720 Pixel in der Höhe definieren. Befolgen Sie die gleiche Zuordnungsregel. Wir können die folgende Designrichtlinie für die Benutzeroberfläche der Android App-Bildschirmgröße erhalten:

HINZUGEFÜGT : Wenn Sie auch an einer "flexiblen" Benutzeroberfläche interessiert sind, schauen Sie sich diese Bibliothek an: Ein Android SDK, das eine neue Größeneinheit bietet - sdp (skalierbares dp). Diese Größeneinheit skaliert mit der Bildschirmgröße (dies wird auch in einer Antwort hier über die SDPBibliothek erwähnt).

ADDED2 Google hat endlich die Nützlichkeit des iOS Storeboard UI-Konzepts verstanden, und hier geht es ConstraintLayoutfür die Android-Welt: Erstellen Sie eine reaktionsschnelle Benutzeroberfläche mit ConstraintLayout

1) dp: (density independent pixels)

Die Anzahl der in einer Einheit dp dargestellten Pixel nimmt mit zunehmender Bildschirmauflösung zu (wenn Sie mehr Punkte / Pixel pro Zoll haben). Umgekehrt verringert sich bei Geräten mit niedrigerer Auflösung die Anzahl der Pixel, die in der Einheit dp dargestellt werden. Da dies eine relative Einheit ist, muss eine Basislinie zum Vergleich vorhanden sein. Diese Grundlinie ist ein Bildschirm mit 160 dpi. Dies ist die Gleichung:px = dp * (dpi / 160).

2) sp: (scale independent pixels)

Dieses Gerät skaliert entsprechend der Bildschirm-dpi (ähnlich wie dp) sowie der bevorzugten Schriftgröße des Benutzers.

3) px: (pixels)

Tatsächliche Pixel oder Punkte auf dem Bildschirm.

Für weitere Details können Sie besuchen

Android-Entwicklerhandbuch> Dimension
Android-Entwicklerhandbuch> Bildschirme

Bildschirmgröße in Android ist in Kategorien gruppiert ldpi, mdpi, hdpi, xhdpi, xxhdpiund xxxhdpi. Die Bildschirmdichte ist die Anzahl der Pixel in einem Bereich (z. B. Zoll) des Bildschirms. Im Allgemeinen wird es in Punkten pro Zoll ( dpi) gemessen .

PX(Pixels):

• unser übliches Standardpixel, das dem Bildschirmpixel zugeordnet ist. pxist für absolute Pixel gedacht. Dies wird verwendet, wenn Sie in absoluten Pixeln für Breite oder Höhe angeben möchten. Nicht empfohlen.

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

• dip == dp. In früheren Android-Versionen wurde dip verwendet und später in geändert dp. Dies ist eine Alternative zu px.

• Im Allgemeinen verwenden wir nie, pxweil es absoluter Wert ist. Wenn Sie pxzum Festlegen von Breite oder Höhe verwenden und diese Anwendung auf Geräte mit unterschiedlicher Bildschirmgröße heruntergeladen wird, wird diese Ansicht nicht gemäß der Originalgröße des Bildschirms gedehnt.

• dpwird dringend empfohlen, anstelle von zu verwenden px. Verwenden dpSie diese Option, wenn Sie Breite und Höhe angeben möchten, um basierend auf den Bildschirmgrößen dynamisch zu wachsen und zu verkleinern.

• Wenn wir geben dp/dip, berechnet Android automatisch die Pixelgröße auf der Grundlage eines Bildschirms mit einer Größe von 160 Pixel.

SP(Scale independent pixels):

• skaliert basierend auf der bevorzugten Schriftgröße des Benutzers. Schriftarten sollten verwendet werden sp.

• Wenn Sie die Schriftgrößen für verschiedene Bildschirmgrößen angeben, verwenden Sie sp. Dies ist ähnlich wie. dpVerwenden Sie diese Option spinsbesondere, damit die Schriftgrößen basierend auf den Bildschirmgrößen dynamisch wachsen und schrumpfen

Android-Dokumentation sagt:

Verwenden Sie bei der Angabe von Abmessungen immer entweder dpoder spEinheiten. A dpist ein dichteunabhängiges Pixel, das der physikalischen Größe eines Pixels bei 160 entspricht dpi. An spist dieselbe Basiseinheit, wird jedoch durch die vom Benutzer bevorzugte Textgröße skaliert (es handelt sich um ein skalierungsunabhängiges Pixel). Daher sollten Sie diese Maßeinheit beim Definieren der Textgröße verwenden

Der Bildschirm eines Mobiltelefons besteht aus Tausenden winziger Punkte, die als Pixel (px) bezeichnet werden . Ein Pixel ist das kleinste Element, mit dem das Bild erstellt wird. Je mehr Pixel ein Bild oder eine Formulierung enthält, desto schärfer wird es und der Bildschirm des Smartphones ist besser lesbar.

Die Bildschirmauflösung wird anhand der Anzahl der Pixel auf dem Bildschirm gemessen. Die Bildschirmauflösung ist eine häufig verwendete Spezifikation beim Kauf eines Geräts, aber beim Entwerfen für Android ist sie eigentlich nicht so nützlich, da das Denken an Bildschirme in Pixel den Begriff der physischen Größe ignoriert, was für ein Touch-Gerät wirklich sehr wichtig ist.

Dichteunabhängige Pixel (dp oder dip) ermöglichen es dem Designer, Elemente zu erstellen, die unabhängig von der Auflösung oder Dichte des Zielgeräts erwartungsgemäß angezeigt werden.

Ein dichteunabhängiges Pixel (dp oder dip) entspricht einem Pixel bei der Basisliniendichte oder 160 dpi (Punkte pro Zoll).

1 px / 1 dp = 160 dpi / 160 dpi

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

wo,

dpi ist Punkte pro Zoll

Bei 320 dpi entspricht 1 dp 2 px.

Formel

px / dp = dpi / 160 dpi

Punkte pro Zoll (dpi) sind ein Maß für die Schärfe (dh die Dichte der beleuchteten Punkte) auf einem Bildschirm. Die Punkte pro Zoll für eine bestimmte Bildauflösung unterscheiden sich je nach Gesamtbildschirmgröße, da die gleiche Anzahl von Pixeln über einen anderen Raum verteilt wird.

Die Arbeit mit dichteunabhängigen Pixeln hilft uns, mit einer Situation umzugehen, in der Sie zwei Geräte mit derselben Pixelauflösung, aber unterschiedlichem Speicherplatz haben. Angenommen, ein Tablet und ein Telefon haben dieselbe Pixelauflösung von 1280 x 800 Pixel (160 dpi) bzw. 800 x 1280 Pixel (320 dpi).

Da sich ein Tablet nun in der Basisliniendichte (160 dpi) befindet, sind seine physischen und dichteunabhängigen Pixel gleich, 1280 x 800. Das Telefon hat andererseits eine höhere Pixeldichte, sodass es halb so viele dichteunabhängige Pixel wie physische hat Pixel. Ein Telefon hat also unabhängige Pixel mit einer Dichte von 400 x 640. Die Verwendung eines dichteunabhängigen Pixels erleichtert die mentale Vorstellung, dass das Tablet viel mehr Platz als das Telefon hat.

Wenn Sie zwei Geräte mit ähnlicher Bildschirmgröße, aber unterschiedlicher Pixeldichte haben, z. B. 800 x 1280 Pixel (320 dpi) und 400 x 640 Pixel (160 dpi), müssen Sie dies nicht vollständig definieren Unterschiedliche Layouts für diese beiden Geräte, da wir Assets in Bezug auf dichteunabhängige Pixel messen können, die für beide Geräte gleich sind.

800 x 1280 Pixel (320 dpi) = 400 x 640 dichteunabhängige Pixel (dp)

400 x 640 Pixel (160 dpi) = 400 x 640 dichteunabhängiges Pixel (dp)

Skalierungsunabhängige Pixel (sp) sind die bevorzugte Einheit für die Schriftgröße. Aus Gründen der Barrierefreiheit können Benutzer mit Android die Schriftgröße ihres Geräts anpassen. Benutzer, die Probleme beim Lesen von Text haben, können die Schriftgröße ihres Geräts erhöhen. Normalerweise finden Sie diese Option in der Anzeigeeinstellung Ihres Telefons oder Tablets unter Schriftgröße. Es ist häufig auch über die Eingabehilfen verfügbar.

Bei skalierungsunabhängigen Pixeln entspricht 16 sp genau 16 dp, wenn die Schriftgröße des Geräts normal oder 100% ist. Wenn die Schriftgröße des Geräts jedoch groß ist, z. B. 125%, bedeutet 16 sp 20 dp oder 1,25 mal 16.

Wenn Sie dp als Einheit für die Schriftgröße verwenden, hat dieser Text eine bestimmte physische Größe, unabhängig davon, ob der Benutzer die Schriftgröße des Geräts angepasst hat. Die Verwendung von SP-Einheiten bietet Menschen mit Sehbehinderung eine bessere Erfahrung.

Referenz : Udacity , Google

sp: skalierungsunabhängiges Pixel

Sie sollten es mit Texten verwenden, da es automatisch entsprechend der Schriftgröße skaliert wird, die der Benutzer auf seinem Gerät verwendet.

px: Pixel oder Bildelement ist der einzelne Punkt auf dem Bildschirm

Pixeldichte

Die Bildschirmpixeldichte und -auflösung variieren je nach Plattform. Geräteunabhängige Pixel und skalierbare Pixel sind Einheiten, die eine flexible Möglichkeit bieten, ein Design plattformübergreifend anzupassen.

Pixeldichte berechnen

Die Anzahl der Pixel, die in einen Zoll passen, wird als Pixeldichte bezeichnet. Bildschirme mit hoher Dichte haben mehr Pixel pro Zoll als Bildschirme mit niedriger Dichte ....

Die Anzahl der Pixel, die in einen Zoll passen, wird als Pixeldichte bezeichnet. Bildschirme mit hoher Dichte haben mehr Pixel pro Zoll als Bildschirme mit niedriger Dichte. Infolgedessen erscheinen UI-Elemente mit denselben Pixelabmessungen auf Bildschirmen mit niedriger Dichte größer und auf Bildschirmen mit hoher Dichte kleiner.

Um die Bildschirmdichte zu berechnen, können Sie folgende Gleichung verwenden:

Bildschirmdichte = Bildschirmbreite (oder -höhe) in Pixel / Bildschirmbreite (oder -höhe) in Zoll

Dichteunabhängigkeit

Die Bildschirmpixeldichte und -auflösung variieren je nach Plattform. Geräteunabhängige Pixel und skalierbare Pixel sind Einheiten, die eine flexible Möglichkeit bieten, ein Design plattformübergreifend anzupassen.

Berechnung der Pixeldichte Die Anzahl der Pixel, die in einen Zoll passen, wird als Pixeldichte bezeichnet . Bildschirme mit hoher Dichte haben mehr Pixel pro Zoll als Bildschirme mit niedriger Dichte ....

Dichteunabhängigkeit bezieht sich auf die einheitliche Anzeige von UI-Elementen auf Bildschirmen mit unterschiedlichen Dichten.

Dichteunabhängige Pixel , geschrieben als dp (ausgesprochen „ Dips “), sind flexible Einheiten, die so skaliert werden, dass sie auf jedem Bildschirm einheitliche Abmessungen aufweisen. Material-Benutzeroberflächen verwenden dichteunabhängige Pixel, um Elemente auf Bildschirmen mit unterschiedlichen Dichten konsistent anzuzeigen.

1. Bildschirm mit niedriger Dichte wird unabhängig von der Dichte angezeigt
2. Bildschirm mit hoher Dichte, der unabhängig von der Dichte angezeigt wird

Lesen Sie den vollständigen Text https://material.io/design/layout/pixel-density.html

Pixel (px) - entspricht den tatsächlichen Pixeln auf dem Bildschirm. Dies wird verwendet, wenn Sie in absoluten Pixeln für Breite oder Höhe angeben möchten.

Dichteunabhängige Pixel (dp oder dip) - eine abstrakte Einheit, die auf der physikalischen Dichte des Bildschirms basiert. Diese Einheiten beziehen sich auf einen Bildschirm mit 160 dpi, sodass ein dp ein Pixel auf einem Bildschirm mit 160 dpi ist. Das Verhältnis von dp zu Pixel ändert sich mit der Bildschirmdichte, jedoch nicht unbedingt in direktem Verhältnis. Hinweis: Der Compiler akzeptiert sowohl "dip" als auch "dp", obwohl "dp" konsistenter mit "sp" ist.

Skalierungsunabhängige Pixel (sp) - Dies entspricht der dp-Einheit, wird jedoch auch anhand der bevorzugten Schriftgröße des Benutzers skaliert. Es wird empfohlen, dieses Gerät bei der Angabe von Schriftgrößen zu verwenden, damit diese sowohl an die Bildschirmdichte als auch an die Vorlieben des Benutzers angepasst werden.

Verwenden Sie immer nur dp und sp. sp für Schriftgrößen und dp für alles andere. Dadurch wird die Benutzeroberfläche für Android-Geräte mit unterschiedlichen Dichten kompatibel. Weitere Informationen zu Pixel und DP finden Sie unter https://www.google.com/design/spec/layout/units-measurements.html#units-measurements-density-independent-pixels-dp-

Quell-URL: - http://www.androidtutorialshub.com/what-is-the-difference-between-px-dp-dip-sp-on-android/

Ich möchte einen einfachen Weg zum Verständnis bieten dp. In der Tat denke ich, dpist am einfachsten zu verstehen. dpist nur eine physikalische Längeneinheit. Es hat die gleiche Dimension wie mmoder inch. Es ist einfach bequem für uns zu schreiben 50dp, 60dpanstatt 50/160 inchoder 60/160 inch, weil man dpgenau 1/160 inchdie Bildschirmgröße oder Auflösung hat.

Das einzige Problem ist, dass die Android-dpi einiger Bildschirme nicht genau sind. Beispielsweise kann ein Bildschirm, der auf 160 dpi klassifiziert ist, tatsächlich 170 dpi haben. Das Berechnungsergebnis von dpist also unscharf. Es sollte ungefähr das gleiche sein wie 1/160 inch.