Introduction

Yes, this behavior is normal. Android TextView sizes are typically defined in sp, which means scale-independent pixels. sp is intentionally affected by the user’s system font-size preference, so when native settings change, your app’s text changes too. That is not a bug by default; it is part of Android’s accessibility model.

Why TextView Changes With System Font Size

Android distinguishes between several units:

• 'dp for layout dimensions,'
• 'sp for text,'
• 'px for raw pixels.'

Text should usually be defined in sp because sp respects the user’s font scale preference.

1<TextView
2    android:layout_width="wrap_content"
3    android:layout_height="wrap_content"
4    android:text="Hello"
5    android:textSize="16sp" />

If the user increases font size in system settings, Android multiplies the text size using the scaled density and the text appears larger.

This Is Usually The Correct Behavior

Supporting system font scaling improves accessibility for users with low vision or device-wide readability needs. In most applications, you should design layouts that adapt rather than trying to freeze text at one physical size.

That means:

• allow enough space for larger text,
• test with large font settings,
• avoid brittle fixed-height containers around text.

The real engineering task is often responsive layout, not preventing scaling.

Why Hard-Coding Pixels Is Usually Wrong

If you use raw pixels or manually fight scaling, the app may look consistent on your device but become less accessible and less robust on others.

This is the right default:

android:textSize="14sp"

This is usually the wrong instinct for app text:

android:textSize="14px"

Pixels ignore the font scale preference and are rarely the correct user-facing choice.

When Developers Want To Stop The Scaling

Sometimes developers want fixed text size because the layout breaks when the user chooses a larger system font. That usually indicates a layout issue rather than a typography issue.

Better fixes include:

• using wrap_content correctly,
• allowing multiline text,
• using ConstraintLayout or flexible containers,
• testing with accessibility font scales early.

Trying to suppress scaling globally often creates a worse user experience than solving the layout properly.

Auto-Sizing Is A Related But Different Feature

Android also supports text auto-sizing, which adjusts text to fit its available bounds. That is separate from system font scaling.

1<TextView
2    android:layout_width="200dp"
3    android:layout_height="wrap_content"
4    android:autoSizeTextType="uniform"
5    android:autoSizeMinTextSize="12sp"
6    android:autoSizeMaxTextSize="20sp"
7    android:autoSizeStepGranularity="2sp" />

Auto-size can help layouts remain usable, but it does not replace understanding how sp responds to user settings.

If You Really Must Read The Scale

You can inspect the current font scale from configuration.

val fontScale = resources.configuration.fontScale
println(fontScale)

This is useful for diagnostics or adaptive layout decisions, but it should not automatically trigger “disable accessibility” behavior.

Design For The Scaling Instead Of Fighting It

A strong Android UI usually accepts that text may grow. That means:

• avoid clipping,
• avoid one-line assumptions for long labels,
• give important text enough room,
• test at small and large font settings.

This is much more maintainable than trying to keep every TextView visually identical across accessibility configurations.

Common Pitfalls

• Treating system-driven text scaling as a bug when sp units are being used correctly.
• Switching to px just to stop the visual change.
• Designing fixed-height layouts that break as soon as text gets larger.
• Confusing system font scaling with TextView auto-size behavior.
• Ignoring accessibility settings during UI testing.

Summary

• 'TextView font size changes with native font settings because sp is designed to scale.'
• This is usually the correct and accessible Android behavior.
• Use sp for text and adapt your layout rather than forcing fixed pixel sizes.
• Auto-size and system font scaling are related but different mechanisms.
• If the UI breaks when text grows, fix the layout instead of fighting the accessibility model.