sp: was ist das, skalierbare Pixel für Text in Android

Was ist sp in Android?

sp (scale-independent pixel) — eine Schriftgrößenmaßeinheit in Android, die automatisch entsprechend den Systemeinstellungen des Benutzers skaliert. Wenn der Gerätebesitzer die Schriftgröße in den Einstellungen erhöht, wachsen alle Elemente mit sp-Werten proportional. Dies gewährleistet die Barrierefreiheit der Oberfläche für Menschen mit Sehbehinderungen.

Das grundlegende Verhältnis: 1 sp = 1 dp bei der Standardschriftgröße 1.0 (normal). Wenn der Benutzer die Schrift auf Groß (1.15×) einstellt, werden aus 16 sp 18.4 physische Pixel. Bei kleiner Schriftgröße (0.85×) werden aus denselben 16 sp 13.6 px. Der Skalierungsmechanismus wird auf Android Framework-Ebene über Settings.System.FONT_SCALE gesteuert.

Gemäß den Google Material Design Guidelines sollte Text ausschließlich in sp angegeben werden. Die Ausnahme sind feste Beschriftungen in Komponenten, bei denen die Größe für das Layout entscheidend ist (z. B. Text in Schaltflächen mit fester Höhe). In solchen Fällen wird die Verwendung von dp mit manueller Barrierefreiheitskontrolle empfohlen.

sp vs dp: Hauptunterschiede

Der Unterschied zwischen sp und dp ist eines der häufigsten Themen in Android-Entwicklerinterviews und echten Code-Reviews. Beide Einheiten sind an dichteunabhängige Pixel gebunden (160 dpi = 1 dp = 1 px auf mdpi-Bildschirmen), verhalten sich jedoch unterschiedlich, wenn sich die Systemschriftgröße ändert.

In der Praxis ist ein häufiger Fehler die Verwendung von dp für Text. Wenn Text in dp festgelegt wird, skaliert er nicht, wenn die Schriftgröße erhöht wird, was die Oberfläche für sehbehinderte Benutzer unzugänglich macht. Der umgekehrte Fehler ist die Verwendung von sp für die Schaltflächenhöhe oder Abstände: Wenn die Schriftgröße zunimmt, kann die Schaltfläche „aufblähen” und das Layout zerstören.

Wie sp-Skalierung funktioniert

Die sp-Skalierung ist auf Android Framework-Ebene in der Klasse TypedValue implementiert. Die Umrechnungsformel lautet: sp = dp × scaledDensity, wobei scaledDensity ein Skalierungsfaktor ist, der sowohl die Bildschirmdichte als auch die Schriftgrößeneinstellung des Benutzers berücksichtigt.

// Programmatisches Abrufen von scaledDensity in Kotlin
val scaledDensity = with(context.resources) {
    displayMetrics.scaledDensity
}

// Umrechnung von sp in px
fun spToPx(sp: Float, context: Context): Float {
    return TypedValue.applyDimension(
        TypedValue.COMPLEX_UNIT_SP,
        sp,
        context.resources.displayMetrics
    )
}

// Umrechnung von px in sp
fun pxToSp(px: Float, context: Context): Float {
    return px / context.resources.displayMetrics.scaledDensity
}

Die Methode TypedValue.applyDimension ist die einzig korrekte Möglichkeit, sp zur Laufzeit in Pixel umzuwandeln. Die direkte Multiplikation mit scaledDensity ist weniger zuverlässig, da sie Randfälle (Nullwerte, Überlauf) nicht behandelt. scaledDensity ändert sich, wenn die Schriftarteinstellungen über Settings > Display > Font size geändert werden.

Skalierungsfaktoren

Android bietet fünf voreingestellte Schriftgrößenstufen: Small (0.85×), Default (1.0×), Large (1.15×), Largest (1.3×) und eine zusätzliche Stufe Very Large (>1.3×) in Android 14+. Gerätehersteller (Samsung, Xiaomi) fügen eigene Stufen hinzu — bis zu 2.0×. Die Mindestschriftgröße in sp garantiert niemals eine feste Pixelanzahl.

Verwendung von sp in XML

In XML-Layouts wird sp ausschließlich im Attribut android:textSize verwendet. Alle anderen Abmessungen — Breite, Höhe, Abstände, Ränder, Erhöhung — werden in dp festgelegt. Die Regel ist einfach: Wenn das Element Text anzeigt, wird seine Größe in sp angegeben; wenn das Element Geometrie definiert, wird die Größe in dp angegeben.

Grundlegendes Beispiel für textSize in XML

<!-- TextView-Layout mit 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" />

<!-- Verwendung von dimens-Ressourcen -->
<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:textSize="@dimen/text_body_large" />

Es wird empfohlen, Textgrößen in eine dimens.xml-Datei auszulagern. Dies vereinfacht die Typografie-Wartung, ermöglicht das Überschreiben von Größen für verschiedene Bildschirmkonfigurationen und gewährleistet Konsistenz in der gesamten Anwendung.

dimens.xml mit typografischen Tokens

<!-- 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 umfasst 13 Größenstufen — von 11sp für kleine Beschriftungen bis 57sp für große Display-Überschriften. Android-Projekte verwenden normalerweise 8–10 Stufen. Alle Werte sollten ein Vielfaches von 1sp sein — Bruchwerte (15.5sp) verschlechtern die Darstellung aufgrund der Subpixel-Positionierung.

Typografie mit Kotlin konfigurieren

In der modernen Android-Entwicklung wird Text selten direkt über textSize in sp festgelegt. Stattdessen wird das System MaterialTheme.typography verwendet, bei dem jeder Stil vordefiniert ist und Größe, Gewicht, Zeilenhöhe und Buchstabenabstand umfasst.

// Benutzerdefinierte Typografie über 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
    )
)

Die Erweiterungsfunktion .sp in Jetpack Compose wird automatisch in skalenunabhängige Pixel übersetzt. Wenn sich die Systemschriftgröße ändert, berechnet Compose fontSize, lineHeight und spacing gemäß der neuen scaledDensity neu. TextUnit (die Klasse, die sp repräsentiert) garantiert, dass Text skaliert, während Abstände dies nicht tun.

sp in Jetpack Compose

In Jetpack Compose wird sp durch den Typ TextUnit dargestellt, der nicht versehentlich für Elementabmessungen verwendet werden kann. Der Kotlin-Compiler gibt einen Fehler aus, wenn TextUnit dort übergeben wird, wo Dp erwartet wird. Dies eliminiert eine ganze Klasse von Fehlern im Zusammenhang mit falscher Skalierung.

// TextUnit in Compose — sicheres Arbeiten mit 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
        )
    }
}

// Explizites Festlegen von fontSize in sp
Text(
    text = "Benutzerdefinierte Größe",
    fontSize = 20.sp,
    fontWeight = FontWeight.Bold,
    color = MaterialTheme.colorScheme.primary
)

Compose hat kein direktes Äquivalent zum XML-Attribut android:textSize — die Textgröße wird über TextStyle.fontSize festgelegt. Das System MaterialTheme.typography bietet vordefinierte Stile, die der Material Design Type Scale entsprechen. Wenn eine benutzerdefinierte Größe benötigt wird, wird das Literal 20.sp verwendet — die Sprache garantiert, dass dies TextUnit und nicht Dp ist.

Best Practices für die Arbeit mit sp

Die korrekte Verwendung von sp ist die Grundlage einer barrierefreien Android-Anwendung. Nachfolgend finden Sie Regeln, die auf den Empfehlungen von Google Material Design und dem Android Developers Guide basieren.

• Verwenden Sie immer sp für Text — setzen Sie textSize niemals in dp oder px, sonst können Benutzer mit vergrößerter Schrift die Oberfläche nicht lesen
• Verwenden Sie dp für Container — Schaltflächenhöhe, Abstände und Kartenbreite sollten in dp sein, sonst können sich Elemente bei großen Schriftarten überlappen
• Lagern Sie Größen in dimens.xml aus — die zentrale Speicherung typografischer Tokens vereinfacht Refactoring und Dark-Theme-Unterstützung
• Verwenden Sie kein sp kleiner als 12sp — kleinere Textgrößen werden auf Geräten mit hohem PPI und bei Standardschriftgrößen unleserlich
• Testen Sie bei maximaler Schriftgröße — aktivieren Sie die größte Schriftart in den Geräteeinstellungen und überprüfen Sie, ob die Oberfläche nicht bricht

Die Hauptregel der Barrierefreiheit: Der Benutzer sollte die Schriftgröße erhöhen können, ohne Funktionalität zu verlieren. Wenn die Anwendung bei einer Schriftgröße von 1.3× korrekt funktioniert, besteht sie die grundlegenden Barrierefreiheitstests. Google Play kann die Anwendung ablehnen, wenn textSize in dp festgelegt ist und die Oberfläche nicht skaliert.