Introduction

On Android, text size should typically be defined in sp (scale-independent pixels), not raw pixels. sp respects user font-scale accessibility preferences, while px ignores them and can hurt readability. A common mistake in Java code is calling setTextSize(float) and assuming the value is sp, even though overload behavior can be confusing in mixed codebases. This guide explains the correct TextView APIs, how to convert units safely, and how to keep runtime text sizing consistent with XML styles and design-system tokens.

Use setTextSize with Explicit Unit

The safest pattern is the two-argument overload with TypedValue.COMPLEX_UNIT_SP.

1import android.util.TypedValue;
2import android.widget.TextView;
3
4TextView title = findViewById(R.id.title);
5title.setTextSize(TypedValue.COMPLEX_UNIT_SP, 18f);

This clearly communicates intent and avoids ambiguity about units. It also ensures Android applies the current font scale.

If you already have dimension resources, prefer resource-driven values for consistency:

<!-- res/values/dimens.xml -->
<dimen name="text_title">18sp</dimen>

float px = getResources().getDimension(R.dimen.text_title);
title.setTextSize(TypedValue.COMPLEX_UNIT_PX, px);

This uses design tokens centrally while still applying the intended rendered size.

Converting Between sp and px

Sometimes APIs require pixel values, especially for custom views. Convert with display metrics.

float sp = 16f;
float scaledDensity = getResources().getDisplayMetrics().scaledDensity;
float px = sp * scaledDensity;

And convert back if needed:

float computedSp = px / getResources().getDisplayMetrics().scaledDensity;

Avoid hard-coded conversion constants, since density and user font scale vary by device and accessibility settings.

Keep Runtime Sizing Compatible with Styles

If your screen applies themed text appearances, changing size at runtime can accidentally override typography hierarchy. Prefer style-level defaults and runtime adjustments only where needed.

TextView subtitle = findViewById(R.id.subtitle);
subtitle.setTextAppearance(this, R.style.AppTextSubtitle);
subtitle.setTextSize(TypedValue.COMPLEX_UNIT_SP, 14f); // optional override

For component libraries, define a small set of semantic sizes (caption, body, title) and map runtime code to those tokens, not arbitrary numbers.

Verify Accessibility and Layout Effects

Large font scales can cause truncation and wrapping issues. Test your dynamic sizing under accessibility settings.

subtitle.setMaxLines(2);
subtitle.setEllipsize(TextUtils.TruncateAt.END);

Then validate on multiple devices with font scale changes in system settings. Runtime text size code should preserve legibility without breaking layout.

Practical Verification Workflow

A reliable way to avoid regressions is to validate the solution in three passes: baseline, controlled change, and repeatability check. First, capture a baseline outcome before you apply fixes. This could be a failing command, a wrong output sample, a stack trace, or a screenshot of current behavior. Second, apply one focused change and rerun exactly the same checks so you can attribute improvements to a specific edit. Third, rerun the checks multiple times or with slightly different inputs to ensure the fix is not accidental or data-specific.

A lightweight template you can adapt for most projects looks like this:

1# 1) reproduce current behavior
2./run_example.sh > before.txt
3
4# 2) apply your change
5# edit config/code based on this article
6
7# 3) verify behavior after change
8./run_example.sh > after.txt
9diff -u before.txt after.txt

If your environment involves tests, add at least one focused regression test that would fail before the fix and pass after it. This turns a one-time troubleshooting success into a durable maintenance improvement, which is especially important when teams rotate ownership or upgrade dependencies later.

Common Pitfalls

• Passing pixel values to APIs while assuming they are interpreted as sp.
• Using raw px for text and unintentionally ignoring user accessibility font scaling.
• Applying runtime sizes everywhere instead of using centralized dimen and style tokens.
• Forgetting to test at larger system font scales, leading to clipped or overlapping text.
• Mixing multiple sizing strategies (XML, Java hard-codes, style overrides) without a hierarchy.

Summary

To assign text size in Java using sp, call setTextSize(TypedValue.COMPLEX_UNIT_SP, value) or use dimen resources with explicit units. Keep typography tokenized, convert units only when necessary, and test with accessibility font scaling enabled. This approach ensures readable, consistent text across devices and user preferences.