android - independent - Was ist der Unterschied zwischen "px", "dip", "dp" und "sp"?




px dp dpi (20)

sp: maßstabsunabhängiges Pixel

Sie sollten es für Texte 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

Was ist der Unterschied zwischen Android-Maßeinheiten?

  • px
  • tauchen
  • dp
  • sp

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 an

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

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

  • 1dp = 1px auf mdpi

sp oder sip ist ein von der Skala unabhängiges Pixel . Sie werden skaliert, wenn die Option Großer Text in Einstellungen > Eingabehilfen aktiviert ist

  • 1sp = 1dp
  • 1sp = 1.2dp mit barrierefreiem Text

Was zu benutzen

Verwenden Sie sp für Textgröße.

Verwenden Sie dp für alles andere.


Aus der Android-Entwicklerdokumentation :

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

  2. im
    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 je nach Größe des Bildschirms.

  5. dp oder dip
    Density -unabhängige Pixel - eine abstrakte Einheit, die auf der physischen Dichte des Bildschirms basiert. Diese Einheiten sind relativ zu einem Bildschirm mit 160 dpi, also ist ein Pixel ein Pixel auf einem Bildschirm mit 160 dpi. 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" eher mit "sp" übereinstimmt.

  6. sp
    Scale -unabhängige Pixel - Dies ist wie bei der dp-Einheit, sie wird jedoch auch nach der Einstellung der Schriftgröße des Benutzers skaliert. Es wird empfohlen, dieses Gerät bei der Angabe von Schriftgrößen zu verwenden, damit diese sowohl der Bildschirmdichte als auch den 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 .

Um die Abmessungen auf einem realen Gerät zu berechnen, kann this App verwendet werden.


Der Unterschied zwischen den dp und sp Einheiten, die als " Präferenz für die Schriftgröße des Benutzers " bezeichnet werden, durch die aus der offiziellen Dokumentation kopierten Antworten kann zur Laufzeit durch Ändern der Option Settings->Accessibility->Large Text angezeigt werden.

Large Text Option " Large Text " zwingt den Text um das 1.3 Fache.

private static final float LARGE_FONT_SCALE = 1.3f;

Dies kann natürlich herstellerabhängig sein, da es in packages/apps/Settings .


Grundsätzlich gilt für px nur ein Pixel. Wenn Sie genau ein Pixel auf dem Bildschirm haben möchten, wie bei einem Teiler:

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

Bei> 120 dpi wird auf 0 gerundet.


Ich habe die folgende Formel berechnet, um die Konvertierungen in dp und sp dp


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

  • Wenn Sie ein MDPI-Gerät verwenden, nimmt ein Bild mit 150 x 150 px Pixeln 150 * 150 dp dp Speicherplatz in Anspruch.
  • Bei einem HDDPI-Gerät benötigt ein Bild mit 150 x 150 px Pixeln 100 * 100 dp Bildschirmfläche.
  • Bei der Ausführung auf einem xhdpi-Gerät nimmt ein Bild mit einer 150x150 px 150 150x150 px 150 150x150 px 75 * 75 dp 150x150 px Speicherplatz in 150x150 px .

Umgekehrt: Sagen Sie, Sie möchten Ihrer Anwendung ein Bild hinzufügen und benötigen ein 100 * 100 dp Steuerelement. Sie müssen Bilder mit unterschiedlichen Größen 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

Sie können den Unterschied zwischen px und dp auf dem Bild unten sehen und Sie können auch feststellen, dass px und dp nicht die gleichen physikalischen Größen auf den verschiedenen Bildschirmen garantieren können.


dpi -

  • Punkte pro Zoll
  • Messung der Pixeldichte des Bildschirms.

px - pixel

  • Für die Zuordnung von Bildschirmpixeln

pt - Punkte

  • Ungefähr 1/72 Zoll in Bezug auf die physikalische Bildschirmgröße.

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

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

sp - maßstabsunabhängiges Pixel.

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

Dip -

  • dip == dp
  • Dichte unabhängiges Pixel.
  • Sie variiert je nach Bildschirmdichte.
  • In einem 160-dpi-Bildschirm ist 1 dp = 1 Pixel.
  • Verwenden Sie dp mit Ausnahme der Schriftgröße.

In 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  

sp = maßstabsunabhängiges Pixel

dp = dip = dichteunabhängige Pixel

dpi = Punkte pro Zoll

Wir sollten es vermeiden, sp einzusetzen .

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 verfügt über 120 Pixel in einer Größe von 1 Zoll.

Dasselbe gilt für andere Dichten ...

Wir als Software-Entwickler sollten diese Umrechnungsformel verwenden:

Pixel = dp * (Dichte / 160)

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

Und ein Gerät mit einer Auflösung von 480 dpi hat 1 dp = 1 * (480/160) = 3 Pixel.

Mit diesem Wissen von 1,5 und 3 Pixeln kann ein Softwareentwickler Layouts für unterschiedliche Dichten erstellen.

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();

Quelle 1

Quelle 2

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

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

dp

Dichteunabhängige Pixel - Eine abstrakte Einheit, die auf der physischen Dichte des Bildschirms basiert. Diese Einheiten sind relativ zu einem Bildschirm mit 160 dpi (Punkte pro Zoll), bei dem 1 dB ungefähr 1 Pixel entspricht. Beim Ausführen auf einem Bildschirm mit höherer Dichte wird die Anzahl der zum Zeichnen von 1 dB verwendeten Pixel um einen für die Bildschirmauflösung geeigneten Faktor erhöht. In ähnlicher Weise wird auf einem Bildschirm mit geringerer Dichte die Anzahl der für 1 dB verwendeten Pixel herunterskaliert. 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 Ansicht in Ihrem Layout für verschiedene Bildschirmdichten korrekt anzupassen. Mit anderen Worten, es bietet Konsistenz für die realen Größen Ihrer Benutzeroberflächenelemente auf verschiedenen Geräten.

sp

Skalenunabhängige Pixel - Dies ist wie bei der dp-Einheit, sie wird jedoch auch nach der Einstellung der Schriftgröße des Benutzers skaliert. Es wird empfohlen, dieses Gerät zum Festlegen der Schriftgrößen zu verwenden, damit diese sowohl der Bildschirmdichte als auch den Vorlieben des Benutzers angepasst werden.

pt

Punkte - 1/72 Zoll je nach 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 variieren kann. Jedes Gerät verfügt möglicherweise über eine andere Anzahl von Pixeln pro Zoll und möglicherweise mehr oder weniger auf dem Bildschirm verfügbare Gesamtpixel.

mm

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

im

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

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


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

Verwenden Sie sp für {Textgröße}.

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

Sehen Sie den Unterschied zwischen px , dp und sp auf verschiedenen Bildschirmgrößen.

Quelle: Android-Programmierung: Der Big Nerd Ranch Guide


Bildschirmgröße in Android ist in Kategorien gruppiert ldpi, mdpi, hdpi, xhdpi, xxhdpiund xxxhdpi. Die Bildschirmdichte ist die Anzahl der Pixel innerhalb eines Bereichs (wie Zoll) des Bildschirms. Im Allgemeinen wird es in Dots per Inch ( dpi) gemessen .

PX(Pixels):

  • unser übliches Standardpixel, das dem Bildschirmpixel entspricht. pxist für absolute Pixel gedacht. Dies wird verwendet, wenn Sie die Breite oder Höhe in absoluten Pixeln 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 geändert dp. Dies ist eine Alternative von px.

  • Im Allgemeinen verwenden wir niemals, pxda es sich um einen absoluten Wert handelt. Wenn Sie pxdie Breite oder Höhe festlegen und diese Anwendung in Geräte mit unterschiedlichen Bildschirmgrößen heruntergeladen wird, wird diese Ansicht nicht entsprechend der Bildschirmgröße des Originals vergrößert.

  • dpwird dringend empfohlen, anstelle von zu verwenden px. Verwenden dpSie diese Option, wenn Sie Breite und Höhe erwähnen möchten, um je nach Bildschirmgröße dynamisch zu wachsen und zu schrumpfen.

  • wenn wir geben dp/dip, Android wird die Pixelgröße auf der Basis von 160 Pixeln Größe Bildschirm automatisch berechnen.

SP(Scale independent pixels):

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

  • Verwenden Sie, wenn Sie die Schriftgrößen für verschiedene Bildschirmgrößen angeben sp. Dies ist ähnlich wie dp.Verwenden Sie spbesonders für Schriftgrößen, um dynamisch zu vergrößern und zu schrumpfen, basierend auf den Bildschirmgrößen

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. Ein spist die gleiche Basiseinheit, wird jedoch nach der vom Benutzer bevorzugten Textgröße skaliert (es handelt sich um ein von der Skala unabhängiges Pixel). Daher sollten Sie diese Maßeinheit zur Definition der Textgröße verwenden


Darüber hinaus sollten Sie die folgenden Konzepte genau verstehen:

Bildschirmgröße:

Tatsächliche physische Größe, gemessen als Diagonale des Bildschirms. Zur Vereinfachung gruppiert Android alle tatsächlichen Bildschirmgrößen in vier allgemeinen Größen: klein, normal, groß und extra groß.

Bildschirmdichte:

Die Anzahl der Pixel in einem physischen Bereich des Bildschirms. normalerweise als dpi (Dots per Inch) 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". Zur Vereinfachung 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, dh das Seitenverhältnis des Bildschirms ist entweder groß oder groß. Beachten Sie, dass verschiedene Geräte nicht nur standardmäßig in unterschiedlichen Ausrichtungen arbeiten. Die Ausrichtung kann sich zur Laufzeit ändern, 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 der Auflösung. Anwendungen sollten sich nur mit der 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 -position auf dichtenunabhängige Weise auszudrücken. Das dichteunabhängige Pixel entspricht einem physischen Pixel auf einem Bildschirm mit 160 dpi. Hierbei handelt es sich um die Basisliniendichte, die das System für einen Bildschirm mit "mittlerer" Dichte annimmt. Zur Laufzeit behandelt das System die Skalierung der dp-Einheiten je nach Bedarf auf der Grundlage der tatsächlichen Dichte des verwendeten Bildschirms transparent. Die Umwandlung von dp-Einheiten in Bildschirmpixel ist einfach: px = dp * (dpi / 160). Auf einem Bildschirm mit 240 dpi entspricht 1 dp beispielsweise 1,5 physikalischen Pixeln. Sie sollten immer dp units verwenden, wenn Sie die Benutzeroberfläche Ihrer Anwendung definieren, um sicherzustellen, dass Ihre Benutzeroberfläche auf Bildschirmen mit unterschiedlichen Dichten angezeigt wird.

Referenz: Android-Entwicklerseite


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

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

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

pt Punkte - 1/72 Zoll je nach Größe des Bildschirms.

dp Density - Independent Pixels - Eine abstrakte Einheit, die auf der physischen Dichte des Bildschirms basiert. Diese Einheiten sind relativ zu einem Bildschirm mit 160 dpi, also ist ein Pixel ein Pixel auf einem Bildschirm mit 160 dpi. Das Verhältnis von dp zu Pixel ändert sich mit der Bildschirmdichte, jedoch nicht unbedingt in direktem Verhältnis. Anmerkung: Der Compiler akzeptiert sowohl dip als auch dp , obwohl dp mit sp übereinstimmt.

sp Skalenunabhängige Pixel - Dies ist wie bei der dp Einheit, wird jedoch auch durch die Schriftgrößeneinstellung des Benutzers skaliert. Es wird empfohlen, dieses Gerät bei der Angabe von Schriftgrößen zu verwenden, damit diese sowohl der Bildschirmdichte als auch den Vorlieben des Benutzers angepasst werden.

Nehmen Sie zum Beispiel zwei Bildschirme, die die gleiche Größe haben, einer jedoch eine Bildschirmdichte von 160 dpi (Punkte pro Zoll, dh Pixel pro Zoll) und der andere Bildschirm ist 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

SDP - eine skalierbare Größe - ist im Grunde keine Einheit, sondern dimensioniert Ressourcen für unterschiedliche Bildschirmgrößen.

Probieren Sie die sdp- Bibliothek von Intuit aus. Es ist sehr praktisch, um Geräteprobleme zu lösen, und Sie können schnell mehrere Bildschirme unterstützen .

Verwendungszweck

android:paddingBottom="@dimen/_15sdp"für positiv und android:layout_marginTop="@dimen/_minus10sdp"für negativ sdp sdp

Es hat einen entsprechenden Wert in dp für jede Größe in values-sw<N>dpOrdnern (sw = kleinste Breite ).

Beachtung

Verwenden Sie es vorsichtig! In den meisten Fällen müssen Sie noch ein anderes Layout für Tablets entwerfen.

Beispiel

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

Sie können db für Textgröße verwenden, aber ich bevorzuge ssp für Textgröße.

Weitere Informationen finden Sie auf der GitHub-Seite der Bibliothek .


Bevor ich diese Frage beantworte, möchte ich zunächst die Anzahl der Einheiten verringern. Also los: dp oder dip sind beide gleich und werden als dichtenunabhängige Pixel bezeichnet .

1. px - steht für Pixel. Pixel sind ein einzelner Punkt auf einem Bildschirm. In der Mobilfunkbranche wird sie normalerweise in ppi (Pixel pro Zoll) gemessen. Die Bildschirmauflösung ist direkt proportional zu ppi. Je größer die Anzahl der Pixel pro Zoll ist, desto höher ist die Bildschirmauflösung.

Wenn Sie beispielsweise ein Bild mit einer Größe von 200 px * 200 px zeichnen , muss das Erscheinungsbild auf einem Gerät mit hoher Auflösung anders sein als bei einem Gerät mit niedriger Auflösung. Der Grund dafür ist, dass ein 200-Pixel- Bild auf einem Telefon mit niedriger Auflösung größer aussieht als auf einem Gerät mit hoher Auflösung.

Die folgenden Bilder zeigen eine Auflösung desselben Bildes auf verschiedenen Telefonen.

  • Telefon mit hoher Bildschirmauflösung

  • Telefon mit niedriger Bildschirmauflösung

2. dip oder dp - eine abstrakte Einheit, die auf der physischen Dichte des Bildschirms basiert. Diese Einheiten sind relativ zu einem Bildschirm mit 160 dpi, also ist ein Pixel ein Pixel auf einem Bildschirm mit 160 dpi. Das Verhältnis von dp zu Pixel ändert sich mit der Bildschirmdichte, jedoch nicht unbedingt in direktem Verhältnis. "Dichteunabhängigkeit" bezieht sich auf die einheitliche Darstellung von UI-Elementen auf Bildschirmen mit unterschiedlichen Dichten.

  • Bild, das 80px (linkes Bild) und 80 dp (rechtes Bild) zeigt . Checkout-Unterschied

Ein dp entspricht einem physischen Pixel auf einem Bildschirm mit einer Dichte von 160 . Dp berechnen:

dp = (Breite in Pixel * 160) / Bildschirmdichte

3. sp - steht für skalierbare Pixel. Im Allgemeinen wird sp für Texte auf der Benutzeroberfläche verwendet und sp behält die Schriftarteinstellungen bei. Wenn zum Beispiel ein Benutzer eine größere Schrift als 30 sp auswählt , wird er automatisch skaliert, um entsprechend den Vorlieben des Benutzers groß zu erscheinen.


Bitte lesen Sie die Antwort aus dem Community-Wiki. Nachfolgend sind einige Informationen aufgeführt, die zusätzlich zu den obigen Antworten zu beachten sind.

sp = maßstabsunabhängiges Pixel

dp = dichteunabhängige Pixel

dpi = Dichte Pixel

Ich habe die obigen Antworten durchgelesen ... sie nicht genau richtig zu finden. sp für Textgröße, dp für Layoutgrenzen - Standard. Aber sp für Textgröße wird das Layout brechen , wenn nachlässig verwendet in den meisten der Geräte.

sp nimmt die Textgröße des Geräts an, während dp den Standard der Gerätedichte annimmt (niemals an 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 kein sp für Text in der Symbolleiste (kann android-Dimens oder dp verwenden)
  • Verwenden Sie kein sp für Text in kleinen, begrenzten Schaltflächen, sehr kleinen Text usw

Einige Benutzer verwenden FONT FONT in ihrem Telefon, um die Lesbarkeit zu verbessern. Wenn Sie einen kleinen, hartcodierten Text eingeben, ist dies ein Problem der UX. Setzen Sie bei Bedarf sp für Text, stellen Sie jedoch sicher, dass das Layout nicht beschädigt wird.

Wenn Sie über eine einzige App verfügen, die alle Dimensionen unterstützt, erhöht das Hinzufügen von xxxhdpi-Assets die App-Größe erheblich. Aber jetzt sind xxxhdpi-Telefone üblich, so dass wir xxxhdpi-Elemente mindestens für Symbole in Seitenleiste, Symbolleiste und Bodenleiste einfügen müssen. Bewegen Sie sich besser zu Vektorbildern, um für alle Bildschirmgrößen eine einheitliche und qualitativ bessere Bilder zu erhalten.


Ich bin auf einen guten Artikel über das Entwerfen von Android-Apps-UI für verschiedene Bildschirmauflösungen gestoßen, und ich möchte es hier nur für jemanden, der in diesem Bereich sucht, lassen. Ja, ich weiß, dass es irgendwie in Google-Dokumenten 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 blöd)). Es blieb mir unklar, wie man Layouts entwerfen kann, 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 die iOS-Storyboard-Funktionen. Das Design einer flexiblen Benutzeroberfläche in Android ist (am besten) keine einfache Sache.

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

JMSTUDIO-Blog: - Legen Sie die Bildschirmgröße der 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 anfänglicher Entwurf für jede Bildschirmgröße einen minimal erforderlichen Speicherplatz erfüllen. Android definiert für jeden verallgemeinerten Bildschirmtyp eine Mindestgröße (in dp). Hier ist eine Richtlinie zur Bildschirmgröße für Android. Wenn wir die Bildschirmgröße in dp erhalten, reicht es nicht aus, die Android-App-Benutzeroberfläche zu entwerfen. Für jede Bildschirmgröße müssen Grafiken und Bitmap-Bilder für jede Dichte vorbereitet werden. Hier ist eine Android-Bildschirmdichtehilfe.

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

So erstellen Sie eine Android-Apps-Benutzeroberfläche in Photoshop

Viele Designer haben Probleme mit der Gestaltung der Android-App-Benutzeroberfläche in Photoshop oder anderen auf Pixel basierenden Grafikdesign-Tools aufgrund einer dichteunabhängigen Einheit (dp). Designer wissen nicht, wie man Pixel in Pixel umwandelt. Google gibt ihnen auch keinen klaren Designleitfaden für Android-Benutzeroberflächen, obwohl sie eine grundlegende Formel für die DP- und Pixel-Übersetzung enthalten.

Laut Android-Definition entspricht 1pd 1px unter 160 dpi (mdpi). Wir möchten also eine Android-App für ein großes Android-Gerät mit einer MDPI-Dichte entwickeln. Wir können unsere UI-Größe in Pixel als 960 Pixel Breite und 720 Pixel Höhe definieren. Befolgen Sie die gleiche Mapping-Regel. Wir können die folgenden Richtlinien für die Bildschirmgröße der Android-App für die Benutzeroberfläche festlegen:

ADDED : Wenn Sie sich auch für eine "flexible" Benutzeroberfläche interessieren, werfen Sie einen Blick auf diese Bibliothek: Ein Android-SDK, das eine neue Einheit der Größe enthält - sdp (skalierbare 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 gilt die ConstraintLayoutAndroid-Welt: Erstellen Sie eine Responsive UI mit ConstraintLayout


Ich möchte einen einfachen Weg zum Verständnis bieten dp. Ich denke, es 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-Auflösung einiger Bildschirme nicht genau ist. Beispielsweise kann ein mit 160 dpi klassifizierter Bildschirm tatsächlich 170 dpi haben. Das Berechnungsergebnis von dpist also unscharf. Es sollte ungefähr das gleiche sein wie 1/160 inch.





units-of-measurement