react-native-enriched-markdown 0.1.1 → 0.2.0

package/android/src/main/java/com/swmansion/enriched/markdown/EnrichedMarkdownText.kt

@@ -1,25 +1,32 @@
 package com.swmansion.enriched.markdown
 
 import android.content.Context
+import android.content.res.Configuration
 import android.graphics.Color
+import android.os.Build
 import android.os.Handler
 import android.os.Looper
-import android.text.method.LinkMovementMethod
+import android.text.Layout
 import android.util.AttributeSet
 import android.util.Log
 import androidx.appcompat.widget.AppCompatTextView
+import androidx.core.view.ViewCompat
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.uimanager.UIManagerHelper
+import com.swmansion.enriched.markdown.accessibility.MarkdownAccessibilityHelper
+import com.swmansion.enriched.markdown.events.LinkLongPressEvent
 import com.swmansion.enriched.markdown.events.LinkPressEvent
+import com.swmansion.enriched.markdown.parser.Md4cFlags
 import com.swmansion.enriched.markdown.parser.Parser
 import com.swmansion.enriched.markdown.renderer.Renderer
 import com.swmansion.enriched.markdown.styles.StyleConfig
+import com.swmansion.enriched.markdown.utils.LinkLongPressMovementMethod
 import com.swmansion.enriched.markdown.utils.createSelectionActionModeCallback
 import java.util.concurrent.Executors
 
 /**
  * EnrichedMarkdownText that handles Markdown parsing and rendering on a background thread.
- * Utilizes PrecomputedText for smoother UI updates on supported Android versions.
+ * View starts invisible and becomes visible after render completes to avoid layout shift.
  */
 class EnrichedMarkdownText
   @JvmOverloads
@@ -31,26 +38,45 @@ class EnrichedMarkdownText
     private val parser = Parser.shared
     private val renderer = Renderer()
     private var onLinkPressCallback: ((String) -> Unit)? = null
+    private var onLinkLongPressCallback: ((String) -> Unit)? = null
 
-    // Background processing tools
     private val mainHandler = Handler(Looper.getMainLooper())
     private val executor = Executors.newSingleThreadExecutor()
     private var currentRenderId = 0L
 
     val layoutManager = EnrichedMarkdownTextLayoutManager(this)
 
+    // Accessibility helper for TalkBack support
+    private val accessibilityHelper = MarkdownAccessibilityHelper(this)
+
     var markdownStyle: StyleConfig? = null
       private set
 
     var currentMarkdown: String = ""
       private set
 
+    var md4cFlags: Md4cFlags = Md4cFlags.DEFAULT
+      private set
+
+    private var lastKnownFontScale: Float = context.resources.configuration.fontScale
+    private var markdownStyleMap: ReadableMap? = null
+
+    private var allowFontScaling: Boolean = true
+    private var maxFontSizeMultiplier: Float = 0f
+    private var allowTrailingMargin: Boolean = false
+
     init {
       setBackgroundColor(Color.TRANSPARENT)
       includeFontPadding = false // Must match setIncludePad(false) in MeasurementStore
-      movementMethod = LinkMovementMethod.getInstance()
+      movementMethod = LinkLongPressMovementMethod.createInstance()
       setTextIsSelectable(true)
       customSelectionActionModeCallback = createSelectionActionModeCallback(this)
+      isVerticalScrollBarEnabled = false
+      isHorizontalScrollBarEnabled = false
+
+      // Set up accessibility for TalkBack
+      // This enables virtual view hierarchy for semantic navigation (headings, links, etc.)
+      ViewCompat.setAccessibilityDelegate(this, accessibilityHelper)
     }
 
     fun setMarkdownContent(markdown: String) {
@@ -60,25 +86,100 @@ class EnrichedMarkdownText
     }
 
     fun setMarkdownStyle(style: ReadableMap?) {
-      val newStyle = style?.let { StyleConfig(it, context) }
+      markdownStyleMap = style
+      // Register font scaling settings when style is set (view should have ID by now)
+      updateMeasurementStoreFontScaling()
+      val newStyle = style?.let { StyleConfig(it, context, allowFontScaling, maxFontSizeMultiplier) }
       if (markdownStyle == newStyle) return
-
       markdownStyle = newStyle
+      updateJustificationMode(newStyle)
       scheduleRender()
     }
 
+    override fun onConfigurationChanged(newConfig: Configuration) {
+      super.onConfigurationChanged(newConfig)
+
+      if (!allowFontScaling) {
+        return
+      }
+
+      val newFontScale = newConfig.fontScale
+      if (newFontScale != lastKnownFontScale) {
+        lastKnownFontScale = newFontScale
+        recreateStyleConfig()
+        scheduleRenderIfNeeded()
+      }
+    }
+
+    fun setMd4cFlags(flags: Md4cFlags) {
+      if (md4cFlags == flags) return
+      md4cFlags = flags
+      scheduleRenderIfNeeded()
+    }
+
+    fun setAllowFontScaling(allow: Boolean) {
+      if (allowFontScaling == allow) return
+      allowFontScaling = allow
+      updateMeasurementStoreFontScaling()
+      recreateStyleConfig()
+      scheduleRenderIfNeeded()
+    }
+
+    fun setMaxFontSizeMultiplier(multiplier: Float) {
+      if (maxFontSizeMultiplier == multiplier) return
+      maxFontSizeMultiplier = multiplier
+      updateMeasurementStoreFontScaling()
+      recreateStyleConfig()
+      scheduleRenderIfNeeded()
+    }
+
+    fun setAllowTrailingMargin(allow: Boolean) {
+      if (allowTrailingMargin == allow) return
+      allowTrailingMargin = allow
+      scheduleRenderIfNeeded()
+    }
+
+    private fun updateMeasurementStoreFontScaling() {
+      MeasurementStore.updateFontScalingSettings(id, allowFontScaling, maxFontSizeMultiplier)
+    }
+
+    private fun scheduleRenderIfNeeded() {
+      if (currentMarkdown.isNotEmpty()) {
+        scheduleRender()
+      }
+    }
+
+    private fun recreateStyleConfig() {
+      markdownStyleMap?.let { styleMap ->
+        markdownStyle = StyleConfig(styleMap, context, allowFontScaling, maxFontSizeMultiplier)
+        updateJustificationMode(markdownStyle)
+      }
+    }
+
+    private fun updateJustificationMode(style: StyleConfig?) {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        justificationMode =
+          if (style?.needsJustify == true) {
+            Layout.JUSTIFICATION_MODE_INTER_WORD
+          } else {
+            Layout.JUSTIFICATION_MODE_NONE
+          }
+      }
+    }
+
     private fun scheduleRender() {
       val style = markdownStyle ?: return
       val markdown = currentMarkdown
+      if (markdown.isEmpty()) return
+
       val renderId = ++currentRenderId
-      val scheduleStart = System.currentTimeMillis()
 
       executor.execute {
         try {
           // 1. Parse Markdown → AST (C++ md4c parser)
           val parseStart = System.currentTimeMillis()
           val ast =
-            parser.parseMarkdown(markdown) ?: run {
+            parser.parseMarkdown(markdown, md4cFlags) ?: run {
               mainHandler.post { if (renderId == currentRenderId) text = "" }
               return@execute
             }
@@ -87,7 +188,7 @@ class EnrichedMarkdownText
           // 2. Render AST → Spannable
           val renderStart = System.currentTimeMillis()
           renderer.configure(style, context)
-          val styledText = renderer.renderDocument(ast, onLinkPressCallback)
+          val styledText = renderer.renderDocument(ast, onLinkPressCallback, onLinkLongPressCallback)
           val renderTime = System.currentTimeMillis() - renderStart
 
           Log.i(TAG, "┌──────────────────────────────────────────────")
@@ -96,10 +197,10 @@ class EnrichedMarkdownText
           Log.i(TAG, "│ 🎨 Spannable render: ${renderTime}ms → ${styledText.length} styled chars")
           Log.i(TAG, "└──────────────────────────────────────────────")
 
+          // 3. Apply to view on main thread
           mainHandler.post {
             if (renderId == currentRenderId) {
               applyRenderedText(styledText)
-              Log.i(TAG, "✅ Total time to display: ${System.currentTimeMillis() - scheduleStart}ms")
             }
           }
         } catch (e: Exception) {
@@ -110,12 +211,11 @@ class EnrichedMarkdownText
     }
 
     private fun applyRenderedText(styledText: CharSequence) {
-      // Sets the text. If it's PrecomputedText, the UI thread skips the measure pass.
       text = styledText
 
-      // LinkMovementMethod check (setText can sometimes reset it)
-      if (movementMethod !is LinkMovementMethod) {
-        movementMethod = LinkMovementMethod.getInstance()
+      // setText on a selectable TextView can reset movementMethod, so re-apply if needed
+      if (movementMethod !is LinkLongPressMovementMethod) {
+        movementMethod = LinkLongPressMovementMethod.createInstance()
       }
 
       // Register ImageSpans from the collector
@@ -124,12 +224,15 @@ class EnrichedMarkdownText
       }
 
       layoutManager.invalidateLayout()
+
+      // Update accessibility items for TalkBack navigation
+      accessibilityHelper.invalidateAccessibilityItems()
     }
 
     fun setIsSelectable(selectable: Boolean) {
       if (isTextSelectable == selectable) return
       setTextIsSelectable(selectable)
-      movementMethod = LinkMovementMethod.getInstance()
+      movementMethod = LinkLongPressMovementMethod.createInstance()
       if (!selectable && !isClickable) isClickable = true
     }
 
@@ -143,10 +246,24 @@ class EnrichedMarkdownText
       )
     }
 
+    fun emitOnLinkLongPress(url: String) {
+      val reactContext = context as? com.facebook.react.bridge.ReactContext ?: return
+      val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+      val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+
+      dispatcher?.dispatchEvent(
+        LinkLongPressEvent(surfaceId, id, url),
+      )
+    }
+
     fun setOnLinkPressCallback(callback: (String) -> Unit) {
       onLinkPressCallback = callback
     }
 
+    fun setOnLinkLongPressCallback(callback: (String) -> Unit) {
+      onLinkLongPressCallback = callback
+    }
+
     companion object {
       private const val TAG = "EnrichedMarkdownMeasure"
     }

package/android/src/main/java/com/swmansion/enriched/markdown/EnrichedMarkdownTextLayoutManager.kt

@@ -1,27 +1,12 @@
 package com.swmansion.enriched.markdown
 
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.uimanager.StateWrapper
-
 class EnrichedMarkdownTextLayoutManager(
   private val view: EnrichedMarkdownText,
 ) {
-  private var forceHeightRecalculationCounter: Int = 0
-
-  var stateWrapper: StateWrapper? = null
-
   fun invalidateLayout() {
     val text = view.text
     val paint = view.paint
-
-    val needUpdate = MeasurementStore.store(view.id, text, paint)
-    if (!needUpdate) return
-
-    val counter = forceHeightRecalculationCounter
-    forceHeightRecalculationCounter++
-    val state = Arguments.createMap()
-    state.putInt("forceHeightRecalculationCounter", counter)
-    stateWrapper?.updateState(state)
+    MeasurementStore.store(view.id, text, paint)
   }
 
   fun releaseMeasurementStore() {

package/android/src/main/java/com/swmansion/enriched/markdown/EnrichedMarkdownTextManager.kt

@@ -3,9 +3,7 @@ package com.swmansion.enriched.markdown
 import android.content.Context
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.module.annotations.ReactModule
-import com.facebook.react.uimanager.ReactStylesDiffMap
 import com.facebook.react.uimanager.SimpleViewManager
-import com.facebook.react.uimanager.StateWrapper
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.ViewManagerDelegate
@@ -13,7 +11,9 @@ import com.facebook.react.uimanager.annotations.ReactProp
 import com.facebook.react.viewmanagers.EnrichedMarkdownTextManagerDelegate
 import com.facebook.react.viewmanagers.EnrichedMarkdownTextManagerInterface
 import com.facebook.yoga.YogaMeasureMode
+import com.swmansion.enriched.markdown.events.LinkLongPressEvent
 import com.swmansion.enriched.markdown.events.LinkPressEvent
+import com.swmansion.enriched.markdown.parser.Md4cFlags
 
 @ReactModule(name = EnrichedMarkdownTextManager.NAME)
 class EnrichedMarkdownTextManager :
@@ -29,21 +29,14 @@ class EnrichedMarkdownTextManager :
 
   override fun onDropViewInstance(view: EnrichedMarkdownText) {
     super.onDropViewInstance(view)
+    MeasurementStore.clearFontScalingSettings(view.id)
     view.layoutManager.releaseMeasurementStore()
   }
 
-  override fun updateState(
-    view: EnrichedMarkdownText,
-    props: ReactStylesDiffMap?,
-    stateWrapper: StateWrapper?,
-  ): Any? {
-    view.layoutManager.stateWrapper = stateWrapper
-    return super.updateState(view, props, stateWrapper)
-  }
-
   override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> {
     val map = mutableMapOf<String, Any>()
     map.put(LinkPressEvent.EVENT_NAME, mapOf("registrationName" to LinkPressEvent.EVENT_NAME))
+    map.put(LinkLongPressEvent.EVENT_NAME, mapOf("registrationName" to LinkLongPressEvent.EVENT_NAME))
     return map
   }
 
@@ -56,6 +49,10 @@ class EnrichedMarkdownTextManager :
       emitOnLinkPress(view, url)
     }
 
+    view?.setOnLinkLongPressCallback { url ->
+      emitOnLinkLongPress(view, url)
+    }
+
     view?.setMarkdownContent(markdown ?: "No markdown content")
   }
 
@@ -67,14 +64,59 @@ class EnrichedMarkdownTextManager :
     view?.setMarkdownStyle(style)
   }
 
-  @ReactProp(name = "isSelectable", defaultBoolean = true)
-  override fun setIsSelectable(
+  @ReactProp(name = "selectable", defaultBoolean = true)
+  override fun setSelectable(
     view: EnrichedMarkdownText?,
     selectable: Boolean,
   ) {
     view?.setIsSelectable(selectable)
   }
 
+  @ReactProp(name = "md4cFlags")
+  override fun setMd4cFlags(
+    view: EnrichedMarkdownText?,
+    flags: ReadableMap?,
+  ) {
+    val md4cFlags =
+      Md4cFlags(
+        underline = flags?.getBoolean("underline") ?: false,
+      )
+    view?.setMd4cFlags(md4cFlags)
+  }
+
+  @ReactProp(name = "allowFontScaling", defaultBoolean = true)
+  override fun setAllowFontScaling(
+    view: EnrichedMarkdownText?,
+    allowFontScaling: Boolean,
+  ) {
+    view?.setAllowFontScaling(allowFontScaling)
+  }
+
+  @ReactProp(name = "maxFontSizeMultiplier", defaultFloat = 0f)
+  override fun setMaxFontSizeMultiplier(
+    view: EnrichedMarkdownText?,
+    maxFontSizeMultiplier: Float,
+  ) {
+    view?.setMaxFontSizeMultiplier(maxFontSizeMultiplier)
+  }
+
+  @ReactProp(name = "allowTrailingMargin", defaultBoolean = false)
+  override fun setAllowTrailingMargin(
+    view: EnrichedMarkdownText?,
+    allowTrailingMargin: Boolean,
+  ) {
+    view?.setAllowTrailingMargin(allowTrailingMargin)
+  }
+
+  @ReactProp(name = "enableLinkPreview", defaultBoolean = true)
+  override fun setEnableLinkPreview(
+    view: EnrichedMarkdownText?,
+    enableLinkPreview: Boolean,
+  ) {
+    // This prop is only used on iOS (to control the system link preview on long press).
+    // Required by the codegen interface but is a no-op on Android.
+  }
+
   override fun setPadding(
     view: EnrichedMarkdownText,
     left: Int,
@@ -98,6 +140,18 @@ class EnrichedMarkdownTextManager :
     eventDispatcher?.dispatchEvent(event)
   }
 
+  private fun emitOnLinkLongPress(
+    view: EnrichedMarkdownText,
+    url: String,
+  ) {
+    val context = view.context as com.facebook.react.bridge.ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(context)
+    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+    val event = LinkLongPressEvent(surfaceId, view.id, url)
+
+    eventDispatcher?.dispatchEvent(event)
+  }
+
   override fun measure(
     context: Context,
     localData: ReadableMap?,