Is it possible to set a custom font for entire of application?

The reflection approach: accessing default fonts

Resetting default font settings directly may be daunting, yet reflection comes in handy. Use Java's reflection to tweak private or protected fields within Typeface, and set up your custom typeface across the board:

// Yes, we're going to play the 'reflection' card!
Field staticField = Typeface.class.getDeclaredField("SERIF");
staticField.setAccessible(true); // Access granted!
staticField.set(null, myCustomTypeface); // Changing the rules of the game!


Warning: Be careful, reflection can cause encapsulation violation and carry compatibility risks, as internal APIs are prone to updates across platform versions.

Troubleshooting: older themes and systems

Unfortunately, certain older themes (like android:Theme.Material.Light) may not play nice with your custom fonts. In cases like these, resorting to an older theme or adjusting your custom font choices could help. Remember, adding a "not working for me too" comment on Android issue trackers is considered as bad practice. Instead, look for alternative solutions.

Light up your fonts with Calligraphy

Calligraphy is a popular Android library that simplifies the task of adding custom fonts in your app. Here's how it's done using a ContextWrapper:

// Our knight in shining armor: Calligraphy
@Override
protected void attachBaseContext(Context newBase) {
    super.attachBaseContext(CalligraphyContextWrapper.wrap(newBase)); // The magical wrap!
}


Pair this with CalligraphyConfig setup in your Application class. Here, you can specify the default font path.

Styled to perfection: using Styles and XML

You can set up a custom font across your Android application using XML. Starting API 21, you can define a fontFamily in styles.xml:

<!-- Get ready for some XML magic -->
<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
    <item name="android:fontFamily">@font/my_custom_font</item>
</style>


Use this style in your AndroidManifest.xml to apply the magic of custom font to all corners of your app.

One-time font loading

Re-loading custom fonts multiple times not only affects performance, but also stands against best coding practices. Solve this by initializing the font once (say, through a singleton pattern, or in your Application class):

// Let's play it smart and load the font just once.
Typeface myTypeface = Typeface.createFromAsset(context.getAssets(), "fonts/myfont.ttf");


This allows your application to reuse the initialized font instance instead of reloading it every time.

Recursive application: touching all views

In cases where your content is dynamic or when you have a ViewGroup, applying a custom font recursively to all the TextViews is a smart move.

// Why apply font individually, when we can do it ALL AT ONCE!
public static void setCustomFont(View view, Typeface typeface) {
    if (view instanceof ViewGroup) {
        ViewGroup group = (ViewGroup) view;
        for (int i = 0; i < group.getChildCount(); i++) {
            setCustomFont(group.getChildAt(i), typeface); // Recursive magic!
        }
    } else if (view instanceof TextView) {
        ((TextView) view).setTypeface(typeface); // Individual component dressing
    }
}


Utility methods like these save precious time and ensure consistency in dynamically rendered or complex view hierarchies.

Custom subclasses for precise control

In situations when standard views don't offer the flexibility you need, resorting to subclassing views allows you to weave in custom font logic into view creation:

// Let's get personal with our custom view!
public class MyTextView extends TextView {
    public MyTextView(Context context) {
        super(context);
        setTypeface(MyCustomTypefaceManager.getTypeface()); // Look at my Typeface!
    }
}


This approach neatly packs the font application logic within the view, maintaining good separation of concerns.