Qual è la differenza tra “px”, “dip”, “dp” e “sp”?

StackOverflow https://stackoverflow.com/questions/2025282

Domanda

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

  • px
  • immersione
  • d.p
  • sp
È stato utile?

Soluzione

Android Developer Documentation :

  1.   

    px
       Pixel -. Corrisponde ai pixel effettivi sullo schermo

  2.   


       pollici -. in base alla dimensione fisica dello schermo
      1 pollice = 2,54 centimetri

  3.   

    mm
       Millimetri -. In base alla dimensione fisica dello schermo

  4.   

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

  5.   

    DP o dip
       Densità -indipendenti Pixel - un'unità di astratto che si basa sulla densità fisica dello schermo. Queste unità sono relativi ad un 160       schermo dpi, quindi uno dp è un pixel su uno schermo dpi 160. Il rapporto di       dp-per-pixel cambia con la densità degli schermi, ma non necessariamente       in proporzione diretta. Nota: Il compilatore accetta sia "dip" e       "Dp", però "dp" è più coerente con "sp".

  6.   

    sp
       Scala -indipendenti Pixel - questo è come l'unità dp, ma viene ridimensionato anche di preferenza la dimensione del carattere dell'utente. Esso si è raccomandato       usare questa unità per specificare le dimensioni dei caratteri, quindi verranno regolati       sia per la densità degli schermi e la preferenza dell'utente.

intesa Densità Indipendenza 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      |               |             |                    | 
+---------+-------------+---------------+-------------+--------------------+

Maggiori informazioni possono essere anche essere trovato nel Google design Documentazione .

Altri suggerimenti

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

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

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

Orientamento
L'orientamento dello schermo dal punto di vista dell'utente vista.Questo è orizzontale o verticale, il che significa che lo schermo Il rapporto d'aspetto è rispettivamente largo o alto.Tieni presente che non dispositivi diversi funzionano solo con orientamenti diversi predefinito, 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 lo fanno non lavorare direttamente con la risoluzione;dovrebbero riguardare solo con le dimensioni e la densità dello schermo, come specificato dal gruppi di dimensioni e densità.

Pixel indipendenti dalla densità (dp)
Un virtuale pixel da utilizzare quando si definisce il layout dell'interfaccia utente, per esprimere dimensioni o posizione del layout in modo indipendente dalla densità.Il pixel indipendente dalla densità è equivalente a un pixel fisico su un 160 dpi, che è la densità di base assunta dal sistema per un Schermo a densità "media".In fase di esecuzione, il sistema gestisce in modo trasparente Eventuale ridimensionamento delle unità DP, 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 pixel fisici.Dovresti sempre usare le unità dp quando definendo l'interfaccia utente dell'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 aver letto almeno una volta il documento di sviluppo del supporto delle schermate.Oltre a ciò, è sempre bene conoscere il numero effettivo di dispositivi attivi che presentano una particolare configurazione dello schermo.

I dilungherò di più su come fa esattamente dp converte in px:

  • Se in esecuzione su un dispositivo MDPI, un'immagine 150 x 150 px occuperà 150 * 150 dp di spazio sullo schermo.
  • Se in esecuzione 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.

Il contrario: dire, si desidera aggiungere un'immagine al tuo applicazione e avete bisogno di riempire un controllo 100 * 100 dp. Avrai bisogno di creare immagini di dimensioni diverse per dimensioni dello schermo supportate:

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

px Pixel -. Punto a scala corrisponde ai pixel effettivi sullo schermo

in Pollici -. In base alla dimensione fisica dello schermo

mm Millimetri -. In base alla dimensione fisica dello schermo

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

dp Densità - Pixel indipendenti - un'unità di astratto che si basa sulla densità fisica dello schermo. Queste unità sono relative a uno schermo dpi 160, così uno dp è un pixel su uno schermo dpi 160. Il rapporto di dp-per-pixel cambia con la densità degli schermi,  ma non necessariamente in proporzione diretta.  Nota:. Il compilatore accetta sia dip e dp, anche se dp è più coerente con sp

sp Pixel -scale indipendente - questo è come l'unità dp,  ma è anche scalato di preferenza la dimensione del carattere dell'utente. Si consiglia di utilizzare questa unità quando si specifica le dimensioni dei caratteri,  in modo che saranno modificate sia per la densità degli schermi e la preferenza dell'utente.

Prendiamo l'esempio di due schermi che sono le stesse dimensioni, ma si ha una densità di 160 dpi schermata (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

Inoltre dovresti avere una chiara comprensione dei seguenti concetti:

Dimensione dello schermo:

Dimensioni fisiche effettive, misurate 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:

La quantità di pixel all'interno di un'area fisica dello schermo;solitamente indicato come dpi (punti per pollice).Ad esempio, un lo schermo a "bassa" densità ha meno pixel all'interno di una data area fisica, rispetto a uno schermo ad alta densità "normale" o "alta".Per semplicità, Android raggruppa tutte le densità effettive dello schermo in quattro Densità:basso, medio, alto e molto alto.

Orientamento:

L'orientamento dello schermo dal punto di vista dell'utente.Questo può essere orizzontale o verticale, il che significa che il Le proporzioni dello schermo sono rispettivamente larghe o alte.Sii consapevole che non solo dispositivi diversi funzionano con orientamenti diversi 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;applicazioni dovrebbero riguardare solo lo schermo dimensione e densità, come specificato dalla dimensione e dalla densità generalizzate Gruppi.

Pixel indipendenti dalla densità (dp):

Un'unità pixel virtuale da utilizzare durante la definizione del layout dell'interfaccia utente, per esprimere le dimensioni del layout o posizione in 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 dp fisici Pixel.Dovresti sempre usare le unità dp quando definisci il tuo dell'interfaccia utente dell'applicazione, per garantire la corretta visualizzazione dell'interfaccia utente sugli schermi con diverse densità.

Riferimento: Sito per sviluppatori Android

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

Usa sp per {text-size} solo.

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

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

Inserire descrizione dell'immagine qui

Fonte: programmazione Android: The Big Nerd Ranch Guida

Ho calcolato la formula sottostante per effettuare la conversione dpi per dp e sp entrare image description qui

Definizioni

px o un punto è 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) ~ 120dpi
  • MDPI (media) ~ 160dpi
  • hdpi (alto) ~ 240 dpi
    • maggior parte dei dispositivi nel 2015 sono qui
  • xhdpi (extra-alto) ~ 320dpi
    • di Apple iPhone 4/5/6, Nexus 4
  • xxhdpi (extra-extra-alto) ~ 480dpi
    • Nexus 5
  • xxxhdpi (extra-extra-extra-alto) ~ 640dpi

dip o dp sono pixel densità-indenpendant , cioè corrispondono a più o meno pixel in funzione della densità fisica.

  • 1DP = 1px su MDPI

entrare descrizione dell'immagine qui

sp o SIP è un scala-indipendente pixel . Essi sono in scala quando il Testo grande opzione è attiva in Impostazioni > Accessibilità

  • 1sp = 1DP
  • 1sp = 1.2dp con l'accessibilità Testo grande

Cosa usare?

  

Usa sp per la dimensione del testo.

     

Usa DP per tutto il resto.

Sorgente 1

Sorgente 2

Fonte 3 : (i dati dalla sorgente 3 si riporta di seguito)

  

Si tratta di 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 supportati da Android:

     

DP

     

I pixel indipendenti dalla densità - Un'unità astratto che si basa sulla   densità fisica dello schermo. Queste unità sono relativi ad un 160 dpi   (punti per pollice) dello schermo, sul quale 1DP è approssimativamente uguale a 1px. quando   in esecuzione su uno schermo più alta densità, il numero di pixel utilizzati per disegnare   1DP è scalato di un fattore appropriato per dpi dello schermo.   Analogamente, quando su uno schermo densità inferiore, il numero di pixel usati   per 1DP è ridimensionato. Il rapporto di dp-per-pixel cambia con la   la densità dello schermo, ma non necessariamente in proporzione diretta. utilizzando dp   unità (invece di unità px) è una soluzione semplice per rendere la vista   dimensioni nel layout ridimensionano correttamente per schermo diverso   densità. In altre parole, fornisce consistenza per il mondo reale   dimensioni dei vostri elementi dell'interfaccia utente su dispositivi differenti.

     

sp

     

I pixel indipendenti dalla scala - Questo è come l'unità dp, ma è anche   in scala di preferenza la dimensione del carattere dell'utente. Si consiglia di utilizzare   questa unità quando si specificano le dimensioni dei caratteri, quindi sarà aggiustato per   sia la densità dello schermo e le preferenze dell'utente.

     

pt

     

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

     

px

     

Pixel - corrispondenti a pixel effettivi sullo schermo. Questa unità di   misura non è raccomandato perché la rappresentazione effettiva può variare   dispositivi attraverso; ciascun dispositivo possono avere un diverso numero di pixel per   pollici e può avere più o meno pixel totali disponibili sullo schermo.

     

mm

     

Millimetri - In base alle dimensioni fisiche dello schermo

.      

     

Inches -. In base alle dimensioni fisiche dello schermo

Nota: Una dimensione è una semplice risorsa a cui fa riferimento utilizzando il valore fornito nel attributo name (non il nome del file XML). Come tale, è possibile combinare le risorse di quota con altre risorse semplici in un unico file XML, sotto un unico elemento.

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

On> 160 dpi, è possibile ottenere 2-3 pixel,

On> 120 dpi, si arrotonda a 0.

px

Pixel - corrisponde ai pixel effettivi sullo schermo

.

DP o dip

I pixel indipendenti dalla densità - un'unità di astratto che si basa sulla densità fisica dello schermo. Queste unità sono relative a uno schermo dpi 160, così uno dp è un pixel su uno schermo dpi 160.

Utilizzo di dp:

Densità indipendenza - Propria applicazione ottiene “indipendenza densità” quando si conserva la dimensione fisica (dal punto di vista dell'utente) degli elementi dell'interfaccia utente, se visualizzato su schermi di diversa densità. (Ie) L'immagine dovrebbe apparire le stesse dimensioni (non ingrandita o accartocciati) in vari tipi di schermi.

sp

Pixel Scala indipendente - questo è come l'unità dp, ma viene ridimensionato anche di preferenza la dimensione del carattere per l'utente

.

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

Dove utilizzare ciò che & rapporto tra px & DP?

pixel indipendenti dalla densità (dp)

Un'unità pixel virtuale si dovrebbe usare quando definire layout dell'interfaccia utente, per esprimere quote di layout o posizione in modo densità-indipendente. Come descritto sopra, la densità di pixel-indipendente è equivalente a un pixel fisico su uno schermo dpi 160, che è la densità basale assunta dal sistema per un retino a densità "medium". 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).

Per esempio, su uno schermo dpi 240, 1 dp è uguale a 1,5 pixel fisici. Si dovrebbe sempre usare le unità dp al momento della definizione dell'interfaccia utente dell'applicazione, per garantire corretta visualizzazione della vostra interfaccia utente su schermi con densità diverse.

pixel intesa per DP e viceversa è molto essenziale (soprattutto per aver dato i valori esatti da DP 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
  • Cercare di ottenere tutti i valori dei pixel in numero pari da parte del team creativo. In caso contrario, la precisione perdere accadrà mentre moltiplicando con 0,5.

px

Si è spiegato sopra. Cercate di evitare in file di layout. Ma ci sono alcuni casi in cui è richiesta px. per esempio, la linea ListView divisore. px è meglio qui per dare una linea da un pixel come un divisore per tutta risoluzioni.

sp

Usa SP per le dimensioni dei caratteri. Solo allora il tipo di carattere all'interno dell'applicazione cambierà mentre le variazioni dei caratteri dispositivo dimensioni (cioè, Display -> Caratteri sul dispositivo). Se si desidera mantenere un carattere statico dimensioni dentro l'applicazione, si può dare la dimensione del carattere in dp. In tal caso, non potrà mai cambiare. Sviluppatori possono ottenere un tale requisito per alcuni schermi specifici, per questo, gli sviluppatori possono utilizzare dp anziché sp. In tutti gli altri casi, si raccomanda sp.

Si può vedere la differenza tra px e dp dalla foto qui sotto, e si può anche trovare che la px e dp non potevano garantire le stesse dimensioni fisiche sui diversi schermi.

entrare descrizione dell'immagine qui

Tutto ciò in relazione con le dimensioni del testo e l'aspetto devono utilizzare sp o pt. Considerando che, tutto ciò che riguarda la dimensione dei controlli, i layout, ecc deve essere utilizzata con dp.

È possibile utilizzare sia dp e dip ai suoi luoghi.

Vorrei usare solo dp.

C'è un gran parlare su come utilizzare "sp" per le dimensioni dei caratteri, e mentre apprezzo il punto, non credo che sia la cosa giusta da fare dal punto di vista del design. Si può finire per rompere il vostro disegno se l'utente ha un po 'di selezione dimensione del carattere wonky, e l'utente finirà per incolpare l'applicazione , e non le proprie scelte di vita.

Inoltre, se si prende un app sp-font su una tavoletta dpi 160, troverete che tutto scale ... ma il tipo di carattere, che sta andando a guardare molto piccolo in confronto. Non è una buona occhiata.

Mentre l'idea di font "sp" ha un buon cuore, è una cattiva idea. Bastone con dp per tutto.

sp = pixel scale indipendente

dp = dip = densità pixel indipendenti

dpi = punti per pollice

  

Dovremmo evitare di utilizzare sp .

     

Si dovrebbe usare DP per supportare schermi multipli.

Android supporta diverse risoluzioni dello schermo

  • ldpi (basso) ~ 120 dpi
  • MDPI (media) ~ 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 120 dp ha 120 pixel di dimensione 1 pollice.

Lo stesso per altre densità ...

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

  

pixel = dp * (densità / 160)

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

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

Usando questa conoscenza 1,5 e 3 pixel, un ingegnere del software in grado di progettare layout per differenti densità.

Per controllare 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 le unità dp e sp indicate come " preferenza dimensione del carattere dell'utente " con le risposte copiati da documentazione ufficiale può essere visto in fase di esecuzione opzione Settings->Accessibility->Large Text cambiando.

opzione forza Large Text testo per diventare volte 1.3 più grande. 

private static final float LARGE_FONT_SCALE = 1.3f;

Questo potrebbe essere ben naturalmente venditore dipendente in quanto si trova in pacchetti / apps / impostazioni .

DPI -

  • Punti per pollici
  • La misurazione della densità di pixel dello schermo.

px - pixel

  • Per i pixel dello schermo mappatura

pt - punti

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

in - pollici  -. Rispetto alla dimensione fisica dello schermo (1 pollice = 2,54 cm)

mm- mm  -. Per quanto riguarda la dimensione dello schermo fisico

sp -. Pixel scala indipendente

  • Sulla base di preferenza gli utenti dimensione del carattere.
  • font dovrebbe essere in 'st'.

dip -

  • dip == dp
  • densità di pixel indipendenti.
  • E 'varia in base alla schermata Densità.
  • Nella schermata 160 dpi, 1 dp = 1 pixel.
  • Usa dp tranne la dimensione del carattere del testo.

In di serie, DP e sp vengono utilizzati. sp per 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 usata da Android:

  

= px dp * (dpi / 160)

Dove dpi è uno dei seguenti densità dello schermo. Per un elenco di tutti i possibili densità andare qui

Si definisce il "DENSITY_ *" costanti.

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

qui .

In questo modo risolvere un sacco di confusione nella traduzione tra px e dp, se si conosce il dpi schermo.

Quindi, diciamo che si desidera un'immagine di 60 DP per uno schermo hdpi allora la dimensione dei pixel fisica di 60 dp è: 

px = 60 * (240 / 160)

Dimensioni dello schermo in Android sono raggruppate in categorie small, medium, large, extra large, double-extra e triple-extra. densità degli schermi è la quantità di pixel in uno spazio (come pollici) dello schermo. In generale si è misurata in punti per pollice (dpi). La densità degli schermi è raggruppato come bassa, media, alta e altissima. La risoluzione è il numero totale di pixel sullo schermo.

  • DP: densità di pixel indipendente, varia in base alla densità dello schermo. Nella schermata 160 dpi, 1 dp = 1 pixel. Fatta eccezione per la dimensione del carattere, utilizzare dp sempre.
  • dip: dip == dp. Nelle versioni precedenti di Android tuffo è stato utilizzato e più tardi cambiato in dp.
  • SP: Scala Pixel indipendente, scalato in base alle preferenze dimensione del carattere dell'utente. Caratteri dovrebbero usare sp.
  • px:. il nostro solito standard pixel che associa al pixel dello schermo
  • in:. pollici, rispetto alle dimensioni dello schermo fisico
  • mm:. millimetri, rispetto alla dimensione fisica dello schermo
  • pt:. a 1/72 di pollice, per quanto riguarda la dimensione dello schermo fisico

Formula per la conversione tra le Unità 

 px = dp * (dpi / 160)

dp a Px dispositivo

A seguito di esempio può aiutare a capire meglio. La scalatura avviene in base alle dimensioni della benna di 120 (ldpi), 160 (MDPI), 240 (hdpi), 320 (xhdpi), 480 (xxhdpi) e 640 (xxxhdpi). Google ha suggerito il rapporto per la progettazione è 3: 4: 6: 8: 12 per ldpi: MDPI: hdpi: xhdpi: xxhdpi

Un'immagine 150px X 150px occuperà,

  
      spazio sullo schermo
  • 150 dp X 150 dp in MDPI
    •   spazio sullo schermo
  • 100 dp X 100 dp in hdpi
    •   
  • 75 dp X 75 dp spazio dello schermo in xhdpi
    •   

È possibile utilizzare il seguente calcolatrice DPI per risolvere i vostri dimensioni delle immagini e altre dimensioni quando si desidera avere un design di 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 seguente link.

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

  • px -. Un pixel, proprio come a quello usato nei CSS, JavaScript, etc
  • sp - pixel indipendenti dalla scala
  • dip - indipendenti dalla densità pixel

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

Si prega di leggere la risposta dalla comunità wiki. Di seguito alcune informazioni da considerare in aggiunta alle risposte di cui sopra.

sp = pixel scale indipendente

dp = densità pixel indipendenti

dpi = pixel densità

Ho passato con le risposte di cui sopra ... non trovare esattamente corretto. sp per la dimensione del testo, DP per limiti di layout - standard. Ma sp per la dimensione del testo si romperà il layout se usato incautamente nella maggior parte dei dispositivi.

sp prendere il TEXTSIZE del dispositivo, mentre dp prendere quella dello standard di densità dispositivo (mai cambiare in un dispositivo) Say testo 100SP can occupa 80% di uno schermo o 100% di uno schermo a seconda delle dimensioni dei caratteri in dispositivo

entrare descrizione dell'immagine qui

È possibile utilizzare sp per limiti di layout anche, funzionerà :) No standard di utilizzo app sp per tutto il testo

Usa SP e DP per la dimensione del testo considerando UX.

  • Non uso sp per il testo in barra degli strumenti (può usare dimens Android disponibile per le diverse dimensioni dello schermo con dp)
  • Non uso sp per il testo in piccoli pulsanti limitati, testo molto più piccolo, etc

Alcune persone usano enorme dimensione del carattere nella loro telefono per più leggibilità, dando loro piccole dimensioni testo hardcoded sarà un problema UX. Mettere sp per il testo, se necessario, ma assicurarsi che non si romperà il layout.

Allo stesso modo se si dispone di una singola applicazione di supporto tutte le dimensioni, aggiungendo le attività xxxhdpi aumenta la dimensione app molto. Ma ora i telefoni xxxhdpi sono comuni quindi dobbiamo includere attività xxxhdpi atleast per le icone di barra laterale, barra degli strumenti e barra inferiore. Il suo meglio per passare a immagini vettoriali di avere una divisa e le immagini di migliore qualità per tutte le dimensioni dello schermo.

Si noti inoltre che le persone usano carattere personalizzato nella loro telefono. Quindi, la mancanza di un font può causare problemi di spaziatura e tutto. Di 'la dimensione del testo 12sp per un carattere personalizzato potrebbe richiedere qualche pixel in più rispetto font predefinito.

Fare riferimento sito degli sviluppatori di Google per screendensities e dettagli basedensity per Android. https://developer.android.com/training/multiscreen/screendensities

ho incontrato un buon articolo sulla progettazione di applicazioni Android UI per diverse risoluzioni dello schermo, e mi piacerebbe lasciarlo qui solo per qualcuno la ricerca in questo settore. Sì, lo so che è in qualche modo descritto in Google Documenti (e citato nei posti di cui sopra), ho letto che ma non era buono per me (sì, posso essere troppo stupido)). E 'ancora chiaro per me come progettare layout in grado di gestire diverse dimensioni dello schermo. Odio concetto DP e così via, quando devo implementare un layout UI "flessibile" per schermi differenti. (Hey sviluppatori iOS - sì, hai ragione è concetto Storyboard)

.

Android ha non male concetto di interfaccia utente, ma manca di iOS Storyboard presenta, purtroppo. La progettazione flessibile interfaccia utente in Android non è cosa facile (al meglio).

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

JMSTUDIO Blog: - Decidere App Android Dimensioni dello schermo

  

Come progettazione di interfacce utente per applicazioni Android per lo schermo di formato differente

     

Per progettare un'interfaccia utente app per diverse dimensioni dello schermo, il nostro progetto iniziale deve   incontrare uno spazio minimo richiesto per ciascuna dimensione dello schermo. Android definisce un   dimensione minima (in dp) per ogni tipo di schermo generalizzato. Ecco un   linea guida Android dimensioni dello schermo.    Dimensioni dello schermo minima per Android in dp   Quando arriviamo la dimensione dello schermo in dp, non è sufficiente per noi di progettare   l'applicazione UI Android. Per ogni dimensione dello schermo, abbiamo bisogno di preparare la grafica   e immagini bitmap per ogni densità. Ecco una densità schermo Android   orientamento.    Densità Android Guideline (dpi)

     

Per facile calcolo, si può seguire la rapporto 3: 8 scalatura fra: 4: 6   i quattro densità generalizzate. Se creiamo un quadro 36 × 36 pixel per   dispositivo ldpi, il resto densità di immagini formato sarà 48 × 48 per mdpi,   72 × 72 per hdpi, e 96 × 96 per xhdpi.

     

Come progettare applicazioni Android UI in Photoshop

     

Molti designer hanno problemi per la progettazione di app per Android UI in Photoshop o altri pixel   strumenti di progettazione grafica basata a causa di unità indipendenti dalla densità, DP.   I progettisti non sanno come mappare dp per pixel. Google, inoltre, non dà   una chiara guida alla progettazione dell'interfaccia utente di Android per loro, anche se danno una base   formula per la traduzione dp e pixel.

     

Come la definizione di Android, 1PD pari a 1px sotto 160 dpi dispositivo (MDPI).   Quindi vogliamo progettare un app Android per xlarge dispositivo Android con   Densità MDPI, possiamo definire la nostra dimensione interfaccia utente in pixel come 960 pixel in larghezza   e 720px di altezza; Seguire la stessa regola di mappatura, possiamo ottenere   dopo Android App disegno dimensioni dello schermo dell'interfaccia utente linea guida:

     

Formato App Android schermo pixel Guideline

AGGIUNTO : Se interessato a UI "flessibile" troppo, dare un'occhiata a questa libreria: un Android SDK che fornisce una nuova unità di misura - SDP (dp scalabile). Questa unità di misura in scala con le dimensioni dello schermo (questo citato anche in una risposta qui, sulla biblioteca SDP)

ADDED2 Google ha finalmente capito l'utilità di iOS Storeboard UI concetto, e qui va ConstraintLayout per il mondo Android: Costruire un Responsive UI con ConstraintLayout

1) dp: (density independent pixels)

Il numero di pixel rappresentati in un'unità di dp aumenterà con l'aumentare della risoluzione dello schermo (quando si hanno più punti / pixel per pollice). Viceversa su dispositivi con bassa risoluzione, il numero di pixel rappresentati in sull'unità di dp diminuirà. Poiché questo è un unità relativa, esso deve avere una linea di base da confrontare con. Questa linea di base è uno schermo dpi 160. Questa è l'equazione: px = dp * (dpi / 160).


2) sp: (scale independent pixels)

Questa unità scale in base alla dpi schermo (simile a dp), così come la preferenza dimensione del carattere dell'utente.


3) px: (pixels)

pixel effettivi o punti sullo schermo.

Per maggiori dettagli si può visitare

  

Guida Sviluppatore Android> Dimension
   Guida Sviluppatore Android> Schermi

Dimensione schermo in Android è raggruppati in categorie ldpi, mdpi, hdpi, xhdpi, xxhdpi e xxxhdpi. densità dello schermo è la quantità di pixel all'interno di una zona (come pollici) dello schermo. Generalmente si misura in punti per pollice (dpi).

PX(Pixels):

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

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

  • dip == dp. Nelle versioni precedenti di Android tuffo è stato utilizzato e più tardi cambiato in dp. Si tratta di un'alternativa di px.

  • In genere non usiamo mai px perché è valore assoluto. Se si utilizza px impostare larghezza o altezza, e se tale applicazione viene scaricato in dispositivi di dimensioni dello schermo differente, allora tale vista non allungare secondo il formato originale dello schermo.

  • dp si consiglia vivamente di utilizzare al posto di px. Utilizzare dp se si vuole parlare di larghezza e l'altezza di crescere e ridursi in modo dinamico in base a dimensioni dello schermo.

  • se diamo dp/dip, Android calcola automaticamente la dimensione dei pixel sulla base dello schermo di dimensioni 160 pixel.

SP(Scale independent pixels):

  • scalato in base alle preferenze dimensione del carattere dell'utente. Caratteri dovrebbero usare sp.

  • quando si citano le dimensioni dei caratteri per adattarsi per varie dimensioni dello schermo, l'uso sp. Questo è simile a dp.Use sp soprattutto per le dimensioni dei caratteri di crescere e ridursi in modo dinamico in base a dimensioni dello schermo

Documentazione Android dice:

  

quando specificando le dimensioni, utilizzare sempre o dp o unità sp. A dp è   un pixel indipendenti dalla densità che corrisponde alla grandezza fisica di un   pixel a 160 dpi. Un sp è la stessa unità di base, ma viene scalato dal   la dimensione del testo preferita dell'utente (si tratta di un pixel in scala-indipendente), in modo da   dovrebbe usare questa unità di misura quando si definisce la dimensione del testo

Lo schermo di un telefono cellulare è composto da migliaia di minuscoli puntini noti come pixel (px) . Un pixel è l'elemento più piccolo che va a rendere l'immagine. Maggiore è il numero di pixel per fare una foto o un testo, 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 usato quando si acquista un dispositivo, ma in realtà non è così utile quando si progetta per Android perché il pensiero di schermi in termini di pixel ignora la nozione di dimensione fisica, che per un dispositivo touch è davvero molto importante.

densità di pixel indipendente (dp o dip) permettono al progettista di creare beni che appaiono in un modo previsto, non importa la risoluzione o la densità del dispositivo di destinazione.

Una densità di pixel indipendente (dp o dip) è pari ad un pixel alla densità basale 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 è pari a 2 px.

Formula

px / dp = dpi / 160dpi

punti per pollice (dpi) è una misura della nitidezza (vale a dire, la densità dei punti luminosi) su uno schermo. I punti per pollice per una data risoluzione dell'immagine saranno diversi in base alla dimensione complessiva dello schermo dal momento che lo stesso numero di pixel vengono distribuite su uno spazio diverso.

Lavorare con densità di pixel indipendenti ci aiutano a che fare con una situazione del genere in cui si dispone di due dispositivi con lo stesso pixel di risoluzione, ma differenti quantità di spazio. Supponiamo che in un caso, un tablet e cellulare ha la stessa risoluzione pixel 1280 per 800 pixel (160 dpi) e 800 x 1280 pixel (320 dpi) rispettivamente.

Ora, poiché è una compressa a densità basale (160 dpi) suoi pixel fisici e densità indipendente dimensioni sono le stesse, 1280 per 800. Il telefono invece ha una densità di pixel maggiore, quindi ha metà di quelli densità indipendente pixel come pixel fisici. Quindi un telefono è dotato di 400 x 640 pixel di densità indipendenti. Quindi, utilizzando un pixel indipendenti dalla densità lo rende più facile immaginare mentalmente che tablet ha molto più spazio rispetto al telefono.

Allo stesso modo, se avete due dispositivi con dimensioni dello schermo simile, ma diversa densità di pixel, dire che uno è di 800 da 1.280 pixel (320 dpi), e l'altro è di 400 per 640 pixel (160 dpi), non abbiamo bisogno di definire totalmente diversi layout per questi due dispositivi, come possiamo valutare le attività in termini di densità di pixel indipendente che è uguale per entrambi i dispositivi.

800 da 1280 pixel (320dpi) = 400 x 640 densità di pixel indipendente (dp)

400 da 640 pixel (160 dpi) = 400 x 640 densità di pixel indipendente (dp)

Scale pixel indipendenti (sp) è l'unità preferito per dimensione del carattere. Per motivi di accessibilità, Android permette agli utenti di personalizzare la dimensione del carattere del loro dispositivo. Gli utenti che hanno difficoltà a leggere il testo può aumentare la dimensione del carattere del proprio dispositivo. Normalmente è possibile trovare questa opzione nelle impostazioni di visualizzazione sul telefono o tablet sotto la dimensione del carattere. Spesso è anche disponibile attraverso le impostazioni di accesso.

Con pixel indipendenti di scala, 16 sp è esattamente la stessa di 16 dp quando la dimensione del carattere del dispositivo è normale o 100%. Ma quando la dimensione del carattere del dispositivo è grande, per esempio 125%, 16 sp sarà translate a 20 dp o 1,25 volte 16.

Se si utilizza dp come l'unità per dimensione, quindi quel pezzo di testo ha una dimensione fisica specifica, non importa se l'utente dispone di personalizzare la dimensione dei caratteri del dispositivo. Utilizzando unità sp farà una migliore esperienza per le persone con problemi alla vista.

Riferimento : Udacity , Google

  

sp: scala di pixel indipendenti

Si dovrebbe usare con i testi, perché è ridimensionato automaticamente in base alla dimensione del font che viene utilizzato dall'utente nel suo dispositivo.

  

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

Prima di rispondere a questa domanda lasciatemi diminuire il numero di unità.Quindi ecco qua: dp o dip sono entrambi uguali e sono conosciuti come Pixel indipendenti dalla densità.

1.px - sta per pixel.I pixel sono un singolo punto, punto su uno schermo.Generalmente nel settore della telefonia mobile si misura in ppi (pixel per pollice).La risoluzione dello schermo è direttamente proporzionale al ppi, maggiore è il numero di pixel per pollice, maggiore è la risoluzione dello schermo.

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

Le immagini sottostanti mostrano la risoluzione della stessa immagine su telefoni diversi:

  • Telefono con alta risoluzione dello schermo

    Enter image description here

  • Telefono con risoluzione dello schermo bassa

    Enter image description here

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

  • Immagine che sta mostrando 80px (immagine lato sinistro) E 80 dp (immagine a destra).Differenza alla cassa.

Enter image description here

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 - sta per pixel scalabili.Generalmente sp viene utilizzato per i testi sull'interfaccia utente e sp conserva le impostazioni del carattere.Ad esempio, se un utente ha selezionato un carattere più grande di 30 sp si ridimensionerà automaticamente per apparire grande in base alle preferenze dell'utente.

Voglio fornire un modo semplice per capire dp. In realtà, credo che dp è il più facile da capire. dp è solo un'unità di lunghezza fisica. E 'della stessa dimensione come mm o inch. E 'solo conveniente per noi di scrivere 50dp, 60dp piuttosto che 50/160 inch o 60/160 inch, perché uno dp è solo 1/160 inch qualunque sia la dimensione dello schermo o la risoluzione è.

L'unico problema è che, il dpi Android di alcuni schermi non sono accurate. Ad esempio, uno schermo classificata a 160dpi 170dpi può avere davvero. Così il risultato del calcolo dp è sfocata. Dovrebbe essere di circa la stessa di 1/160 inch.

SDP - un'unità di dimensione scalabile -. In fondo non è un'unità, ma le risorse dimensione per dimensioni dello schermo

Prova il SDP libreria da Intuit. E 'molto utile per risolvere i problemi di unità, e si può supportare rapidamente schermi multipli .

Uso

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

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

Attenzione

Usare con cautela! Nella maggior parte dei casi è comunque necessario progettare un layout diverso per le tavolette.

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>

È possibile utilizzare db per la dimensione del testo, ma io preferisco ssp per la dimensione del testo.

Per ulteriori informazioni, consultare biblioteca pagina di GitHub .

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top