sp: cosa sono, pixel scalabili per il testo in Android

Cosa sono gli sp in Android?

sp (scale-independent pixel) — unità di misura della dimensione del carattere in Android che si ridimensiona automaticamente secondo le impostazioni di sistema dell'utente. Quando il proprietario del dispositivo aumenta la dimensione del carattere nelle impostazioni, tutti gli elementi con valori in sp crescono proporzionalmente. Questo garantisce l'accessibilità dell'interfaccia per le persone con disabilità visive.

Il rapporto di base: 1 sp = 1 dp alla scala del carattere standard 1.0 (normale). Se l'utente imposta il carattere su Grande (1.15×), 16 sp diventano 18.4 pixel fisici. Con dimensione del carattere Piccola (0.85×), gli stessi 16 sp diventano 13.6 px. Il meccanismo di ridimensionamento è gestito tramite Settings.System.FONT_SCALE a livello di Android Framework.

Secondo le Google Material Design Guidelines, il testo dovrebbe essere specificato esclusivamente in sp. L'eccezione sono le etichette fisse in componenti dove la dimensione è critica per il layout (ad esempio, testo all'interno di pulsanti di altezza fissa). In tali casi, si raccomanda di usare dp con controllo manuale dell'accessibilità.

sp vs dp: Differenze Chiave

La differenza tra sp e dp è uno degli argomenti più comuni nei colloqui per sviluppatori Android e nelle revisioni del codice reali. Entrambe le unità sono legate ai pixel indipendenti dalla densità (160 dpi = 1 dp = 1 px su schermi mdpi), ma si comportano diversamente quando cambia la dimensione del carattere di sistema.

In pratica, un errore comune è usare dp per il testo. Se il testo è impostato in dp, non si ridimensiona quando la dimensione del carattere aumenta, rendendo l'interfaccia inaccessibile per gli utenti con problemi di vista. L'errore opposto è usare sp per l'altezza dei pulsanti o il padding: quando il carattere aumenta, il pulsante può "gonfiarsi", rompendo il layout.

Come Funziona il Ridimensionamento di sp

Il ridimensionamento di sp è implementato a livello di Android Framework nella classe TypedValue. La formula di conversione è: sp = dp × scaledDensity, dove scaledDensity è un fattore di scala che tiene conto sia della densità dello schermo che dell'impostazione del carattere dell'utente.

// Ottenimento programmatico di scaledDensity in Kotlin
val scaledDensity = with(context.resources) {
    displayMetrics.scaledDensity
}

// Conversione da sp a px
fun spToPx(sp: Float, context: Context): Float {
    return TypedValue.applyDimension(
        TypedValue.COMPLEX_UNIT_SP,
        sp,
        context.resources.displayMetrics
    )
}

// Conversione da px a sp
fun pxToSp(px: Float, context: Context): Float {
    return px / context.resources.displayMetrics.scaledDensity
}

Il metodo TypedValue.applyDimension è l'unico modo corretto per convertire sp in pixel a runtime. La moltiplicazione diretta per scaledDensity è meno affidabile poiché non gestisce casi limite (valori zero, overflow). scaledDensity cambia quando le impostazioni del carattere vengono modificate tramite Settings > Display > Font size.

Fattori di Scala

Android fornisce cinque livelli predefiniti di scala del carattere: Small (0.85×), Default (1.0×), Large (1.15×), Largest (1.3×) e un livello aggiuntivo Very Large (>1.3×) in Android 14+. I produttori di dispositivi (Samsung, Xiaomi) aggiungono i propri livelli — fino a 2.0×. La dimensione minima del testo in sp non garantisce mai un numero fisso di pixel.

Uso di sp in XML

Nei layout XML, sp viene utilizzato esclusivamente nell'attributo android:textSize. Tutte le altre dimensioni — larghezza, altezza, padding, margine, elevazione — sono impostate in dp. La regola è semplice: se l'elemento visualizza testo, la sua dimensione è in sp; se l'elemento definisce geometria, la dimensione è in dp.

Esempio base di textSize in XML

<!-- Layout TextView con textSize in sp -->
<TextView
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:text="@string/hello"
    android:textSize="16sp"
    android:padding="12dp"
    android:lineSpacingExtra="4dp" />

<!-- Uso delle risorse dimens -->
<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:textSize="@dimen/text_body_large" />

Si consiglia di estrarre le dimensioni del testo in un file dimens.xml. Questo semplifica la manutenzione della tipografia, permette di sovrascrivere le dimensioni per diverse configurazioni dello schermo e garantisce coerenza in tutta l'applicazione.

dimens.xml con Token Tipografici

<!-- res/values/dimens.xml -->
<resources>
    <!-- Material Design Type Scale -->
    <dimen name="text_display_large">34sp</dimen>
    <dimen name="text_display_medium">28sp</dimen>
    <dimen name="text_headline_large">24sp</dimen>
    <dimen name="text_headline_medium">20sp</dimen>
    <dimen name="text_title_large">18sp</dimen>
    <dimen name="text_body_large">16sp</dimen>
    <dimen name="text_body_medium">14sp</dimen>
    <dimen name="text_label_large">14sp</dimen>
    <dimen name="text_label_small">11sp</dimen>
</resources>

Material Design Type Scale include 13 livelli di dimensione — da 11sp per piccole etichette a 57sp per grandi titoli di visualizzazione. I progetti Android di solito usano 8–10 livelli. Tutti i valori devono essere multipli di 1sp — i valori frazionari (15.5sp) degradano il rendering a causa del posizionamento subpixel.

Configurazione della Tipografia tramite Kotlin

Nello sviluppo Android moderno, il testo viene raramente impostato direttamente tramite textSize in sp. Invece, viene utilizzato il sistema MaterialTheme.typography, dove ogni stile è predefinito e include dimensione, peso, altezza della riga e spaziatura delle lettere.

// Tipografia personalizzata tramite Typography API
val AppTypography = Typography(
    displayLarge = TextStyle(
        fontWeight = FontWeight.Normal,
        fontSize = 34.sp,
        lineHeight = 40.sp,
        letterSpacing = 0.sp
    ),
    headlineLarge = TextStyle(
        fontWeight = FontWeight.SemiBold,
        fontSize = 24.sp,
        lineHeight = 32.sp
    ),
    titleLarge = TextStyle(
        fontWeight = FontWeight.Medium,
        fontSize = 18.sp,
        lineHeight = 24.sp
    ),
    bodyLarge = TextStyle(
        fontWeight = FontWeight.Normal,
        fontSize = 16.sp,
        lineHeight = 24.sp,
        letterSpacing = 0.5.sp
    ),
    labelSmall = TextStyle(
        fontWeight = FontWeight.Medium,
        fontSize = 11.sp,
        lineHeight = 16.sp,
        letterSpacing = 0.5.sp
    )
)

La funzione di estensione .sp in Jetpack Compose si traduce automaticamente in pixel indipendenti dalla scala. Quando la dimensione del carattere di sistema cambia, Compose ricalcola fontSize, lineHeight e spacing in base alla nuova scaledDensity. TextUnit (la classe che rappresenta sp) garantisce che il testo si ridimensioni mentre il padding no.

sp in Jetpack Compose

In Jetpack Compose, sp è rappresentato dal tipo TextUnit, che non può essere accidentalmente utilizzato per dimensioni degli elementi. Il compilatore Kotlin genererà un errore se TextUnit viene passato dove ci si aspetta Dp. Questo elimina un'intera classe di bug relativi a un ridimensionamento errato.

// TextUnit in Compose — lavoro sicuro con sp
@Composable
fun ArticleCard(title: String, description: String) {
    Card(modifier = Modifier
        .fillMaxWidth()
        .padding(16.dp)
    ) {
        Text(
            text = title,
            style = MaterialTheme.typography.titleLarge
        )
        Spacer(modifier = Modifier.height(8.dp))
        Text(
            text = description,
            style = MaterialTheme.typography.bodyMedium
        )
    }
}

// Impostazione esplicita di fontSize in sp
Text(
    text = "Dimensione personalizzata",
    fontSize = 20.sp,
    fontWeight = FontWeight.Bold,
    color = MaterialTheme.colorScheme.primary
)

Compose non ha un equivalente diretto dell'attributo XML android:textSize — la dimensione del testo viene impostata tramite TextStyle.fontSize. Il sistema MaterialTheme.typography fornisce stili predefiniti che corrispondono a Material Design Type Scale. Se è necessaria una dimensione personalizzata, viene usato il letterale 20.sp — il linguaggio garantisce che questo è TextUnit, non Dp.

Migliori Pratiche con sp

L'uso corretto di sp è il fondamento di un'applicazione Android accessibile. Di seguito sono riportate le regole basate sulle raccomandazioni di Google Material Design e Android Developers Guide.

• Usa sempre sp per il testo — non impostare mai textSize in dp o px, altrimenti gli utenti con caratteri ingranditi non potranno leggere l'interfaccia
• Usa dp per i contenitori — l'altezza dei pulsanti, il padding e la larghezza delle carte devono essere in dp, altrimenti gli elementi potrebbero sovrapporsi con caratteri grandi
• Estrai le dimensioni in dimens.xml — l'archiviazione centralizzata dei token tipografici semplifica il refactoring e il supporto del tema scuro
• Non usare sp inferiori a 12sp — il testo più piccolo diventa illeggibile su dispositivi con PPI elevato e dimensioni del carattere standard
• Testa alla scala massima del carattere — attiva il carattere più grande nelle impostazioni del dispositivo e verifica che l'interfaccia non si rompa

La regola principale dell'accessibilità: l'utente dovrebbe essere in grado di aumentare la dimensione del carattere senza perdere funzionalità. Se l'applicazione funziona correttamente a una scala del carattere di 1.3×, supererà i test di accessibilità di base. Google Play può rifiutare l'applicazione se textSize è impostato in dp e l'interfaccia non si ridimensiona.