Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -25,7 +25,6 @@ import android.content.res.Configuration
import android.os.Bundle
import android.text.TextUtils
import android.util.Log
import android.util.TypedValue
import android.view.KeyEvent
import android.view.View
import android.view.ViewGroup.LayoutParams
Expand Down Expand Up @@ -135,7 +134,6 @@ import com.itsaky.androidide.utils.UniqueNameBuilder
import com.itsaky.androidide.utils.capHeightToSpaceBelow
import com.itsaky.androidide.utils.flashError
import com.itsaky.androidide.utils.flashSuccess
import com.itsaky.androidide.utils.forEachViewRecursively
import com.itsaky.androidide.utils.hasVisibleDialog
import com.itsaky.androidide.utils.isDeepLinkTargetOfOpenProject
import com.itsaky.androidide.utils.recordProjectOpenedBookkeeping
Expand All @@ -154,7 +152,6 @@ import org.greenrobot.eventbus.ThreadMode
import org.koin.android.ext.android.inject
import org.koin.core.qualifier.named
import java.io.File
import java.util.WeakHashMap
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.CopyOnWriteArrayList
import java.util.concurrent.atomic.AtomicBoolean
Expand Down Expand Up @@ -183,8 +180,7 @@ open class EditorHandlerActivity :

private val pluginTabIndices = mutableMapOf<String, Int>()
private val tabIndexToPluginId = mutableMapOf<Int, String>()
private var lastAppliedPluginFontScale = EditorPreferences.editorFontScale
private val pluginTextBaseSizes = WeakHashMap<TextView, Float>()
private val pluginTextScaler = PluginTextScaler(EditorPreferences.editorFontScale)

private val pluginFontScalingListener =
object : FragmentManager.FragmentLifecycleCallbacks() {
Expand All @@ -194,9 +190,8 @@ open class EditorHandlerActivity :
view: View,
savedInstanceState: Bundle?,
) {
val scale = EditorPreferences.editorFontScale
if (scale != 1f && isPluginFragment(mFragment)) {
applyPluginFontScale(view, scale)
if (isPluginFragment(mFragment)) {
Comment thread
davidschachterADFA marked this conversation as resolved.
Resolved
pluginTextScaler.track(view)
}
}
}
Expand Down Expand Up @@ -2026,47 +2021,13 @@ open class EditorHandlerActivity :
}
}

// Also run from onStart: the event is missed while another activity, such as Preferences, is in front.
private fun syncPluginUiFontSize() {
val scale = EditorPreferences.editorFontScale
if (scale == lastAppliedPluginFontScale) {
return
}
lastAppliedPluginFontScale = scale

val pluginFragments = mutableListOf<Fragment>()
collectPluginFragments(supportFragmentManager, pluginFragments)
pluginFragments.forEach { fragment ->
fragment.view?.let { applyPluginFontScale(it, scale) }
}
pluginTextScaler.onEditorFontScaleChanged(EditorPreferences.editorFontScale)
}

private fun isPluginFragment(fragment: Fragment): Boolean = fragment.javaClass.classLoader !== javaClass.classLoader

private fun applyPluginFontScale(
root: View,
scale: Float,
) {
root.forEachViewRecursively { view ->
if (view is TextView) {
val baseSize = pluginTextBaseSizes.getOrPut(view) { view.textSize }
view.setTextSize(TypedValue.COMPLEX_UNIT_PX, baseSize * scale)
}
}
}

private fun collectPluginFragments(
manager: FragmentManager,
into: MutableList<Fragment>,
) {
manager.fragments.forEach { fragment ->
if (isPluginFragment(fragment)) {
into.add(fragment)
} else {
collectPluginFragments(fragment.childFragmentManager, into)
}
}
}

/**
* Shows [dialog] above any floating windows, tracking it when it was actually raised.
*
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,180 @@
package com.itsaky.androidide.activities.editor

import android.util.TypedValue
import android.view.View
import android.view.ViewTreeObserver
import android.widget.TextView
import com.itsaky.androidide.utils.forEachViewRecursively
import java.util.Collections
import java.util.WeakHashMap
import kotlin.math.max

/**
* Scales the text in plugin views by the editor's font-size preference (ADFA-4212).
*
* The scale never goes below 1 (ADFA-7142). The editor's size goes down to 6sp, often by pinching
* the code, and plugin tabs followed it to under half their size. Views a plugin adds after its
* view was built (list rows, chips) are scaled too; without that, one panel mixed two sizes.
*
* Sizes are px, scaled from the size each [TextView] was given by its plugin, so applying the same
* scale twice changes nothing. A size the plugin sets again later becomes that view's new base.
* Auto-sized text is left alone: [TextView.setTextSize] does nothing to it.
*/
internal class PluginTextScaler(
editorFontScale: Float,
) {
private class Sizing(
val base: Float,
var applied: Float,
)

private val sizings = WeakHashMap<TextView, Sizing>()
private val trackedRoots: MutableSet<View> = Collections.newSetFromMap(WeakHashMap())

// Keyed by the window's observer; an entry lasts while some tracked root is in that window.
private val windowWatchers = HashMap<ViewTreeObserver, WindowWatcher>()

private var scale = max(1f, editorFontScale)

/**
* Scales the text under [root] now, and in the views added under it later. A root tracked
* again, as a fragment that reuses its view causes, is still watched once.
*/
fun track(root: View) {
scaleNewText(root)
if (trackedRoots.add(root)) {
root.addOnAttachStateChangeListener(attachListener)
if (root.isAttachedToWindow) startWatching(root)
}
}

/**
* Follows a change to the editor's font scale. Unless the plugin text scale stays the same (any
* size below the editor's default leaves it at 1), the text under every tracked root is rescaled,
* and so is every text view seen before that is now off the window, such as a pooled list row.
* After that no text is left at an old scale, so at scale 1 no frame needs a walk.
*/
fun onEditorFontScaleChanged(editorFontScale: Float) {
val newScale = max(1f, editorFontScale)
if (newScale == scale) return
scale = newScale
for (root in trackedRoots.toList()) {
root.forEachViewRecursively { view ->
if (view is TextView && !view.isAutoSized()) apply(view, sizingFor(view), scale)
}
}
for (view in sizings.keys.toList()) {
if (view.isAutoSized()) continue
val sizing = sizingFor(view)
if (sizing.applied != scale) apply(view, sizing, scale)
}
}

/**
* Brings every text view under [root] to the current scale: new ones, and ones the plugin
* resized. At scale 1 there is nothing to do: plugin text is drawn at its own size, and a scale
* change leaves no view at an old one. Returns whether any changed.
*/
private fun scaleNewText(root: View): Boolean {
if (scale == 1f) return false
var changed = false
root.forEachViewRecursively { view ->
if (view !is TextView || view.isAutoSized()) return@forEachViewRecursively
val sizing = sizingFor(view)
if (sizing.applied != scale) {
apply(view, sizing, scale)
changed = true
}
}
return changed
}

// Re-recorded when the size is no longer the one this class set: the plugin has set its own.
private fun sizingFor(view: TextView): Sizing {
val known = sizings[view]
if (known != null && view.textSize == known.base * known.applied) return known
Comment thread
davidschachterADFA marked this conversation as resolved.
Resolved
return Sizing(view.textSize, 1f).also { sizings[view] = it }
}

private fun apply(
view: TextView,
sizing: Sizing,
scale: Float,
) {
view.setTextSize(TypedValue.COMPLEX_UNIT_PX, sizing.base * scale)
sizing.applied = scale
}

private fun TextView.isAutoSized() = autoSizeTextType != TextView.AUTO_SIZE_TEXT_TYPE_NONE

private val attachListener =
object : View.OnAttachStateChangeListener {
override fun onViewAttachedToWindow(v: View) = startWatching(v)

override fun onViewDetachedFromWindow(v: View) = stopWatching(v)
}

private fun startWatching(root: View) {
val observer = root.viewTreeObserver
val watcher =
windowWatchers.getOrPut(observer) {
WindowWatcher().also { observer.addOnPreDrawListener(it) }
}
watcher.roots.add(root)
}

// Found by its roots: once a view has left its window, root.viewTreeObserver is a different
// observer, which could not remove the listener.
private fun stopWatching(root: View) {
val entry = windowWatchers.entries.firstOrNull { root in it.value.roots } ?: return
val (observer, watcher) = entry
watcher.roots.remove(root)
if (watcher.roots.isEmpty()) {
if (observer.isAlive) observer.removeOnPreDrawListener(watcher)
windowWatchers.remove(observer)
}
}

/**
* Catches views added under the tracked roots in one window before the frame that would draw
* them. A pre-draw listener, not a layout one: a scrolling RecyclerView or ListView adds rows
* without any layout pass. A frame in which something was resized is skipped, so its text is
* never drawn at the old size; the next one is laid out for the new size. Never two in a row,
* though: a plugin that sets its own size on every layout would otherwise have every frame
* skipped, and the window would stop drawing.
*
* One per window, not one per root: the window skips a frame if any of its listeners asks it
* to, so two roots each skipping every other frame, a frame apart, would skip them all. Plugin
* dialogs and bottom sheets are windows of their own, so each window decides for itself.
*/
private inner class WindowWatcher : ViewTreeObserver.OnPreDrawListener {
val roots = LinkedHashSet<View>()
private var skippedLast = false

// Hidden text is caught on the frame that first shows it. At scale 1 nothing is looked at:
// a scale change leaves no text at an old scale (see onEditorFontScaleChanged).
override fun onPreDraw(): Boolean {
if (scale == 1f) {
skippedLast = false
return true
}
var changed = false
for (root in roots) {
if (root.isShown && !isInsideAnotherRoot(root) && scaleNewText(root)) changed = true
}
val skip = changed && !skippedLast
skippedLast = skip
return !skip
}

// A plugin fragment nested in another's view is tracked too; the outer walk covers it.
private fun isInsideAnotherRoot(root: View): Boolean {
var parent = root.parent
while (parent is View) {
if (parent in roots) return true
parent = parent.parent
}
return false
}
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,108 @@
package com.itsaky.androidide.activities.editor

import android.util.TypedValue
import android.widget.TextView
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentManager
import com.google.common.truth.Truth.assertThat
import com.itsaky.androidide.app.BaseApplication
import com.itsaky.androidide.eventbus.events.preferences.PreferenceChangeEvent
import com.itsaky.androidide.preferences.internal.EditorPreferences
import org.greenrobot.eventbus.Subscribe
import org.greenrobot.eventbus.ThreadMode
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.Robolectric
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config

/**
* How [EditorHandlerActivity] feeds [PluginTextScaler] (ADFA-7142): which fragments it tracks and
* which preference changes rescale them. The activity is built but not created, as in the other
* activity tests here, so its own handlers run without the editor's views. Two calls need a
* created activity and are not reached: the callbacks' registration in `onCreate`, and the
* re-read in `onStart` (a direct `onStart` fails in FragmentManager without one).
*/
@RunWith(RobolectricTestRunner::class)
@Config(application = EditorPluginTextScalingTest.TestApp::class)
class EditorPluginTextScalingTest {
open class TestApp : BaseApplication()

/** Stands in for a plugin's fragment once [pluginFragment] loads it through its own class loader. */
class StandInFragment : Fragment()

@Test
fun onlyAPluginFragmentsViewIsScaled() {
EditorPreferences.fontSize = 28f
val activity = activity()
val pluginText = textView(activity)
val ideText = textView(activity)

fragmentCallbacks(activity).run {
onFragmentViewCreated(activity.supportFragmentManager, pluginFragment(), pluginText, null)
onFragmentViewCreated(activity.supportFragmentManager, StandInFragment(), ideText, null)
}

assertThat(pluginText.textSize).isEqualTo(40f)
assertThat(ideText.textSize).isEqualTo(20f)
}

@Test
fun aFontSizeChangeRescalesPluginTextAndOtherPreferencesDoNot() {
val activity = activity()
val text = textView(activity)
fragmentCallbacks(activity).onFragmentViewCreated(activity.supportFragmentManager, pluginFragment(), text, null)
assertThat(text.textSize).isEqualTo(20f)

EditorPreferences.fontSize = 28f
activity.onPreferenceChanged(PreferenceChangeEvent(EditorPreferences.TAB_SIZE, 8))
assertThat(text.textSize).isEqualTo(20f)

activity.onPreferenceChanged(PreferenceChangeEvent(EditorPreferences.FONT_SIZE, 28f))
assertThat(text.textSize).isEqualTo(40f)
}

// Pinch-zoom saves through PreferenceManager, which posts the event; this is what receives it.
@Test
fun theFontSizeHandlerIsSubscribedOnTheMainThread() {
val subscribe =
EditorHandlerActivity::class.java
.getMethod("onPreferenceChanged", PreferenceChangeEvent::class.java)
.getAnnotation(Subscribe::class.java)

assertThat(subscribe).isNotNull()
assertThat(subscribe!!.threadMode).isEqualTo(ThreadMode.MAIN)
}

private fun activity(): EditorHandlerActivity = Robolectric.buildActivity(EditorHandlerActivity::class.java).get()

private fun textView(activity: EditorHandlerActivity) = TextView(activity).apply { setTextSize(TypedValue.COMPLEX_UNIT_PX, 20f) }

private fun fragmentCallbacks(activity: EditorHandlerActivity) =
EditorHandlerActivity::class.java
.getDeclaredField("pluginFontScalingListener")
.apply { isAccessible = true }
.get(activity) as FragmentManager.FragmentLifecycleCallbacks

// The activity tells a plugin's fragment by its class loader, so define the stand-in again in
// a loader of its own, the way the plugin manager loads a .cgp.
private fun pluginFragment(): Fragment {
val name = StandInFragment::class.java.name
val parent = StandInFragment::class.java.classLoader!!
val loader =
object : ClassLoader(parent) {
override fun loadClass(
className: String,
resolve: Boolean,
): Class<*> {
if (className != name) return super.loadClass(className, resolve)
synchronized(this) {
findLoadedClass(className)?.let { return it }
val bytes = parent.getResourceAsStream(className.replace('.', '/') + ".class")!!.use { it.readBytes() }
return defineClass(className, bytes, 0, bytes.size)
}
}
}
return loader.loadClass(name).getDeclaredConstructor().newInstance() as Fragment
}
}
Loading
Loading