sp : qu'est-ce que c'est, pixels évolutifs pour le texte dans Android

Qu'est-ce que sp dans Android ?

sp (scale-independent pixel) — unité de mesure de taille de police dans Android qui s'adapte automatiquement selon les paramètres système de l'utilisateur. Lorsque le propriétaire de l'appareil augmente la taille de la police dans les paramètres, tous les éléments avec des valeurs en sp croissent proportionnellement. Cela garantit l'accessibilité de l'interface pour les personnes malvoyantes.

Le rapport de base : 1 sp = 1 dp à l'échelle de police standard 1,0 (normale). Si l'utilisateur définit la police sur Large (1,15×), 16 sp devient 18,4 pixels physiques. À la taille de police Small (0,85×), les mêmes 16 sp deviennent 13,6 px. Le mécanisme de redimensionnement est géré via Settings.System.FONT_SCALE au niveau du Framework Android.

Selon les Google Material Design Guidelines, le texte doit être spécifié exclusivement en sp. L'exception concerne les étiquettes fixes dans les composants où la taille est critique pour la disposition (par exemple, le texte à l'intérieur de boutons de hauteur fixe). Dans ces cas, il est recommandé d'utiliser dp avec un contrôle manuel de l'accessibilité.

sp vs dp : Différences Clés

La différence entre sp et dp est l'un des sujets les plus courants dans les entretiens de développeurs Android et les révisions de code réelles. Les deux unités sont liées aux pixels indépendants de la densité (160 dpi = 1 dp = 1 px sur les écrans mdpi), mais se comportent différemment lorsque la taille de police du système change.

En pratique, une erreur courante est d'utiliser dp pour le texte. Si le texte est défini en dp, il ne s'adapte pas lorsque la taille de la police augmente, rendant l'interface inaccessible pour les utilisateurs malvoyants. L'erreur inverse est d'utiliser sp pour la hauteur des boutons ou le padding : lorsque la police augmente, le bouton peut « gonfler », cassant la disposition.

Comment fonctionne le redimensionnement de sp

Le redimensionnement de sp est implémenté au niveau du Framework Android dans la classe TypedValue. La formule de conversion est : sp = dp × scaledDensity, où scaledDensity est un facteur d'échelle qui tient compte à la fois de la densité de l'écran et du réglage de police de l'utilisateur.

// Obtention programmatique de scaledDensity en Kotlin
val scaledDensity = with(context.resources) {
    displayMetrics.scaledDensity
}

// Conversion de sp en px
fun spToPx(sp: Float, context: Context): Float {
    return TypedValue.applyDimension(
        TypedValue.COMPLEX_UNIT_SP,
        sp,
        context.resources.displayMetrics
    )
}

// Conversion de px en sp
fun pxToSp(px: Float, context: Context): Float {
    return px / context.resources.displayMetrics.scaledDensity
}

La méthode TypedValue.applyDimension est la seule façon correcte de convertir sp en pixels à l'exécution. La multiplication directe par scaledDensity est moins fiable car elle ne gère pas les cas limites (valeurs nulles, débordement). scaledDensity change lorsque les paramètres de police sont modifiés via Settings > Display > Font size.

Facteurs d'échelle

Android fournit cinq niveaux prédéfinis d'échelle de police : Small (0,85×), Default (1,0×), Large (1,15×), Largest (1,3×) et un niveau supplémentaire Very Large (>1,3×) dans Android 14+. Les fabricants d'appareils (Samsung, Xiaomi) ajoutent leurs propres niveaux — jusqu'à 2,0×. La taille minimale de texte en sp ne garantit jamais un nombre fixe de pixels.

Utilisation de sp en XML

Dans les mises en page XML, sp est utilisé exclusivement dans l'attribut android:textSize. Toutes les autres dimensions — largeur, hauteur, padding, marge, élévation — sont définies en dp. La règle est simple : si l'élément affiche du texte, sa taille est en sp ; si l'élément définit une géométrie, la taille est en dp.

Exemple de base de textSize en XML

<!-- Disposition TextView avec textSize en 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" />

<!-- Utilisation des ressources dimens -->
<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:textSize="@dimen/text_body_large" />

Il est recommandé d'extraire les tailles de texte dans un fichier dimens.xml. Cela simplifie la maintenance de la typographie, permet de remplacer les tailles pour différentes configurations d'écran et garantit la cohérence dans toute l'application.

dimens.xml avec des jetons typographiques

<!-- 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 comprend 13 niveaux de taille — de 11sp pour les petites étiquettes à 57sp pour les grands titres d'affichage. Les projets Android utilisent généralement 8 à 10 niveaux. Toutes les valeurs doivent être des multiples de 1sp — les valeurs fractionnaires (15,5sp) dégradent le rendu en raison du positionnement sous-pixel.

Configuration de la typographie avec Kotlin

Dans le développement Android moderne, le texte est rarement défini directement via textSize en sp. Au lieu de cela, le système MaterialTheme.typography est utilisé, où chaque style est prédéfini et inclut la taille, le poids, la hauteur de ligne et l'espacement des lettres.

// Typographie personnalisée via 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 fonction d'extension .sp dans Jetpack Compose se traduit automatiquement en pixels indépendants de l'échelle. Lorsque la taille de police du système change, Compose recalcule fontSize, lineHeight et spacing en fonction de la nouvelle scaledDensity. TextUnit (la classe représentant sp) garantit que le texte s'adapte alors que le padding ne s'adapte pas.

sp dans Jetpack Compose

Dans Jetpack Compose, sp est représenté par le type TextUnit, qui ne peut pas être utilisé accidentellement pour les dimensions d'éléments. Le compilateur Kotlin générera une erreur si TextUnit est passé là où Dp est attendu. Cela élimine toute une classe de bogues liés à un mauvais redimensionnement.

// TextUnit dans Compose — travail sécurisé avec 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
        )
    }
}

// Définition explicite de fontSize en sp
Text(
    text = "Taille personnalisée",
    fontSize = 20.sp,
    fontWeight = FontWeight.Bold,
    color = MaterialTheme.colorScheme.primary
)

Compose n'a pas d'équivalent direct de l'attribut XML android:textSize — la taille du texte est définie via TextStyle.fontSize. Le système MaterialTheme.typography fournit des styles prédéfinis qui correspondent à Material Design Type Scale. Si une taille personnalisée est nécessaire, le littéral 20.sp est utilisé — le langage garantit qu'il s'agit de TextUnit, pas de Dp.

Meilleures pratiques avec sp

L'utilisation correcte de sp est le fondement d'une application Android accessible. Voici des règles basées sur les recommandations de Google Material Design et Android Developers Guide.

• Utilisez toujours sp pour le texte — ne définissez jamais textSize en dp ou px, sinon les utilisateurs avec des polices agrandies ne pourront pas lire l'interface
• Utilisez dp pour les conteneurs — la hauteur des boutons, le padding et la largeur des cartes doivent être en dp, sinon les éléments peuvent se chevaucher avec de grandes polices
• Extrayez les tailles dans dimens.xml — le stockage centralisé des jetons typographiques simplifie le refactoring et la prise en charge du thème sombre
• N'utilisez pas de sp inférieur à 12sp — un texte plus petit devient illisible sur les appareils à haut PPI et avec les tailles de police standard
• Testez à l'échelle de police maximale — activez la plus grande police dans les paramètres de l'appareil et vérifiez que l'interface ne se casse pas

La règle principale d'accessibilité : l'utilisateur doit pouvoir augmenter la taille de la police sans perdre de fonctionnalité. Si l'application fonctionne correctement à une échelle de police de 1,3×, elle réussira les tests d'accessibilité de base. Google Play peut rejeter l'application si textSize est défini en dp et que l'interface ne s'adapte pas.