Qual è la differenza tra le unità di misura Android?

• px
• tuffo
• dp
• sp

Dalla documentazione per sviluppatori Android :

1. 
   Pixel px : corrisponde ai pixel effettivi sullo schermo.

2. in
   pollici - in base alle dimensioni fisiche dello schermo.
   1 pollice = 2,54 centimetri

3. mm
   Millimetri : basati sulla dimensione fisica dello schermo.

4. 
   Punti pt - 1/72 di pollice in base alla dimensione fisica dello schermo.

5. dp o dip Pixel indipendenti dalla
   densità - un'unità astratta che si basa sulla densità fisica dello schermo. Queste unità sono relative ad uno schermo da 160 dpi, quindi un dp è un pixel su uno schermo da 160 dpi. Il rapporto tra dp-pixel cambierà con la densità dello schermo, ma non necessariamente in proporzione diretta. Nota: il compilatore accetta sia "dip" che "dp", sebbene "dp" sia più coerente con "sp".

6. sp Pixel indipendenti dalla
   scala : questo è come l'unità dp, ma è anche ridimensionato dalla preferenza della dimensione del carattere dell'utente. Si consiglia di utilizzare questa unità quando si specificano le dimensioni dei caratteri, quindi saranno regolate sia per la densità dello schermo che per le preferenze dell'utente.

Dalla comprensione dell'indipendenza dalla densità 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      |               |             |                    | 
+---------+-------------+---------------+-------------+--------------------+

Ulteriori informazioni sono disponibili anche nella documentazione di progettazione di Google .

Praticamente tutto su questo e su come ottenere il miglior supporto per più schermi di diverse dimensioni e densità è molto ben documentato qui:

• Supporto di più schermi

Dimensione dello schermo Dimensione
fisica effettiva, misurata come diagonale dello schermo. Per semplicità, Android raggruppa tutte le dimensioni effettive dello schermo in quattro dimensioni generalizzate: piccola, normale, grande ed extra-grande.

Densità schermo
Il numero di pixel all'interno di un'area fisica dello schermo; di solito indicato come dpi (punti per pollice). Ad esempio, uno schermo a "bassa" densità ha meno pixel all'interno di una determinata area fisica, rispetto a uno schermo "normale" o "ad alta" densità. Per semplicità, Android raggruppa tutte le densità di schermo effettive in sei densità generalizzate: bassa, media, alta, extra-alta, extra-extra-alta e extra-extra-extra-alta.

Orientamento
L'orientamento dello schermo dal punto di vista dell'utente. Questo è orizzontale o verticale, il che significa che le proporzioni dello schermo sono rispettivamente larghe o alte. Tenere presente che, per impostazione predefinita, non solo dispositivi diversi funzionano con orientamenti diversi, ma l'orientamento può cambiare in fase di esecuzione quando l'utente ruota il dispositivo.

Risoluzione
Il numero totale di pixel fisici su uno schermo. Quando si aggiunge il supporto per più schermi, le applicazioni non funzionano direttamente con la risoluzione; le applicazioni dovrebbero riguardare solo le dimensioni e la densità dello schermo, come specificato dai gruppi di dimensioni e densità generalizzati.

Pixel indipendente dalla densità (dp)
Unità pixel virtuale che è necessario utilizzare durante la definizione del layout dell'interfaccia utente, per esprimere le dimensioni o la posizione del layout in modo indipendente dalla densità. Il pixel indipendente dalla densità equivale a un pixel fisico su uno schermo a 160 dpi, che è la densità di base assunta dal sistema per uno schermo a densità "media". In fase di esecuzione, il sistema gestisce in modo trasparente qualsiasi ridimensionamento delle unità dp, se necessario, in base alla densità effettiva dello schermo in uso. La conversione di unità dp per pixel dello schermo è semplice: px = dp * (dpi / 160). Ad esempio, su uno schermo a 240 dpi, 1 dp equivale a 1,5 pixel fisici. È necessario utilizzare sempre le unità DP durante la definizione dell'interfaccia utente dell'applicazione, per garantire la corretta visualizzazione dell'interfaccia utente su schermi con densità diverse.

Se sei seriamente intenzionato a sviluppare un'app Android per più di un tipo di dispositivo, dovresti aver letto almeno una volta i documenti di supporto dello schermo. Inoltre, è sempre utile conoscere il numero effettivo di dispositivi attivi con una particolare configurazione dello schermo.

• Dimensioni dello schermo e densità

Elaborerò di più su come esattamente dp converte in px:

• Se in esecuzione su un dispositivo mdpi, 150 x 150 pxun'immagine occuperà 150 * 150 dpspazio sullo schermo.
• Se in esecuzione su un dispositivo HDPI, 150 x 150 pxun'immagine occuperà 100 * 100 dpspazio sullo schermo.
• Se in esecuzione su un dispositivo xhdpi, 150x150 pxun'immagine occuperà 75 * 75 dpspazio sullo schermo.

Al contrario: diciamo, vuoi aggiungere un'immagine alla tua applicazione e ne hai bisogno per riempire un 100 * 100 dpcontrollo. Dovrai creare immagini di dimensioni diverse per le dimensioni dello schermo supportate:

• 100 * 100 px immagine per mdpi
• 150 * 150 px immagine per hdpi
• 200 * 200 px immagine per xhdpi

px - Pixel - il punto per scala corrisponde ai pixel effettivi sullo schermo.

i - Pollici - in base alle dimensioni fisiche dello schermo.

mm - Millimetri - in base alle dimensioni fisiche dello schermo.

pt - Punti - 1/72 di pollice in base alla dimensione fisica dello schermo.

dp - Pixel indipendenti dalla densità - un'unità astratta che si basa sulla densità fisica dello schermo. Queste unità sono relative a uno schermo da 160 dpi, quindi uno dpè un pixel su uno schermo da 160 dpi. Il rapporto tra dp-pixel cambierà con la densità dello schermo, ma non necessariamente in proporzione diretta. Nota: il compilatore accetta entrambi dipe dp, sebbene dpsia più coerente con sp.

sp - Pixel indipendenti dalla scala : è simile dpall'unità, ma è anche ridimensionato dalla preferenza della dimensione del carattere dell'utente. Si consiglia di utilizzare questa unità quando si specificano le dimensioni dei caratteri, in modo che vengano regolate sia per la densità dello schermo che per le preferenze dell'utente.

Prendi l'esempio di due schermi che hanno le stesse dimensioni ma uno ha una densità dello schermo di 160 dpi (punti per pollice, cioè pixel per pollice) e l'altro è 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

Inoltre, dovresti avere una chiara comprensione dei seguenti concetti:

Grandezza schermo:

Dimensione fisica effettiva, misurata come diagonale dello schermo. Per semplicità, Android raggruppa tutte le dimensioni effettive dello schermo in quattro dimensioni generalizzate: piccola, normale, grande ed extra grande.

Densità dello schermo:

La quantità di pixel all'interno di un'area fisica dello schermo; di solito indicato come dpi (punti per pollice). Ad esempio, uno schermo a "bassa" densità ha meno pixel all'interno di una determinata area fisica, rispetto a uno schermo "normale" o "ad alta" densità. Per semplicità, Android raggruppa tutte le densità effettive dello schermo in quattro densità generalizzate: bassa, media, alta ed extra alta.

Orientamento:

L'orientamento dello schermo dal punto di vista dell'utente. Questo è orizzontale o verticale, il che significa che le proporzioni dello schermo sono rispettivamente larghe o alte. Tenere presente che, per impostazione predefinita, non solo dispositivi diversi funzionano con orientamenti diversi, ma l'orientamento può cambiare in fase di esecuzione quando l'utente ruota il dispositivo.

Risoluzione:

Il numero totale di pixel fisici su uno schermo. Quando si aggiunge il supporto per più schermi, le applicazioni non funzionano direttamente con la risoluzione; le applicazioni dovrebbero riguardare solo le dimensioni e la densità dello schermo, come specificato dai gruppi di dimensioni e densità generalizzati.

Pixel indipendente dalla densità (dp):

Un'unità pixel virtuale da utilizzare durante la definizione del layout dell'interfaccia utente, per esprimere le dimensioni o la posizione del layout in modo indipendente dalla densità. Il pixel indipendente dalla densità equivale a un pixel fisico su uno schermo a 160 dpi, che è la densità di base assunta dal sistema per uno schermo a densità "media". In fase di esecuzione, il sistema gestisce in modo trasparente qualsiasi ridimensionamento delle unità dp, se necessario, in base alla densità effettiva dello schermo in uso. La conversione di unità dp in pixel dello schermo è semplice: px = dp * (dpi / 160). Ad esempio, su uno schermo a 240 dpi, 1 dp equivale a 1,5 pixel fisici. È necessario utilizzare sempre le unità DP durante la definizione dell'interfaccia utente dell'applicazione, per garantire la corretta visualizzazione dell'interfaccia utente su schermi con densità diverse.

Riferimento: sito per sviluppatori Android

dplo è dip. Usalo per tutto (margine, imbottitura, ecc.).

Utilizzare solo spper {text-size}.

Per ottenere le stesse dimensioni su diverse densità dello schermo, Android converte queste unità in pixel in fase di esecuzione, quindi non c'è matematica difficile da fare.

Vedere la differenza tra px, dpe spsulle diverse dimensioni dello schermo.

Fonte: Programmazione Android: The Big Nerd Ranch Guide

Ho calcolato la formula seguente per effettuare le conversioni dpia dpesp

definizioni

px o dot è un pixel sullo schermo fisico.

dpi sono pixel per pollice sullo schermo fisico e rappresentano la densità del display.

Android dà nomi alias a diverse densità

• LDPI (basso) ~ 120 dpi
• mpi (medio) ~ 160 dpi
• hdpi (alto) ~ 240 dpi
  • la maggior parte dei dispositivi nel 2015 sono qui
• xhdpi (extra alto) ~ 320 dpi
  • Apple iPhone 4/5/6, Nexus 4
• xxhdpi (extra-extra-alto) ~ 480 dpi
  • Nexus 5
• xxxhdpi (extra-extra-extra-alto) ~ 640 dpi

dip o dp sono pixel indipendenti dalla densità , cioè corrispondono a più o meno pixel a seconda della densità fisica.

• 1dp = 1px su mdpi

sp o sip è un pixel indipendente dalla scala . Sono ridimensionati quando l' opzione Testo grande è attivata in Settings>Accessibility

• 1sp = 1dp
• 1sp = 1.2dp con accessibilità Testo grande

Cosa usare?

Usa sp per Dimensione testo.

Usa dp per tutto il resto.

Fonte 1

Fonte 2

Fonte 3 : (i dati dalla fonte 3 sono riportati di seguito)

Questi sono valori di dimensione definiti in XML. Una dimensione è specificata con un numero seguito da un'unità di misura. Ad esempio: 10px, 2in, 5sp. Le seguenti unità di misura sono supportate da Android:

dp

Pixel indipendenti dalla densità - Un'unità astratta basata sulla densità fisica dello schermo. Queste unità sono relative ad uno schermo di 160 dpi (punti per pollice), su cui 1dp è approssimativamente uguale a 1px. Quando si esegue su uno schermo a densità più elevata, il numero di pixel utilizzati per disegnare 1dp viene aumentato di un fattore appropriato per i dpi dello schermo. Allo stesso modo, quando su uno schermo a densità inferiore, il numero di pixel utilizzati per 1dp viene ridotto. Il rapporto tra dp-pixel cambierà con la densità dello schermo, ma non necessariamente in proporzione diretta. L'uso di unità dp (anziché unità px) è una soluzione semplice per ridimensionare correttamente le dimensioni della vista nel layout per diverse densità dello schermo. In altre parole, fornisce coerenza per le dimensioni del mondo reale degli elementi dell'interfaccia utente su dispositivi diversi.

sp

Pixel indipendenti dalla scala - Questo è come l'unità dp, ma è anche ridimensionato dalla preferenza della dimensione del carattere dell'utente. Si consiglia di utilizzare questa unità quando si specificano le dimensioni dei caratteri, in modo che vengano regolate sia per la densità dello schermo che per le preferenze dell'utente.

pt

Punti: 1/72 di pollice in base alla dimensione fisica dello schermo.

px

Pixel: corrisponde ai pixel effettivi sullo schermo. Questa unità di misura non è consigliata perché la rappresentazione effettiva può variare a seconda del dispositivo; ogni dispositivo può avere un diverso numero di pixel per pollice e può avere più o meno pixel totali disponibili sullo schermo.

mm

Millimetri: basati sulla dimensione fisica dello schermo.

in

Pollici: in base alle dimensioni fisiche dello schermo.

Nota: una dimensione è una semplice risorsa a cui viene fatto riferimento utilizzando il valore fornito nell'attributo name (non il nome del file XML). Pertanto, è possibile combinare le risorse dimensione con altre risorse semplici in un file XML, sotto un elemento.

Fondamentalmente l'unica volta in cui si applica px è un px, e questo è se si desidera esattamente un pixel sullo schermo come nel caso di un divisore:

Con> 160 dpi, potresti ottenere 2-3 pixel,

Su> 120 dpi, viene arrotondato a 0.

px

Pixel: corrisponde ai pixel effettivi sullo schermo.

dp o dip

Pixel indipendenti dalla densità: un'unità astratta basata sulla densità fisica dello schermo. Queste unità sono relative ad uno schermo da 160 dpi, quindi un dp è un pixel su uno schermo da 160 dpi.

Uso di dp:

Indipendenza dalla densità : l'applicazione ottiene l'indipendenza dalla densità quando conserva le dimensioni fisiche (dal punto di vista dell'utente) degli elementi dell'interfaccia utente quando vengono visualizzate su schermi con densità diverse. (ad es.) L'immagine dovrebbe avere le stesse dimensioni (non ingrandita o ridotta) in diversi tipi di schermi.

sp

Pixel indipendenti dalla scala: questo è come l'unità dp, ma è anche ridimensionato dalla preferenza della dimensione del carattere dell'utente.

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

Dove usare cosa e relazione tra px e dp?

Pixel indipendente dalla densità (dp)

Un'unità pixel virtuale da utilizzare durante la definizione del layout dell'interfaccia utente, per esprimere le dimensioni o la posizione del layout in modo indipendente dalla densità. Come descritto sopra, il pixel indipendente dalla densità equivale a un pixel fisico su uno schermo a 160 dpi, che è la densità di base assunta dal sistema per uno schermo a densità "media". In fase di esecuzione, il sistema gestisce in modo trasparente qualsiasi ridimensionamento delle unità dp, se necessario, in base alla densità effettiva dello schermo in uso. La conversione di unità DP in pixel dello schermo è semplice:

px = dp * (dpi / 160).

Ad esempio, su uno schermo a 240 dpi, 1 dp equivale a 1,5 pixel fisici. È necessario utilizzare sempre le unità DP durante la definizione dell'interfaccia utente dell'applicazione, per garantire la corretta visualizzazione dell'interfaccia utente su schermi con densità diverse.

Comprendere i pixel in dp e viceversa è molto essenziale (soprattutto per fornire valori esatti di dp al team creativo)

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

• Cerca di ottenere tutti i valori di pixel in numeri pari dal team creativo. Altrimenti si verificherà una perdita di precisione durante la moltiplicazione per 0,5.

px

È spiegato sopra. Cerca di evitare nei file di layout. Ma ci sono alcuni casi in cui è richiesto px. ad esempio, la linea di divisione ListView. px è meglio qui per dare una linea di un pixel come divisore per tutte le risoluzioni dello schermo.

sp

Usa sp per le dimensioni dei caratteri. Quindi cambierà solo il carattere all'interno dell'applicazione mentre cambiano le dimensioni dei caratteri del dispositivo (ovvero Display -> Caratteri sul dispositivo). Se vuoi mantenere un carattere di dimensioni statiche all'interno dell'app, puoi dare la dimensione del carattere in dp. In tal caso, non cambierà mai. Gli sviluppatori possono ottenere tale requisito per alcune schermate specifiche, per questo, gli sviluppatori possono utilizzare dp anziché sp. In tutti gli altri casi, si consiglia di utilizzare sp.

Puoi vedere la differenza tra pxe dpdall'immagine qui sotto e puoi anche scoprire che il pxe dpnon potrebbe garantire le stesse dimensioni fisiche sulle diverse schermate.

Tutto ciò che riguarda la dimensione del testo e l'aspetto deve usare spo pt. Considerando che, tutto ciò che riguarda la dimensione dei controlli, i layout, ecc. Deve essere utilizzato con dp.

Puoi usare entrambi dpe dipal suo posto.

Vorrei solo usare dp.

Si parla molto dell'uso di "sp" per le dimensioni dei caratteri, e mentre apprezzo il punto, non penso che sia la cosa giusta da fare dal punto di vista del design. Puoi finire per rompere il tuo design se l'utente ha una selezione di dimensioni del carattere traballante e l'utente finirà per incolpare l'app e non le proprie scelte di vita.

Inoltre, se prendi un'app sp-font su un tablet da 160 dpi, scoprirai che tutto si ingrandisce ... ma il tuo font, che sarà minuscolo in confronto. Non è un bell'aspetto.

Mentre l'idea dei caratteri "sp" ha un buon cuore, è una cattiva idea. Stick con dp per tutto.

sp = scala pixel indipendenti

dp = dip = pixel indipendenti dalla densità

dpi = punti per pollice

Dovremmo evitare di usare sp .

Dovremmo usare dp per supportare più schermi.

Android supporta diverse risoluzioni dello schermo

• ldpi (basso) ~ 120 dpi
• mdpi (medio) ~ 160 dpi
• hdpi (alto) ~ 240 dpi
• xhdpi (extra-alto) ~ 320 dpi
• xxhdpi (extra-extra-alto) ~ 480 dpi
• xxxhdpi (extra extra extra extra) ~ 640 dpi

Un dispositivo ldpi da 120 dp ha 120 pixel con dimensioni di 1 pollice.

Lo stesso per altre densità ...

Come ingegneri del software dovremmo utilizzare questa formula di conversione:

pixel = dp * (densità / 160)

Quindi 1 dp del dispositivo a 240 dpi avrà = 1 * (240/160) = 3/2 = 1,5 pixel.

E 1 dp del dispositivo 480 dpi avrà = 1 * (480/160) = 3 pixel.

Utilizzando questa conoscenza di 1,5 e 3 pixel, un ingegnere del software può progettare layout per densità diverse.

Per controllare i parametri dello schermo di qualsiasi dispositivo:

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);

Toast.makeText(
    this,
    "4:" + metrics.heightPixels + "," + metrics.density + ","
    + metrics.densityDpi, Toast.LENGTH_LONG).show();

La differenza tra dpe le spunità indicate come " preferenza dimensione carattere utente " dalle risposte copiate dalla documentazione ufficiale può essere vista in fase di esecuzione modificando l' Settings->Accessibility->Large Textopzione.

Large Textopzione forza il testo a diventare 1.3volte più grande

private static final float LARGE_FONT_SCALE = 1.3f;

Questo potrebbe ovviamente dipendere dal fornitore poiché risiede in pacchetti / app / Impostazioni .

dpi -

• Punti per pollice
• Misurare la densità di pixel dello schermo.

px - pixel

• Per la mappatura dei pixel dello schermo

pt - punti

• Circa 1/72 di pollice, rispetto alle dimensioni dello schermo fisico.

pollici - rispetto alle dimensioni fisiche dello schermo (1 pollice = 2,54 cm).

mm - millimetro - rispetto alle dimensioni fisiche dello schermo.

sp - pixel indipendente dalla scala.

• Basato sulla preferenza della dimensione del carattere dell'utente.
• Il carattere dovrebbe essere in 'sp'.

dip -

• dip == dp
• Pixel indipendente dalla densità.
• Varia in base alla densità dello schermo.
• Nello schermo da 160 dpi, 1 dp = 1 pixel.
• Usa dp tranne la dimensione del carattere del testo.

In standard, vengono utilizzati dp e sp. sp per la dimensione del carattere e dp per tutto il resto.

Formula per la conversione di unità:

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  

Ecco la formula utilizzata da Android:

px = dp * (dpi / 160)

Dove dpi è una delle seguenti densità dello schermo. Per un elenco di tutte le densità possibili vai qui

Definisce le costanti "DENSITY_ *".

• lpi (basso) ~ 120 dpi
• mpi (medio) ~ 160 dpi
• hdpi (alto) ~ 240 dpi
• xhdpi (extra alto) ~ 320 dpi
• xxhdpi (extra-extra-alto) ~ 480 dpi
• xxxhdpi (extra-extra-extra-alto) ~ 640 dpi

Tratto da qui .

Questo risolverà molta confusione durante la traduzione tra px e dp, se conosci il tuo dpi dello schermo.

Quindi, supponiamo che tu voglia un'immagine di 60 dp per uno schermo hdpi, quindi la dimensione fisica dei pixel di 60 dp è:

px = 60 * (240 / 160)

Dimensioni dello schermo in Androidsono raggruppate in categorie small, medium, large, extra large, double-extrae triple-extra. La densità dello schermo è la quantità di pixel all'interno di un'area (come pollici) dello schermo. Generalmente viene misurato in punti per pollice (dpi). La densità dello schermo è raggruppata come bassa, media, alta ed extra alta. La risoluzione è il numero totale di pixel sullo schermo.

• dp: Pixel indipendente dalla densità, varia in base alla densità dello schermo. Nello schermo da 160 dpi, 1 dp = 1 pixel. Ad eccezione della dimensione del carattere, usa sempre dp.
• dip: dip == dp. Nelle versioni precedenti di Android veniva utilizzato dip e successivamente cambiato in dp.
• sp: ridimensiona pixel indipendenti, ridimensionato in base alla preferenza della dimensione del carattere dell'utente. I caratteri dovrebbero usare sp.
• px: il nostro solito pixel standard che si associa al pixel dello schermo.
• in: pollici, rispetto alle dimensioni dello schermo fisico.
• mm: millimetri, rispetto alle dimensioni dello schermo fisico.
• pt: 1/72 di pollice, rispetto alle dimensioni dello schermo fisico.

Formula per la conversione tra unità

 px = dp * (dpi / 160)

dp in px nel dispositivo

L'esempio seguente può aiutare a capire meglio. Il ridimensionamento avviene in base alla dimensione del bucket di 120 (ldpi), 160 (mdpi), 240 (hdpi), 320 (xhdpi), 480 (xxhdpi) e 640 (xxxhdpi). Il rapporto suggerito da Google per la progettazione è 3: 4: 6: 8: 12 per ldpi: mdpi: hdpi: xhdpi: xxhdpi

Un'immagine di 150 pixel X 150 pixel occuperà,

• 150 dp X 150 dp di spazio su schermo in mppi
• 100 dp X 100 dp spazio su schermo in hdpi
• 75 dp X 75 dp di spazio su schermo in xhdpi

È possibile utilizzare il seguente calcolatore DPI per correggere le dimensioni delle immagini e altre dimensioni quando si desidera avere un design dell'interfaccia utente uniforme in tutti i dispositivi Android.

Calcolatore DPI 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);        
   }
}

Ulteriori informazioni si riferiscono al seguente link.

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

Si prega di leggere la risposta dal wiki della community. Di seguito sono riportate alcune informazioni da considerare in aggiunta alle risposte di cui sopra. La maggior parte degli sviluppatori Android manca questo durante lo sviluppo di app, quindi sto aggiungendo questi punti.

sp = scala pixel indipendenti

dp = pixel indipendenti dalla densità

dpi = pixel di densità

Ho esaminato le risposte sopra ... non trovandole esattamente corrette. sp per le dimensioni del testo, dp per i limiti del layout - standard. Ma sp per la dimensione del testo interromperà il layout se usato con noncuranza nella maggior parte dei dispositivi.

sp prende la dimensione del testo del dispositivo, mentre dp prende quella dello standard di densità del dispositivo (mai cambiare in un dispositivo) Supponiamo che il testo 100sp possa occupare l'80% dello schermo o il 100% dello schermo a seconda della dimensione del carattere impostata nel dispositivo

Puoi usare sp anche per i limiti del layout, funzionerà :) Nessun app standard usa sp per tutto il testo

Usa sp e dp per la dimensione del testo considerando UX.

• Non usare sp per il testo nella barra degli strumenti (puoi usare dimens Android disponibili per schermi di dimensioni diverse con dp)
• Non usare sp per il testo in piccoli pulsanti delimitati, testo molto più piccolo, ecc

Alcune persone usano enormi dimensioni FONT nel telefono per una maggiore leggibilità, dando loro un testo di dimensioni ridotte con codice hard sarà un problema UX. Inserisci sp per il testo dove necessario, ma assicurati che non interrompa il layout quando l'utente modifica le sue impostazioni.

Allo stesso modo se hai una singola app che supporta tutte le dimensioni, l'aggiunta di risorse xxxhdpi aumenta notevolmente le dimensioni dell'app. Ma ora i telefoni xxxhdpi sono comuni, quindi dobbiamo includere almeno risorse xxxhdpi per le icone nella barra laterale, nella barra degli strumenti e nella barra inferiore. È meglio passare a immagini vettoriali per avere immagini uniformi e di qualità migliore per tutte le dimensioni dello schermo.

Si noti inoltre che le persone utilizzano caratteri personalizzati nel proprio telefono. Quindi la mancanza di un carattere può causare problemi di spaziatura e tutto il resto. Supponiamo che la dimensione del testo 12sp per un carattere personalizzato possa richiedere alcuni pixel in più rispetto al carattere predefinito.

Fare riferimento al sito dello sviluppatore di Google per dettagli sulla densità e sulla base per Android. https://developer.android.com/training/multiscreen/screendensities

• px - un pixel, uguale a quello utilizzato in CSS, JavaScript, ecc.
• sp - pixel indipendenti dalla scala
• dip - pixel indipendenti dalla densità

Normalmente sp viene utilizzato per le dimensioni dei caratteri, mentre dip viene utilizzato (anche chiamato dp) per gli altri.

Ho trovato un buon articolo sulla progettazione dell'interfaccia utente delle app Android per diverse risoluzioni dello schermo e mi piacerebbe lasciarlo qui solo per qualcuno che cerca in quest'area. Sì, lo so che è in qualche modo descritto nei documenti di Google (e menzionato nei post sopra), l'ho letto ma non è stato un bene per me (sì, potrei essere troppo stupido)). Non è chiaro per me come progettare layout in grado di gestire diverse dimensioni dello schermo. Odio il concetto di DP e così via, quando devo implementare un layout dell'interfaccia utente "flessibile" per schermi diversi. (Ehi sviluppatori iOS - sì, hai ragione è il concetto di Storyboard).

Android non ha un cattivo concetto di interfaccia utente, ma sfortunatamente manca le funzionalità di Storyboard per iOS. Progettare un'interfaccia utente flessibile in Android non è cosa facile (nella migliore delle ipotesi).

Ecco l'articolo che mi ha aiutato a capire cosa fare in Android per creare layout per schermi di dimensioni diverse:

Blog JMSTUDIO: - Decidi la dimensione dello schermo dell'app Android

Come progettare l'interfaccia utente per le app Android per schermi di dimensioni diverse

Per progettare un'interfaccia utente dell'app per schermi di dimensioni diverse, il nostro progetto iniziale deve soddisfare uno spazio minimo richiesto per ogni dimensione dello schermo. Android definisce una dimensione minima (in dp) per ogni tipo di schermo generalizzato. Ecco una guida alle dimensioni dello schermo Android. Quando otteniamo le dimensioni dello schermo in dp, non è sufficiente progettare l'interfaccia utente dell'app Android. Per ogni dimensione dello schermo, dobbiamo preparare immagini grafiche e bitmap per ogni densità. Ecco una guida per la densità dello schermo Android.

Per un facile calcolo, possiamo seguire il rapporto di ridimensionamento 3: 4: 6: 8 tra le quattro densità generalizzate. Se creiamo un'immagine di 36 × 36 pixel per il dispositivo ldpi, la dimensione delle immagini delle altre densità sarà di 48 × 48 per mdpi, 72 × 72 per hdpi e 96 × 96 per xhdpi.

Come progettare l'interfaccia utente delle app Android in Photoshop

Molti designer hanno problemi per la progettazione dell'interfaccia utente dell'app Android in Photoshop o in altri strumenti di progettazione grafica basati su pixel a causa di un'unità indipendente dalla densità, dp. I designer non sanno come mappare dp in pixel. Google non fornisce inoltre una chiara guida alla progettazione dell'interfaccia utente Android, sebbene fornisca una formula di base per la traduzione di dp e pixel.

Come definizione di Android, 1pd equivale a 1px con un dispositivo a 160 dpi (mdpi). Quindi vogliamo progettare un'app Android per dispositivi Android xlarge con densità mdpi, possiamo definire la nostra dimensione dell'interfaccia utente in pixel come larghezza 960 pixel e altezza 720px; Segui la stessa regola di mappatura, possiamo ottenere le seguenti linee guida per la progettazione dell'interfaccia utente delle dimensioni dello schermo dell'app Android:

AGGIUNTO : Se sei interessato anche all'interfaccia utente "flessibile", dai un'occhiata a questa libreria: un SDK per Android che fornisce una nuova unità di dimensioni - sdp (dp scalabile). Questa unità di dimensioni si ridimensiona in base alle dimensioni dello schermo (menzionata anche in una risposta qui, sulla SDPlibreria)

ADDED2 Google ha finalmente compreso l'utilità del concetto dell'interfaccia utente di iOS Storeboard, e qui vale ConstraintLayoutper il mondo Android: crea un'interfaccia utente reattiva con ConstraintLayout

1) dp: (density independent pixels)

Il numero di pixel rappresentati in un'unità di dp aumenta all'aumentare della risoluzione dello schermo (quando si hanno più punti / pixel per pollice). Viceversa su dispositivi con una risoluzione inferiore, il numero di pixel rappresentati nell'unità di dp diminuirà. Poiché si tratta di un'unità relativa, deve essere confrontata una linea di base. Questa linea di base è uno schermo da 160 dpi. Questa è l'equazione:px = dp * (dpi / 160).

2) sp: (scale independent pixels)

Questa unità viene ridimensionata in base al dpi dello schermo (simile a dp) e alla preferenza della dimensione del carattere dell'utente.

3) px: (pixels)

Pixel o punti reali sullo schermo.

Per maggiori dettagli puoi visitare

Guida per sviluppatori Android> Guida per sviluppatori Dimension
Android> Schermate

Dimensioni dello schermo in Android sono raggruppate in categorie ldpi, mdpi, hdpi, xhdpi, xxhdpie xxxhdpi. La densità dello schermo è la quantità di pixel all'interno di un'area (come pollici) dello schermo. Generalmente viene misurato in punti per pollice ( dpi).

PX(Pixels):

• il nostro solito pixel standard che si associa al pixel dello schermo. pxè pensato per pixel assoluti. Questo è usato se vuoi dare in termini di pixel assoluti per larghezza o altezza. Non consigliato.

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

• dip == dp. Nelle versioni precedenti di Android è stato utilizzato dip e successivamente modificato in dp. Questa è un'alternativa di px.

• Generalmente non lo usiamo mai pxperché è un valore assoluto. Se si utilizza pxper impostare la larghezza o l'altezza e se l'applicazione viene scaricata su dispositivi di dimensioni dello schermo diverse, tale vista non si allungherà in base alle dimensioni originali dello schermo.

• dpsi consiglia vivamente di utilizzare al posto di px. Utilizzare dpse si desidera menzionare la larghezza e l'altezza per crescere e ridurle dinamicamente in base alle dimensioni dello schermo.

• se diamo dp/dip, Android calcolerà automaticamente la dimensione dei pixel sulla base di uno schermo di 160 pixel.

SP(Scale independent pixels):

• ridimensionato in base alla preferenza della dimensione del carattere dell'utente. I caratteri dovrebbero usare sp.

• quando si menzionano le dimensioni del carattere per adattarsi a varie dimensioni dello schermo, utilizzare sp. Questo è simile a dp.Utilizzare spsoprattutto per le dimensioni dei caratteri per crescere e ridursi dinamicamente in base alle dimensioni dello schermo

La documentazione di Android dice:

quando si specificano le dimensioni, utilizzare sempre uno dpo più spunità. A dpè un pixel indipendente dalla densità che corrisponde alla dimensione fisica di un pixel a 160 dpi. An spè la stessa unità di base, ma viene ridimensionata in base alla dimensione del testo preferita dall'utente (è un pixel indipendente dalla scala), quindi è necessario utilizzare questa unità di misura quando si definisce la dimensione del testo

Lo schermo di un telefono cellulare è costituito da migliaia di piccoli punti noti come pixel (px) . Un pixel è l'elemento più piccolo che va a fare l'immagine. Maggiore è il numero di pixel per creare un'immagine o una formulazione, più nitida diventa e rende lo schermo dello smartphone più facilmente leggibile.

La risoluzione dello schermo è misurata in termini di numero di pixel sullo schermo. La risoluzione dello schermo è una specifica comunemente usata quando si acquista un dispositivo, ma in realtà non è così utile quando si progetta per Android perché pensare agli schermi in termini di pixel ignora il concetto di dimensione fisica, che per un dispositivo touch è davvero molto importante.

I pixel indipendenti dalla densità (dp o dip) consentono al progettista di creare risorse che appaiono in modo previsto, indipendentemente dalla risoluzione o dalla densità del dispositivo di destinazione.

Un pixel indipendente dalla densità (dp o dip) è uguale a un pixel alla densità di base o 160 dpi (punti per pollice).

1 px / 1dp = 160 dpi / 160 dpi

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

dove,

dpi è punti per pollice

Quindi, a 320 dpi, 1 dp è uguale a 2 px.

Formula

px / dp = dpi / 160 dpi

I punti per pollice (dpi) sono una misura della nitidezza (ovvero la densità dei punti illuminati) su uno schermo. I punti per pollice per una determinata risoluzione dell'immagine differiranno in base alla dimensione complessiva dello schermo poiché lo stesso numero di pixel viene distribuito su uno spazio diverso.

Lavorare con pixel indipendenti dalla densità ci aiuta ad affrontare una situazione come quella in cui hai due dispositivi con la stessa risoluzione di pixel, ma con una diversa quantità di spazio. Supponiamo che in un caso tablet e telefono abbiano la stessa risoluzione di pixel rispettivamente di 1280 per 800 pixel (160 dpi) e 800 per 1280 pixel (320 dpi).

Ora, poiché un tablet ha una densità di base (160 dpi), le sue dimensioni di pixel fisici e indipendenti dalla densità sono le stesse, 1280 per 800. D'altra parte, il telefono ha una densità di pixel superiore, quindi ha la metà di pixel indipendenti dalla densità rispetto a quelli fisici pixel. Quindi un telefono ha pixel indipendenti dalla densità 400 per 640. Quindi l'uso di un pixel indipendente dalla densità rende più facile immaginare mentalmente che il tablet abbia molto più spazio del telefono.

Allo stesso modo, se hai due dispositivi con dimensioni dello schermo simili, ma diversa densità di pixel, supponiamo che uno sia 800 per 1280 pixel (320 dpi) e l'altro sia 400 per 640 pixel (160 dpi), non è necessario definire totalmente layout diversi per questi due dispositivi in ​​quanto possiamo misurare le risorse in termini di pixel indipendenti dalla densità, che è lo stesso per entrambi i dispositivi.

800 per 1280 pixel (320 dpi) = 400 per 640 pixel indipendenti dalla densità (dp)

400 per 640 pixel (160 dpi) = 400 per 640 pixel indipendenti dalla densità (dp)

Ridimensionare pixel indipendenti (sp) è l'unità preferita per la dimensione del carattere. Ai fini dell'accessibilità, Android consente agli utenti di personalizzare la dimensione del carattere del proprio dispositivo. Gli utenti che hanno difficoltà a leggere il testo possono aumentare le dimensioni del carattere del proprio dispositivo. Normalmente puoi trovare questa opzione nell'impostazione di visualizzazione sul tuo telefono o tablet sotto la dimensione del carattere. È spesso disponibile anche attraverso le impostazioni di accessibilità.

Con pixel indipendenti dalla scala, 16 sp è esattamente uguale a 16 dp quando la dimensione del carattere del dispositivo è normale o del 100%. Ma quando la dimensione del carattere del dispositivo è grande, ad esempio 125%, 16 sp si tradurrà in 20 dp o 1,25 volte 16.

Se usi dp come unità per la dimensione del carattere, quel pezzo di testo ha una dimensione fisica specifica, indipendentemente dal fatto che l'utente abbia personalizzato la dimensione del carattere del dispositivo. L'uso di unità SP renderà un'esperienza migliore per le persone con problemi di vista.

Riferimento : Udacity , Google

sp: ridimensiona pixel indipendenti

Dovresti usarlo con i testi perché viene ridimensionato automaticamente in base alle dimensioni del carattere utilizzato dall'utente nel suo dispositivo.

px: pixel o picture element è il singolo punto sullo schermo

Densità di pixel

La densità e la risoluzione dei pixel dello schermo variano in base alla piattaforma. I pixel indipendenti dal dispositivo e i pixel scalabili sono unità che offrono un modo flessibile per adattarsi a un design su più piattaforme.

Calcolo della densità dei pixel

Il numero di pixel che si adattano a un pollice è indicato come densità di pixel. Gli schermi ad alta densità hanno più pixel per pollice di quelli a bassa densità ....

Il numero di pixel che si adattano a un pollice è indicato come densità di pixel. Gli schermi ad alta densità hanno più pixel per pollice di quelli a bassa densità. Di conseguenza, gli elementi dell'interfaccia utente con le stesse dimensioni dei pixel appaiono più grandi su schermi a bassa densità e più piccoli su schermi ad alta densità.

Per calcolare la densità dello schermo, puoi usare questa equazione:

Densità schermo = Larghezza (o altezza) dello schermo in pixel / Larghezza (o altezza) dello schermo in pollici

Indipendenza dalla densità

La densità e la risoluzione dei pixel dello schermo variano in base alla piattaforma. I pixel indipendenti dal dispositivo e i pixel scalabili sono unità che offrono un modo flessibile per adattarsi a un design su più piattaforme.

Calcolo della densità dei pixel Il numero di pixel che rientrano in un pollice è indicato come densità dei pixel . Gli schermi ad alta densità hanno più pixel per pollice di quelli a bassa densità ....

L'indipendenza della densità si riferisce alla visualizzazione uniforme degli elementi dell'interfaccia utente su schermi con densità diverse.

I pixel indipendenti dalla densità , scritti come dp (pronunciati " avvallamenti "), sono unità flessibili che si ridimensionano per avere dimensioni uniformi su qualsiasi schermo. Le UI dei materiali utilizzano pixel indipendenti dalla densità per visualizzare gli elementi in modo coerente su schermi con densità diverse.

1. Schermo a bassa densità visualizzato con indipendenza di densità
2. Schermo ad alta densità visualizzato con indipendenza di densità

Leggi il testo completo https://material.io/design/layout/pixel-density.html

Pixel (px) : corrisponde ai pixel effettivi sullo schermo. Questo è usato se vuoi dare in termini di pixel assoluti per larghezza o altezza.

Pixel indipendenti dalla densità (dp o dip) - un'unità astratta che si basa sulla densità fisica dello schermo. Queste unità sono relative ad uno schermo da 160 dpi, quindi un dp è un pixel su uno schermo da 160 dpi. Il rapporto tra dp-pixel cambierà con la densità dello schermo, ma non necessariamente in proporzione diretta. Nota: il compilatore accetta sia "dip" che "dp", sebbene "dp" sia più coerente con "sp".

Pixel indipendenti dalla scala (sp) : questo è come l'unità dp, ma è anche ridimensionato dalla preferenza della dimensione del carattere dell'utente. Si consiglia di utilizzare questa unità quando si specificano le dimensioni dei caratteri, quindi saranno regolate sia per la densità dello schermo che per le preferenze dell'utente.

Usa sempre solo dp e sp. sp per le dimensioni dei caratteri e dp per tutto il resto. Renderà l'interfaccia utente compatibile per i dispositivi Android con densità diverse. Puoi saperne di più su pixel e dp da https://www.google.com/design/spec/layout/units-measurements.html#units-measurements-density-independent-pixels-dp-

URL della fonte: - http://www.androidtutorialshub.com/what-is-the-difference-between-px-dp-dip-sp-on-android/

Voglio fornire un modo semplice per capire dp. In effetti, penso che dpsia il più semplice da capire. dpè solo un'unità di lunghezza fisica. È della stessa dimensione di mmo inch. È conveniente per noi scrivere 50dp, 60dppiuttosto che 50/160 incho 60/160 inch, perché uno dpè 1/160 inchqualunque sia la dimensione dello schermo o la risoluzione.

L'unico problema è che i dpi Android di alcuni schermi non sono accurati. Ad esempio, uno schermo classificato a 160 dpi può avere effettivamente 170 dpi. Quindi il risultato di calcolo di dpè sfocato. Dovrebbe essere approssimativamente lo stesso di 1/160 inch.