34 Domanda: Qual è la differenza tra "px", "dip", "dp" e "sp"?

domanda creata a Mon, Dec 3, 2018 12:00 AM

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

  • px
  • dip
  • DP
  • sp
5560
  1. questa è l'uso della piena differenza tra px, dip, dp e sp in android [ developer.android.com/guida /argomenti /risorse /...
    2012-05-25 09: 34: 20Z
  2. Questo convertitore nifty lo dimostra meglio , secondo me. È anche estremamente utile per esportare gli sprite da Photoshop o per progettare il layout per una dimensione fisica.
    2014-07-01 09: 28: 04Z
  3. nuova descrizione su Google Design Unità e misure
    2015-04-27 11: 31: 32Z
  4. 2017-07-15 10: 40: 21Z
  5. 2017-09-13 07: 41: 50Z
30 risposte                              30                         

Dalla documentazione per sviluppatori Android :

  1.   

    px
    Pixel - corrisponde ai pixel effettivi sullo schermo.

  2.   

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

  3.   

    mm
    Millimetri - in base alle dimensioni fisiche dello schermo.

  4.   

    pt
    Punti : 1/72 di pollice in base alle dimensioni fisiche dello schermo.

  5.   

    dp o dip
    Density - Pixel indipendenti: un'unità astratta basata sulla densità fisica dello schermo. Queste unità sono relative a un 160       schermo dpi, quindi un dp è un pixel su uno schermo a 160 dpi. Il rapporto di       dp-to-pixel cambierà con la densità dello schermo, ma non necessariamente       in proporzione diretta. Nota: il compilatore accetta sia "dip" che       "dp", anche se "dp" è più coerente con "sp".

  6.   

    sp
    Scala - Pixel indipendenti: è come l'unità dp, ma viene ridimensionata anche dalla preferenza della dimensione del carattere dell'utente. Ti è raccomandato       utilizzare questa unità quando si specificano le dimensioni dei caratteri, quindi verranno regolati       sia per la densità dello schermo che per le preferenze dell'utente.

Da 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 possono essere trovate anche nella documentazione di Google Design .

    
5552
2018-12-03 05: 07: 41Z
  1. anche se dovrebbero essere la stessa cosa tendo ad avere molti problemi con dp mentre tutto funziona bene con dip
    2011-07-04 06: 07: 31Z
  2. Una nota su db /sp che non è del tutto ovvia: il ridimensionamento che si verifica per questi dipende non dalla densità reale dei dispositivi (dpi) ma da quale "bucket" di densità in cui cade: le benne disponibili sono: 120.160.240.320. Ciò può causare alcuni problemi nella gestione di schermate che sono significativamente diverse ma che vengono ridimensionate uguali.
    2011-10-29 04: 10: 05Z
  3. Si noti che la documentazione non menziona più "dip", solo "dp", sebbene il compilatore sembri comunque accettare "dip".
    2013-05-28 00: 28: 51Z
  4. @ android_developer (5 commenti sopra) dp ha non la stessa lunghezza fisica. (Anche se è vicino.) Vedi il commento di @ Fraggle sul bucketing. Ciò significa che 48dp sarà di circa 8 mm (0,3 pollici), ma può variare fino a 11 mm.
    2013-06-15 06: 59: 43Z
  5. Il motivo del bucketing è che gli sviluppatori possono testare le loro app su alcuni dispositivi con densità diverse e essere sicuri che i layout sembreranno gli stessi su una moltitudine di dispositivi. Quindi, anche se le dimensioni fisiche dei pulsanti, ecc., Cambiano un po ', l'aspetto generale di un'attività sarà lo stesso.
    2013-06-15 07: 03: 34Z

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

  

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

     

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

     

Orientamento
L'orientamento dello schermo dal punto di vista dell'utente   vista. Questo è orizzontale o verticale, il che significa che lo schermo è   le proporzioni sono rispettivamente ampie o alte. Sii consapevole che no   solo i dispositivi diversi operano in diversi orientamenti da   predefinito, ma l'orientamento può cambiare in fase di esecuzione quando l'utente   ruota il dispositivo.

     

Risoluzione
Il numero totale di pixel fisici attivi   uno schermo. Quando si aggiunge il supporto per più schermi, le applicazioni lo fanno   non lavorare direttamente con la risoluzione; le domande dovrebbero essere preoccupate   solo con dimensioni e densità dello schermo, come specificato dal generalizzato   gruppi di dimensioni e densità.

     

pixel indipendente dalla densità (dp)
Un virtuale   unità pixel che dovresti usare quando definisci il layout dell'interfaccia utente, per esprimere   dimensioni del layout o posizione in modo indipendente dalla densità.   Il pixel indipendente dalla densità è equivalente a un pixel fisico su un 160   schermo dpi, che è la densità di base assunta dal sistema per a   schermo a "media" densità. Durante il runtime, il sistema gestisce in modo trasparente   qualsiasi ridimensionamento delle unità dp, secondo necessità, in base alla densità effettiva   dello schermo in uso. La conversione delle unità dp in pixel dello schermo è   semplice:    px = dp * (dpi / 160).   Ad esempio, su uno schermo a 240 dpi, 1 dp   è uguale a 1,5 pixel fisici. Dovresti sempre usare le unità dp quando   definizione dell'interfaccia utente della tua applicazione, per garantire la corretta visualizzazione dell'interfaccia utente   schermi con densità diverse.

Se sei seriamente intenzionato a sviluppare un'app Android per più di un tipo di dispositivo, dovresti leggere almeno una volta le schermate di supporto del documento di sviluppo. In aggiunta a ciò, è sempre una buona cosa sapere il numero effettivo di dispositivi attivi che hanno un particolare schermoit configurazione.

657
2018-11-27 09: 16: 27Z
  1. Quindi se si utilizza dp per un pulsante e sp per le dimensioni del carattere del testo del pulsante, cosa succede quando l'utente inizia a ridimensionare? Il testo si ingrandirà, ma il pulsante lo consentirà ingrandendo anche?
    2012-10-05 09: 35: 46Z
  2. @ Wytze, no. Per le cose in cui il montaggio del testo potrebbe essere un problema, vorrei semplicemente usare il dip così che le cose non trabocchino.
    2013-07-13 17: 39: 50Z
  3. @ Wytze E io, al contrario, uso sp sia per il testo che per tutto ciò che contiene. Ad esempio, se ho un pulsante con una dimensione fissa e un testo al suo interno, assegnerei la dimensione del pulsante in sp in modo che si riduca anche quando necessario. Altrimenti, l'utente sarà seccato di aver aumentato le dimensioni del testo e non è aumentato. Ovviamente, il layout dovrebbe essere abbastanza flessibile da permetterlo.
    2013-10-14 23: 15: 04Z
  4. Se i tuoi progettisti non lasceranno spazio alla possibilità di ridimensionare gli elementi basati sul testo in base alla dimensione dello sp, un'opzione è quella di passare a qualsiasi layout che useresti per un restringimento dispositivo, quindi ridimensiona tutto uniformemente (DisplayMetrics.scaledDensity /DisplayMetrics.density).
    2014-07-16 17: 52: 16Z
  5. @ Sam mancanza di spazio libero causerà problemi anche durante i18n
    2018-07-16 09: 14: 30Z

Elaborerò ulteriori informazioni su come esattamente convertire dp in px:

  • Se è in esecuzione su un dispositivo mdpi, un'immagine 150 x 150 px occuperà 150 * 150 dp di spazio sullo schermo.
  • Se si esegue su un dispositivo hdpi, un'immagine 150 x 150 px occuperà 100 * 100 dp di spazio sullo schermo.
  • Se è in esecuzione su un dispositivo xhdpi, un'immagine 150x150 px occuperà 75 * 75 dp di spazio sullo schermo.

Viceversa: ad esempio, vuoi aggiungere un'immagine alla tua applicazione e ne hai bisogno per riempire un controllo 100 * 100 dp. Dovrai creare immagini di dimensioni diverse per le dimensioni dello schermo supportate:

  •  Immagine 100 * 100 px per mdpi
  •  Immagine 150 * 150 px per hdpi
  •  Immagine 200 * 200 px per xhdpi
325
2018-04-06 19: 03: 33Z
  1. Come calcoliamo i pixel per hdpi, ldpi, mdpi, ecc. Ho sentito che usiamo questa formula..px = dp * (dpi /160); mi puoi spiegare con questa formula plz?
    2015-03-07 12: 25: 35Z
  2. @ Rakeshpatanga A una densità di 160 dpi, 1 px = 1 dp (il pixel fisico e l'astrazione dp sono gli stessi). Cioè, per un singolo dp abbiamo (1) * (160/160) = 1, o esattamente 1 px. A una densità maggiore di 320 dpi, un singolo dp è (1) * (320/160) = 2 pixel e due dp sono (2) * (320/160) = 4 px.
    2017-09-06 14: 32: 17Z
  3. Allineare questi in monospazio per vedere: | 1dp |, | ___ | ___ | 160, | _ | _ | _ | _ | 320 (inserire interruzioni di riga dopo le virgole). | _ | = 1 p i x el.
    2017-09-06 14: 49: 48Z
  4. re "Dovrai creare immagini di dimensioni diverse per le dimensioni dello schermo supportate:" Dipende. Per le immagini piccole ad alto contrasto , ad es. icone, è consigliabile creare almeno la dimensione più piccola (per essere sicuri che sia chiaro) più una dimensione abbastanza grande (in modo che le versioni di grandi dimensioni non appaiano sfocate). Ma anche per le icone, è possibile consentire a un'immagine di ridimensionarsi su una gamma di dimensioni, a densità più elevate. Per le fotografie, basta specificare l'area di visualizzazione che si desidera riempire e fare affidamento sul ridimensionamento del dispositivo.
    2018-05-22 11: 51: 30Z

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

in 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 alle dimensioni fisiche dello schermo.

dp Densità - Pixel indipendenti: un'unità astratta basata sulla densità fisica dello schermo. Queste unità sono relative a uno schermo da 160 dpi, quindi un dp è un pixel su uno schermo da 160 dpi. Il rapporto tra dp-to-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.

sp -Calcolli 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 regolati 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 è di 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
    
269
2018-11-27 10: 48: 04Z

Inoltre dovresti avere una chiara comprensione dei seguenti concetti:

Dimensioni schermo:

  

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

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, a   lo schermo a "bassa" densità ha meno pixel all'interno di una determinata area fisica,   confrontato con uno schermo con densità "normale" o "alta". Per semplicità,   Android raggruppa tutte le densità dello schermo effettive in quattro generalizzate   densità: bassa, media, alta e altissima.

Orientamento:

  

L'orientamento dello schermo dal punto di vista dell'utente. Questo è o paesaggio o ritratto, il che significa che il   le proporzioni dello schermo sono rispettivamente ampie o alte. Sii consapevole   che non solo i diversi dispositivi operano in diversi orientamenti   per impostazione predefinita, 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 risoluzione; le applicazioni dovrebbero riguardare solo lo schermo   dimensione e densità, come specificato dalle dimensioni e dalla densità generalizzate   gruppi.

pixel indipendente dalla densità (dp):

  

Un'unità di pixel virtuale che dovresti usare quando definisci il layout dell'interfaccia utente, per esprimere le dimensioni del layout o   posizione in un modo indipendente dalla densità. Il pixel indipendente dalla densità   è equivalente a un pixel fisico su uno schermo a 160 dpi, che è il   densità di base assunta dal sistema per uno schermo a densità "media".   In fase di esecuzione, il sistema gestisce in modo trasparente qualsiasi ridimensionamento del dp   unità, se necessario, in base alla densità effettiva dello schermo in uso.   La conversione delle 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 fisico   pixel. Dovresti sempre usare le unità dp quando definisci il tuo   interfaccia utente dell'applicazione, per garantire la corretta visualizzazione dell'interfaccia utente con gli schermi   diverse densità.

Riferimento: sito per sviluppatori Android

    
216
2018-11-27 13: 10: 53Z

dp è dip. Usalo per tutto (margine, spaziatura, ecc.).

Utilizza sp solo per {text-size}.


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


Guarda la differenza tra px, dp e sp su diverse dimensioni dello schermo.

Inserisci qui la descrizione dell'immagine

Fonte: Programmazione Android: The Big Nerd Ranch Guide

    
190
2015-08-11 20: 53: 46Z

Ho calcolato la seguente formula per convertire le conversioni da dpi a dp e sp inserisci la descrizione dell'immagine qui

    
135
2017-04-06 10: 24: 04Z
  1. Dovrebbe essere ppi invece di dpi
    2014-01-29 17: 02: 47Z

Definizioni

px o dot è un pixel sullo schermo fisico.

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

Android fornisce nomi alias a diverse densità

  • ldpi (basso) ~ 120 dpi
  • mdpi (medio) ~ 160 dpi
  • hdpi (alto) ~ 240 dpi
    • molti 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à , ovvero corrispondono a più o meno pixel in base alla densità fisica.

  • 1dp = 1px su mdpi

 inserisci la descrizione dell'immagine qui

sp o sip è un pixel indipendente dalla scala . Vengono ridimensionati quando l'opzione Testo di grandi dimensioni è attivata in Impostazioni > Accessibilità

  • 1sp = 1dp
  • 1sp = 1.2dp con Accessibility Large Text

Che cosa usare?

  

Utilizza sp per le dimensioni del testo.

     

Utilizza dp per tutto il resto.

    
128
2016-03-02 09: 39: 05Z

Source 1

Source 2

Source 3 : (dati dalla fonte 3 è indicato 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 su   densità fisica dello schermo. Queste unità sono relative a 160 dpi   (punti per pollice), su cui 1pp è approssimativamente uguale a 1px. quando   in esecuzione su uno schermo a densità più alta, il numero di pixel utilizzati per disegnare   1dp viene ridimensionato di un fattore appropriato per il dpi dello schermo.   Allo stesso modo, quando su uno schermo a densità inferiore, il numero di pixel utilizzati   per 1 dp è ridimensionato. Il rapporto tra dp-to-pixel cambierà con il   densità dello schermo, ma non necessariamente in proporzione diretta. Usando dp   unità (invece di unità px) è una soluzione semplice per rendere la vista   le dimensioni del tuo layout vengono ridimensionate correttamente per lo schermo differente   densità. In altre parole, fornisce coerenza per the nel mondo reale   dimensioni degli elementi dell'interfaccia utente su diversi dispositivi.

     

sp

     

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

     

pt

     

Punti: 1/72 di pollice in base alle dimensioni fisiche dello schermo.

     

px

     

Pixel - Corrisponde ai pixel effettivi sullo schermo. Questa unità di   la misura non è raccomandata in quanto la rappresentazione effettiva può variare   attraverso i dispositivi; ogni dispositivo può avere un numero diverso di pixel per   pollici e potrebbe avere più o meno pixel totali disponibili sullo schermo.

     

mm

     

Millimetri - In base alle dimensioni fisiche dello schermo.

     

     

Pollici - In base alle dimensioni fisiche dello schermo.

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

    
122
2018-11-27 09: 15: 09Z
  1. Inoltre: qual è il valore aggiunto di questa risposta? Non sembra esserci nulla che non sia già stato menzionato in altre risposte.
    2013-12-27 09: 28: 25Z

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

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

Su > 120 dpi, arrotonda a 0.

    
110
2018-03-31 10: 05: 28Z
  1. getDimensionPixelOffset arrotonda, getDimensionPixelSize arrotonda.
    2017-05-28 22: 24: 38Z

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 a uno schermo da 160 dpi, quindi un dp è un pixel su uno schermo da 160 dpi.

Uso di dp:

Indipendenza dalla densità - L'applicazione raggiunge la "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. (cioè) L'immagine dovrebbe avere le stesse dimensioni (non ingrandite o ridotte) 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

    
93
2013-04-02 06: 35: 37Z

Dove usare cosa & relazione tra px e amp; dp?

Pixel indipendente dalla densità (dp)

Un'unità di pixel virtuale che dovresti usare quando definisci il layout dell'interfaccia utente, per esprimere le dimensioni del layout o la posizione in un modo indipendente dalla densità. Come descritto sopra, il pixel indipendente dalla densità è equivalente 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 runtime, il sistema gestisce in modo trasparente qualsiasi ridimensionamento delle unità dp, secondo necessità, in base alla densità effettiva dello schermo in uso. La conversione delle 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 quando si definisce l'interfaccia utente della propria applicazione, per garantire visualizzazione corretta dell'interfaccia utente su schermi con densità diverse.

Comprendere i pixel su dp e viceversa è molto essenziale (specialmente per dare esatti valori 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 dei pixel in numeri pari dal team creativo. Altrimenti, la perdita di precisione avverrà mentre si moltiplica con 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 da un pixel come divisore per tutte le risoluzioni dello schermo.

sp

Usa sp per le dimensioni dei caratteri. Quindi, solo il carattere all'interno dell'applicazione cambierà mentre cambiano le dimensioni dei caratteri del dispositivo (ovvero, Visualizza - > 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 avere questo requisito per alcuni schermi specifici, per questo gli sviluppatori possono usare dp invece di sp. In tutti gli altri casi, è consigliato lo sp.

    
91
2015-06-06 14: 31: 47Z

Puoi vedere la differenza tra px e dp dall'immagine in basso, e puoi anche scoprire che il px e il dp non potrebbero garantire le stesse dimensioni fisiche sui diversi schermi.

inserisci la descrizione dell'immagine qui

    
83
2015-02-13 18: 50: 12Z
  1. @ EnesBattal, penso perché il dp non è una dimensione fisica acuta, è un valore approssimativo. Citando CapTech: "dp - Questa è un'unità indipendente dalla densità, tuttavia la dimensione fisica di un singolo" dp "è approssimativamente la stessa su tutte le densità dello schermo. Ci sono circa 160" dp "in un pollice. sul bucket di densità del dispositivo, viene applicato per convertire "dp" al numero di pixel a 160 dpi. Il numero di pixel che un singolo "dp" si traduce in varia a seconda del pixel sulla densità dello schermo e del bucket di densità che il dispositivo cade in ".
    2015-09-17 14: 12: 16Z
  2. @ RuchirBaronia, penso che il DP o il DIP siano ancora lì dentro apk, perché l'apk non sa con quale tipo di densità dello schermo verrà eseguito ancora, quindi il l'indipendenza del dispositivo dovrebbe essere mantenuta.
    2015-11-25 18: 18: 55Z

Qualsiasi cosa relativa alle dimensioni del testo e dell'aspetto deve usare sp o pt. Mentre tutto ciò che riguarda le dimensioni dei controlli, i layout, ecc. Deve essere usato con dp.

Puoi utilizzare sia dp sia dip al suo posto.

    
74
2015-07-01 14: 30: 11Z

Vorrei usare solo 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 font stupefacente, e l'utente finirà per incolpare l'app , e non le proprie scelte di vita.

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

Sebbene l'idea dei caratteri "sp" abbia un buon cuore, è una pessima idea. Rimani con dp per tutto.

    
65
2015-06-06 14: 42: 19Z
  1. Sai che il fattore di scala font applicato a sp è un fattore, giusto? Nullaquello riguarda dp interesserà anche sp. Detto questo, è comunque preferibile specificare le dimensioni dei caratteri utilizzando dp anziché sp se il layout è molto stretto e le dimensioni più grandi non si adattano, meglio avere un testo più piccolo di quello che l'utente desidera che un layout completamente incasinato. Ma in prima istanza dovresti sempre sforzarti di rispettare la preferenza della dimensione del carattere dell'utente - anche l'impostazione più grande non è così grande.
    2017-02-26 22: 06: 15Z

sp = pixel indipendente dalla scala

dp = dip = pixel indipendenti dalla densità

dpi = punti per pollice

  

Evitiamo 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-alto) ~ 640 dpi

Un dispositivo ldpi da 120 dpi ha 120 pixel in 1 pollice.

Lo stesso per altre densità ...

Noi come ingegneri del software dovremmo usare questa formula di conversione:

  

pixel = dp * (density /160)

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

Il 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();
    
61
2018-07-27 07: 02: 15Z
  1. Un ottimo tutorial per la comprensione è: http: /vinsol.com/blog/2014/11/20/tips-for-designers-from-a-developer
    2015-03-16 10: 06: 05Z
  2. "Dovremmo evitare di usare sp" Perché è così? Dovresti usare sp quando hai a che fare con le dimensioni dei caratteri perché tiene conto delle dimensioni del testo preferite dall'utente, developer.android.com/training/multiscreen/screendensities.html
    2015-03-20 10: 05: 57Z
  3. Ho risposto relativamente alla prospettiva del layout. Si prega di leggere sul link fornito "quindi è necessario utilizzare questa unità di misura quando si definiscono le dimensioni del testo (ma mai per le dimensioni del layout). "
    2015-03-20 10: 22: 31Z
  4. La domanda era "Differenza tra px, dp, dip e sp in Android?" la tua risposta diceva "dovremmo evitare di usare sp". Non è stata menzionata la "prospettiva di layout" ovunque.
    2015-03-20 10: 28: 32Z
  5. Sì .. dp e dip sono uguali ... usati in modo intercambiabile ... La mia risposta risolve la tua domanda?
    2015-11-24 06: 36: 23Z

La differenza tra le unità dp e sp menzionate come " preferenza per la dimensione del carattere dell'utente " dalle risposte copiate dalla documentazione ufficiale può essere vista in fase di esecuzione modificando l'opzione Settings->Accessibility->Large Text.

L'opzione Large Text impone al testo di diventare 1.3 volte più grande.

 
private static final float LARGE_FONT_SCALE = 1.3f;

Questo potrebbe essere ovviamente dipendente dal fornitore poiché si trova in pacchetti /app /Impostazioni .

    
58
2013-10-14 08: 44: 10Z

dpi -

  • Punti per pollici
  • Misurazione della densità dei pixel dello schermo.

px - pixel

  • Per mapixel dello schermo popping

pt - points

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

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

mm- mm  - in relazione alle dimensioni dello schermo fisico.

sp - pixel indipendente dalla scala.

  • In base alla preferenza per la 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 a 160 dpi, 1 dp = 1 pixel.
  • Utilizza dp tranne la dimensione del carattere del testo.

In standard, vengono utilizzati dp e sp. sp per dimensione 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  
    
50
2015-11-24 08: 32: 41Z
  1. Come da documentazione Il compilatore accetta sia "dip" che "dp", sebbene "dp" sia più coerente con "sp".
    2015-11-24 08: 15: 46Z

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_ *".

  • 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-alto) ~ 640 dpi

Tratto da qui .

Questo risolve un sacco di confusione quando si traduce tra px e dp, se si conosce la risoluzione dello schermo.

Quindi, supponiamo di volere un'immagine di 60 dp per uno schermo hdpi, quindi la dimensione fisica del pixel di 60 dp è:

 
px = 60 * (240 / 160)
    
43
2018-03-09 06: 24: 59Z

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

  • dp: Pixel indipendente dalla densità, varia in base alla densità dello schermo. Nello schermo 160 dpi, 1 dp = 1 pixel. Ad eccezione delle dimensioni del carattere, usa sempre dp.
  • dip: dip == dp. Nelle versioni precedenti di Android è stato utilizzato dip e successivamente è stato modificato in dp.
  • sp: Pixel indipendente dalla scala, 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, in relazione alle dimensioni dello schermo fisico.
  • mm: millimetri, in relazione alle dimensioni dello schermo fisico.
  • pt: 1/72 di pollice, rispetto alle dimensioni dello schermo fisico.

Formula per la conversione tra le unità

 
 px = dp * (dpi / 160)

Da dp a px nel dispositivo

L'esempio seguente può aiutare a capire meglio. Il ridimensionamento si verifica in base alla dimensione del bucket di 120 (ldpi), 160 (m dpi), 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 150px X 150px occuperà,

  
  • 150 dp X 150 spazio dello schermo dp in mdpi
  •   
  • Spazio dello schermo di 100 dp X 100 dp in hdpi
  •   
  • 75 dp X 75 spazio dello schermo dp in xhdpi
  •   

Puoi utilizzare il seguente calcolatore DPI per correggere le dimensioni dell'immagine e altre dimensioni quando desideri avere un design dell'interfaccia utente uniforme in tutti i dispositivi Android.

DPI Calculator 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 /differenza-tra-dp-dip-sp-px-in-mm-pt-in-android /

    
43
2018-03-28 10: 24: 14Z
  • px - un pixel, uguale a ciò che viene utilizzato in CSS, JavaScript, ecc.
  • sp - pixel indipendenti dalla scala
  • dip - pixel indipendenti dalla densità

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

    
42
2015-06-06 14: 41: 25Z

Leggi la risposta dal wiki della comunità. Di seguito sono riportate alcune informazioni da considerare in aggiunta alle risposte di cui sopra.

sp = pixel indipendente dalla scala

dp = pixel indipendenti dalla densità

dpi = pixel di densità

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

sp prende il testo del dispositivo, mentre dp prende quello dello standard di densità del dispositivo (non cambia mai in un dispositivo) Il testo 100sp può occupare l'80% dello schermo o il 100% dello schermo a seconda della dimensione del carattere impostata nel dispositivo

 inserisci la descrizione dell'immagine qui

Puoi usare sp anche per i confini del layout, funzionerà :) Nessuna app standard utilizzata per tutto il testo

Usa sp e dp per le dimensioni del testo considerando UX.

  • Non usare sp per il testo nella barra degli strumenti (puoi usare le dimensioni di Android disponibili per diverse dimensioni dello schermo con dp)
  • Non usare lo sp per il testo in piccoli pulsanti limitati, testo molto più piccolo, ecc.

Alcune persone usano una dimensione FONT enorme nel loro telefono per una maggiore leggibilità, dando loro un testo di dimensioni ridotte con hardcoded sarà un problema di UX. Metti sp per il testo dove necessario, ma assicurati che non interrompa il layout.

Allo stesso modo, se hai una singola app che supporta tutte le dimensioni, l'aggiunta di asset xxxhdpi aumenta molto la dimensione dell'app. Ma ora i telefoni xxxhdpi sono comuni, quindi dobbiamo includere atlante xxxhdpi per le icone nella barra laterale, nella barra degli strumenti e nella barra in basso. È meglio passare alle immagini vettoriali per ottenere immagini uniformi e di qualità migliore per tutte le dimensioni dello schermo.

Nota anche che le persone usano caratteri personalizzati nel loro telefono. Quindi la mancanza di un font può causare problemi di spaziatura e tutto. Le dimensioni del testo di 12sp per un carattere personalizzato potrebbero richiedere alcuni pixel in più rispetto al carattere predefinito.

Consulta il sito per gli sviluppatori di google per screendensità e dettagli di base per Android. https://developer.android.com/training/multiscreen/screendensities

    
38
2019-05-16 10: 37: 03Z

Ho trovato un buon articolo sulla progettazione dell'interfaccia utente delle app Android per risoluzioni dello schermo diverse, 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 precedenti), l'ho letto ma non è stato buono 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 ho bisogno di implementare un layout di interfaccia utente "flessibile" per schermi diversi. (Ehi sviluppatori iOS - sì, hai ragione è il concetto Storyboard).

Android non ha un cattivo concetto di interfaccia utente, ma sfiora le caratteristiche di iOS Storyboard, sfortunatamente. 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 diverse dimensioni dello schermo:

Blog JMSTUDIO: - Decidi le dimensioni dello schermo dell'app Android

  

Come progettare l'interfaccia utente per le app Android per diverse dimensioni dello schermo

     

Per progettare un'interfaccia utente dell'app per diverse dimensioni dello schermo, il nostro progetto iniziale deve   soddisfare uno spazio minimo richiesto per ogni dimensione dello schermo. Android definisce a   dimensione minima (in dp) per ogni tipo di schermo generalizzato. Quiè un   Linea guida per le dimensioni dello schermo Android.    Dimensione minima dello schermo per Android in dp   Quando otteniamo le dimensioni dello schermo in dp, non è sufficiente per noi progettare   l'interfaccia utente dell'app Android. Per ogni dimensione dello schermo, abbiamo bisogno di preparare la grafica   e immagini bitmap per ogni densità. Ecco una densità dello schermo Android   orientamento.    Android Density Guideline (dpi)

     

Per facilitare il calcolo, possiamo seguire il rapporto di scala 3: 4: 6: 8 tra   le quattro densità generalizzate. Se creiamo un'immagine di 36 × 36 pixel per   dispositivo ldpi, la dimensione delle immagini della densità di riposo sarà 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 con la progettazione dell'interfaccia utente di app Android in Photoshop o in altri pixel   strumenti di progettazione grafica basati sull'unità indipendente dalla densità, dp.   I progettisti non sanno come mappare da dp a pixel. Google inoltre non dà   una chiara guida alla progettazione dell'interfaccia utente Android per loro, anche se forniscono una base   formula per la conversione di dp e pixel.

     

Come definizione di Android, 1pd uguale a 1px sotto il dispositivo 160 dpi (mdpi).   Quindi vogliamo progettare un'app Android per il dispositivo Android xlarge con   densità mdpi, possiamo definire la nostra dimensione dell'interfaccia utente in pixel con una larghezza di 960 pixel   e 720px in altezza; Seguiamo la stessa regola di mappatura, possiamo ottenere   seguendo le linee guida per la progettazione delle interfacce per le app delle applicazioni Android:

     

 Dimensione schermo app Android in linea guida pixel

AGGIUNTA : se sei interessato anche all'interfaccia utente "flessibile", dai un'occhiata a questa libreria: Un SDK Android che fornisce una nuova unità di misura: sdp (dp scalabile). Questa unità di misura scala con le dimensioni dello schermo (questo anche citato in una risposta qui, sulla libreria SDP)

ADDED2 Google ha finalmente compreso l'utilità del concetto di interfaccia utente dello Storeboard iOS, e qui va ConstraintLayout per il mondo Android: Crea un'interfaccia utente reattiva con ConstraintLayout

    
36
2018-09-14 15: 03: 37Z

1) dp: (density independent pixels)

Il numero di pixel rappresentati in una unità di dp aumenterà all'aumentare della risoluzione dello schermo (quando si hanno più punti /pixel per pollice). Al contrario su dispositivi con risoluzione inferiore, il numero di pixel rappresentati nell'unità di dp diminuirà. Poiché si tratta di un'unità relativa, deve essere confrontata con 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à si ridimensiona in base allo schermo dpi (simile a dp) e alle preferenze per le dimensioni dei caratteri dell'utente.


3) px: (pixels)

Pixel o punti effettivi sullo schermo.

Per ulteriori dettagli puoi visitare

  

Guida per gli sviluppatori Android > Dimensione
Guida per gli sviluppatori Android > Schermate

    
29
2018-04-02 13: 58: 40Z

Le dimensioni dello schermo in Android sono raggruppate nelle categorie ldpi, mdpi, hdpi, xhdpi, xxhdpi e xxxhdpi. Densità dello schermo è la quantità di pixel all'interno di un'area (come in 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 è inteso per i 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 è stato modificato in dp. Questa è un'alternativa di px.

  • Generalmente non usiamo mai il px perché è un valore assoluto. Se usipx per impostare larghezza o altezza, e se l'applicazione viene scaricata in dispositivi di dimensioni diverse dello schermo, la vista non si allungherà secondo le dimensioni originali dello schermo.

  • Si consiglia vivamente di utilizzare dp al posto di px. Usa dp se vuoi menzionare larghezza e altezza per crescere & riduci dinamicamente in base alle dimensioni dello schermo.

  • se diamo dp/dip, Android calcolerà automaticamente la dimensione in 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 citano le dimensioni dei caratteri per adattarsi a varie dimensioni dello schermo, usare sp. Questo è simile a dp. Utilizzare sp specialmente per le dimensioni dei caratteri per crescere e amp; riduci dinamicamente in base alle dimensioni dello schermo

La documentazione di Android dice:

  

quando si specificano le dimensioni, utilizzare sempre le unità dp o sp. A dp è   un pixel indipendente dalla densità che corrisponde alla dimensione fisica di a   pixel a 160 dpi. Un sp è la stessa unità base, ma è ridimensionato dal   la dimensione del testo preferita dall'utente (è un pixel indipendente dalla scala), quindi tu   dovrebbe usare questa unità di misura quando si definiscono le dimensioni del testo

    
28
2015-10-07 08: 47: 56Z

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

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

Il pixel indipendente dalla densità (dp o dip) consente al progettista di creare risorse che appaiono in modo prevedibile, 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

Punti per pollice (dpi) è una misura della nitidezza (ovvero la densità dei punti illuminati) su uno schermo. I punti per pollice per una determinata risoluzione dell'immagine variano in base alle dimensioni complessive 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 si hanno due dispositivi con la stessa risoluzione in pixel, ma con una quantità di spazio diversa. Supponiamo che, in un caso, un tablet e un telefono abbiano la stessa risoluzione di 1280 per 800 pixel (160 dpi) e 800 per 1280 pixel (320 dpi) rispettivamente.

Ora, dato che un tablet è alla densità di base (160 dpi), le dimensioni dei pixel indipendenti fisici e di densità sono le stesse, 1280 per 800. Il telefono invece ha una densità di pixel più alta, quindi ha meno della metà di densità indipendente pixel come pixel fisici. Quindi un telefono ha i pixel indipendenti dalla densità di 400 per 640. Quindi, utilizzando un pixel indipendente dalla densità, è 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 una densità di pixel diversa, ad esempio uno è 800 per 1280 pixel (320 dpi) e l'altro è 400 per 640 pixel (160 dpi), non è necessario per definire layout completamente 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)

Scala pixel indipendenti (sp) è l'unità preferita per le dimensioni del carattere. Per motivi di accessibilità, Android consente agli utenti di personalizzare le dimensioni del carattere del dispositivo. Gli utenti che hanno difficoltà a leggere il testo possono aumentare la dimensione del carattere del dispositivo. Normalmente puoi trovare questa opzione nelle impostazioni del display del tuo telefono o tablet con le dimensioni del carattere. Spesso è anche disponibile 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 100%. Ma quando la dimensione del carattere del dispositivo è large, ad esempio 125%, 16 sp si tradurrà in 20 dp o 1,25 volte 16.

Se si utilizza dp come unità per le dimensioni del carattere, allora quella parte di testo ha una dimensione fisica specifica, indipendentemente dal fatto che l'utente abbia la dimensione del carattere del dispositivo personalizzata. L'uso delle unità sp renderà un'esperienza migliore per le persone con problemi alla vista.

Riferimento : Udacity , Google

    
21
2017-10-18 05: 31: 24Z
  

sp: pixel indipendente dalla scala

Dovresti usarlo con i testi perché viene ridimensionato automaticamente in base alla dimensione del font che viene utilizzata dall'utente nel suo dispositivo.

  

px: pixel o elemento immagine è il singolo punto sullo schermo

    
17
2018-03-09 08: 59: 48Z

Prima di rispondere a questa domanda fammi ridurre il numero di unità prima. Quindi ecco qua: dp o dip sono entrambi uguali e sono noti come pixel indipendenti dalla densità .

1. px - indica i pixel. I pixel sono un singolo punto, punto su uno schermo. Generalmente nel settore della telefonia mobile è misurato in ppi (pixel per pollice). La risoluzione dello schermo è direttamente proporzionale a ppi, maggiore è il numero di pixel per pollice più alta è la risoluzione dello schermo.

Ad esempio, se disegni un'immagine di una dimensione 200 px * 200 px , il suo aspetto deve essere diverso su un dispositivo ad alta risoluzione rispetto a un basso dispositivo di risoluzione. Il motivo è che un'immagine di 200 px su un telefono a bassa risoluzione sarà più grande rispetto a un dispositivo ad alta risoluzione.

Le immagini sottostanti mostrano una risoluzione della stessa immagine su diversi telefoni -

  • Telefono con risoluzione dello schermo elevata ​​strong>

     Inserisci la descrizione dell'immagine qui

  • Telefono con bassa risoluzione dello schermo

     Inserisci la descrizione dell'immagine qui

2. dip o dp - un'unità astratta che si basa sulla densità fisica dello schermo. Queste unità sono relative a una schermata 160 dpi, quindi un dp è un pixel su una schermata 160 dpi. Il rapporto tra dp-to-pixel cambierà con la densità dello schermo, ma non necessariamente in proporzione diretta. "Indipendenza dalla densità" si riferisce alla visualizzazione uniforme degli elementi dell'interfaccia utente su schermi con densità diverse.

  • Immagine che mostra 80px (immagine lato sinistro) e 80 dp (immagine lato destro) . Differenza di controllo.

 Inserisci la descrizione dell'immagine qui

Un dp è uguale a un pixel fisico su uno schermo con una densità di 160 . Per calcolare dp:

dp = (larghezza in pixel * 160) /densità dello schermo

3. sp - indica i pixel scalabili. Generalmente sp viene utilizzato per i testi sull'interfaccia utente e sp mantiene le impostazioni dei caratteri. Ad esempio, se un utente ha selezionato un carattere più grande di 30 sp , verrà ridimensionato automaticamente in base alle preferenze dell'utente.

    
14
2017-12-07 17: 58: 56Z
  1. hai confuso il Phone with low screen resolution con l'immagine appropriata ​​div>
    2017-12-04 12: 30: 52Z
  2. @ RoyiNamir Potresti spiegare il tuo commento o, se possibile, suggerire di modificare
    2017-12-07 13: 23: 30Z
  3. questo è un telefono con una risoluzione elevata. non basso: i.imgur.com/tnu87VR.jpg
    2017-12-07 13: 24: 34Z

Voglio fornire un modo semplice per capire dp. In effetti, penso che il dp sia il più facile da capire. dp è solo un'unità di lunghezza fisica. È della stessa dimensione di mm o inch. Per noi è semplicemente conveniente scrivere 50dp, 60dp anziché 50/160 inch o 60/160 inch, perché un dp è solo 1/160 inch qualunque sia la dimensione o la risoluzione dello schermo.

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 del calcolo di dp è sfocato. Dovrebbe essere all'incirca lo stesso di 1/160 inch.

    
13
2016-04-02 03: 35: 21Z

SDP : un'unità di dimensioni scalabili, in pratica non è un'unità, ma risorse di dimensioni per diverse dimensioni dello schermo.

Prova la sdp libreria di Intuit. È molto utile per risolvere i problemi di unità e puoi supportare rapidamente più schermi .

Uso

android:paddingBottom="@dimen/_15sdp" per positivo e android:layout_marginTop="@dimen/_minus10sdp" per sdp sdp negativo

Ha un valore equivalente in dp per ogni dimensione nelle cartelle values-sw<N>dp (sw = smallestWidth).

Attenzione

Usalo con attenzione! Nella maggior parte dei casi è ancora necessario progettare un layout diverso per i tablet.

Esempio

 
<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>

Puoi utilizzare db per le dimensioni del testo, ma preferisco ssp per le dimensioni del testo.

Per ulteriori dettagli, consulta la pagina GitHub della libreria .

    
13
2017-10-18 05: 26: 33Z
fonte posta Qui