Was ist der Unterschied zwischen „px“, „dip“, „dp“ und „sp“?

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

Frage

Was ist der Unterschied zwischen Android Maßeinheiten?

  • Pixel
  • dip
  • dp
  • sp
War es hilfreich?

Lösung

Von der Android Developer Dokumentation :

  1.   

    Pixel
       Pixel -. Entspricht den aktuellen Pixel auf dem Bildschirm

  2.   


       Zoll -. Auf der Grundlage der physikalischen Größe des Bildschirms
      1 Inch = 2,54 cm

  3.   

    mm
       Millimeter -. Auf der Grundlage der physikalischen Größe des Bildschirms

  4.   

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

  5.   

    dp oder dip
       Dichte -unabhängigen Pixel - eine abstrakte Einheit, die auf der physikalischen Dichte des Bildschirms basiert. Diese Einheiten sind im Verhältnis zu einem 160       dpi Bildschirm, so dass ein dp ist ein Pixel auf einem 160 dpi-Bildschirm. Das Verhältnis von       dp-zu-Pixel wird mit der Rasterdichte ändern, aber nicht unbedingt       in direktem Verhältnis. Hinweis: Der Compiler akzeptiert sowohl „dip“ und       "Dp", obwohl "dp" ist mehr im Einklang mit "sp".

  6.   

    sp
       Scale -unabhängigen Pixel - das ist wie die dp-Einheit, aber es wird auch durch die Benutzer-Schriftgröße bevorzugt skaliert. Es wird Ihnen empfohlen       Verwenden Sie dieses Gerät bei Schriftgrößen spezifizieren, so werden sie angepasst werden       sowohl für die Rasterdichte und Vorlieben des Benutzers.

Legendes Dichte Independence 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 können auch in der Google Design-Dokumentation finden werden .

Andere Tipps

So ziemlich alles über diese und wie man die beste Unterstützung für mehrere Bildschirme in verschiedenen Größen und Dichten zu erreichen, ist hier sehr gut dokumentiert:

  

Bildschirmgröße
  Die tatsächliche physikalische Größe, gemessen als der Bildschirm Diagonale.   Der Einfachheit halber Android Gruppen alle aktuellen Bildschirmgrößen in vier   verallgemeinern Größen. klein, normal, groß und extra-large

     

Bildschirm Dichte
  Die Anzahl der Pixel innerhalb eines physischen Bereich der   Bildschirm; in der Regel bezeichnet als dpi (dots per inch). Zum Beispiel kann ein   „Niedrige“ Dichte Bild weniger Pixel innerhalb eines gegebenen physischen Bereich hat,   im Vergleich zu einem „normalen“ oder „hohen“ Dichte-Bildschirm. Aus Gründen der Einfachheit   Android Gruppen alle aktuellen Bildschirmdichten in sechs generali   Dichten: niedrig, mittel, hoch, extra hoch, extra-extra-hoch, und   Extra-extra-extra-hoch.

     

Ausrichtung
die Ausrichtung des Bildschirms vom Standpunkt des Benutzers   Aussicht. Dies ist entweder Landschaft oder Portrait, was bedeutet, dass der Bildschirm des   Seitenverhältnis ist entweder breit oder hoch ist. Beachten Sie, dass nicht   nur betreiben verschiedene Geräte in unterschiedlichen Orientierungen durch   Standard, aber die Orientierung kann zur Laufzeit geändert werden, wenn der Benutzer   dreht sich das Gerät aus.

     

Auflösung
Die Gesamtzahl der physikalischen Pixel auf   ein Bildschirm. Wenn die Unterstützung für mehrere Bildschirme hinzufügen, Anwendungen tun   arbeitet nicht direkt mit einer Auflösung; Anwendungen sollten besorgt sein   nur mit Bildschirmgröße und Dichte, wie sie in der verallgemeinerten angegebenen   Größe und Dichte-Gruppen.

     

dichteunabhängige Pixel (dp)
eine virtuelle   Pixeleinheit, die Sie verwenden sollten, wenn UI-Layout definieren, zum Ausdruck bringen   Layout-Abmessungen oder die Position in einer dichteunabhängige Art und Weise.   Die Dichte unabhängige Pixel sind äquivalent zu einem physikalischen Pixel auf einem 160   dpi-Bildschirm, der die Basisliniendichte, die durch das System für ein ausgegangen ist   „Mittel“ Dichte-Bildschirm. Zur Laufzeit übernimmt das System transparent   jede Skalierung der dp-Einheiten, falls erforderlich, auf der Grundlage der tatsächlichen Dichte   des Bildschirms verwendet wird. Die Umwandlung von dp Einheiten Bildschirmpixel ist   einfach:   px = dp * (dpi / 160).   Zum Beispiel auf einem 240 dpi-Bildschirm, 1 dp   gleich 1,5 physikalische Pixel. Sie sollten immer dp Einheiten verwenden, wenn   Ihre Anwendung Benutzeroberfläche zu definieren, um eine korrekte Anzeige der Benutzeroberfläche sorgen auf   Bildschirm mit unterschiedlichen Dichten.

Wenn Sie ein ernsthaft über einen Android-App für mehr als eine Art von Gerät zu entwickeln, sollten Sie den Bildschirm unterstützen die Entwicklung Dokument mindestens einmal gelesen haben. Hinzu kommt, dass, es ist immer eine gute Sache, die tatsächliche Anzahl der aktiven Geräte zu kennen, die eine bestimmte Bildschirmkonfiguration haben.

Ich werde näher auf mehr wie genau funktioniert dp px konvertieren:

  • Wenn auf einem MDPI Gerät ausgeführt wird, wird ein 150 x 150 px Bild 150 * 150 dp Platz auf dem Bildschirm einnehmen.
  • Wenn auf einem hdpi Gerät ausgeführt wird, wird ein 150 x 150 px Bild 100 * 100 dp Platz auf dem Bildschirm einnehmen.
  • Wenn auf einem xhdpi Gerät ausgeführt wird, wird ein 150x150 px Bild 75 * 75 dp Platz auf dem Bildschirm einnehmen.

Die andersrum: sagen, Sie ein Bild Ihrer Anwendung hinzufügen möchten, und Sie benötigen sie eine 100 * 100 dp Kontrolle zu füllen. Sie werden unterschiedlich große Bilder für die unterstützten Bildschirmgrößen erstellen müssen:

  • 100 * 100 px für MDPI
  • 150 * 150 px für hdpi
  • 200 * 200 px für xhdpi

px Pixel -. Punkt pro Skala entspricht den aktuellen Pixel auf dem Bildschirm

Zoll -. Auf der Grundlage der physikalischen Größe des Bildschirms

mm Millimeter -. Auf der Grundlage der physikalischen Größe des Bildschirms

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

dp Dichte - unabhängig Pixel - eine abstrakte Einheit, die auf der physikalischen Dichte des Bildschirms basiert. Diese Einheiten sind im Verhältnis zu einem 160 dpi-Bildschirm, so dass man dp ist ein Pixel auf einem 160 dpi-Bildschirm. Das Verhältnis von dp-zu-Pixel werden mit der Rasterdichte ändern,  aber nicht unbedingt in direktem Verhältnis.  . Hinweis: Der Compiler sowohl dip und dp akzeptiert, obwohl dp mehr im Einklang mit sp ist

sp -Skala unabhängige Pixel - das ist wie die dp Einheit ist,  aber es wird auch durch die Benutzer-Schriftgröße bevorzugt skaliert. Es wird empfohlen, dass Sie dieses Gerät verwenden, wenn die Schriftgrößen spezifizieren,  so werden sie angepasst werden, um sowohl die Rasterdichte und der Präferenz des Benutzers.

Nehmen wir das Beispiel von zwei Bildschirmen, die die gleiche Größe haben, sondern man hat eine Rasterdichte von 160 dpi (dots per inch, d.h. Pixel pro Zoll), und die andere 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

Außerdem sollten Sie klares Verständnis über die folgenden Begriffe haben:

Bildschirmgröße:

  

Die tatsächliche physikalische Größe, wie die Diagonale des Bildschirms gemessen. Der Einfachheit halber Android Gruppen alle aktuellen Bildschirmgrößen in   vier generali Größen. klein, normal, groß und extra groß

Bildschirmdichte:

  

Die Menge von Pixeln innerhalb eines physikalischen Bereich des Bildschirms; in der Regel bezeichnet als dpi (dots per inch). Zum Beispiel kann ein   „Niedrige“ Dichte Bild weniger Pixel innerhalb eines gegebenen physischen Bereich hat,   im Vergleich zu einem „normalen“ oder „hohen“ Dichte-Bildschirm. Aus Gründen der Einfachheit   Android Gruppen alle aktuellen Bildschirmdichten in vier generali   Dichten. niedrig, mittel, hoch und extra hohe

Ausrichtung:

  

Die Ausrichtung des Bildschirms aus der Sicht des Benutzers. Dies ist entweder Landschaft oder Portrait, was bedeutet, dass die   Seitenverhältnis des Bildschirms entweder breit oder hoch ist. Sei vorsichtig   nur das nicht arbeiten verschiedene Geräte in unterschiedlichen Ausrichtungen   In der Standardeinstellung, aber die Orientierung kann zur Laufzeit ändern, wenn der Benutzer   dreht sich das Gerät aus.

Auflösung:

  

Die Gesamtzahl der physikalischen Pixel auf einem Bildschirm. Wenn die Unterstützung für mehrere Bildschirme hinzufügen, Anwendungen funktionieren nicht direkt   mit einer Auflösung; Anwendungen sollten nur mit Bildschirm betroffen sein   Größe und Dichte, wie sie in der verallgemeinerten Größe angegeben und Dichte   Gruppen.

dichteunabhängige Pixel (dp):

  

Eine virtuelle Pixeleinheit, die Sie verwenden sollen bei der Definition von UI-Layout, Layout Dimensionen auszudrücken oder   Position in einer Dichte unabhängig. Die dichteunabhängige Pixel   ist äquivalent zu einem physikalischen Pixel auf einen 160 dpi-Bildschirm, der das ist,   Basisliniendichte, die durch das System für ein „mittleres“ Dichtebild angenommen.   Zur Laufzeit übernimmt das System transparent beliebige Skalierung des dp   Einheiten, falls erforderlich, auf der tatsächlichen Dichte des Bildschirms im Einsatz basierten.   Die Umwandlung von dp Einheiten Bildschirmpixel ist einfach: px = dp * (dpi   / 160). Zum Beispiel auf einem 240 dpi-Bildschirm, 1 dp gleich 1,5 physikalischen   Pixel. Sie sollten immer dp Einheiten verwenden, wenn die Definition Ihrer   Anwendung UI, mit der richtigen Anzeige der Benutzeroberfläche auf den Bildschirmen, um sicherzustellen,   unterschiedliche Dichten.

Referenz: Android-Entwickler-Website

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

Verwenden sp für {text-size} nur.

Um die gleiche Größe auf unterschiedliche Bildschirmdichten zu erhalten, übersetzt Android diese Einheiten in Pixel zur Laufzeit, so dass es keine knifflige Mathematik für Sie tun.

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

Geben Sie Bildbeschreibung hier

Quelle: Android Programmierung: The Big Nerd-Ranch-Führer

Ich habe die Formel unten berechnet die Umwandlungen dpi zu machen dp und sp eingeben Bild Beschreibung hier

Definitionen

Pixel oder Punkt ist ein Pixel auf dem physischen Bildschirm.

dpi sind Pixel pro Zoll auf dem physischen Bildschirm und die Dichte der Anzeige dar.

Android gibt Alias-Namen zu mehreren Dichten

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

dip oder dp ist Dichte-indenpendant Pixel , dh sie entsprechen mehr oder weniger Pixel auf der physikalischen Dichte abhängig.

  • 1 dp = 1px auf MDPI

image description hier

sp oder sip ist ein Scale-unabhängigen Pixel . Sie werden skaliert, wenn die Große Schrift Option aktiviert ist in Einstellungen > Bedienungshilfen

  • 1sp = 1 dp
  • 1sp = 1.2dp mit Zugänglichkeit Großer Schrift

Was zu benutzen?

  

Mit sp für Textgröße.

     

Mit dp für alles andere.

Quelle 1

Quelle 2

Quelle 3: (Daten von der Quelle 3 ist unten angegeben)

  

Dies sind Bemaßungswerte in XML definiert. Eine Dimension spezifiziert   mit einer Anzahl von einer Messeinheit folgt. Zum Beispiel: 10px, 2in,   5sp. Die folgenden Maßeinheiten werden von Android unterstützt:

     

dp

     

Dichte unabhängige Pixel - Eine abstrakte Einheit, die auf der Basis   physikalische Dichte des Bildschirms. Diese Einheiten sind im Verhältnis zu einem 160 dpi   (Punkte pro Zoll) auf dem Bildschirm, auf dem 1dP ungefähr gleich ist 1px. Wann   Laufen auf einem Bildschirm mit höherer Dichte, die Anzahl der verwendeten Pixel zu zeichnen   1 dp wird um einen Faktor geeignet für den Bildschirm des dpi skaliert.   Ebenso wird, wenn auf einem Bildschirm mit geringerer Dichte, die Anzahl der verwendeten Pixel   für 1 dp wird verkleinert. Das Verhältnis von dp-zu-Pixel wird mit der Änderung   Rasterdichte, aber nicht unbedingt in direktem Verhältnis. Mit dp   Einheiten (statt px Einheiten) ist eine einfache Lösung, um die Ansicht zu machen   Abmessungen im Layout der Größe richtig für verschiedenen Bildschirm   Dichten. Mit anderen Worten, es Konsistenz für die reale Welt   Größen Ihrer UI-Elemente auf verschiedenen Geräten.

     

sp

     

Scale-unabhängige Pixel - Das ist wie die dp-Einheit, aber es ist auch   skaliert durch die Schriftgröße Vorlieben des Benutzers. Es wird empfohlen, dass Sie verwenden   dieses Gerät bei der Angabe von Schriftgrößen, so werden sie so eingestellt werden,   sowohl die Rasterdichte und die Vorlieben des Benutzers.

     

pt

     

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

     

Pixel

     

Pixel - Entspricht tatsächlichen Pixel auf dem Bildschirm. Diese Einheit von   Maßnahme wird nicht empfohlen, da die tatsächliche Darstellung variieren kann   auf verschiedene Geräte; Vorrichtungen können jeweils eine unterschiedliche Anzahl von Pixeln pro haben   Zoll und kann mehr oder weniger Gesamt Pixel auf dem Bildschirm hat.

     

mm

     

Millimeter - Basierend auf der physikalischen Größe des Bildschirms

.      

     

Inches -. Basierend auf der physikalischen Größe des Bildschirms

Hinweis: Eine Dimension ist eine einfache Ressource, die den Wert im Namensattribut versehen verwiesen wird (nicht der Name der XML-Datei). Als solches Sie Dimension Ressourcen mit anderen einfachen Mitteln in der eine XML-Datei unter einem Element kombinieren können.

Grundsätzlich ist die einzige Zeit, wo Pixel gelten, ist ein Pixel, und das ist, wenn Sie genau ein Pixel auf dem Bildschirm, wie im Fall eines Teilers wollen:

Ein> 160 dpi, Sie 2-3 Pixel erhalten können,

Ein> 120 dpi, es rundet auf 0.

Pixel

Pixel - entspricht die aktuellen Pixel auf dem Bildschirm

.

dp oder dip

Dichte unabhängige Pixel - eine abstrakte Einheit, die auf der physikalischen Dichte des Bildschirms basiert. Diese Einheiten sind im Verhältnis zu einem 160 dpi-Bildschirm, so ist ein dp ein Pixel auf einem 160 dpi-Bildschirm.

Verwendung von dp:

Dichte Unabhängigkeit - Ihre Anwendung erreicht „Dichte Unabhängigkeit“, wenn es die physische Größe bewahrt (aus der Sicht des Benutzers) von Elementen der Benutzeroberfläche, wenn auf Bildschirme mit unterschiedlichen Dichten angezeigt. (Dh) Das Bild sollte die gleiche Größe aussehen (nicht vergrößert oder verkleinert) in verschiedenen Arten von Bildschirmen.

sp

Scale-unabhängige Pixel - das ist wie die dp-Einheit, aber es wird auch durch die Benutzer-Schriftgröße bevorzugt skaliert

.

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

Wo was & Beziehung zwischen Pixel und dp benutzen?

Dichte unabhängige Pixel (dp)

Eine virtuelle Pixeleinheit, die Sie verwenden sollen, wenn UI-Layout definieren, Layout Dimensionen oder Position in einer dichteunabhängige Weise auszudrücken. Wie oben beschrieben, ist der dichteunabhängige Bildpunkt entspricht einen physikalischen Pixel auf einen 160 dpi-Bildschirm, der die Basisliniendichte, die durch das System für ein „mittleres“ Dichtebild angenommen wird. Zur Laufzeit übernimmt das System transparent beliebige Skalierung der dp-Einheiten, falls erforderlich, auf der Grundlage der tatsächlichen Dichte des Bildschirms verwendet wird. Die Umwandlung von dp Einheiten Bildschirmpixel ist einfach:

px = dp * (dpi / 160).

Zum Beispiel auf einem 240 dpi-Bildschirm, 1 dp gleich 1,5 physikalischen Pixeln. Sie sollten immer dp Einheiten verwenden, wenn die Anwendung der Benutzeroberfläche zu definieren, um sicherzustellen, korrekte Anzeige der Benutzeroberfläche auf Bildschirme mit unterschiedlichen Dichten.

Verstehen Pixel dp und umgekehrt ist sehr wichtig (vor allem für die exakten dp Werte Kreativteam 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 aus dem kreativen Team zu bekommen. Ansonsten Präzision verlieren passieren wird, während mit 0,5 multipliziert wird.

Pixel

Es ist oben erläutert. Versuchen Sie in Layout-Dateien zu vermeiden. Aber es gibt einige Fälle, in denen Pixel erforderlich ist. beispielsweise Listview Trennlinie. px besser ist hier für das Geben einer Ein-Pixel-Linie als Teiler für alle über Bildschirmauflösungen.

sp

Verwenden Sie sp für Schriftgrößen. Dann wird nur die Schriftart in der Anwendung wird während Geräteschriftgrößenänderungen ändern (das heißt, Display -> Schriften auf Device). Wenn Sie eine statische Größe der Schrift in der App halten möchten, können Sie die Schriftart Dimension in dp geben. In einem solchen Fall wird es sich nie ändern. Entwickler können eine solche Anforderung für bestimmte Bildschirme bekommen, denn das können Entwickler dp anstelle von sp. In allen anderen Fällen, sp wird empfohlen.

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

eingeben Bild Beschreibung hier

Alles, was mit der Größe von Text und das Aussehen im Zusammenhang muss sp oder pt verwenden. Während auf die Größe der Kontrollen im Zusammenhang alles, Layouts usw. muß mit dp verwendet werden.

Sie können sowohl dp und dip an ihren Orten.

Ich würde verwenden nur dp.

Es gibt eine Menge Gerede über „sp“ für Schriftgrößen verwendet, und während ich den Punkt zu schätzen wissen, glaube ich nicht, dass es das Richtige ist von einer Design-Sicht zu tun. Sie können bis zu brechen Ihr Design beenden, wenn der Benutzer etwas wackelig Schriftgröße Auswahl hat, und der Benutzer wird die Schuld am Ende die App , und nicht ihre eigenen Entscheidungen im Leben.

Auch wenn Sie ein sp-font-App auf eine 160 dpi Tablette nehmen, werden Sie feststellen, dass alles skaliert ... aber Ihre Schrift, die im Vergleich winzig aussehen wird. Es ist kein gutes Aussehen.

Während die Idee von „sp“ fonts ein gutes Herz hat, ist es eine schlechte Idee. Stick mit dp für alles.

sp = Maßstab unabhängige Pixel

dp = dip = Dichte unabhängige Pixel

dpi = dots per inch

  

Wir sollten vermeiden, verwenden sp .

     

Wir verwenden sollte dp mehrere Bildschirme unterstützen.

Android unterstützt verschiedene Bildschirmauflösungen

  • LDPI (low) ~ 120 dpi
  • MDPI (mittel) ~ 160 dpi
  • hdpi (hoch) ~ 240 dpi
  • xhdpi (extra-high) ~ 320 dpi
  • xxhdpi (extra-extra-high) ~ 480 dpi
  • xxxhdpi (extra-extra-extra-hoch) ~ 640 dpi

Eine 120 dp LDPI Vorrichtung weist 120 Pixel in 1 Zoll Grße.

Das gleiche gilt für andere Dichten ...

Wir als Softwareingenieure sollten diese Umrechnungsformel verwenden:

  

Pixel = dp * (Dichte / 160)

So 240 1en dpi Gerät dp wird = 1 * (240/160) = 3/2 = 1,5 Pixel.

Und 480 1en dpi Gerät dp wird = 1 * (480/160) = 3 Pixel.

Mit diesem 1,5 und 3 Pixel Wissen kann ein Software-Ingenieur-Layout entwirft für unterschiedliche Dichten.

Um Bildschirmparameter von jedem Gerät zu überprüfen: 

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 dp und sp Einheiten erwähnt als „ Benutzer-Schriftgröße bevorzugt “ durch die von den offiziellen Dokumentation kopiert Antworten kann durch Änderung Settings->Accessibility->Large Text Option zur Laufzeit zu sehen.

Large Text Option zwingt Text werden 1.3 mal größer. 

private static final float LARGE_FONT_SCALE = 1.3f;

Dies könnte natürlich auch Anbieter abhängig sein, da es in packages / apps / Einstellungen .

dpi -

  • Punkte pro Zoll
  • Die Messung der Pixeldichte des Bildschirms.

Pixel - Pixel

  • Für Mapping-Bildschirmpixel

pt - Punkte

  • über 1/72 Zoll, in Bezug auf physische Bildschirmgröße.

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

mm- milimeter  -. In Bezug auf physische Bildschirmgröße

sp -. Schuppen unabhängige Pixel

  • Basierend auf oben Benutzer Schriftgröße bevorzugt.
  • Font sollte in 'sp' sein.

dip -

  • dip == dp
  • Dichte unabhängige Pixel.
  • Es variiert je nach Bildschirm Dichte.
  • in 160 dpi-Bildschirm, 1 dp = 1 Pixel.
  • Verwenden Sie dp mit Ausnahme der Textschriftgröße.

In dem Standard, 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 Formel von Android verwendet:

  

px = dp * (dpi / 160)

Wo dpi eine der folgenden Rasterdichten. Eine Liste aller möglichen Dichten hier gehen

Es definiert die "DENSITY_ *" Konstanten sind.

  • LDPI (low) ~ 120 dpi
  • MDPI (mittel) ~ 160dpi
  • hdpi (hoch) ~ 240dpi
  • xhdpi (extra-high) ~ 320dpi
  • xxhdpi (extra-extra-high) ~ 480dpi
  • xxxhdpi (extra-extra-extra-high) ~ 640dpi

Genommen von hier .

Dies wird eine Menge Verwirrung aussortieren, wenn zwischen px und dp übersetzen, wenn Sie Ihren Bildschirm dpi kennen.

Also, sagen wir, Sie ein Bild von 60 dp für eine hdpi Bildschirm wollen dann die physikalische Pixelgröße von 60 dp ist: 

px = 60 * (240 / 160)

Bildschirmgröße in Android gruppiert in Kategorien small, medium, large, extra large, double-extra und triple-extra. Rasterdichte ist die Anzahl der Pixel innerhalb eines Gebietes (wie inch) des Bildschirms. Generell ist es in dots-per-inch (dpi) gemessen. Rasterdichte so niedrig gruppiert, mittel, hoch und extra hoch. Die Auflösung ist die Gesamtzahl der Pixel auf dem Bildschirm.

  • dp: Dichte Unabhängige Pixel, variiert sie anhand von Rasterdichte. In 160 dpi-Bildschirm, 1 dp = 1 Pixel. Mit Ausnahme der Schriftgröße, verwenden dp immer.
  • dip: dip == dp. In früheren dip wurde Android-Versionen verwendet und später geändert zu dp.
  • sp: Scale unabhängige Pixel, skaliert basierend auf Schriftgröße Vorlieben des Benutzers. Schriften sollten sp verwenden.
  • px:. unsere üblichen Standardpixel, die auf dem Bildschirm Pixel abbildet
  • . Zoll, in Bezug auf die physische Bildschirmgröße
  • mm:. Millimeter, in Bezug auf die physische Bildschirmgröße
  • pt. 1/72 Zoll, in Bezug auf die physische Bildschirmgröße

Formel für die Konvertierung zwischen Einheiten 

 px = dp * (dpi / 160)

dp in Gerät Px

Beispiel folgend kann helfen, besser zu verstehen. Die Skalierung erfolgt basierend auf Bucket-Größe von 120 (LDPI), 160 (MDPI), 240 (hdpi), 320 (xhdpi), 480 (xxhdpi) und 640 (xxxhdpi). Das Google vorgeschlagene Verhältnis für den Entwurf ist 3: 4: 6: 8: 12 für LDPI: MDPI: hdpi: xhdpi: xxhdpi

Ein 150px X 150px Bild wird besetzen,

  
      
  • 150 dp X 150 dp Platz auf dem Bildschirm in MDPI
    •   
  • 100 dp X 100 dp Platz auf dem Bildschirm in hdpi
    •   
  • 75 dp X 75 dp Platz auf dem Bildschirm in xhdpi
    •   

Sie können den folgenden DPI-Rechner verwenden, um Ihre Bildgrößen und andere Dimensionen zu beheben, wenn Sie ein einheitliches UI-Design in allen Android-Geräten haben mögen.

DPI Calculator 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 folgender Link beziehen.

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

  • Pixel -. Ein Pixel, das gleiche, was in CSS verwendet wird, JavaScript, usw.
  • sp - skalenunabhängige Pixel
  • dip - dichteunabhängige Pixel

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

Bitte lesen Sie die Antwort aus Community Wiki. Im Folgenden einige Informationen genannt sind zusätzlich zu den oben genannten Antworten berücksichtigt werden.

sp = Maßstab unabhängige Pixel

dp = Dichte unabhängige Pixel

dpi = Dichte Pixel

Ich habe durch die oben genannten Antworten gegangen ... nicht finden sie genau richtig. 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.

nehmen sp die Textgröße des Geräts, während dp, dass die Gerätedichte Standard nehmen (nie in einem Gerät ändern) Sagen 100SP Text kann 80% des Bildschirms oder 100% des Bildschirms auf der Schriftgröße in Gerät eingestellt abhängig belegt

Sie können auch sp für Layoutgrenzen verwenden, es funktioniert :) Nein Standard App Verwendung sp für ganzen Text

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

  • Dont Verwendung sp für Text in der Toolbar (für unterschiedliche Bildschirmgrößen mit dp verfügbar android dimens verwenden)
  • Dont Verwendung sp für Text in kleinen beschränkten Tasten, sehr kleinen Text, usw.

Einige Leute benutzen große Schriftgröße in ihrem Handy für mehr Lesbarkeit, ihnen kleinen hartkodierte Größe Text geben werden ein UX Problem sein. Setzen Sie sp für Text, wo nötig, aber stellen Sie sicher, dass es nicht um das Layout brechen.

Ebenso, wenn Sie eine einzelne App haben alle Dimensionen unterstützt, erhöht xxxhdpi Vermögen das Hinzufügen einer Menge der APP-Größe. Aber jetzt xxxhdpi Telefone sind häufig so müssen wir xxxhdpi Vermögenswerte atleast für Symbole in der Seitenleiste, Symbolleiste und untere Leiste enthalten. Es ist besser, auf Vektor-Bilder zu bewegen, um eine einheitliche und bessere Bildqualität für alle Bildschirmgrößen haben.

Beachten Sie auch, dass die Menschen benutzerdefinierte Schriftart in ihrem Handy nutzen. So Fehlen einer Schrift kann zu Problemen in Bezug auf Abstand verursachen und alle. Sagen Sie Textgröße 12sp für eine benutzerdefinierte Schriftart einige Pixel zusätzliche dauern kann als Standard-Schriftart.

Siehe Google Entwickler-Site für screendensities und basedensity Details für Android. https://developer.android.com/training/multiscreen/screendensities

Ich habe über einen guten Artikel kommen über Android Apps Benutzeroberfläche für verschiedene Bildschirmauflösungen entwerfen, und ich möchte es hier lassen nur für jemanden in diesem Bereich zu suchen. Ja, ich weiß, dass es irgendwie in Google Text & Tabellen beschrieben ist (und in den Pfosten oben erwähnt), las ich, dass aber es war nicht gut für mich (ja, ich kann zu dumm sein)). Es blieb mir unklar, wie Layouts zu entwerfen fähig unterschiedliche Bildschirmgröße zu behandeln. Ich hasse DP Konzept und so weiter, wenn ich eine „flexible“ UI-Layout für verschiedene Bildschirme implementieren müssen. (Hey iOS Entwickler - ja, du hast recht es Storyboard-Konzept ist)

.

Android hat nicht schlecht UI-Konzept, aber es fehlt iOS Storyboard verfügt, leider. Designing flexible Benutzeroberfläche in Android ist nicht einfach Sache (am besten).

Hier geht der Artikel, der mir geholfen, zu verstehen, was in Android zu tun Layouts für verschiedene Bildschirmgrößen zu machen:

JMStudio Blog: - Entscheiden Android App Bildschirmgröße

  

Wie UI-Design für Android Apps für verschiedene Bildschirmgröße

     

eine App UI Design für verschiedene Bildschirmgrößen, unser ursprüngliches Design muss   einen minimalen Platzbedarf für jede Bildschirmgröße entsprechen. Android definiert ein   Mindestgröße (in dp) für jeden verallgemeinerten Bildschirmtyp. Hier ist ein   Android Bildschirmgröße Richtlinie.    Mindestbildschirmgröße für Android in dp   Wenn wir die Bildschirmgröße in dp bekommen, ist es nicht genug für uns zu entwerfen   die Android App UI. Für jede Bildschirmgröße, müssen wir Grafiken vorbereiten   und Bitmap-Bilder für jede Dichte. Hier ist eine Android-Bildschirm Dichte   Richtlinie.    Android Density-Richtlinie (dpi)

     4: 6: 8 Skalierungsverhältnis zwischen

Für eine einfache Berechnung, können wir das 3 folgen   die vier generali Dichten. Wenn wir ein 36 × 36 Pixel-Bild erstellen für   LDPI Gerät Dichten der Rest Bilder Größe 48 × 48 für MDPI sein wird,   72 × 72 für hdpi und 96 × 96 für xhdpi.

     

Wie Android Apps UI in Photoshop

zum Design      

Viele Designer haben Probleme für die Gestaltung Android App UI in Photoshop oder anderen Pixel   basierte Grafik-Design-Tools, weil der dichteunabhängige Einheit, dp.   Designer wissen nicht, wie dp Pixel abzubilden. Google auch nicht geben   ein klarer Android UI-Design-Guide für sie, obwohl sie einen Grund geben   Formel für dp und Pixel Übersetzung.

     

Als Android-Definition, 1PD gleich unter 160 dpi Gerät 1px (MDPI).   So wollen wir einen Android-App für xlarge Android-Gerät entwerfen, mit   MDPI Dichte, können wir unsere UI Größe in Pixel als 960 Pixel in der Breite definieren   und 720px Höhe; Folgen Sie die gleiche Abbildungsvorschrift, die wir bekommen können   Folgender Android App Bildschirmgröße UI-Design-Richtlinie:

     

Android App Bildschirmgröße in Pixel-Richtlinie

ADDED : Wenn Sie sich für "flexible" UI auch einen Blick auf diese Bibliothek haben: Erstellen Sie eine Responsive UI mit ConstraintLayout

1) dp: (density independent pixels)

Die Anzahl der Pixel in einer Einheit von dp dargestellt wird, wie die Bildschirmauflösung zunimmt (wenn Sie mehr Punkte haben / Pixel pro Zoll). Umgekehrt wird bei Geräten mit geringerer Auflösung, die Anzahl der Pixel auf Einheit dp dargestellt in abnehmen. Da dies eine relative Einheit ist, muss es eine Grundlage haben, mit zu vergleichen. Diese Basislinie ist ein 160 dpi-Bildschirm. Dies ist die Gleichung: px = dp * (dpi / 160).


2) sp: (scale independent pixels)

Diese Einheit skaliert entsprechend den Bildschirm dpi (ähnlich dp) sowie die Schriftgröße Vorlieben des Benutzers.


3) px: (pixels)

Tatsächliche Pixel oder Punkte auf dem Bildschirm.


Für weitere Informationen besuchen Sie

  

Android Developer Guide> Dimension
   Android Developer Guide> Screens

Bildschirmgröße in Android ist in Kategorien gruppiert ldpi, mdpi, hdpi, xhdpi, xxhdpi und xxxhdpi. Rasterdichte ist die Anzahl der Pixel innerhalb eines Gebietes (wie inch) des Bildschirms. Im allgemeinen wird es gemessen in Punkten pro Zoll (dpi).

PX(Pixels):

  • unsere üblichen Standardpixel, die auf dem Bildschirmpixel abbildet. px für absolute Pixel gemeint. Dies wird verwendet, wenn Sie in Bezug auf die absolute Pixel für die Breite oder Höhe geben wollen. Nicht zu empfehlen.

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

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

  • Im Allgemeinen wir nie px verwenden, da es absoluter Wert ist. Wenn Sie px verwenden einstellen Breite oder Höhe, und wenn diese Anwendung in verschiedenen Bildschirm große Geräte heruntergeladen, dann wird diese Ansicht nicht gemäß dem Bildschirm ursprünglichen Größe ausdehnen.

  • dp ist sehr anstelle von px empfohlen zu verwenden. Verwenden Sie dp wenn Sie Breite erwähnen möchte, und die Höhe zu wachsen und schrumpfen dynamisch basierend auf Bildschirmgrößen.

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

SP(Scale independent pixels):

  • skaliert basierend auf Benutzer-Schriftgröße bevorzugt. Schriften sollten sp verwenden.

  • , wenn die Schriftgrößen Erwähnen für verschiedene Bildschirmgrößen passen, verwenden sp. Dies ist ähnlich dp sp.Use speziell für Schriftgrößen dynamisch zu wachsen und schrumpfen basierend auf Bildschirmgrößen

Android-Dokumentation sagt:

  

, wenn Dimensionen spezifizieren, immer entweder dp oder sp Einheiten verwenden. Ein dp ist   ein dichteunabhängige Pixel, das auf die physikalische Größe a entspricht   Pixel bei 160 dpi. Ein sp ist die gleiche Basiseinheit, sondern wird durch die skalierte   Benutzer bevorzugte Textgröße (es ist ein Maßstab unabhängige Pixel), so dass Sie   sollte diese Maßeinheit verwenden, wenn die Textgröße

definieren

Der Bildschirm eines Mobiltelefons besteht aus Tausenden von winzigen Punkten bekannt als Pixel (px) . Ein Pixel ist das kleinste Element, das das Bild zu machen geht. Je mehr die Anzahl der Pixel ein Bild oder Text zu machen, desto schärfer wird es und macht den Smartphone-Bildschirm leichter lesbar.

Bildschirmauflösung wird in Bezug auf die Anzahl der Pixel auf dem Bildschirm gemessen. Bildschirmauflösung ist eine häufig verwendete Spezifikation, wenn ein Gerät zu kaufen, aber es ist eigentlich nicht so nützlich, wenn für Android Gestaltung weil Denken von Bildschirmen in Form von Pixeln, den Begriff der physikalischen Größe ignoriert, die für ein Touch-Gerät ist wirklich sehr wichtig.

Dichte unabhängige Pixel (dp oder dip) erlaubt es dem Designer Vermögenswerte zu schaffen, die in einer erwarteten Weise erscheinen, unabhängig von der Auflösung oder der Dichte des Zielgerätes.

Eine Dichte unabhängige Pixel (dp oder dip) gleich einen Bildpunkt an der Grundlinie der Dichte oder 160 dpi (dots per inch).

1 px / 1 dp = 160 dpi / 160 dpi

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

Dabei gilt,

dpi dots per inch

Also, bei 320 dpi, 1 dp gleich 2 px.

Formel

px / dp = dpi / 160dpi

Punkte pro Zoll (dpi) ist ein Maß für die Schärfe (das heißt, die Dichte der Leuchtpunkte) auf einem Bildschirm. Die Punkte pro Zoll für eine Auflösung gegeben Bildes werden auf der gesamten Bildschirmgröße unterschiedlich eingeschätzt werden, da die gleiche Anzahl von Pixeln über einen anderen Raum verteilt werden.

Arbeiten mit Dichte unabhängige Pixel helfen uns mit einer Situation zu tun, wie, wo Sie zwei Geräte mit dem gleichen Pixelauflösung, aber vielen Raum unterscheiden. Angenommen, in einem Fall, eine Tablette und Telefon hat die gleiche Pixelauflösung 1280 mal 800 Pixel (160 dpi) und 800 x 1280 Pixel (320 dpi) auf.

Nun, da eine Tablette zu Beginn der Studie Dichte (160 dpi) seine physikalischen und Dichte unabhängiger Pixel Größen sind die gleiche, 1280 von 800. Das Telefon auf der anderen Seite hat eine höhere Pixeldichte, so hat es halb so viele Dichte unabhängig Pixel, die als physikalischer Pixel. So ein Telefon verfügt über 400 von 640 Dichte unabhängige Pixel. So eine dichteunabhängige Pixel unter Verwendung macht es einfacher, geistig vorstellen, dass Tablette hat viel mehr Platz als das Telefon.

Und falls Sie zwei Geräte mit ähnlichen Bildschirmgröße, aber unterschiedliche Pixeldichte, etwa ein 800 x 1280 Pixel (320 dpi) ist, und das andere ist 400 x 640 Pixel (160 dpi), brauchen wir nicht völlig verschiedene Layouts für diese beiden Geräte zu definieren, wie wir Vermögenswerte in Bezug auf die Dichte unabhängig Pixel messen können, die für beide Geräte gleich ist.

800 von 1280 Pixel (320dpi) = 400 x 640 Dichte unabhängigen Pixel (dp)

400 x 640 Pixel (160 dpi) = 400 x 640 Pixel-Dichte unabhängiger (dp)

Scale unabhängige Pixel (sp) ist die bevorzugte Einheit für Schriftgröße. Für Zugänglichkeit Zwecke ermöglicht Android-Nutzer ihr Gerät verwendete Schriftgröße anpassen. Benutzer, die Probleme beim Lesen Text haben kann ihr Gerät verwendete Schriftgröße erhöhen. Sie können in der Regel diese Option in der Anzeigeeinstellung auf Ihrem Telefon oder Tablet unter Schriftgröße finden. Oft ist es auch durch die Zugänglichkeit Einstellungen.

Mit Skala unabhängige Pixel, 16 sp ist genau das gleiche wie 16 dp, wenn die Schriftgröße des Geräts normal oder 100%. Aber wenn Schriftgröße des Geräts groß ist, beispielsweise 125%, 16 sp auf 20 dp übersetzen oder 1,25 mal 16.

Wenn Sie dp als Einheit für Schriftgröße verwenden, dann ist das Stück Text hat eine bestimmte physikalische Größe, egal, ob der Benutzer anpassen Schriftgröße hat das Gerät. sp-Einheiten verwendet, wird eine bessere Erfahrung für Menschen mit eingeschränkter Sehkraft machen.

Referenz : Udacity , Google

  

sp: scale unabhängige Pixel

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

  

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

Vor der Beantwortung dieser Frage lassen Sie mich zunächst die Anzahl der Einheiten verringern. Also los geht. dp oder dip sind beide gleich und sind bekannt als dichteunabhängige Pixel

1. px - steht für Pixel. Pixel sind ein einzelner Punkt, Punkt auf einem Bildschirm. Im allgemeinen in der Mobilindustrie ist es in ppi (Pixel pro Zoll) gemessen. Bildschirmauflösung ist direkt proportional zu ppi, je größer die Anzahl der Pixel pro Zoll, je höher die Bildschirmauflösung.

Zum Beispiel, wenn Sie ein Bild mit einer Größe zeichnen 200 px * 200 px , dann muss sein Aussehen unterschiedlich sein auf einem hochauflösendes Gerät im Vergleich zu einem Low- Auflösungseinrichtung. Der Grund dafür ist ein 200 px Bild auf einem niedrig auflösenden Telefon wird als auf einem hochauflösendes Gerät größer erscheinen werden.

Im Folgenden Bilder werden mit einer Auflösung des gleichen Bildes auf verschiedenen Telefonen zeigt -

  • Telefon mit hohen Bildschirmauflösung

    Gib Bild Beschreibung hier

  • Telefon mit Low Bildschirmauflösung

    Gib Bild Beschreibung hier

2. Dip oder dp - eine abstrakte Einheit, die auf der physikalischen Dichte des Bildschirms basiert. Diese Einheiten sind in Bezug auf einen 160 dpi Bildschirm, so dass ein dp ist ein Pixel auf einem 160 dpi-Bildschirm. Das Verhältnis von dp-zu-Pixel wird mit der Rasterdichte ändern, aber nicht unbedingt in direktem Verhältnis. „Dichte Unabhängigkeit“ bezieht sich auf die einheitliche Darstellung von UI-Elementen auf Bildschirme mit unterschiedlichen Dichten.

  • Bild, das zeigt 80px (linke Seite Bild) und 80 dp (rechts Bild) . Kasse Unterschied.

Gib Bild Beschreibung hier

A dp gleich einen physikalischen Pixel auf einem Bildschirm mit einer Dichte von 160 . Zur Berechnung dp:

dp = (Breite in Pixel * 160) / Rasterdichte

3. sp - steht für skalierbare Pixel. Im Allgemeinen sp für Texte auf der Benutzeroberfläche verwendet und sp bewahrt die Schrifteinstellungen. Wenn ein Benutzer zum Beispiel ausgewählt, um eine größere Schrift als 30 sp wird es automatisch Skala erscheinen groß nach einer Benutzerpräferenz.

Ich möchte eine einfache Möglichkeit, dp zu verstehen. In der Tat denke ich dp die am einfachsten zu verstehen ist. dp ist nur eine physikalische Längeneinheit. Es ist die gleiche Dimension wie mm oder inch. Es ist einfach praktisch für uns 50dp zu schreiben, 60dp statt 50/160 inch oder 60/160 inch, weil man dp nur 1/160 inch ist unabhängig von der Bildschirmgröße oder Auflösung.

Das einzige Problem ist, dass der Android-dpi von einigen Bildschirmen nicht korrekt ist. Zum Beispiel klassifizierte ein Bildschirm zu 160dpi 170dpi in der Tat haben kann. So das Berechnungsergebnis von dp ist unscharf. Es sollte ungefähr die gleiche wie 1/160 inch sein.

SDP - eine skalierbare Größe Einheit -. Im Grunde genommen ist es keine Einheit, sondern Dimension Ressourcen für unterschiedliche Bildschirmgröße

Versuchen Sie, die sdp Bibliothek von Intuit. Es ist sehr handliches Gerät Probleme zu lösen, und Sie können schnell mehrere Bildschirme unterstützen.

Verwendung

android:paddingBottom="@dimen/_15sdp" für positive und android:layout_marginTop="@dimen/_minus10sdp" für negative sdp SDP

Es hat Äquivalenzwert in dp für jede Größe in values-sw<N>dp Ordner (sw = smallestWidth).

Achtung:

Verwenden Sie es sorgfältig! In den meisten Fällen müssen Sie noch ein anderes Layout für Tabletten 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 ziehe ssp für Textgröße.

Für weitere Informationen, lesen Sie die Bibliothek GitHub Seite .

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top