Provide a preference to scale all UI text

app/src/main/java/com/keylesspalace/tusky/BaseActivity.java

@@ -16,6 +16,7 @@
 package com.keylesspalace.tusky;
 
 import android.app.ActivityManager;
+import android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
 import android.content.pm.PackageManager;
@@ -45,6 +46,8 @@
 import com.keylesspalace.tusky.di.Injectable;
 import com.keylesspalace.tusky.interfaces.AccountSelectionListener;
 import com.keylesspalace.tusky.interfaces.PermissionRequester;
+import com.keylesspalace.tusky.settings.PrefKeys;
+import com.keylesspalace.tusky.util.FontScaleContextWrapper;
 import com.keylesspalace.tusky.util.ThemeUtils;
 
 import java.util.ArrayList;
@@ -54,6 +57,7 @@
 import javax.inject.Inject;
 
 public abstract class BaseActivity extends AppCompatActivity implements Injectable {
+    private static final String TAG = "BaseActivity";
 
     @Inject
     public AccountManager accountManager;
@@ -93,6 +97,19 @@ protected void onCreate(@Nullable Bundle savedInstanceState) {
         requesters = new HashMap<>();
     }
 
+    @Override
+    protected void attachBaseContext(Context newBase) {
+        Log.d(TAG, "attachBaseContext()");
+        SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(newBase);
+
+        float uiScaleRatio = preferences.getFloat(PrefKeys.UI_SCALE_RATIO, 100F);
+        Context context = FontScaleContextWrapper.Companion.wrap(
+                newBase,
+                uiScaleRatio / 100.f
+        );
+        super.attachBaseContext(context);
+    }
+
     protected boolean requiresLogin() {
         return true;
     }

app/src/main/java/com/keylesspalace/tusky/components/preference/PreferencesActivity.kt

@@ -93,7 +93,9 @@ class PreferencesActivity :
         }
 
         onBackPressedDispatcher.addCallback(this, restartActivitiesOnBackPressedCallback)
-        restartActivitiesOnBackPressedCallback.isEnabled = savedInstanceState?.getBoolean(EXTRA_RESTART_ON_BACK, false) ?: false
+        restartActivitiesOnBackPressedCallback.isEnabled = intent.extras?.getBoolean(
+            EXTRA_RESTART_ON_BACK
+        ) ?: savedInstanceState?.getBoolean(EXTRA_RESTART_ON_BACK, false) ?: false
     }
 
     override fun onPreferenceStartFragment(
@@ -149,6 +151,10 @@ class PreferencesActivity :
                 restartActivitiesOnBackPressedCallback.isEnabled = true
                 this.restartCurrentActivity()
             }
+            PrefKeys.UI_SCALE_RATIO -> {
+                restartActivitiesOnBackPressedCallback.isEnabled = true
+                this.restartCurrentActivity()
+            }
             "statusTextSize", "absoluteTimeView", "showBotOverlay", "animateGifAvatars", "useBlurhash",
             "showSelfUsername", "showCardsInTimelines", "confirmReblogs", "confirmFavourites",
             "enableSwipeForTabs", "mainNavPosition", PrefKeys.HIDE_TOP_TOOLBAR -> {
@@ -172,7 +178,7 @@ class PreferencesActivity :
     override fun androidInjector() = androidInjector
 
     companion object {
-
+        const val TAG = "PreferencesActivity"
         const val GENERAL_PREFERENCES = 0
         const val ACCOUNT_PREFERENCES = 1
         const val NOTIFICATION_PREFERENCES = 2

app/src/main/java/com/keylesspalace/tusky/components/preference/PreferencesFragment.kt

@@ -29,6 +29,7 @@ import com.keylesspalace.tusky.settings.listPreference
 import com.keylesspalace.tusky.settings.makePreferenceScreen
 import com.keylesspalace.tusky.settings.preference
 import com.keylesspalace.tusky.settings.preferenceCategory
+import com.keylesspalace.tusky.settings.sliderPreference
 import com.keylesspalace.tusky.settings.switchPreference
 import com.keylesspalace.tusky.util.LocaleManager
 import com.keylesspalace.tusky.util.deserialize
@@ -98,6 +99,19 @@ class PreferencesFragment : PreferenceFragmentCompat(), Injectable {
                     preferenceDataStore = localeManager
                 }
 
+                sliderPreference {
+                    key = PrefKeys.UI_SCALE_RATIO
+                    setDefaultValue(100F)
+                    valueTo = 150F
+                    valueFrom = 50F
+                    stepSize = 5F
+                    setTitle(R.string.pref_ui_text_size)
+                    format = "%.0f%%"
+                    decrementIcon = makeIcon(GoogleMaterial.Icon.gmd_zoom_out)
+                    incrementIcon = makeIcon(GoogleMaterial.Icon.gmd_zoom_in)
+                    icon = makeIcon(GoogleMaterial.Icon.gmd_format_size)
+                }
+
                 listPreference {
                     setDefaultValue("medium")
                     setEntries(R.array.post_text_size_names)

app/src/main/java/com/keylesspalace/tusky/settings/SettingsConstants.kt

@@ -68,4 +68,7 @@ object PrefKeys {
 
     const val TAB_FILTER_HOME_REPLIES = "tabFilterHomeReplies_v2" // This was changed once to reset an unintentionally set default.
     const val TAB_FILTER_HOME_BOOSTS = "tabFilterHomeBoosts"
+
+    /** UI scaling factor, stored as float, 100 = 100% = no scaling */
+    const val UI_SCALE_RATIO = "uiScaleRatio"
 }

app/src/main/java/com/keylesspalace/tusky/settings/SettingsDSL.kt

@@ -14,6 +14,7 @@ import androidx.preference.PreferenceCategory
 import androidx.preference.PreferenceFragmentCompat
 import androidx.preference.PreferenceScreen
 import androidx.preference.SwitchPreference
+import com.keylesspalace.tusky.view.SliderPreference
 import de.c1710.filemojicompat_ui.views.picker.preference.EmojiPickerPreference
 
 class PreferenceParent(
@@ -43,6 +44,15 @@ inline fun <A> PreferenceParent.emojiPreference(activity: A, builder: EmojiPicke
     return pref
 }
 
+inline fun PreferenceParent.sliderPreference(
+    builder: SliderPreference.() -> Unit
+): SliderPreference {
+    val pref = SliderPreference(context)
+    builder(pref)
+    addPref(pref)
+    return pref
+}
+
 inline fun PreferenceParent.switchPreference(
     builder: SwitchPreference.() -> Unit
 ): SwitchPreference {

app/src/main/java/com/keylesspalace/tusky/util/FontScaleContextWrapper.kt

@@ -0,0 +1,43 @@
+package com.keylesspalace.tusky.util
+
+import android.content.Context
+import android.content.ContextWrapper
+
+class FontScaleContextWrapper(base: Context?) : ContextWrapper(base) {
+    companion object {
+        const val TAG = "FontScaleContextWrapper"
+
+        /**
+         * Wraps `context`, setting the correct `fontScale` from `fontScaleRatio`.
+         */
+        fun wrap(context: Context, fontScaleRatio: Float): FontScaleContextWrapper {
+            val configuration = context.resources.configuration
+
+            // Can't simply adjust the `fontScale` in `context`, because that will contain the
+            // result of previous adjustments. E.g., going from 100% to 80% to 100% does not return
+            // you to the original 100%, it leaves it at 80%.
+            //
+            // The application context is unaffected by changes to the base context, so always use
+            // the `fontScale` from that as the initial value to multiply. This will also contain
+            // any changes to the font scale from "Settings > Display > Font size" in the device
+            // settings.
+            val appConfiguration = context.applicationContext.resources.configuration
+
+            // This only adjusts the fonts, anything measured in `dp` is unaffected by this.
+            // You can try to adjust `densityDpi` as shown in the commented out code below. This
+            // works, to a point. However, dialogs do not react well to this. Beyond a certain
+            // scale (~ 120%) the right hand edge of the dialog will clip off the right of the
+            // screen.
+            //
+            // So for now, just adjust the font scale
+            //
+            // val displayMetrics = appContext.resources.displayMetrics
+            // configuration.densityDpi = ((displayMetrics.densityDpi * uiScaleRatio).toInt())
+
+            configuration.fontScale = appConfiguration.fontScale * fontScaleRatio
+
+            val newContext = context.createConfigurationContext(configuration)
+            return FontScaleContextWrapper(newContext)
+        }
+    }
+}

app/src/main/java/com/keylesspalace/tusky/view/SliderPreference.kt

@@ -0,0 +1,185 @@
+package com.keylesspalace.tusky.view
+
+import android.content.Context
+import android.content.res.TypedArray
+import android.graphics.drawable.Drawable
+import android.util.AttributeSet
+import android.view.View.VISIBLE
+import androidx.appcompat.content.res.AppCompatResources
+import androidx.preference.Preference
+import androidx.preference.PreferenceViewHolder
+import com.google.android.material.slider.LabelFormatter.LABEL_GONE
+import com.google.android.material.slider.Slider
+import com.keylesspalace.tusky.R
+import com.keylesspalace.tusky.databinding.PrefSliderBinding
+import java.lang.Float.max
+import java.lang.Float.min
+
+/**
+ * Slider preference
+ *
+ * Similar to [SeekBarPreference], but better because:
+ *
+ * - Uses a [Slider] instead of a [SeekBar]. Slider supports float values, and step sizes
+ *   other than 1.
+ * - Displays the currently selected value in the Preference's summary, for consistency
+ *   with platform norms.
+ * - Icon buttons can be displayed at the start/end of the slider. Pressing them will
+ *   increment/decrement the slider by `stepSize`.
+ * - User can supply a custom formatter to format the summary value
+ */
+class SliderPreference @JvmOverloads constructor(
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = R.attr.preferenceStyle,
+    defStyleRes: Int = 0
+) : Preference(context, attrs, defStyleAttr, defStyleRes),
+    Slider.OnChangeListener,
+    Slider.OnSliderTouchListener {
+
+    /** Backing property for `value` */
+    private var _value = 0F
+
+    /**
+     * @see Slider.getValue
+     * @see Slider.setValue
+     */
+    var value: Float = defaultValue
+        get() = _value
+        set(v) {
+            val clamped = max(max(v, valueFrom), min(v, valueTo))
+            if (clamped == field) return
+            _value = clamped
+            persistFloat(v)
+            notifyChanged()
+        }
+
+    /** @see Slider.setValueFrom */
+    var valueFrom: Float
+
+    /** @see Slider.setValueTo */
+    var valueTo: Float
+
+    /** @see Slider.setStepSize */
+    var stepSize: Float
+
+    /**
+     * Format string to be applied to values before setting the summary. For more control set
+     * [SliderPreference.formatter]
+     */
+    var format: String = defaultFormat
+
+    /**
+     * Function that will be used to format the summary. The default formatter formats using the
+     * value of the [SliderPreference.format] property.
+     */
+    var formatter: (Float) -> String = { format.format(it) }
+
+    /**
+     * Optional icon to show in a button at the start of the slide. If non-null the button is
+     * shown. Clicking the button decrements the value by one step.
+     */
+    var decrementIcon: Drawable? = null
+
+    /**
+     * Optional icon to show in a button at the end of the slider. If non-null the button is
+     * shown. Clicking the button increments the value by one step.
+     */
+    var incrementIcon: Drawable? = null
+
+    /** View binding */
+    private lateinit var binding: PrefSliderBinding
+
+    init {
+        // Using `widgetLayoutResource` here would be incorrect, as that tries to put the entire
+        // preference layout to the right of the title and summary.
+        layoutResource = R.layout.pref_slider
+
+        val a = context.obtainStyledAttributes(attrs, R.styleable.SliderPreference, defStyleAttr, defStyleRes)
+
+        value = a.getFloat(R.styleable.Slider_android_value, defaultValue)
+        valueFrom = a.getFloat(R.styleable.SliderPreference_android_valueFrom, defaultValueFrom)
+        valueTo = a.getFloat(R.styleable.SliderPreference_android_valueTo, defaultValueTo)
+        stepSize = a.getFloat(R.styleable.SliderPreference_android_stepSize, defaultStepSize)
+        format = a.getString(R.styleable.SliderPreference_format) ?: defaultFormat
+
+        val decrementIconResource = a.getResourceId(R.styleable.SliderPreference_iconStart, -1)
+        if (decrementIconResource != -1) {
+            decrementIcon = AppCompatResources.getDrawable(context, decrementIconResource)
+        }
+
+        val incrementIconResource = a.getResourceId(R.styleable.SliderPreference_iconEnd, -1)
+        if (incrementIconResource != -1) {
+            incrementIcon = AppCompatResources.getDrawable(context, incrementIconResource)
+        }
+
+        a.recycle()
+    }
+
+    override fun onGetDefaultValue(a: TypedArray, i: Int): Any {
+        return a.getFloat(i, defaultValue)
+    }
+
+    override fun onSetInitialValue(defaultValue: Any?) {
+        value = getPersistedFloat((defaultValue ?: Companion.defaultValue) as Float)
+    }
+
+    override fun onBindViewHolder(holder: PreferenceViewHolder) {
+        super.onBindViewHolder(holder)
+        binding = PrefSliderBinding.bind(holder.itemView)
+
+        binding.root.isClickable = false
+
+        binding.slider.addOnChangeListener(this)
+        binding.slider.addOnSliderTouchListener(this)
+        binding.slider.value = value // sliderValue
+        binding.slider.valueTo = valueTo
+        binding.slider.valueFrom = valueFrom
+        binding.slider.stepSize = stepSize
+
+        // Disable the label, the value is shown in the preference summary
+        binding.slider.labelBehavior = LABEL_GONE
+        binding.slider.isEnabled = isEnabled
+
+        binding.summary.visibility = VISIBLE
+        binding.summary.text = formatter(value)
+
+        decrementIcon?.let { icon ->
+            binding.decrement.icon = icon
+            binding.decrement.visibility = VISIBLE
+            binding.decrement.setOnClickListener {
+                value -= stepSize
+            }
+        }
+
+        incrementIcon?.let { icon ->
+            binding.increment.icon = icon
+            binding.increment.visibility = VISIBLE
+            binding.increment.setOnClickListener {
+                value += stepSize
+            }
+        }
+    }
+
+    override fun onValueChange(slider: Slider, value: Float, fromUser: Boolean) {
+        if (!fromUser) return
+        binding.summary.text = formatter(value)
+    }
+
+    override fun onStartTrackingTouch(slider: Slider) {
+        // Deliberately empty
+    }
+
+    override fun onStopTrackingTouch(slider: Slider) {
+        value = slider.value
+    }
+
+    companion object {
+        const val TAG = "FloatSeekBarPreference"
+        const val defaultValueFrom = 0F
+        const val defaultValueTo = 1F
+        const val defaultValue = 0.5F
+        const val defaultStepSize = 0.1F
+        const val defaultFormat = "%3.1f"
+    }
+}