How to change the Font Size in a whole Application programmatically, Android?-ThrowExceptions

Exception or error:

I have created Spinner with the list of Font Sizes from “8” to “46” . I could be able to click the font Size and in a spinner it has shown me .

My need is, if i click the Font Size “26” inside a Spinner then it should be applied to my whole project. Like applying to my Screen, Textview appearance, Edittext – Bold/ Italic, etc. Again if i click 46 size then it should be apply to my whole project.

How could i do this by programmatically ?

How to solve:

The probable solution would be you create a base class which extends TextView, and use this text view class as edit text. Hope you are asking for size in first screen. In any case, u set the text size in the base class. This will solve your problem.

like u create this class in package com.example and class name is BaseTextView, then in xml file instead of <TextView .../> you will write <com.example.BaseTextView ... />

Hope this helps.


Android documentation is not specific on the most efficient way to change the font size globally through the user’s selection at application level.

There is a problem I think with the answer given by Black Devil.

The problem is that many of the Android widgets subclass TextView, such as Button, RadioButton, and CheckBox. Some of these are indirect subclasses of TextView, which makes implementing customized version of TextView in these classes very difficult.

However as pointed out by Siddharth Lele in his comment, using styles or themes is much better way to handle change in the text size throughout the app.

We set styles for layouts to control the look and feel of the view. Themes are essentially just collections of these styles. However, we can use a theme just for text size settings; without defining values for every property. Using a theme over styles provides us with one huge advantage: we can set a theme for the entire view programmatically.


    <style name="FontSizeSmall">
        <item name="android:textSize">12sp</item>
    <style name="FontSizeMedium">
        <item name="android:textSize">16sp</item>
    <style name="FontSizeLarge">
        <item name="android:textSize">20sp</item>

Create a class to handle loading our preferences:

public class BaseActivity extends Activity {
    public void onStart() {

        // Enclose everything in a try block so we can just
        // use the default view if anything goes wrong.
        try {
            // Get the font size value from SharedPreferences.
            SharedPreferences settings =
                getSharedPreferences("com.example.YourAppPackage", Context.MODE_PRIVATE);

            // Get the font size option.  We use "FONT_SIZE" as the key.
            // Make sure to use this key when you set the value in SharedPreferences.
            // We specify "Medium" as the default value, if it does not exist.
            String fontSizePref = settings.getString("FONT_SIZE", "Medium");

            // Select the proper theme ID.
            // These will correspond to your theme names as defined in themes.xml.
            int themeID =;
            if (fontSizePref == "Small") {
                themeID =;
            else if (fontSizePref == "Large") {
                themeID =;

            // Set the theme for the activity.
        catch (Exception ex) {

Finally, create activities by extending BaseActivity, like this:

public class AppActivity extends BaseActivity{

As most of the application have a much fewer amount of Activities than TextViews or widgets that inherit TextView. This will be exponentially so as complexity increases, so this solution requires less changes in code.

Thanks to Ray Kuhnell


you can scale to text size of your app up/down using base activity Configuration, make all activities inherent base activity.

Scale normal value is 1.0, 2.0 would double the font size and .50 would make it half.

public  void adjustFontScale( Configuration configuration,float scale) {

    configuration.fontScale = scale;
    DisplayMetrics metrics = getResources().getDisplayMetrics();
    WindowManager wm = (WindowManager) getSystemService(WINDOW_SERVICE);
    metrics.scaledDensity = configuration.fontScale * metrics.density;
    getBaseContext().getResources().updateConfiguration(configuration, metrics);


protected void onCreate(@Nullable Bundle savedInstanceState) {
    adjustFontScale( getResources().getConfiguration());


Create a function and pass the spinner size value as

void setSize(int size){
// on All of the layout texts and views on screen


Call setTextSize() on all of your views and layout texts on the screen.

Check out the Documentations Here


To scale the font size of all components(mean whole application), there is pretty well approach which is implemented and tested trough several devices. This solution could be applied for cases like; declaring dp size unit statically(android sp by default) , scaling to desired font sizes and etc.

The solution is similar to answer given by Usama Saeed US but will cover all buggy cases.

Declare static util method which will scale font size.

    public static Context adjustFontSize(Context context){
        Configuration configuration = context.getResources().getConfiguration();
        // This will apply to all text like -> Your given text size * fontScale
        configuration.fontScale = 1.0f;

        return context.createConfigurationContext(configuration);

In your all activities, override the attachBaseContext and call util method in onCreate.

    protected void attachBaseContext(Context newBase) {

    public void onCreate(Bundle savedInstanceState) {

If you are using fragments then override onAttach method

public void onAttach(Context context) {

Leave a Reply

Your email address will not be published. Required fields are marked *