android - independent - Qual è la differenza tra "px", "dip", "dp" e "sp"?




ppi to dp converter (20)

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

  • px
  • tuffo
  • dp
  • sp

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 grafico è il singolo punto sullo schermo


definizioni

px o dot è un pixel sullo schermo fisico.

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

Android assegna i nomi alias a diverse densità

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

dip o dp sono pixel indenpendant di densità , ovvero corrispondono a più o meno pixel in base alla densità fisica.

  • 1dp = 1px su mdpi

sp or sip è un pixel indipendente dalla scala . Vengono ridimensionati quando l'opzione Testo grande è attivata in Impostazioni > Accessibilità

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

Cosa usare?

Usa sp per le dimensioni del testo.

Usa dp per tutto il resto.


Dalla documentazione per gli sviluppatori Android :

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

  2. nel
    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
    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. 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".

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

Dalla comprensione dell'indipendenza dalla densità in Android :

+----------------+----------------+---------------+-------------------------------+
| Density Bucket | Screen Density | Physical Size | Pixel Size                    | 
+----------------+----------------+---------------+-------------------------------+
| ldpi           | 120 dpi        | 0.5 x 0.5 in  | 0.5 in * 120 dpi = 60x60 px   | 
+----------------+----------------+---------------+-------------------------------+
| mdpi           | 160 dpi        | 0.5 x 0.5 in  | 0.5 in * 160 dpi = 80x80 px   | 
+----------------+----------------+---------------+-------------------------------+
| hdpi           | 240 dpi        | 0.5 x 0.5 in  | 0.5 in * 240 dpi = 120x120 px | 
+----------------+----------------+---------------+-------------------------------+
| xhdpi          | 320 dpi        | 0.5 x 0.5 in  | 0.5 in * 320 dpi = 160x160 px | 
+----------------+----------------+---------------+-------------------------------+
| xxhdpi         | 480 dpi        | 0.5 x 0.5 in  | 0.5 in * 480 dpi = 240x240 px | 
+----------------+----------------+---------------+-------------------------------+
| xxxhdpi        | 640 dpi        | 0.5 x 0.5 in  | 0.5 in * 640 dpi = 320x320 px | 
+----------------+----------------+---------------+-------------------------------+
+---------+-------------+---------------+-------------+--------------------+
| Unit    | Description | Units Per     | Density     | Same Physical Size | 
|         |             | Physical Inch | Independent | On Every Screen    | 
+---------+-------------+---------------+-------------+--------------------+
| px      | Pixels      | Varies        | No          | No                 | 
+---------+-------------+---------------+-------------+--------------------+
| in      | Inches      | 1             | Yes         | Yes                | 
+---------+-------------+---------------+-------------+--------------------+
| mm      | Millimeters | 25.4          | Yes         | Yes                | 
+---------+-------------+---------------+-------------+--------------------+
| pt      | Points      | 72            | Yes         | Yes                | 
+---------+-------------+---------------+-------------+--------------------+
| dp      | Density     | ~160          | Yes         | No                 | 
|         | Independent |               |             |                    | 
|         | Pixels      |               |             |                    | 
+---------+-------------+---------------+-------------+--------------------+
| sp      | Scale       | ~160          | Yes         | No                 | 
|         | Independent |               |             |                    | 
|         | Pixels      |               |             |                    | 
+---------+-------------+---------------+-------------+--------------------+

Ulteriori informazioni possono essere trovate nella documentazione di Google Design .

Per calcolare le dimensioni sul dispositivo reale, è possibile utilizzare this app.


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

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

Al contrario: per esempio, vuoi aggiungere un'immagine alla tua applicazione e ti serve per riempire un controllo da 100 * 100 dp . Dovrai creare immagini di dimensioni diverse per le dimensioni dello schermo supportate:

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

Ho calcolato la seguente formula per convertire le conversioni in dpi in dp e sp


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

Large Text opzione Large Text obbliga il testo a 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 packages/apps/Settings .


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


Qualunque cosa sia relativa alla dimensione 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 usare sia dp che dip nei suoi posti.


dpi -

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

px - pixel

  • Per mappare i pixel dello schermo

pt - punti

  • 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 - rispetto alle dimensioni dello schermo fisico.

sp - pixel indipendenti 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 160 dpi, 1 dp = 1 pixel.
  • Usa dp tranne la dimensione del carattere del testo.

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

Formula per la conversione di unità:

px = dp * (dpi / 160);

Density Bucket -> Screen Display => Physical Size        => Pixel Size                   

ldpi         -> 120 dpi          => 0.5 x 0.5 in         => 0.5 in * 120 dpi = 60x60 px   

mdpi         -> 160 dpi          => 0.5 x 0.5 in         => 0.5 in * 160 dpi = 80x80 px   

hdpi         -> 240 dpi          => 0.5 x 0.5 in         => 0.5 in * 240 dpi = 120x120 px  

xhdpi        -> 320 dpi          => 0.5 x 0.5 in         => 0.5 in * 320 dpi = 160x160 px  

xxhdpi       -> 480 dpi          => 0.5 x 0.5 in         => 0.5 in * 480 dpi = 240x240 px 

xxxhdpi      -> 640 dpi          => 0.5 x 0.5 in         => 0.5 in * 640 dpi = 320x320 px  

sp = pixel indipendenti dalla scala

dp = dip = pixel indipendenti dalla densità

dpi = punti per pollice

Dovremmo evitare di usare sp .

Dovremmo usare dp per supportare più schermi.

Android supporta diverse risoluzioni dello schermo

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

Un dispositivo 120 dp ldpi ha 120 pixel in 1 pollice.

Lo stesso per altre densità ...

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

pixel = dp * (densità / 160)

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

E il dp del dispositivo a 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();

Fonte 1

Fonte 2

Fonte 3 : (i dati della fonte 3 sono forniti di seguito)

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

dp

Pixel indipendenti dalla densità: un'unità astratta basata sulla densità fisica dello schermo. Queste unità sono relative a uno schermo da 160 dpi (punti per pollice), in cui 1 dpi è approssimativamente uguale a 1 pixel. Quando si esegue 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 viene ridimensionato. Il rapporto tra dp-to-pixel cambierà con la densità dello schermo, ma non necessariamente in proporzione diretta. L'uso delle unità dp (invece delle unità px) è una soluzione semplice per rendere le dimensioni della vista nel layout ridimensionate correttamente per diverse densità dello schermo. In altre parole, fornisce coerenza per le dimensioni reali degli elementi dell'interfaccia utente su dispositivi diversi.

sp

Pixel indipendente dalla scala: è come l'unità dp, ma è anche ridimensionato dalla preferenza della dimensione del carattere dell'utente. Si consiglia di utilizzare questa unità quando si specificano le dimensioni dei caratteri, in modo che vengano regolate sia per la densità dello schermo sia per 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 misura non è raccomandata in quanto la rappresentazione effettiva può variare tra i vari dispositivi; ogni dispositivo può avere un numero diverso di pixel per pollice e può avere più o meno pixel totali disponibili sullo schermo.

mm

Millimetri - In base alle dimensioni fisiche dello schermo.

nel

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 nome (non il nome del file XML). Pertanto, è possibile combinare risorse di dimensione con altre risorse semplici in un unico file XML, sotto un elemento.


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

Utilizzare sp per {text-size}.

Per ottenere le stesse dimensioni su diverse densità dello schermo, Android converte 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.

Fonte: Programmazione Android: The Big Nerd Ranch Guide


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

Preso da qui .

Questo risolve un sacco di confusione quando si traduce tra px e dp, se si conosce lo schermo dpi.

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)

Inoltre dovresti avere una chiara comprensione dei seguenti concetti:

Dimensione dello schermo:

Dimensione fisica effettiva, misurata come diagonale dello schermo. Per semplicità, Android raggruppa tutte le dimensioni effettive dello schermo in quattro dimensioni generalizzate: piccola, normale, grande ed extra 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, uno schermo con densità "bassa" ha meno pixel all'interno di una determinata area fisica, rispetto a uno schermo con densità "normale" o "alta". Per semplicità, Android raggruppa tutte le densità dello schermo effettive in quattro densità generalizzate: bassa, media, alta e molto alta.

Orientamento:

L'orientamento dello schermo dal punto di vista dell'utente. Questo è orizzontale o verticale, il che significa che le proporzioni dello schermo sono rispettivamente ampie o alte. Si noti che non solo i dispositivi diversi 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 la risoluzione; le applicazioni dovrebbero riguardare solo le dimensioni e la densità dello schermo, come specificato dai gruppi di dimensioni e densità generalizzate.

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à. 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 esecuzione, il sistema gestisce in modo trasparente qualsiasi ridimensionamento delle unità dp, in base alle 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. Dovresti sempre utilizzare le unità dp quando definisci l'interfaccia utente della tua applicazione, per garantire la corretta visualizzazione dell'interfaccia utente su schermi con densità diverse.

Riferimento: sito per sviluppatori Android


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

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

dp Density - 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 e dp , anche se dp è più coerente con sp .

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

Prendiamo l'esempio di due schermi che hanno le stesse dimensioni ma uno ha una densità dello schermo di 160 dpi (punti per pollice, ovvero 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

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

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

uso

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

Ha un valore equivalente in dp per ogni dimensione nelle values-sw<N>dpcartelle (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 usare db per le dimensioni del testo, ma preferisco ssp per le dimensioni del testo.

Per maggiori dettagli, consultare la pagina GitHub della libreria .


Ho trovato un buon articolo su come progettare l'interfaccia utente di app Android per risoluzioni di 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 di 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 (al meglio).

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

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 schermi di dimensioni diverse, il nostro progetto iniziale deve soddisfare uno spazio minimo richiesto per ogni dimensione dello schermo. Android definisce una dimensione minima (in dp) per ogni tipo di schermo generalizzato. Ecco una linea guida per le dimensioni dello schermo Android. 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 immagini grafiche e bitmap per ogni densità. Ecco una linea guida sulla densità dello schermo Android.

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

Come progettare l'interfaccia utente di app Android in Photoshop

Molti designer hanno problemi a progettare l'interfaccia utente di app Android in Photoshop o altri strumenti di progettazione grafica basati su pixel a causa dell'unità indipendente dalla densità, dp. I progettisti non sanno come mappare da dp a pixel. Google inoltre non fornisce una chiara guida alla progettazione dell'interfaccia utente Android per loro, sebbene forniscano una formula di base 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 per Android per un dispositivo xlarge Android con densità mdpi, possiamo definire la nostra dimensione dell'interfaccia utente in pixel di 960 pixel in larghezza e 720px in altezza; Segui la stessa regola di mappatura, possiamo seguire le seguenti linee guida per la progettazione delle interfacce per l'interfaccia utente di Android:

AGGIUNTO : 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 SDPlibreria)

ADDED2 Google ha finalmente capito l'utilità del concetto di interfaccia utente di iOS Storeboard, e qui va ConstraintLayoutper il mondo Android: Costruire un'interfaccia utente reattiva con ConstraintLayout


Lo schermo di un telefono cellulare è composto da migliaia di piccoli punti noti come pixel (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 più leggibile lo schermo dello smartphone.

La risoluzione dello schermo è 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.

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 / 1 dp = 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 data risoluzione dell'immagine differiscono in base alla dimensione complessiva dello schermo poiché lo stesso numero di pixel viene distribuito su uno spazio diverso.

Lavorare con pixel indipendenti dalla densità ci aiuta ad affrontare una situazione come quella in cui si hanno due dispositivi con la stessa risoluzione in pixel, ma con una quantità di spazio diversa. Supponiamo che 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 la metà di molti pixel indipendenti dalla densità del fisico pixel. Quindi un telefono ha 400 pixel per la densità indipendenti di 640 pixel. 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 definirlo completamente layout diversi per questi due dispositivi in ​​quanto possiamo misurare le risorse in termini di pixel indipendenti dalla densità, che è lo stesso per entrambi i dispositivi.

800 x 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 dei caratteri 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 è grande, ad esempio il 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


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

sp = pixel indipendenti dalla scala

dp = pixel indipendenti dalla densità

dpi = pixel di densità

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

sp prendere il testo del dispositivo, mentre dp prendere quello dello standard di densità del dispositivo (non cambiare 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

Puoi usare sp anche per i confini del layout, funzionerà :) Nessuna app standard usa sp 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 o dp)
  • Non usare sp per il testo in piccoli pulsanti limitati, testo molto più piccolo, ecc

Alcune persone usano enormi FONT nel loro telefono per una maggiore leggibilità, dando loro un testo di piccole dimensioni con hardcoded che 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 inferiore. È meglio passare alle immagini vettoriali per ottenere immagini uniformi e di migliore qualità per tutte le dimensioni dello schermo.


Voglio fornire un modo semplice per capire dp. In realtà, penso che dpsia il più facile da capire. dpè solo un'unità di lunghezza fisica. È della stessa dimensione di mmo inch. È semplicemente conveniente per noi scrivere 50dp, 60dppiuttosto che 50/160 incho 60/160 inch, perché uno dpè 1/160 inchqualsiasi 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 dpè fuzzy. Dovrebbe essere approssimativamente lo stesso di 1/160 inch.





units-of-measurement