Hvad er forskellen mellem Android-måleenheder?


* px
* dip
* dp
* sp

Hvad er forskellen mellem "px", "dip", "dp" og "sp"?
====================================================


Fra [Android Developer Documentation] ([http://developer.android.com/guide/topics/resources/more-resources.html#Dimension](https://developer.android.com/guide/topics/resources/more-resources.html#Dimension)):


1. > 
> **px**
> **Pixels** - svarer til faktiske pixels på skærmen.
> 
> 
>
2. > 
> **in**
> **Inches** - er baseret på skærmens fysiske størrelse.  
> 
> 1 tomme = 2,54 centimeter
> 
> 
>
3. > 
> **mm**
> **Millimeter** - baseret på skærmens fysiske størrelse.
> 
> 
>
4. > 
> **pt**
> **Points** - 1/72 af en tomme baseret på den fysiske størrelse af skærmen.
> 
> 
>
5. > 
> **dp** eller **dip**
> **Density**-uafhængige pixel - en abstrakt enhed, der er baseret på skærmens fysiske tæthed. Disse enheder er relative i forhold til en 160
> dpi-skærm, så en dp er en pixel på en 160 dpi-skærm. Forholdet mellem
> dp-til-pixel ændres med skærmens tæthed, men ikke nødvendigvis
> i direkte forhold. Bemærk: Compileren accepterer både "dip" og
> "dp", selv om "dp" er mere i overensstemmelse med "sp".
> 
> 
>
6. > 
> **sp****
> **Skala**-uafhængige pixels - dette er ligesom dp-enheden, men den er også skaleret af brugerens skriftstørrelsespræference. Det anbefales, at du
> at bruge denne enhed, når du angiver skriftstørrelser, så de bliver justeret
> til både skærmtætheden og brugerens præferencer.
> 
> 
>


Fra [Understanding Density Independence In Android] (<https://www.captechconsulting.com/blogs/understanding-density-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      |               |             |                    | 
+---------+-------------+---------------+-------------+--------------------+
```

Du kan også finde flere oplysninger i [Google Design Documentation] (<https://www.google.com/design/spec/layout/units-measurements.html>#).


Stort set alt om dette, og hvordan man opnår den bedste understøttelse af flere skærme i forskellige størrelser og tætheder, er meget godt dokumenteret her:


* [Understøttelse af flere skærme](https://developer.android.com/guide/practices/screens_support.html)



> 
> **Skærmstørrelse**  
> 
> Faktisk fysisk størrelse, målt som skærmens diagonal.
> For nemheds skyld grupperer Android alle faktiske skærmstørrelser i fire
> generaliserede størrelser: lille, normal, stor og ekstra stor.
> 
> 
> **Skærmdensitet**  
> 
> Antallet af pixels inden for et fysisk område af
> skærm; normalt omtalt som dpi (dots per inch). For eksempel, en
> skærm med "lav" tæthed har færre pixels inden for et givet fysisk område,
> sammenlignet med en skærm med "normal" eller "høj" tæthed. For nemheds skyld,
> Android grupperer alle faktiske skærmtætheder i seks generelle
> tætheder: lav, middel, høj, ekstra høj, ekstra høj, ekstra ekstra ekstra høj og
> ekstra-ekstra-ekstra-høj.
> 
> 
> **Orientering**  
> Skærmens orientering fra brugerens synsvinkel
> synsvinkel. Dette er enten landskab eller portræt, hvilket betyder, at skærmens
> formatforhold er enten bred eller høj. Vær opmærksom på, at ikke
> ikke kun forskellige enheder fungerer i forskellige orienteringer ved
> som standard, men orienteringen kan også ændres under kørslen, når brugeren
> roterer enheden.
> 
> 
> 



> 
> **Opløsning**  
>  Det samlede antal fysiske pixels på
> en skærm. Når der tilføjes understøttelse af flere skærme, gør programmer
> ikke direkte med opløsningen; programmerne skal være opmærksomme på
> kun med skærmstørrelse og -densitet, som specificeret af den generaliserede
> størrelses- og tæthedsgradgrupper.
> 
> 
> 



> 
> **Densitetsuafhængig pixel (dp)**  
>  En virtuel
> pixelenhed, som du bør bruge, når du definerer UI-layout, for at udtrykke
> layoutdimensioner eller -position på en tæthedsindeksuafhængig måde.
> Den tæthedsafhængige pixel svarer til en fysisk pixel på en 160
> dpi-skærm, hvilket er den baseline-tæthed, som systemet antager for en
> skærm med "medium" tæthed. Ved kørselstid håndterer systemet på gennemsigtig vis
> en eventuel skalering af dp-enhederne, hvis det er nødvendigt, baseret på den faktiske tæthed
> af den anvendte skærm. Omregningen af dp-enheder til skærmpixels er
> enkel:
> `px = dp * (dpi / 160)`.
> På en skærm med 240 dpi er 1 dp f.eks.
> lig med 1,5 fysiske pixels. Du bør altid bruge dp-enheder, når
> definere dit programs brugergrænseflade, for at sikre korrekt visning af din brugergrænseflade på
> skærme med forskellige tætheder.
> 
> 
> 


Hvis du er seriøs med hensyn til at udvikle en Android-app til mere end én type enhed, bør du have læst dokumentet om udvikling af støtte til skærme mindst én gang. Derudover er det altid en god ting at kende det faktiske antal aktive enheder, der har en bestemt skærmkonfiguration.


* [Skærmstørrelser og tætheder](https://developer.android.com/resources/dashboard/screens.html)

Jeg vil uddybe mere om, hvordan dp præcist konverteres til px:


* Hvis det kører på en mdpi-enhed, vil et `150 x 150 px`-billede fylde `150 * 150 dp` på skærmen.
* Hvis det kører på en hdpi-enhed, vil et `150 x 150 px`-billede fylde `100 * 100 dp` på skærmen.
* Hvis det kører på en xhdpi-enhed, vil et `150x150 px`-billede fylde `75 * 75 dp` på skærmen.


Omvendt: Lad os sige, at du ønsker at tilføje et billede til dit program, og at det skal fylde en `100 * 100 dp`-kontrol. Du skal oprette billeder i forskellige størrelser til understøttede skærmstørrelser:


* `100 * 100 px`-billede for mdpi
* `150 * 150 px`-billede til hdpi
* `200 * 200 px` billede til xhdpi
