graphics: Override system fonts with user-selected overlays

Only using user-selected fonts for a subset of system apps leads to an
inconsistent visual experience. While we've already applied them to the
system's Material UI themes, many apps have hard-code references to
sans-serif (whether it's through XML styles or Typeface.SANS_SERIF), so
it is also necessary to override Typeface fonts at runtime.

Changing overlays causes OverlayManagerService to schedule
ApplicationInfo updates for affected apps, which forces a configuration
change by incrementing Configuration#assetsSeq.

TODO: figure out why not all apps get consistent configuration updates
until manually relaunching activities

Change-Id: I684a56315808f78f24a14cd6efeda0ea05e25abf
Signed-off-by: Chiranth A J <chiranth@m.ms.evolution-x.org>
Signed-off-by: aswin7469 <aswinas@pixysos.com>
Signed-off-by: Abhinav Kumar <abhinav.115260@gmail.com>

Author: kdrag0n

core/java/android/app/ConfigurationController.java

@@ -29,6 +29,9 @@
 import android.content.res.Resources;
 import android.graphics.Bitmap;
 import android.graphics.HardwareRenderer;
+import android.graphics.Typeface;
+import android.inputmethodservice.InputMethodService;
+import android.os.Build;
 import android.os.LocaleList;
 import android.os.Trace;
 import android.util.DisplayMetrics;
@@ -198,6 +201,7 @@ private void handleConfigurationChangedInner(@Nullable Configuration config,
 
             final Application app = mActivityThread.getApplication();
             final Resources appResources = app.getResources();
+            Typeface.updateDefaultFont(appResources);
             mResourcesManager.applyConfigurationToResources(config, compat);
             updateLocaleListFromAppContext(app.getApplicationContext());
 

core/res/res/values/droidx_symbols.xml

@@ -14,4 +14,7 @@
     <java-symbol type="string" name="config_lightFontFamily" />
     <java-symbol type="string" name="config_regularFontFamily" />
 
+     <!-- For dynamic default font styles -->
+    <java-symbol type="string" name="config_bodyFontFamily" />
+
 </resources>

graphics/java/android/graphics/Typeface.java

@@ -29,6 +29,7 @@
 import android.annotation.UiThread;
 import android.compat.annotation.UnsupportedAppUsage;
 import android.content.res.AssetManager;
+import android.content.res.Resources;
 import android.graphics.fonts.Font;
 import android.graphics.fonts.FontFamily;
 import android.graphics.fonts.FontStyle;
@@ -70,12 +71,14 @@
 import java.io.InputStream;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -145,6 +148,9 @@ public class Typeface {
     private static final LruCache<String, Typeface> sDynamicTypefaceCache = new LruCache<>(16);
     private static final Object sDynamicCacheLock = new Object();
 
+    // For dynamic default font styles
+    private static final HashMap<String, Typeface> sSystemFontOverrides = new HashMap<>();
+
     private static final LruCache<Long, LruCache<String, Typeface>> sVariableCache =
             new LruCache<>(16);
     private static final Object sVariableCacheLock = new Object();
@@ -929,7 +935,7 @@ public CustomFallbackBuilder(@NonNull FontFamily family) {
      * @return The best matching typeface.
      */
     public static Typeface create(String familyName, @Style int style) {
-        return create(getSystemDefaultTypeface(familyName), style);
+        return create(getSystemOverrideTypeface(familyName), style);
     }
 
     /**
@@ -1296,6 +1302,11 @@ public void releaseNativeObjectForTest() {
         mCleaner.run();
     }
 
+    private static Typeface getSystemOverrideTypeface(@NonNull String familyName) {
+        Typeface tf = sSystemFontOverrides.get(familyName);
+        return tf == null ? getSystemDefaultTypeface(familyName) : tf;
+    }
+
     private static Typeface getSystemDefaultTypeface(@NonNull String familyName) {
         Typeface tf = sSystemFontMap.get(familyName);
         return tf == null ? Typeface.DEFAULT : tf;
@@ -1477,6 +1488,60 @@ public static void setSystemFontMap(@Nullable SharedMemory sharedMemory)
         }
     }
 
+    private static void setPublicDefaults(String familyName) {
+        synchronized (SYSTEM_FONT_MAP_LOCK) {
+            sDefaults = new Typeface[] {
+                DEFAULT,
+                DEFAULT_BOLD,
+                create(getSystemDefaultTypeface(familyName), Typeface.ITALIC),
+                create(getSystemDefaultTypeface(familyName), Typeface.BOLD_ITALIC),
+            };
+        }
+    }
+
+    private static void setFinalField(String fieldName, Typeface value) {
+        synchronized (SYSTEM_FONT_MAP_LOCK) {
+            try {
+                Field field = Typeface.class.getDeclaredField(fieldName);
+                // isAccessible bypasses final on ART
+                field.setAccessible(true);
+                field.set(null, value);
+                field.setAccessible(false);
+            } catch (NoSuchFieldException | IllegalAccessException e) {
+                Log.e(TAG, "Failed to set Typeface." + fieldName, e);
+            }
+        }
+    }
+
+    /** @hide */
+    public static void updateDefaultFont(Resources res) {
+        synchronized (SYSTEM_FONT_MAP_LOCK) {
+            String familyName = res.getString(com.android.internal.R.string.config_bodyFontFamily);
+            Typeface typeface = sSystemFontMap.get(familyName);
+            if (typeface == null) {
+                // This should never happen, but if the system font family name is invalid, just return
+                // instead of crashing the app.
+                return;
+            }
+
+            setDefault(typeface);
+
+            // Static typefaces in public API
+            setFinalField("DEFAULT", create(getSystemDefaultTypeface(familyName), 0));
+            setFinalField("DEFAULT_BOLD", create(getSystemDefaultTypeface(familyName), Typeface.BOLD));
+            setFinalField("SANS_SERIF", DEFAULT);
+
+            // For default aliases used in framework styles
+            sSystemFontOverrides.put("sans-serif", typeface);
+            sSystemFontOverrides.put("sans-serif-thin", create(typeface, 100, false));
+            sSystemFontOverrides.put("sans-serif-light", create(typeface, 300, false));
+            sSystemFontOverrides.put("sans-serif-medium", create(typeface, 500, false));
+            sSystemFontOverrides.put("sans-serif-black", create(typeface, 900, false));
+
+            setPublicDefaults(familyName);
+        }
+    }
+
     /** @hide */
     @VisibleForTesting
     public static void setSystemFontMap(Map<String, Typeface> systemFontMap) {
@@ -1497,12 +1562,7 @@ public static void setSystemFontMap(Map<String, Typeface> systemFontMap) {
             nativeForceSetStaticFinalField("SERIF", create("serif", 0));
             nativeForceSetStaticFinalField("MONOSPACE", create("monospace", 0));
 
-            sDefaults = new Typeface[]{
-                DEFAULT,
-                DEFAULT_BOLD,
-                create((String) null, Typeface.ITALIC),
-                create((String) null, Typeface.BOLD_ITALIC),
-            };
+            setPublicDefaults(null);
 
             // A list of generic families to be registered in native.
             // https://www.w3.org/TR/css-fonts-4/#generic-font-families