Was ist der Unterschied zwischen Android Maßeinheiten?
Aus der Android Developer Documentation :
px
Pixel - entsprechen den tatsächlichen Pixeln auf dem Bildschirm.
in
Zoll - basierend auf der physischen Größe des Bildschirms.
[...] 1 Zoll = 2,54 Zentimeter
mm
Millimeter - basierend auf der physischen Größe des Bildschirms.
pt
Punkte - 1/72 Zoll basierend auf der physischen Größe des Bildschirms.
dp oder dip
Dichte - unabhä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 Bildpunkt 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.
sp
Skalieren - unabhängige Pixel - Dies entspricht der dp-Einheit, wird jedoch auch anhand der vom Benutzer bevorzugten Schriftgröße skaliert. Es wird empfohlen, dieses Gerät zum Festlegen von Schriftgrößen zu verwenden, damit diese sowohl an die Bildschirmdichte als auch an die Vorlieben des Benutzers angepasst werden.
Von Dichteunabhängigkeit in Android verstehen :
+----------------+----------------+---------------+-------------------------------+
| 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 Documentation .
Praktisch alles darüber und wie Sie die beste Unterstützung für mehrere Bildschirme unterschiedlicher Größen und Dichten erzielen, ist hier sehr gut dokumentiert:
Bildschirmgröße
Tatsächliche physische Größe, gemessen als Bildschirmdiagonale. Der Einfachheit halber gruppiert Android alle tatsächlichen Bildschirmgrößen in vier verallgemeinerte 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 im Vergleich zu einem Bildschirm mit "normaler" oder "hoher" Dichte weniger Pixel in einem bestimmten physikalischen Bereich. Der Einfachheit halber gruppiert Android alle tatsächlichen Bildschirmdichten in sechs verallgemeinerte Dichten: niedrig, mittel, hoch, extra hoch, extra hoch und extra 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 betrieben werden, sondern sich die Ausrichtung auch 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, funktionieren 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 Benutzeroberflächenlayouts verwenden sollten, um Layoutabmessungen oder -positionen unabhängig von der Dichte auszudrücken. Das dichteunabhängige Pixel entspricht einem physischen Pixel auf einem Bildschirm mit 160 dpi. Dies ist die vom System für einen Bildschirm mit "mittlerer" Dichte angenommene Basisliniendichte. Zur Laufzeit verarbeitet das System die Skalierung der dp-Einheiten nach Bedarf auf der Grundlage der tatsächlichen Dichte des verwendeten Bildschirms. Die Umrechnung von dp-Einheiten in Bildschirmpixel ist einfach:px = dp * (dpi / 160)
. Beispiel: Auf einem 240-dpi-Bildschirm entspricht 1 dpi 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 unterschiedlicher Dichte zu gewährleisten.
Wenn Sie es ernst meinen, eine Android App für mehr als einen Gerätetyp zu entwickeln, sollten Sie das Dokument zur Unterstützung der Bildschirmentwicklung 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.
Ich werde näher darauf eingehen, wie genau dp in px konvertiert:
150 x 150 px
Bild 150 * 150 dp
Bildschirmplatz.150 x 150 px
Bild 100 * 100 dp
Platz auf dem Bildschirm.150x150 px
Bild 75 * 75 dp
Bildschirmplatz.Umgekehrt: Nehmen wir an, Sie möchten Ihrer Anwendung ein Bild hinzufügen, das Sie benötigen, um ein 100 * 100 dp
-Steuerelement auszufüllen. Für die unterstützten Bildschirmgrößen müssen Sie Bilder in verschiedenen Größen erstellen:
100 * 100 px
Bild für mdpi150 * 150 px
Bild für HDPI200 * 200 px
Bild für xhdpipx Pixel - 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 basierend auf der physischen Größe des Bildschirms.
dp Density - unabhängige Pixel - eine abstrakte Einheit, die auf der physikalischen Dichte des Bildschirms basiert. Diese Einheiten beziehen sich auf einen 160-dpi-Bildschirm, sodass ein dp
ein Pixel auf einem 160-dpi-Bildschirm 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
mit sp
konsistenter ist.
sp -Scale-independent Pixels - Dies entspricht der dp
-Einheit, wird jedoch auch anhand der bevorzugten Schriftgröße des Benutzers skaliert. Es wird empfohlen, dieses Gerät zum Festlegen von 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 gleicher Größe, von denen einer eine Bildschirmdichte von 160 dpi (Punkte pro Zoll, d. H. Pixel pro Zoll) und der andere 240 dpi hat.
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 die folgenden Konzepte genau kennen:
Bildschirmgröße:
Tatsächliche physische Größe, gemessen als Bildschirmdiagonale. Der Einfachheit halber gruppiert Android alle tatsächlichen Bildschirmgrößen in vier verallgemeinerte 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 im Vergleich zu einem Bildschirm mit "normaler" oder "hoher" Dichte weniger Pixel in einem bestimmten physikalischen Bereich. Der Einfachheit halber gruppiert Android alle tatsächlichen Bildschirmdichten in vier verallgemeinerte 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 betrieben werden, sondern sich die Ausrichtung auch 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, funktionieren 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 Layoutabmessungen oder -positionen unabhängig von der Dichte auszudrücken. Das dichteunabhängige Pixel entspricht einem physischen Pixel auf einem Bildschirm mit 160 dpi. Dies ist die vom System für einen Bildschirm mit "mittlerer" Dichte angenommene Basisliniendichte. Zur Laufzeit verarbeitet das System die Skalierung der dp-Einheiten nach Bedarf auf der Grundlage der tatsächlichen Dichte des verwendeten Bildschirms. Die Umrechnung von dp-Einheiten in Bildschirmpixel ist einfach: px = dp * (dpi/160). Beispiel: Auf einem 240-dpi-Bildschirm entspricht 1 dpi 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 unterschiedlicher Dichte zu gewährleisten.
Referenz: Android Entwicklerseite
dp
ist dip
. Verwenden Sie es für alles (Rand, Polsterung usw.).
Verwenden Sie sp
nur für {text-size}.
Sehen Sie den Unterschied zwischen px
, dp
und sp
auf verschiedenen Bildschirmgrößen.
px oder dot 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
dip oder dp sind dichteunabhängig Pixel , dh sie entsprechen je nach physikalischer Dichte mehr oder weniger Pixeln.
sp oder sip ist eine unabhängiges Pixel . Sie werden skaliert, wenn die Option Großer Text in aktiviert ist Settings > Accessibility
Verwenden Sie sp für die Textgröße.
Verwenden Sie dp für alles andere.
Quelle : (Daten von 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. Die folgenden Maßeinheiten werden von Android unterstützt:
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 (Dots per Inch), auf dem 1dp ungefähr 1px entspricht. Wenn Sie auf einem Bildschirm mit höherer Dichte arbeiten, wird die Anzahl der zum Zeichnen von 1 dpi verwendeten Pixel um einen Faktor erhöht, der für die Auflösung des Bildschirms geeignet ist. In ähnlicher Weise wird auf einem Bildschirm mit niedrigerer Dichte die Anzahl der für 1 dpi 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 Ansichtsabmessungen in Ihrem Layout für unterschiedliche Bildschirmdichten korrekt 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 zum Festlegen von 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 variieren kann. Jedes Gerät kann eine andere Anzahl von Pixeln pro Zoll haben und es können mehr oder weniger Gesamtpixel auf dem Bildschirm verfügbar sein.
mm
Millimeter - Basierend auf der physischen Größe des Bildschirms.
in
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 für px nur ein px. Wenn Sie genau ein Pixel auf dem Bildschirm anzeigen 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 physikalischen Dichte des Bildschirms basiert. Diese Einheiten beziehen sich auf einen Bildschirm mit 160 dpi, sodass ein Bildpunkt 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) der Benutzeroberflächenelemente bei der Anzeige auf Bildschirmen beibehalten wird mit unterschiedlichen Dichten. (dh) Das Bild sollte auf verschiedenen Arten von Bildschirmen gleich groß (nicht vergrößert oder verkleinert) aussehen.
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
Eine virtuelle Pixeleinheit, die Sie beim Definieren des UI-Layouts verwenden sollten, um Layoutabmessungen oder -positionen unabhängig von der Dichte auszudrücken. Wie oben beschrieben, entspricht das dichteunabhängige Pixel einem physikalischen Pixel auf einem Bildschirm mit 160 dpi. Dies ist die vom System für einen Bildschirm mit "mittlerer" Dichte angenommene Basisliniendichte. Zur Laufzeit verarbeitet das System die Skalierung der dp-Einheiten nach Bedarf auf der Grundlage der tatsächlichen Dichte des verwendeten Bildschirms. Die Umrechnung von dp-Einheiten in Bildschirmpixel ist einfach:
px = dp * (dpi/160).
Beispiel: Auf einem 240-dpi-Bildschirm entspricht 1 dpi 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 unterschiedlicher Dichte zu gewährleisten.
Das Verständnis von Pixel zu DP und umgekehrt ist sehr wichtig (insbesondere, um Kreativteams 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
Es ist oben erklärt. Versuchen Sie, in Layout-Dateien zu vermeiden. Es gibt jedoch einige Fälle, in denen px erforderlich ist. Beispiel: ListView-Trennlinie. px ist hier besser, um eine Ein-Pixel-Linie als Teiler für alle Bildschirmauflösungen anzugeben.
Verwenden Sie sp für Schriftgrößen. Dann ändert sich nur die Schriftart in der Anwendung, während sich die Größe der Geräteschriftarten ändert (d. H. Anzeige -> Schriftarten auf dem Gerät). Wenn Sie eine statische Schriftgröße in der App beibehalten möchten, können Sie die Schriftgröße in dp angeben. In einem solchen Fall wird es sich nie ändern. Entwickler können eine solche Anforderung für einige bestimmte Bildschirme erhalten, dafür können Entwickler dp anstelle von sp verwenden. In allen anderen Fällen wird sp empfohlen.
Sie können den Unterschied zwischen px
und dp
auf dem folgenden Bild erkennen, und Sie können auch feststellen, dass px
und dp
nicht die gleichen physischen Größen auf den verschiedenen garantieren konnten Bildschirme.
Alles, was mit der Größe des Texts und dem Erscheinungsbild zusammenhängt, muss sp
oder pt
verwenden. Während alles, was mit der Größe der Steuerelemente, Layouts usw. zusammenhängt, mit dp
verwendet werden muss.
Sie können an seinen Stellen sowohl dp
als auch dip
verwenden.
Ich würde nur dp verwenden.
Es wird viel darüber geredet, "sp" für Schriftgrößen zu verwenden, 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 wird am Ende die App beschuldigen und nicht seine eigenen Lebensentscheidungen.
Wenn Sie eine sp-font-App auf einem 160-dpi-Tablet verwenden, werden Sie feststellen, dass alles skaliert ... aber Ihre Schriftart, die im Vergleich dazu winzig aussehen wird. Es sieht nicht gut aus.
Während die Idee der "sp" -Schriften ein gutes Herz hat, ist es eine schlechte Idee. Bleib für alles bei dp.
sp = skalierunabhä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
Ein 120-dp-LDPI-Gerät hat 120 Pixel in 1 Zoll Größe.
Das gleiche gilt für andere Dichten ...
Wir als Softwareentwickler sollten diese Umrechnungsformel verwenden:
pixel = dp * (Dichte/160)
Daher hat das 1-dpi-Gerät mit 240 dpi = 1 * (240/160) = 3/2 = 1,5 Pixel.
Und das Gerät mit 480 dpi und 1 dpi hat = 1 * (480/160) = 3 Pixel.
Mit diesen Kenntnissen von 1,5 und 3 Pixeln 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 dp
und sp
Einheiten, die als " Benutzer-Schriftgrößenpräferenz " durch die aus der amtlichen Dokumentation kopierten Antworten erwähnt werden, ist ersichtlich zur Laufzeit durch Ändern der Option Settings->Accessibility->Large Text
.
Die Option Large Text
zwingt den Text, 1.3
mal größer zu werden.
private static final float LARGE_FONT_SCALE = 1.3f;
Dies kann natürlich herstellerabhängig sein, da es in packages/apps/settings liegt.
dpi -
px - pixel
pt - Punkte
zoll - in Bezug auf die physische Bildschirmgröße (1 Zoll = 2,54 cm).
mm-mm - in Bezug auf die physikalische Bildschirmgröße.
sp - skalierungsunabhängiges Pixel.
dip -
Standardmäßig werden dp und sp verwendet. sp für Schriftgröße und dp für alles andere.
Formel zur 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
Die Bildschirmgröße in Android
ist in Kategorien small
, medium
, large
, extra large
, double-extra
und triple-extra
. Die Bildschirmdichte ist die Anzahl der Pixel innerhalb eines Bereichs (z. B. Zoll) des Bildschirms. Im Allgemeinen wird es in Punkten pro Zoll (dpi) gemessen. Die Bildschirmdichte wird in niedrig, mittel, hoch und besonders hoch eingeteilt. Die Auflösung ist die Gesamtzahl der Pixel auf dem Bildschirm.
Formel zur Umrechnung zwischen Einheiten
px = dp * (dpi / 160)
dp zu px im Gerät
Das folgende Beispiel kann zum besseren Verständnis beitragen. Die Skalierung basiert 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 150px X 150px-Bild belegt
- 150 dpi x 150 dpi Bildschirmfläche in mdpi
- 100 dp x 100 dp Bildschirmbereich in HDPI
- 75 dpi x 75 dpi Bildschirmfläche in xhdpi
Mit dem folgenden DPI-Rechner können Sie Ihre Bildgrößen und andere Abmessungen festlegen, wenn Sie ein einheitliches UI-Design für alle Android Geräte wünschen.
/*
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/
Hier ist die von Android verwendete Formel:
px = dp * (dpi/160)
Wobei dpi eine der folgenden Bildschirmdichten ist. Für eine Liste aller möglichen Dichten hier klicken
Es definiert die "DENSITY_ *" - Konstanten.
Entnommen aus hier .
Dies wird die Verwirrung bei der Übersetzung zwischen px und dp beseitigen, wenn Sie Ihre Bildschirmauflösung kennen.
Angenommen, Sie möchten ein Bild mit 60 dpi für einen HDP-Bildschirm, dann beträgt die physikalische Pixelgröße von 60 dpi:
px = 60 * (240 / 160)
Normalerweise wird sp für Schriftgrößen verwendet, während dip für andere verwendet wird (auch dp genannt).
Bitte lies die Antwort aus dem Community-Wiki. Nachstehend sind einige Informationen aufgeführt, die zusätzlich zu den obigen Antworten zu berücksichtigen sind.
sp = skalierunabhängiges Pixel
dp = dichteunabhängige Pixel
dpi = Dichte Pixel
Ich habe die obigen Antworten durchgesehen ... finde sie nicht genau richtig. 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 nimmt die Textgröße des Geräts an, während dp die des Gerätedichtestandards annimmt (niemals an einem Gerät ändern). Angenommen, 100sp-Text belegt je nach der im Gerät eingestellten Schriftgröße 80% des Bildschirms oder 100% des Bildschirms
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.
Einige Benutzer verwenden eine große Schriftgröße in ihrem Telefon, um die Lesbarkeit zu verbessern. Daher ist es ein UX-Problem, wenn sie kleinen Text in fester Codierung erhalten. Geben Sie bei Bedarf sp für Text ein, stellen Sie jedoch sicher, dass das Layout nicht beschädigt wird.
Wenn Sie eine einzige App haben, die alle Dimensionen unterstützt, erhöht das Hinzufügen von xxxhdpi-Elementen die App-Größe erheblich. Aber jetzt sind xxxhdpi-Telefone üblich, daher müssen wir xxxhdpi-Assets mindestens für Symbole in der Seitenleiste, Symbolleiste und unteren Leiste einfügen. Es ist besser, zu Vektorgrafiken zu wechseln, um für alle Bildschirmgrößen einheitliche und qualitativ bessere Bilder zu erhalten.
Beachten Sie auch, dass Benutzer in ihrem Telefon benutzerdefinierte Schriftarten verwenden. Das Fehlen einer Schriftart kann daher zu Problemen hinsichtlich des Abstands führen. Angenommen, die Textgröße 12sp für eine benutzerdefinierte Schriftart benötigt möglicherweise einige Pixel mehr als die Standardschriftart.
Auf der Google Developer Site finden Sie Informationen zu Bildschirmintensitäten und Basisintensitäten für Android. https://developer.Android.com/training/multiscreen/screendensities
Ich habe einen guten Artikel über das Entwerfen von Android Apps-Benutzeroberflächen 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 Posts 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 mit unterschiedlichen Bildschirmgrößen umgehen können. Ich hasse das DP-Konzept und so weiter, wenn ich ein "flexibles" UI-Layout für verschiedene Bildschirme implementieren muss. (Hey iOS-Entwickler - ja, du hast recht, es ist ein 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: - Entscheide für Android App-Bildschirmgröße
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ängliches Design einen für jede Bildschirmgröße erforderlichen Mindestspeicherplatz erfüllen. Android definiert eine Mindestgröße (in dp) für jeden generalisierten Bildschirmtyp. Hier ist eine Android Richtlinie für die Bildschirmgröße.
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 Richtlinie zur Bildschirmdichte.
Zur einfachen Berechnung können wir das 3: 4: 6: 8-Skalierungsverhältnis zwischen den vier verallgemeinerten Dichten verfolgen. Wenn Sie ein Bild mit 36 × 36 Pixel für ein LDPI-Gerät erstellen, beträgt die Bildgröße für die Restdichte 48 × 48 Pixel für MDPI, 72 × 72 Pixel für HDPI und 96 × 96 Pixel für HDPI.
Entwerfen von Android Apps-Benutzeroberfläche in Photoshop
Viele Designer haben Probleme beim Entwerfen der Android -Anwendungsoberfläche in Photoshop oder anderen pixelbasierten Grafikdesign-Tools, da die Einheit dp von der Dichte unabhängig ist. Designer können dp nicht auf Pixel abbilden. Google gibt auch keine eindeutige Android Benutzeroberfläche für sie heraus, obwohl sie eine Grundformel 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 xlarge Android Gerät mit MPI-Dichte entwerfen. Wir können 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 folgende Android Richtlinien zur Gestaltung der Benutzeroberfläche für die App-Bildschirmgröße erhalten:
ADDED: Wenn Sie sich auch für "flexible" Benutzeroberflächen interessieren, schauen Sie sich diese Bibliothek an: An Android SDK, das eine neue Größeneinheit bereitstellt - sdp (scalable dp). Diese Größeneinheit skaliert mit der Bildschirmgröße (dies wird auch in einer Antwort hier über die Bibliothek SDP
erwähnt).
ADDED2 Google hat endlich die Nützlichkeit des iOS Storeboard UI-Konzepts verstanden und hier ist ConstraintLayout
für Android world: Erstellen Sie eine responsive Benutzeroberfläche mit ConstraintLayout
1) dp: (density independent pixels)
Die Anzahl der in einer Einheit von dp dargestellten Pixel erhöht sich mit zunehmender Bildschirmauflösung (wenn Sie mehr Punkte/Pixel pro Zoll haben). Umgekehrt nimmt bei Geräten mit niedrigerer Auflösung die Anzahl der Pixel in der Einheit dp ab. Da es sich um eine relative Einheit handelt, muss eine Basislinie angegeben werden, mit der verglichen werden kann. Diese Basislinie ist ein Bildschirm mit 160 dpi. Dies ist die Gleichung: px = dp * (dpi / 160).
2) sp: (scale independent pixels)
Dieses Gerät skaliert nach der Bildschirmauflösung (ähnlich wie bei dp) sowie der vom Benutzer bevorzugten Schriftgröße.
3) px: (pixels)
Tatsächliche Pixel oder Punkte auf dem Bildschirm.
Für weitere Informationen können Sie besuchen
Android Developer Guide> Dimension
Android Developer Guide> Bildschirme
Bildschirmgröße in Android ist in Kategorien ldpi
, mdpi
, hdpi
, xhdpi
, xxhdpi
gruppiert und xxxhdpi
. Bildschirmdichte ist die Anzahl der Pixel innerhalb eines Bereichs (wie Zoll) des Bildschirms. Im Allgemeinen wird es in Punkten pro Zoll (dpi
) gemessen.
PX(Pixels):
px
ist 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 Versionen von Android wurde dip verwendet und später in dp
geändert. Dies ist eine Alternative zu px
.
Im Allgemeinen wird px
nie verwendet, da es sich um einen absoluten Wert handelt. Wenn Sie zum Einstellen der Breite oder Höhe px
verwenden und diese Anwendung auf Geräte mit unterschiedlichen Bildschirmgrößen heruntergeladen wird, wird diese Ansicht nicht entsprechend der ursprünglichen Bildschirmgröße vergrößert.
Es wird dringend empfohlen, dp
anstelle von px
zu verwenden. Verwenden Sie dp
, wenn Sie Breite und Höhe angeben möchten, um dynamisch auf der Grundlage der Bildschirmgröße zu wachsen und zu schrumpfen.
wenn wir dp/dip
angeben, berechnet Android automatisch die Pixelgröße auf der Grundlage eines 160-Pixel-Bildschirms.
SP(Scale independent pixels):
skaliert auf der Grundlage der bevorzugten Schriftgröße des Benutzers. Schriftarten sollten sp
verwenden.
wenn Sie die Schriftgrößen angeben, die für verschiedene Bildschirmgrößen geeignet sind, verwenden Sie sp
. Dies ähnelt dp
. Verwenden Sie sp
, insbesondere für Schriftgrößen, die dynamisch auf der Grundlage der Bildschirmgröße vergrößert und verkleinert werden sollen
Die Android-Dokumentation sagt:
verwenden Sie bei der Angabe von Abmessungen immer entweder
dp
odersp
Einheiten. Eindp
ist ein dichteunabhängiges Pixel, das der physikalischen Größe eines Pixels bei 160dpi
entspricht. Einsp
ist dieselbe Basiseinheit, wird jedoch mit der vom Benutzer bevorzugten Textgröße skaliert (es ist ein skalierungsunabhängiges Pixel). Verwenden Sie diese Maßeinheit, wenn Sie die Textgröße definieren
Der Bildschirm eines Mobiltelefons besteht aus Tausenden winziger Punkte, die als Pixel (px) bezeichnet werden. Ein Pixel ist das kleinste Element, das das Bild erzeugt. Je mehr Pixel ein Bild oder ein Text enthalten soll, desto schärfer wird es und der Bildschirm des Smartphones wird besser lesbar.
Die Bildschirmauflösung wird als Anzahl der Pixel auf dem Bildschirm gemessen. Die Bildschirmauflösung wird häufig beim Kauf eines Geräts verwendet, ist jedoch beim Entwerfen für Android nicht besonders nützlich, da beim Betrachten von Bildschirmen in Pixeln der Begriff der physischen Größe, der für ein Touch-Gerät gilt, ignoriert wird wirklich sehr wichtig.
Dichteunabhängige Pixel (dp oder dip) ermöglichen es dem Designer, Objekte zu erstellen, die wie erwartet aussehen, unabhängig von der Auflösung oder Dichte des Zielgeräts.
Ein von der Dichte unabhängiges Pixel (dp oder dip) entspricht einem Pixel bei der Grundliniendichte oder 160 dpi (Punkte pro Zoll).
1 px/1dp = 160 dpi/160 dpi
2 px/1dp = 320 dpi (2x)/160 dpi
wo,
dpi ist Punkte pro Zoll
Bei 320 dpi entspricht also 1 dp 2 px.
Formel
px/dp = dpi/160 dpi
Punkte pro Zoll (dpi) ist ein Maß für die Schärfe (dh die Dichte der beleuchteten Punkte) auf einem Bildschirm. Die Punkte pro Zoll für eine gegebene Bildauflösung unterscheiden sich basierend auf der gesamten Bildschirmgröße, da die gleiche Anzahl von Pixeln über einen anderen Raum verteilt wird.
Durch die Arbeit mit dichteunabhängigen Pixeln können wir beispielsweise mit zwei Geräten mit gleicher Pixelauflösung und unterschiedlichem Speicherplatz umgehen. Angenommen, ein Tablet und ein Telefon haben in einem Fall die gleiche Pixelauflösung von 1280 x 800 Pixel (160 dpi) bzw. 800 x 1280 Pixel (320 dpi).
Da sich ein Tablet bei der Basisdichte (160 dpi) befindet, sind seine physischen und dichteunabhängigen Pixelgrößen mit 1280 x 800 gleich. Das Telefon hat andererseits eine höhere Pixeldichte, sodass es halb so viele dichteunabhängige Pixel wie physische Pixel hat Pixel. Ein Telefon hat also unabhängig von der Dichte 400 x 640 Pixel. Die Verwendung eines dichteunabhängigen Pixels macht es also einfacher, sich vorzustellen, 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 keine vollständige Definition vornehmen Unterschiedliche Layouts für diese beiden Geräte, da wir Assets in Form von dichteunabhängigen Pixeln 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ängige Pixel (dp)
Unabhängige Pixel skalieren (sp) ist 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. Diese Option finden Sie normalerweise in der Anzeigeeinstellung Ihres Telefons oder Tablets unter Schriftgröße. Es ist oft auch über die Einstellungen für 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%, wird 16 sp in 20 dp oder 1,25 mal 16 übersetzt.
Wenn Sie dp als Einheit für die Schriftgröße verwenden, hat dieses Textstück eine bestimmte physikalische Größe, unabhängig davon, ob der Benutzer die Schriftgröße des Geräts angepasst hat. Die Verwendung von sp-Einheiten verbessert die Erfahrung von Menschen mit eingeschränkter Sehkraft.
Referenz : dacity , Google
sp: skaliere unabhängige Pixel
Sie sollten es mit Texten verwenden, da es automatisch entsprechend der vom Benutzer auf seinem Gerät verwendeten Schriftgröße skaliert wird.
px: Pixel oder Bildelement ist der einzelne Punkt auf dem Bildschirm
Bevor ich diese Frage beantworte, möchte ich zunächst die Anzahl der Einheiten verringern. Also los geht's: dp oder dip sind beide gleich und werden als dichteunabhängige Pixel bezeichnet.
1. px - steht für Pixel. Pixel sind ein einzelner Punkt auf einem Bildschirm. In der Mobilfunkbranche wird dies im Allgemeinen in ppi (Pixel pro Zoll) gemessen. Die Bildschirmauflösung ist direkt proportional zu ppi. Je größer die Anzahl der Pixel pro Zoll, 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 in der Höhe unterschiedlich sein -Auflösungsgerät im Vergleich zu einem Gerät mit niedriger Auflösung. Der Grund ist, dass ein 200 px großes 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 Handys.
2. dip oder dp - eine abstrakte Einheit, die auf der physikalischen Dichte des Bildschirms basiert. Diese Einheiten beziehen sich auf einen Bildschirm mit 160 dpi, sodass ein Pixel auf einem Bildschirm mit 160 dpi entspricht. 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 Anzeige von Oberflächenelementen auf Bildschirmen mit unterschiedlichen Dichten.
Ein dp entspricht einem physikalischen 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 ein Benutzer beispielsweise eine größere Schrift als 30 sp auswählt, wird sie automatisch entsprechend den Benutzerpräferenzen so skaliert, dass sie groß erscheint.
SDP - eine skalierbare Größeneinheit - im Grunde handelt es sich nicht um eine Einheit, sondern um Bemaßungsressourcen für unterschiedliche Bildschirmgrößen.
Probieren Sie die sdp Bibliothek von Intuit aus. Es ist sehr praktisch, Geräteprobleme zu lösen, und Sie können schnell mehrere Bildschirme unterstützen .
Verwendungszweck
Android:paddingBottom="@dimen/_15sdp"
für positive und Android:layout_marginTop="@dimen/_minus10sdp"
für negative sdp sdp
Für jede Größe in values-sw<N>dp
-Ordnern hat es den entsprechenden Wert in dp (sw = LowestWidth).
Achtung
Gehen Sie vorsichtig damit um! In den meisten Fällen müssen Sie immer 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 die Textgröße verwenden, aber ich bevorzuge ssp für die Textgröße.
Weitere Informationen finden Sie unter auf der GitHub-Seite der Bibliothek .
Ich möchte eine einfache Möglichkeit bieten, dp
zu verstehen. Tatsächlich denke ich, dass dp
am einfachsten zu verstehen ist. dp
ist nur eine physikalische Längeneinheit. Es hat die gleiche Dimension wie mm
oder inch
. Es ist einfach bequem für uns, 50dp
, 60dp
anstatt 50/160 inch
oder 60/160 inch
zu schreiben, da ein dp
nur 1/160 inch
ist, unabhängig von der Bildschirmgröße oder Auflösung ist.
Das einzige Problem ist, dass die Android dpi einiger Bildschirme nicht korrekt sind. Beispielsweise kann ein Bildschirm mit 160 dpi tatsächlich 170 dpi haben. Das Berechnungsergebnis von dp
ist also unscharf. Es sollte ungefähr das gleiche sein wie 1/160 inch
.
Hier gibt es auch SDP.
SDP - eine skalierbare Größeneinheit
Ein Android SDK, das eine neue Größeneinheit bereitstellt - sdp (scalable dp). Diese Größeneinheit skaliert mit der Bildschirmgröße. Es kann Android Entwicklern dabei helfen, mehrere Bildschirme zu unterstützen.
Informationen zu Textansichten finden Sie unter ssp , das auf der SP-Größeneinheit für Texte basiert.
Beachtung!
Gehen Sie vorsichtig damit um! In den meisten Fällen müssen Sie beispielsweise noch ein anderes Layout für Tablets entwerfen.
Pixel (px) - entspricht den tatsächlichen Pixeln auf dem Bildschirm. Dies wird verwendet, wenn Sie die Breite oder Höhe in absoluten Pixeln 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 Bildpunkt 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 vom Benutzer bevorzugten Schriftgröße skaliert. Es wird empfohlen, dieses Gerät zum Festlegen 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 erhalten Sie unter https://www.google.com/design/spec/layout/units-measurements.html#units-measurements-density-independent-pixels-dp-
Quell-URL: - http://www.androidtutorialshub.com/was-ist-der-Unterschied-zwischen-px-dp-dip-sp-on-Android/
Die Pixeldichte und Auflösung des Bildschirms variieren je nach Plattform. Geräteunabhängige Pixel und skalierbare Pixel sind Einheiten, die eine flexible Möglichkeit zur plattformübergreifenden Gestaltung bieten.
Die Anzahl der Pixel, die in einen Zoll passen, wird als Pixeldichte bezeichnet. High-Density-Bildschirme haben mehr Pixel pro Zoll als Low-Density-Bildschirme.
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 Benutzeroberflächenelemente mit den gleichen Pixeldimensionen auf Bildschirmen mit niedriger Dichte größer und auf Bildschirmen mit hoher Dichte kleiner.
Zur Berechnung der Bildschirmdichte können Sie folgende Gleichung verwenden:
Bildschirmdichte = Bildschirmbreite (oder -höhe) in Pixel/Bildschirmbreite (oder -höhe) in Zoll
Die Pixeldichte und Auflösung des Bildschirms variieren je nach Plattform. Geräteunabhängige Pixel und skalierbare Pixel sind Einheiten, die eine flexible Möglichkeit zur plattformübergreifenden Gestaltung bieten.
Berechnung der Pixeldichte Die Anzahl der Pixel, die in einen Zoll passen, wird als Pixeldichte bezeichnet. High-Density-Bildschirme haben mehr Pixel pro Zoll als Low-Density-Bildschirme.
Dichteunabhängigkeit bezieht sich auf die einheitliche Anzeige von Oberflächenelementen auf Bildschirmen mit unterschiedlicher Dichte.
Dichteunabhängige Pixel , geschrieben als dp (ausgesprochen " dips ") sind flexible Einheiten, die so skaliert werden können, dass sie auf jedem Bildschirm einheitliche Abmessungen haben. Material-Benutzeroberflächen verwenden dichteunabhängige Pixel, um Elemente auf Bildschirmen mit unterschiedlicher Dichte konsistent anzuzeigen.
Lesen Sie den vollständigen Text https://material.io/design/layout/pixel-density.html
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" konsistenter ist mit "sp".
Skalierungsunabhängige Pixel - Dies entspricht der Einheit dp, wird jedoch auch anhand der vom Benutzer bevorzugten Schriftgröße skaliert.
Android SP vs DP
Wofür stehen sie zuerst?
sp
steht für scale-independent
Pixel.
dp or dip
(benutze einfach dp
in deinem Code, wenn du cool bist) steht für dichteunabhängige Pixel.
Was ist der Unterschied zwischen den beiden?
Keiner!
Sie haben beide 160 Einheiten pro Quadratzoll, sind beide unabhängig von der Dichte und haben beide nicht die gleiche physikalische Größe auf verschiedenen Bildschirmen.
Wann sollten Sie also sp
und wann dp
verwenden?
Verwenden Sie sp
für Textgröße…, da dies jedoch durch die vom Benutzer bevorzugte Schriftgröße skaliert wird.
Verwenden Sie dp
für alles andere.