how to prevent system font-size changing effects to android application?

Question

I recently finished developing my android application. I used sp (Scaled pixels) for all textSize. The problem is when i adjusted the system font-size, my application's font-sizes are changing. I can use dp (Device independent pixels) but it will take too long to maintain my application.

I referenced text size from this.

Is there a way to prevent system font-size changing effects to my application ?

score 73 · Accepted Answer · edited Nov 16 '19 at 05:15

73

If you require your text to remain the same size, you'll have to use dp.

To quote the documentation:

An sp is the same base unit, but is scaled by the user's preferred text size (it’s a scale-independent pixel), so you should use this measurement unit when defining text size (but never for layout sizes).

Emphasis mine.

So you're seeing the expected behaviour for using sp as your units for text size.

I don't understand what you mean about using dp taking too long to maintain your app - as far as I can tell, it'll exactly be the same amount of effort? (perhaps less, though it'll likely make it less usable for users with poor eyesight)

edited Nov 16 '19 at 05:15

ivan

1,155
8
21

answered Feb 04 '14 at 07:57

Adam S

14,954
6
51
79

I agreed your explaination. But in IOS it restricted to specific applications like calendar, mails, ect by the System. For Android, there is not restriction. So can i prevent my application from changing system font-szie. – james Feb 04 '14 at 08:05
1

You cannot stop the user from changing the system font size; you'll just have to use `dp` and ignore the lint errors! There's a [blog post on how to disable lint errors](http://tools.android.com/recent/ignoringlintwarnings) which might be useful. – Adam S Feb 04 '14 at 08:10
2

While your usage may be very specific and require a constant font size, I'd recommend considering how you can accommodate varying font sizes in your layouts, rather than just avoiding it altogether. It'll make for a much better experience for your users. – Adam S Feb 04 '14 at 08:19
If you have a working app, switching all `sp` values to `dp` values is error prone and requires more time to do so. Then if chose to switch back to support it again, you need to revert all these changes. It just makes more sense to override `fontScale` in a parent activity. This requires less effort than changing resources. It is also better maintainability. Answer below overriding `Context` is the way to go. – parohy Apr 07 '21 at 05:18

score 57 · Answer 2 · edited Aug 12 '20 at 12:46

I recently ran into this problem as well. Our UI didn't scale well on phones with limited screen dimensions and changing the entire UI on the off chance a user set's their Accessibility Options to "Huge" seemed silly.

I found this question on StackOverflow to be most helpful.

What I did was put the following code below in my BaseActivity (an Activity class that all my activities extend from)

public void adjustFontScale(Configuration configuration) {
    if (configuration.fontScale > 1.30) {
        LogUtil.log(LogUtil.WARN, TAG, "fontScale=" + configuration.fontScale); //Custom Log class, you can use Log.w
        LogUtil.log(LogUtil.WARN, TAG, "font too big. scale down..."); //Custom Log class, you can use Log.w
        configuration.fontScale = 1.30f;
        DisplayMetrics metrics = getResources().getDisplayMetrics();
        WindowManager wm = (WindowManager) getSystemService(WINDOW_SERVICE);
        wm.getDefaultDisplay().getMetrics(metrics);
        metrics.scaledDensity = configuration.fontScale * metrics.density;
        getBaseContext().getResources().updateConfiguration(configuration, metrics);
    }
}

And called it right after my super.onCreate() like so

adjustFontScale(getResources().getConfiguration());

What this code does is identify if the user set their font scale in Accessibility Settings to something greater than 1.30f (1.30f is "Large" on The Note 5, but probably varies a bit from device-to-device). If the user set their font too large ("Extra Large", "Huge"...), we scale the application only to "Large".

This allows your app to scale to a user's preferences (to a degree) without distorting your UI. Hopefully this will help others. Good luck scaling!

Other Tips

If you want certain layouts to scale with your fonts (say...a RelativeLayout that you use as a backdrop against your fonts), you can set their width/height with sp instead of the classic dp. When a user changes their font size, the layout will change accordingly with the fonts in your application. Nice little trick.

Can I ask why your example is slightly different from the question you linked, regarding this line: `WindowManager wm = (WindowManager) getSystemService(WINDOW_SERVICE);`. I'm new to android and am trying to pick the 'best' answer. Thanks! — Tallboy, Mar 12 '16 at 22:55
@Tallboy good question. I've seen code get the window manager both ways (using the getSystemService call like I did and using getWindowManager() like the example I linked to). I just tested my code both ways and they both worked fine. I believe I read somewhere that getWindowManager returns a read-only Window Manager object and that may be a key difference between the two methods, but for this example it didn't matter. — welshk91, Mar 15 '16 at 00:39
This doesn't work on Nougat. Upto Marshmallow it works fine. — Nayan, Mar 29 '17 at 11:30
I've looked across the entire web for days, and this is the only solution that works with Capacitor! Thanks! — nachshon f, Oct 20 '20 at 19:09

score 29 · Answer 3 · answered Jul 26 '19 at 18:59

29

None of the previous answers worked for me, on Android 8.1 (API 27). Here's what worked: Add the following code to your activity:

Kotlin Code:

override fun attachBaseContext(newBase: Context?) {
    super.attachBaseContext(newBase)
    val newOverride = Configuration(newBase?.resources?.configuration)
    newOverride.fontScale = 1.0f
    applyOverrideConfiguration(newOverride)
}

Java Code:

@Override
protected void attachBaseContext(Context newBase) {
    super.attachBaseContext(newBase);
    final Configuration override = new Configuration(newBase.getResources().getConfiguration());
    override.fontScale = 1.0f;
    applyOverrideConfiguration(override);
}

You don't need to change your AndroidManifest.xml.

answered Jul 26 '19 at 18:59

diogenesgg

2,091
2
18
24

2

This is the solution for Android API > N, Not tested on devices below N. – Dr. DS Apr 18 '20 at 14:33
java.lang.IllegalStateException: getResources() or getAssets() has already been called – Hiren Patel Nov 20 '20 at 06:00
@Dr.DS is it API > N or API >= N ? For me, it's not working on N. Just wanted to confirm – Sethuraman Srinivasan Nov 30 '20 at 11:24
@Dr.DS I have tested in below N device which working good – Nik Jan 21 '21 at 18:24
@diogenesgg working fine but activity is being recreated when I change font/zoom level while app is in background that's why I lost data in dialog and other calculations, I'm also not able to call onconfigurationchanged() method from base activity. – Naseer Attari Jan 25 '21 at 08:26

localhost · Answer 4 · 2016-09-07T08:40:07.230

8

That's how we do it. In Application class override onConfigurationChanged() like this. If you want different behavior for different activities - override onConfigurationChanged() in Activity.

Don't forget to add manifest tag android:configChanges="fontScale" since you are hadnling this configuration change yourself.

@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);

    // In some cases modifying newConfig leads to unexpected behavior,
    // so it's better to edit new instance.
    Configuration configuration = new Configuration(newConfig);
    SystemUtils.adjustFontScale(getApplicationContext(), configuration);
}

In some helper class we have adjustFontScale() method.

public static void adjustFontScale(Context context, Configuration configuration) {
    if (configuration.fontScale != 1) {
        configuration.fontScale = 1;
        DisplayMetrics metrics = context.getResources().getDisplayMetrics();
        WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        wm.getDefaultDisplay().getMetrics(metrics);
        metrics.scaledDensity = configuration.fontScale * metrics.density;
        context.getResources().updateConfiguration(configuration, metrics);
    }
}

WARNING! That will totally ignore Accessibility Font Scale user settings and will prevent your App fonts scaling!

edited Sep 07 '16 at 08:40

answered Sep 06 '16 at 09:59

localhost

5,432
1
30
50

1

It does not work. The onConfigurationChanged is never triggered. – zed Jan 10 '17 at 11:25
@zed you need to set android:configChanges="orientation|screenSize" on the application or activity in the manifest – speedynomads Dec 06 '17 at 15:13
This solution is working on only tablet not smart devices. – Praveen Kumar Verma Jan 11 '19 at 15:07
it works on nexus 5-Android 6, i will check on other device. – Sameer Z. Sep 14 '19 at 06:22
1

Didn’t worked on Android 9 – Krutika Chotara May 08 '21 at 15:00
Looking at a few source code implementations (in 5.1 and 10) for `updateConfiguration`, updating `scaledDensity` manually is not necessary. They do it for you. – Peter May 20 '21 at 09:33

Maxim Saplin · Answer 5 · 2018-12-29T14:24:14.990

That's how you do it in 2018 (Xamarin.Android/C# - same approach in other languages):

public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity
{
    protected override void OnCreate(Bundle bundle)
    {
...
    }

    protected override void AttachBaseContext(Context @base)
    {
        var configuration = new Configuration(@base.Resources.Configuration);

        configuration.FontScale = 1f;
        var config =  Application.Context.CreateConfigurationContext(configuration);

        base.AttachBaseContext(config);
    }
}

All you need is override attachBaseContext method of activity and update config there.

getBaseContext().getResources().updateConfiguration() is deprecated though there're numerous examples with this method. If you use this approach besides the IDE warning you might find some parts of your app not scaled.

score 4 · Answer 6 · answered Mar 24 '18 at 04:45

There's another way to prevent app layout issue / font issue from the setting font size change. You can try

// ignore the font scale here
final Configuration newConfiguration = new Configuration(
    newBase.getResources().getConfiguration()
);

newConfiguration.fontScale = 1.0f;
applyOverrideConfiguration(newConfiguration);

where newBase is from attachBaseContext function. You need to override this callback in your Activity.

But, the side effect is that if you wanna use animation (objectanimator/valueanimator), then it will cause the weird behavior.

score 1 · Answer 7 · answered May 08 '20 at 06:36

you can force to text size of your app using base activity Configuration, make all activities inherent base activity. 1.0f will force the app font size to normal ignoring system settings.

public  void adjustFontScale( Configuration configuration,float scale) {

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

}

@Override
 protected void onCreate(@Nullable Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     adjustFontScale( getResources().getConfiguration(),1.0f);
}

score 0 · Answer 8 · answered Nov 23 '20 at 09:46

I think use dp is the best way, but in some case you may want to use a font style, but the style is using sp, you can convert sp to dp by:

fun TextView.getSizeInSp() = textSize / context.resources.displayMetrics.scaleDensity

fun TextView.convertToDpSize() = setTextSize(TypedValue.COMPLEX_UNIT_DIP, getSizeInSp())

so you can use the sp value from style without dynamic font size, and no need to hardcode the font size

how to prevent system font-size changing effects to android application?

8 Answers8

Linked