react-native-readium 4.0.2 → 5.0.0-rc.1

package/android/src/main/java/com/reactnativereadium/reader/BaseReaderFragment.kt

@@ -4,20 +4,26 @@ import android.os.Bundle
 import android.view.*
 import androidx.fragment.app.Fragment
 import androidx.lifecycle.lifecycleScope
+import com.reactnativereadium.utils.EventChannel
 import com.reactnativereadium.utils.LinkOrLocator
+import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
-import org.readium.r2.navigator.*
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.delay
+import org.readium.r2.navigator.Decoration
+import org.readium.r2.navigator.DecorableNavigator
+import org.readium.r2.navigator.Navigator
+import org.readium.r2.navigator.OverflowableNavigator
+import org.readium.r2.navigator.SelectableNavigator
 import org.readium.r2.shared.publication.Locator
-import com.reactnativereadium.utils.EventChannel
-import kotlinx.coroutines.channels.Channel
+import org.readium.r2.shared.publication.services.positions
 
 /*
  * Base reader fragment class
  *
  * Provides common menu items and saves last location on stop.
  */
-@OptIn(ExperimentalDecorator::class)
 abstract class BaseReaderFragment : Fragment() {
   val channel = EventChannel(
     Channel<ReaderViewModel.Event>(Channel.BUFFERED),
@@ -27,6 +33,24 @@ abstract class BaseReaderFragment : Fragment() {
   protected abstract val model: ReaderViewModel
   protected abstract val navigator: Navigator
 
+  // Track active decoration listeners to avoid duplicates
+  private val activeDecorationGroups = mutableSetOf<String>()
+
+  // Store decorations if they're set before navigator is ready
+  private var pendingDecorations: Map<String, List<Decoration>>? = null
+
+  // Check if navigator is ready to use
+  private val isNavigatorReady: Boolean
+    get() {
+      if (view == null) return false
+      return try {
+        navigator
+        true
+      } catch (e: UninitializedPropertyAccessException) {
+        false
+      }
+    }
+
   override fun onCreate(savedInstanceState: Bundle?) {
     setHasOptionsMenu(true)
     super.onCreate(savedInstanceState)
@@ -37,10 +61,33 @@ abstract class BaseReaderFragment : Fragment() {
 
     val viewScope = viewLifecycleOwner.lifecycleScope
 
-    channel.send(ReaderViewModel.Event.TableOfContentsLoaded(model.publication.tableOfContents))
+    // Emit PublicationReady event with all metadata
+    viewScope.launch {
+      // positions() is a suspending function that returns List<Locator>
+      val positions = try {
+        model.publication.positions()
+      } catch (e: Exception) {
+        emptyList<Locator>()
+      }
+
+      channel.send(
+        ReaderViewModel.Event.PublicationReady(
+          tableOfContents = model.publication.tableOfContents,
+          positions = positions,
+          metadata = model.publication.metadata
+        )
+      )
+    }
+
     navigator.currentLocator
       .onEach { channel.send(ReaderViewModel.Event.LocatorUpdate(it)) }
       .launchIn(viewScope)
+
+    // Apply any pending decorations now that navigator is ready
+    pendingDecorations?.let { applyDecorations(it) }
+
+    // Start monitoring text selection
+    startSelectionMonitoring()
   }
 
   override fun onHiddenChanged(hidden: Boolean) {
@@ -50,10 +97,16 @@ abstract class BaseReaderFragment : Fragment() {
   }
 
   fun go(location: LinkOrLocator, animated: Boolean): Boolean {
+    // Check if navigator is initialized
+    if (!isNavigatorReady) {
+      android.util.Log.w("BaseReaderFragment", "Navigator not initialized yet")
+      return false
+    }
+
     var locator: Locator? = null
     when (location) {
       is LinkOrLocator.Link -> {
-        locator = navigator.publication.locatorFromLink(location.link)
+        locator = model.publication.locatorFromLink(location.link)
       }
       is LinkOrLocator.Locator -> {
         locator = location.locator
@@ -73,4 +126,159 @@ abstract class BaseReaderFragment : Fragment() {
     return navigator.go(locator, animated)
   }
 
+  fun goForward(): Boolean {
+    if (!isNavigatorReady) return false
+    val overflowNav = navigator as? OverflowableNavigator ?: return false
+    return overflowNav.goForward(animated = true)
+  }
+
+  fun goBackward(): Boolean {
+    if (!isNavigatorReady) return false
+    val overflowNav = navigator as? OverflowableNavigator ?: return false
+    return overflowNav.goBackward(animated = true)
+  }
+
+  /**
+   * Apply pre-converted Readium decoration groups directly (no JSON round-trip).
+   */
+  fun applyDecorations(groups: Map<String, List<Decoration>>?) {
+    if (groups == null) {
+      pendingDecorations = null
+      return
+    }
+
+    // Check if navigator is initialized
+    if (!isNavigatorReady) {
+      pendingDecorations = groups
+      return
+    }
+
+    val decorableNavigator = navigator as? DecorableNavigator
+    if (decorableNavigator == null) {
+      android.util.Log.w("BaseReaderFragment", "Navigator does not support decorations")
+      return
+    }
+
+    val viewScope = viewLifecycleOwner.lifecycleScope
+
+    groups.forEach { (group, decorations) ->
+      viewScope.launch {
+        decorableNavigator.applyDecorations(decorations, group)
+      }
+
+      // Set up listener for this group if not already active
+      if (!activeDecorationGroups.contains(group)) {
+        activeDecorationGroups.add(group)
+        setupDecorationListener(decorableNavigator, group)
+      }
+    }
+
+    // Clear pending decorations as they've been applied
+    pendingDecorations = null
+  }
+
+  /**
+   * Set up a decoration listener for a specific group
+   */
+  private fun setupDecorationListener(decorableNavigator: DecorableNavigator, group: String) {
+    val viewScope = viewLifecycleOwner.lifecycleScope
+
+    decorableNavigator.addDecorationListener(group, object : DecorableNavigator.Listener {
+      override fun onDecorationActivated(event: DecorableNavigator.OnActivatedEvent): Boolean {
+        viewScope.launch {
+          channel.send(
+            ReaderViewModel.Event.DecorationActivated(
+              decoration = event.decoration,
+              group = event.group,
+              rect = event.rect,
+              point = event.point
+            )
+          )
+        }
+        return true
+      }
+    })
+  }
+
+  /**
+   * Get the current text selection from the navigator
+   * Returns the selection locator which includes text position information needed for highlighting
+   */
+  suspend fun getCurrentSelection(): Locator? {
+    if (!isNavigatorReady) {
+      android.util.Log.w("BaseReaderFragment", "Navigator not initialized yet")
+      return null
+    }
+
+    val selectableNavigator = navigator as? SelectableNavigator
+    if (selectableNavigator == null) {
+      android.util.Log.w("BaseReaderFragment", "Navigator does not support text selection")
+      return null
+    }
+
+    val selection = selectableNavigator.currentSelection()
+    if (selection == null) {
+      return null
+    }
+
+    return selection.locator
+  }
+
+  /**
+   * Start monitoring text selection and emit selection change events.
+   *
+   * Uses 500ms polling because Readium's [SelectableNavigator] does not
+   * provide an observable API (Flow, callback, or listener) for selection
+   * changes. The only available method is the suspending
+   * [SelectableNavigator.currentSelection], which must be called on-demand.
+   * Polling is the least-invasive way to detect changes without forking the
+   * Readium toolkit.
+   */
+  private fun startSelectionMonitoring() {
+    val viewScope = viewLifecycleOwner.lifecycleScope
+
+    viewScope.launch {
+      var previousSelection: Locator? = null
+
+      while (true) {
+        delay(500) // Check every 500ms
+
+        if (!isNavigatorReady) continue
+
+        val selectableNavigator = navigator as? SelectableNavigator
+        if (selectableNavigator == null) continue
+
+        val currentSelection = try {
+          selectableNavigator.currentSelection()
+        } catch (e: Exception) {
+          android.util.Log.w("BaseReaderFragment", "Error getting selection: ${e.message}")
+          null
+        }
+
+        val currentLocator = currentSelection?.locator
+        val currentText = currentLocator?.text?.highlight
+
+        // Check if selection has changed
+        val hasChanged = when {
+          previousSelection == null && currentLocator == null -> false
+          previousSelection == null || currentLocator == null -> true
+          previousSelection.href != currentLocator.href -> true
+          previousSelection.text.highlight != currentText -> true
+          else -> false
+        }
+
+        if (hasChanged) {
+          channel.send(
+            ReaderViewModel.Event.SelectionChanged(
+              locator = currentLocator,
+              selectedText = currentText
+            )
+          )
+
+          previousSelection = currentLocator
+        }
+      }
+    }
+  }
+
 }

package/android/src/main/java/com/reactnativereadium/reader/EpubReaderFragment.kt

@@ -6,49 +6,63 @@
 
 package com.reactnativereadium.reader
 
-import android.graphics.Color
-import android.graphics.PointF
 import android.os.Bundle
 import android.view.*
 import android.view.accessibility.AccessibilityManager
 import androidx.appcompat.app.AppCompatActivity
-import androidx.appcompat.widget.SearchView
 import androidx.fragment.app.commitNow
 import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.lifecycleScope
 import com.reactnativereadium.R
-import com.reactnativereadium.utils.toggleSystemUi
-import java.net.URL
-import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import org.readium.r2.navigator.DecorableNavigator
+import org.readium.r2.navigator.SelectableNavigator
 import org.readium.r2.navigator.epub.EpubNavigatorFragment
-import org.readium.r2.navigator.ExperimentalDecorator
 import org.readium.r2.navigator.Navigator
 import org.readium.r2.navigator.epub.EpubPreferences
-import org.readium.r2.navigator.epub.EpubPreferencesSerializer
+import org.readium.r2.navigator.epub.EpubNavigatorFactory
 import org.readium.r2.shared.publication.Locator
 import org.readium.r2.shared.publication.Publication
-import org.readium.r2.shared.ReadiumCSSName
+import org.readium.r2.navigator.preferences.Theme
 
-@OptIn(ExperimentalDecorator::class)
-class EpubReaderFragment : VisualReaderFragment(), EpubNavigatorFragment.Listener {
+data class SelectionAction(
+    val id: String,
+    val label: String
+)
+
+class EpubReaderFragment : VisualReaderFragment() {
 
     override lateinit var model: ReaderViewModel
     override lateinit var navigator: Navigator
     private lateinit var publication: Publication
     lateinit var navigatorFragment: EpubNavigatorFragment
     private lateinit var factory: ReaderViewModel.Factory
-    private var initialPreferencesJsonString: String? = null
-
-    private lateinit var menuScreenReader: MenuItem
-    private lateinit var menuSearch: MenuItem
-    lateinit var menuSearchView: SearchView
+    private lateinit var navigatorFactory: EpubNavigatorFactory
+    private var pendingPreferences: EpubPreferences? = null
 
     private lateinit var userPreferences: EpubPreferences
-    private var isScreenReaderVisible = false
-    private var isSearchViewIconified = true
 
     // Accessibility
     private var isExploreByTouchEnabled = false
 
+    // Selection actions configuration
+    private var selectionActions: List<SelectionAction> = emptyList()
+
+    // Custom selection action mode callback for adding custom action buttons
+    val customSelectionActionModeCallback: ActionMode.Callback by lazy {
+        SelectionActionModeCallback()
+    }
+
+    private fun ensureUserPreferencesInitialized() {
+      if (this::userPreferences.isInitialized) return
+      userPreferences = pendingPreferences ?: EpubPreferences()
+    }
+
+    private fun applyPendingPreferencesIfNeeded() {
+      if (!this::navigator.isInitialized) return
+      pendingPreferences?.let { updatePreferences(it) }
+    }
+
     fun initFactory(
       publication: Publication,
       initialLocation: Locator?
@@ -57,29 +71,40 @@ class EpubReaderFragment : VisualReaderFragment(), EpubNavigatorFragment.Listene
         publication,
         initialLocation
       )
+      navigatorFactory = EpubNavigatorFactory(publication)
     }
 
-    fun updatePreferencesFromJsonString(serialisedPreferences: String) {
-      if (this::userPreferences.isInitialized) {
-        val serializer = EpubPreferencesSerializer()
-        this.userPreferences = serializer.deserialize(serialisedPreferences)
-        if (navigator is EpubNavigatorFragment) {
-          (navigator as EpubNavigatorFragment).submitPreferences(this.userPreferences)
-        }
-        initialPreferencesJsonString = null
+    fun updatePreferences(epubPreferences: EpubPreferences) {
+      userPreferences = epubPreferences
+
+      if (this::navigator.isInitialized && navigator is EpubNavigatorFragment) {
+        (navigator as EpubNavigatorFragment).submitPreferences(userPreferences)
+        pendingPreferences = null
+
+        // Update position label color to match theme, similar to iOS implementation
+        updatePositionLabelColor()
       } else {
-        initialPreferencesJsonString = serialisedPreferences
+        pendingPreferences = epubPreferences
       }
     }
 
-    override fun onCreate(savedInstanceState: Bundle?) {
-        // FIXME: this should be checked
-        // check(R2App.isServerStarted)
+    private fun updatePositionLabelColor() {
+      // Priority 1: Use explicit textColor if set
+      val color = userPreferences.textColor?.int
+      // Priority 2: Use theme's content color
+      ?: userPreferences.theme?.contentColor
+      // Priority 3: Default to dark gray
+      ?: android.graphics.Color.DKGRAY
 
-        if (savedInstanceState != null) {
-            isScreenReaderVisible = savedInstanceState.getBoolean(IS_SCREEN_READER_VISIBLE_KEY)
-            isSearchViewIconified = savedInstanceState.getBoolean(IS_SEARCH_VIEW_ICONIFIED)
-        }
+      setPositionLabelColor(color)
+    }
+
+    fun updateSelectionActions(actions: List<SelectionAction>) {
+      selectionActions = actions
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+      check(::navigatorFactory.isInitialized) { "EpubReaderFragment factory was not initialized" }
 
         ViewModelProvider(this, factory)
           .get(ReaderViewModel::class.java)
@@ -88,18 +113,15 @@ class EpubReaderFragment : VisualReaderFragment(), EpubNavigatorFragment.Listene
             publication = it.publication
           }
 
+          ensureUserPreferencesInitialized()
 
-        childFragmentManager.fragmentFactory =
-            EpubNavigatorFragment.createFactory(
-                publication = publication,
-                initialLocator = model.initialLocation,
-                listener = this,
-                config = EpubNavigatorFragment.Configuration().apply {
-                    // Register the HTML template for our custom [DecorationStyleAnnotationMark].
-                    // TODO: remove?
-                    /* decorationTemplates[DecorationStyleAnnotationMark::class] = annotationMarkTemplate(activity) */
-                    /* selectionActionModeCallback = customSelectionActionModeCallback */
-                }
+          childFragmentManager.fragmentFactory =
+            navigatorFactory.createFragmentFactory(
+              initialLocator = model.initialLocation,
+              initialPreferences = userPreferences,
+              configuration = EpubNavigatorFragment.Configuration {
+                selectionActionModeCallback = customSelectionActionModeCallback
+              }
             )
 
         setHasOptionsMenu(true)
@@ -119,57 +141,108 @@ class EpubReaderFragment : VisualReaderFragment(), EpubNavigatorFragment.Listene
         navigator = childFragmentManager.findFragmentByTag(navigatorFragmentTag) as Navigator
         navigatorFragment = navigator as EpubNavigatorFragment
 
+        applyPendingPreferencesIfNeeded()
+
         return view
     }
 
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         super.onViewCreated(view, savedInstanceState)
+
+        // Set initial position label color based on current preferences
+        updatePositionLabelColor()
     }
 
     override fun onResume() {
         super.onResume()
         val activity = requireActivity()
 
-        if (!this::userPreferences.isInitialized) {
-          userPreferences = EpubPreferences()
-        }
-        initialPreferencesJsonString?.let { updatePreferencesFromJsonString(it)}
+        ensureUserPreferencesInitialized()
+        applyPendingPreferencesIfNeeded()
 
         // If TalkBack or any touch exploration service is activated we force scroll mode (and
         // override user preferences)
         val am = activity.getSystemService(AppCompatActivity.ACCESSIBILITY_SERVICE) as AccessibilityManager
         isExploreByTouchEnabled = am.isTouchExplorationEnabled
 
-        if (isExploreByTouchEnabled) {
-          this.userPreferences = this.userPreferences.plus(
-            EpubPreferences(scroll = true)
-          )
+        userPreferences = if (isExploreByTouchEnabled) {
+            userPreferences.plus(EpubPreferences(scroll = true))
         } else {
-            if (publication.cssStyle != "cjk-vertical") {
-              this.userPreferences = this.userPreferences.plus(
-                EpubPreferences(scroll = null)
-              )
-            }
+            userPreferences.plus(EpubPreferences(scroll = null))
         }
+        (navigator as? EpubNavigatorFragment)?.submitPreferences(userPreferences)
     }
 
-    override fun onSaveInstanceState(outState: Bundle) {
-        super.onSaveInstanceState(outState)
-        outState.putBoolean(IS_SCREEN_READER_VISIBLE_KEY, isScreenReaderVisible)
-        outState.putBoolean(IS_SEARCH_VIEW_ICONIFIED, isSearchViewIconified)
-    }
+    private inner class SelectionActionModeCallback : ActionMode.Callback {
+        // Store action IDs mapped to their menu item IDs for lookup
+        private val actionIdMap = mutableMapOf<Int, String>()
 
-    override fun onTap(point: PointF): Boolean {
-        return true
-    }
+        override fun onCreateActionMode(mode: ActionMode, menu: Menu): Boolean {
+            // Clear previous action mappings
+            actionIdMap.clear()
 
-    companion object {
+            // Only add menu items if navigator supports decorations
+            if (navigator !is DecorableNavigator) {
+                return true
+            }
 
-        private const val SEARCH_FRAGMENT_TAG = "search"
+            // Dynamically add menu items for each configured action
+            selectionActions.forEachIndexed { index, action ->
+                // Generate a unique menu item ID using the action's hash
+                val menuItemId = action.id.hashCode()
+                actionIdMap[menuItemId] = action.id
+
+                // Add menu item with the action's label
+                menu.add(Menu.NONE, menuItemId, index, action.label).apply {
+                    // Show as action button if there's space
+                    setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM)
+                    // Use star icon for highlight action, otherwise use default
+                    if (action.id == "highlight") {
+                        setIcon(android.R.drawable.btn_star_big_on)
+                    }
+                }
+            }
 
-        private const val IS_SCREEN_READER_VISIBLE_KEY = "isScreenReaderVisible"
+            return true
+        }
 
-        private const val IS_SEARCH_VIEW_ICONIFIED = "isSearchViewIconified"
+        override fun onPrepareActionMode(mode: ActionMode, menu: Menu): Boolean {
+            return false
+        }
+
+        override fun onActionItemClicked(mode: ActionMode, item: MenuItem): Boolean {
+            val actionId = actionIdMap[item.itemId]
+            if (actionId != null) {
+                // Get the current selection from the navigator
+                lifecycleScope.launch {
+                    val selectableNavigator = navigator as? SelectableNavigator
+                    val selection = selectableNavigator?.currentSelection()
+
+                    if (selection != null) {
+                        // Emit generic SelectionAction event to React Native
+                        channel.send(
+                            ReaderViewModel.Event.SelectionAction(
+                                actionId = actionId,
+                                locator = selection.locator,
+                                selectedText = selection.locator.text.highlight ?: ""
+                            )
+                        )
+                    }
+                }
+
+                mode.finish()
+                return true
+            }
+            return false
+        }
+
+        override fun onDestroyActionMode(mode: ActionMode) {
+            // Clean up action mappings
+            actionIdMap.clear()
+        }
+    }
+
+    companion object {
 
         fun newInstance(): EpubReaderFragment {
             return EpubReaderFragment()