Introduction

Changing the font on an Android TextView is easy once you choose where the font should live. For modern apps, the cleanest approach is to place the font in res/font and reference it from XML or load it through ResourcesCompat in code.

Use res/font for Modern Android Projects

Put a font file such as lora_regular.ttf or inter_bold.otf in app/src/main/res/font/. Once the file is there, you can reference it directly in XML:

1<?xml version="1.0" encoding="utf-8"?>
2<TextView xmlns:android="http://schemas.android.com/apk/res/android"
3    android:id="@+id/titleView"
4    android:layout_width="wrap_content"
5    android:layout_height="wrap_content"
6    android:text="Hello"
7    android:textSize="24sp"
8    android:fontFamily="@font/lora_regular" />

This is the simplest solution because the font becomes part of the normal Android resource system.

Set the Font Programmatically

If you need to change the font in code, load it and assign the resulting Typeface:

1import android.os.Bundle
2import android.widget.TextView
3import androidx.appcompat.app.AppCompatActivity
4import androidx.core.content.res.ResourcesCompat
5
6class MainActivity : AppCompatActivity() {
7    override fun onCreate(savedInstanceState: Bundle?) {
8        super.onCreate(savedInstanceState)
9        setContentView(R.layout.activity_main)
10
11        val titleView = findViewById<TextView>(R.id.titleView)
12        val typeface = ResourcesCompat.getFont(this, R.font.lora_regular)
13
14        if (typeface != null) {
15            titleView.typeface = typeface
16        }
17    }
18}

This is useful when the font depends on user preferences, theme, or runtime state.

Built-In Families Are Also an Option

If you do not need a custom file, Android already provides built-in font families. In XML:

1<TextView
2    android:layout_width="wrap_content"
3    android:layout_height="wrap_content"
4    android:text="System font example"
5    android:fontFamily="serif" />

This is quick and keeps APK size down, but it gives you less control over branding and design.

Applying the Same Font to Many Views

If several text elements should share the same look, define a style:

1<style name="HeadlineText">
2    <item name="android:fontFamily">@font/lora_regular</item>
3    <item name="android:textSize">22sp</item>
4</style>

Then apply it:

1<TextView
2    style="@style/HeadlineText"
3    android:layout_width="wrap_content"
4    android:layout_height="wrap_content"
5    android:text="Styled title" />

This avoids repeating font configuration throughout the layout files.

Avoid the Old assets Pattern Unless You Need It

Older tutorials often load fonts from assets/fonts with Typeface.createFromAsset(...). That still works, but res/font is better integrated with Android resources and is usually easier to maintain.

Legacy approach:

Typeface typeface = Typeface.createFromAsset(getAssets(), "fonts/lora_regular.ttf");
textView.setTypeface(typeface);

Use this only if you are maintaining an older codebase that already follows the assets-based pattern.

Theme-Level Consistency

If the app uses the same font family across many screens, consider applying it through styles and themes rather than setting it view by view. That keeps typography consistent and makes future font changes cheaper because the change lives in one place instead of being copied across layouts.

Readability Matters More Than Novelty

Custom fonts can improve branding, but they can also hurt legibility. Test:

• Small text sizes.
• Bold and normal weights.
• Different screen densities.
• Accessibility font scaling.

A decorative font may work for headings and still be a bad choice for body text. UI quality depends more on readability than novelty.

Common Pitfalls

• Putting the font file in the wrong directory and referencing it as a resource anyway.
• Using a custom font everywhere, including dense body text, without testing readability.
• Repeating font settings manually instead of using a style.
• Loading fonts from assets in new projects when res/font would be simpler.
• Assuming all font weights exist when only one actual font file was added.

Summary

• For modern Android apps, store custom fonts in res/font.
• Use android:fontFamily in XML for the simplest setup.
• Use ResourcesCompat.getFont() when the font must be chosen in code.
• Shared styles keep font usage consistent across the app.
• Prefer readable fonts and test them at real sizes and accessibility scales.