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

Fra [Android Developer Documentation] (http://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

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

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