Android
Stödja skärmar med olika upplösningar, storlekar
Sök…
Anmärkningar
Villkor och begrepp
Skärmstorlek
Faktisk fysisk storlek, mätt som skärmens diagonal. För enkelhets skull grupperar Android alla faktiska skärmstorlekar i fyra generaliserade storlekar: små, normala, stora och extra stora.
Skärmdensitet
Mängden pixlar inom ett fysiskt område på skärmen; vanligtvis kallad dpi (prickar per tum). Till exempel har en "låg" täthetsskärm färre pixlar inom ett givet fysiskt område, jämfört med en "normal" eller "hög" täthetsskärm. För enkelhets skull grupperar Android alla faktiska skärmdensiteter i sex generaliserade tätheter: låg, medium, hög, extra hög, extra-extra-hög och extra-extra-extra-hög.
Orientering
Riktningen på skärmen ur användarens synvinkel. Detta är antingen liggande eller porträtt, vilket innebär att skärmens bildförhållande är antingen bred eller hög. Var medveten om att inte bara olika enheter fungerar i olika riktningar som standard, utan orienteringen kan ändras vid körning när användaren roterar enheten. Upplösning Det totala antalet fysiska pixlar på en skärm. När du lägger till stöd för flera skärmar fungerar inte applikationer direkt med upplösning. applikationer bör endast handla om skärmstorlek och densitet, som specificeras av de allmänna storleken och densitetsgrupperna. Densitetsoberoende pixel (dp) En virtuell pixelenhet som du bör använda när du definierar UI-layout, för att uttrycka layoutdimensioner eller position på ett densitetsoberoende sätt. Den densitetsoberoende pixeln är ekvivalent med en fysisk pixel på en 160 dpi-skärm, vilket är den baslinjetäthet som systemet antar för en "medel" densitetsskärm. Vid driftstid hanterar systemet transparent alla skalningar av dp-enheterna, efter behov, baserat på den faktiska tätheten för skärmen som används. Konverteringen av dp-enheter till skärmpixlar är enkel: px = dp * (dpi / 160). Till exempel på en 240 dpi-skärm är 1 dp lika med 1,5 fysiska pixlar. Du bör alltid använda dp-enheter när du definierar applikationens användargränssnitt för att säkerställa korrekt visning av ditt användargränssnitt på skärmar med olika tätheter.
Enheter
px
Pixlar - motsvarar faktiska pixlar på skärmen.
i
Tummar - baserat på den fysiska storleken på skärmen. 1 tum = 2,54 centimeter
mm
Millimeter - baserat på skärmens fysiska storlek.
pt
Poäng - 1/72 tum baserat på skärmens fysiska storlek.
dp eller dopp
Densitetsoberoende pixlar - en abstrakt enhet som bygger på skärmens fysiska täthet. Dessa enheter är relativt en 160 dpi-skärm, så en dp är en pixel på en 160 dpi-skärm. Förhållandet mellan dp-till-pixel kommer att förändras med skärmdensiteten, men inte nödvändigtvis i direkt proportion. Obs: Kompilatorn accepterar både "dip" och "dp", men "dp" är mer konsekvent med "sp".
sp
Skala-oberoende pixlar - det här är som dp-enheten, men det skalas också av användarens fontstorlek. Det rekommenderas att du använder den här enheten när du specificerar teckenstorlekar, så att de kommer att justeras för både skärmdensitet och användarens preferenser. Från att förstå täthetsoberoende i Android:
| Enhet | Beskrivning | Enheter per fysisk tum | Densitet Oberoende | Samma fysiska storlek på varje skärm |
|---|---|---|---|---|
| px | pixlar | Varierar | Nej | Nej |
| i | inches | 1 | Ja | Ja |
| mm | millimeter | 25,4 | Ja | Ja |
| pt | Points | 72 | Ja | Ja |
| dp | Densitetsoberoende pixlar | ~ 160 | Ja | Nej |
| sp | Skala oberoende pixlar | ~ 160 | Ja | Nej |
referenser:
Med hjälp av konfigureringskvalifikatorer
Android stöder flera konfigureringskvalifikationer som gör att du kan kontrollera hur systemet väljer dina alternativa resurser baserat på egenskaperna för den aktuella enhetsskärmen. En konfigurationskvalificering är en sträng som du kan lägga till en resurskatalog i ditt Android-projekt och anger den konfiguration som resurserna inuti är utformade för.
Så här använder du en konfigurationskvalificering:
- Skapa en ny katalog i projektets res / katalog och namnge den med formatet:
<resources_name>-<qualifier>.<resources_name>är standardresursnamnet (som rita eller layout). -
<qualifier>är en konfigureringskvalifikator som anger den skärmkonfiguration som dessa resurser ska användas för (till exempel hdpi eller xlarge).
Exempelvis tillhandahåller följande applikationsresurskataloger olika layoutdesign för olika skärmstorlekar och olika dragbara. Använd mipmap/ mapparna för start-ikoner.
res/layout/my_layout.xml // layout for normal screen size ("default")
res/layout-large/my_layout.xml // layout for large screen size
res/layout-xlarge/my_layout.xml // layout for extra-large screen size
res/layout-xlarge-land/my_layout.xml // layout for extra-large in landscape orientation
res/drawable-mdpi/graphic.png // bitmap for medium-density
res/drawable-hdpi/graphic.png // bitmap for high-density
res/drawable-xhdpi/graphic.png // bitmap for extra-high-density
res/drawable-xxhdpi/graphic.png // bitmap for extra-extra-high-density
res/mipmap-mdpi/my_icon.png // launcher icon for medium-density
res/mipmap-hdpi/my_icon.png // launcher icon for high-density
res/mipmap-xhdpi/my_icon.png // launcher icon for extra-high-density
res/mipmap-xxhdpi/my_icon.png // launcher icon for extra-extra-high-density
res/mipmap-xxxhdpi/my_icon.png // launcher icon for extra-extra-extra-high-density
Konvertera dp och sp till pixlar
När du måste ställa in ett pixelvärde för något som Paint.setTextSize men ändå vill att det ska skalas baserat på enheten kan du konvertera dp- och sp-värden.
DisplayMetrics metrics = Resources.getSystem().getDisplayMetrics();
float pixels = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, 12f, metrics);
DisplayMetrics metrics = Resources.getSystem().getDisplayMetrics();
float pixels = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 12f, metrics);
Alternativt kan du konvertera en dimensionresurs till pixlar om du har en kontext att ladda resursen från.
<?xml version="1.0" encoding="utf-8"?>
<resources>
<dimen name="size_in_sp">12sp</dimen>
<dimen name="size_in_dp">12dp</dimen>
</resources>
// Get the exact dimension specified by the resource
float pixels = context.getResources().getDimension(R.dimen.size_in_sp);
float pixels = context.getResources().getDimension(R.dimen.size_in_dp);
// Get the dimension specified by the resource for use as a size.
// The value is rounded down to the nearest integer but is at least 1px.
int pixels = context.getResources().getDimensionPixelSize(R.dimen.size_in_sp);
int pixels = context.getResources().getDimensionPixelSize(R.dimen.size_in_dp);
// Get the dimension specified by the resource for use as an offset.
// The value is rounded down to the nearest integer and can be 0px.
int pixels = context.getResources().getDimensionPixelOffset(R.dimen.size_in_sp);
int pixels = context.getResources().getDimensionPixelOffset(R.dimen.size_in_dp);
Textstorlek och olika skärmstorlekar på Android
Ibland är det bättre att bara ha tre alternativ
style="@android:style/TextAppearance.Small"
style="@android:style/TextAppearance.Medium"
style="@android:style/TextAppearance.Large"
Använd liten och stor för att skilja från normal skärmstorlek.
<TextView
android:id="@+id/TextViewTopBarTitle"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
style="@android:style/TextAppearance.Small"/>
För normalt behöver du inte ange något.
<TextView
android:id="@+id/TextViewTopBarTitle"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
Med detta kan du undvika att testa och specificera dimensioner för olika skärmstorlekar.