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

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

@@ -0,0 +1,132 @@
+package com.reactnativereadium.reader
+
+import android.graphics.Color
+import android.view.Gravity
+import android.widget.FrameLayout
+import android.widget.TextView
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import org.readium.r2.shared.publication.Publication
+import org.readium.r2.shared.publication.services.positions
+
+/**
+ * Manages the position label display for the reader.
+ * Similar to iOS PositionLabelManager, this class handles the display of current position
+ * and total position count in a TextView overlay.
+ */
+class PositionLabelManager(
+    private val containerView: FrameLayout,
+    private val publication: Publication,
+    private val lifecycleScope: CoroutineScope
+) {
+    private val label: TextView = TextView(containerView.context)
+    private var positionsCount: Int? = null
+    private var positionsLoadingJob: Job? = null
+    private var lastKnownPosition: Int? = null
+    private var lastKnownProgression: Double? = null
+
+    init {
+        setupLabel()
+    }
+
+    companion object {
+        private const val LABEL_TEXT_SIZE_SP = 12f
+        private const val LABEL_PADDING_HORIZONTAL_DP = 10
+        private const val LABEL_PADDING_VERTICAL_DP = 5
+        private const val LABEL_BOTTOM_MARGIN_DP = 20
+        private const val LABEL_ELEVATION_DP = 4f
+    }
+
+    private fun setupLabel() {
+        val density = containerView.resources.displayMetrics.density
+
+        label.apply {
+            textSize = LABEL_TEXT_SIZE_SP
+            setTextColor(Color.DKGRAY) // Default, will be updated based on theme
+            setBackgroundColor(Color.TRANSPARENT)
+            gravity = Gravity.CENTER
+            setPadding(
+                (LABEL_PADDING_HORIZONTAL_DP * density).toInt(),
+                (LABEL_PADDING_VERTICAL_DP * density).toInt(),
+                (LABEL_PADDING_HORIZONTAL_DP * density).toInt(),
+                (LABEL_PADDING_VERTICAL_DP * density).toInt()
+            )
+            elevation = LABEL_ELEVATION_DP * density
+        }
+
+        val params = FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.WRAP_CONTENT,
+            FrameLayout.LayoutParams.WRAP_CONTENT
+        ).apply {
+            gravity = Gravity.BOTTOM or Gravity.CENTER_HORIZONTAL
+            bottomMargin = (LABEL_BOTTOM_MARGIN_DP * density).toInt()
+        }
+
+        containerView.addView(label, params)
+        // Ensure label is above navigator fragment
+        label.bringToFront()
+    }
+
+    /**
+     * Update the position label with current position and progression.
+     * Should be called on the main thread.
+     */
+    fun update(position: Int?, totalProgression: Double?) {
+        lastKnownPosition = position
+        lastKnownProgression = totalProgression
+        label.text = positionLabelText(position, totalProgression)
+    }
+
+    private fun positionLabelText(position: Int?, totalProgression: Double?): String? {
+        return when {
+            position != null -> {
+                val total = positionsCount
+                if (total != null) {
+                    "$position / $total"
+                } else {
+                    loadPositionsCountIfNeeded()
+                    "$position"
+                }
+            }
+            totalProgression != null -> {
+                "${(totalProgression * 100).toInt()}%"
+            }
+            else -> null
+        }
+    }
+
+    private fun loadPositionsCountIfNeeded() {
+        if (positionsCount != null) return
+        if (positionsLoadingJob?.isActive == true) return
+
+        positionsLoadingJob = lifecycleScope.launch {
+            try {
+                val positions = publication.positions()
+                positionsCount = positions.size
+
+                // Refresh label with the new count
+                label.text = positionLabelText(lastKnownPosition, lastKnownProgression)
+            } catch (e: Exception) {
+                // Failed to load positions, continue showing position without total
+            }
+        }
+    }
+
+    /**
+     * Update the text color of the position label.
+     * Should be called on the main thread.
+     */
+    fun setTextColor(color: Int) {
+        label.setTextColor(color)
+    }
+
+    /**
+     * Cancel any ongoing loading operations and remove the label from the view hierarchy.
+     */
+    fun cleanup() {
+        positionsLoadingJob?.cancel()
+        positionsLoadingJob = null
+        containerView.removeView(label)
+    }
+}

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

@@ -1,49 +1,37 @@
 package com.reactnativereadium.reader
 
-import android.annotation.SuppressLint
-import androidx.lifecycle.ViewModelStore
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.util.RNLog
 import com.reactnativereadium.utils.LinkOrLocator
 import java.io.File
-import java.io.IOException
-import java.net.ServerSocket
-import org.readium.r2.shared.extensions.mediaType
-import org.readium.r2.shared.extensions.tryOrNull
+import java.util.Locale
 import org.readium.r2.shared.publication.Locator
-import org.readium.r2.shared.publication.asset.FileAsset
 import org.readium.r2.shared.publication.Publication
-import org.readium.r2.streamer.server.Server
-import org.readium.r2.streamer.Streamer
+import org.readium.r2.shared.util.FileExtension
+import org.readium.r2.shared.util.asset.AssetRetriever
+import org.readium.r2.shared.util.format.FormatHints
+import org.readium.r2.shared.util.http.DefaultHttpClient
+import org.readium.r2.shared.util.toUrl
+import org.readium.r2.streamer.PublicationOpener
+import org.readium.r2.streamer.parser.DefaultPublicationParser
 
 
 class ReaderService(
   private val reactContext: ReactApplicationContext
 ) {
-  private var streamer = Streamer(reactContext)
-  // see R2App.onCreate
-  private var server: Server
-  // val channel = EventChannel(Channel<Event>(Channel.BUFFERED), viewModelScope)
-  private var store = ViewModelStore()
-
-  companion object {
-    @SuppressLint("StaticFieldLeak")
-    lateinit var server: Server
-      private set
-
-    lateinit var R2DIRECTORY: String
-      private set
-
-    var isServerStarted = false
-      private set
-  }
-
-  init {
-    val s = ServerSocket(0)
-    s.close()
-    server = Server(s.localPort, reactContext)
-    this.startServer()
-  }
+  private val httpClient = DefaultHttpClient()
+  private val assetRetriever = AssetRetriever(
+    reactContext.contentResolver,
+    httpClient
+  )
+  private val publicationOpener = PublicationOpener(
+    publicationParser = DefaultPublicationParser(
+      context = reactContext,
+      assetRetriever = assetRetriever,
+      httpClient = httpClient,
+      pdfFactory = null,
+    )
+  )
 
   fun locatorFromLinkOrLocator(
     location: LinkOrLocator?,
@@ -69,44 +57,55 @@ class ReaderService(
     initialLocation: LinkOrLocator?,
     callback: suspend (fragment: BaseReaderFragment) -> Unit
   ) {
-    val file = File(fileName)
-    val asset = FileAsset(file, file.mediaType())
+    val publicationFile = File(fileName).absoluteFile
+    if (!publicationFile.exists()) {
+      RNLog.e(reactContext, "Failed to open publication: File does not exist: $fileName")
+      return
+    }
+    val publicationUrl = runCatching {
+      publicationFile.toUrl()
+    }
+      .onFailure {
+        RNLog.e(
+          reactContext,
+          "Invalid publication path: $fileName - ${it.message}"
+        )
+      }
+      .getOrNull()
+      ?: return
 
-    streamer.open(
-      asset,
-      allowUserInteraction = false,
-      sender = reactContext
-    )
-      .onSuccess {
-          val locator = locatorFromLinkOrLocator(initialLocation, it)
-          val readerFragment = EpubReaderFragment.newInstance()
-          readerFragment.initFactory(it, locator)
-          callback.invoke(readerFragment)
+    val fileExtension = publicationFile.extension
+      .takeIf { it.isNotEmpty() }?.lowercase(Locale.ROOT)
 
-      }
+    val asset = assetRetriever
+      .retrieve(
+        publicationUrl,
+        FormatHints(fileExtension = fileExtension?.let { FileExtension(it) })
+      )
       .onFailure {
-        tryOrNull { asset.file.delete() }
-        RNLog.w(reactContext, "Error executing ReaderService.openPublication")
-        // TODO: implement failure event
+        RNLog.w(reactContext, "Unable to retrieve publication asset: ${it.message}")
       }
-  }
-
-  private fun startServer() {
-    if (!server.isAlive) {
-      try {
-        server.start()
-      } catch (e: IOException) {
-        RNLog.e(reactContext, "Unable to start the Readium server.")
+      .getOrNull()
+      ?: return
+
+    publicationOpener
+      .open(
+        asset = asset,
+        allowUserInteraction = false
+      )
+      .onSuccess {
+        val locator = locatorFromLinkOrLocator(initialLocation, it)
+        val readerFragment = EpubReaderFragment.newInstance()
+        readerFragment.initFactory(it, locator)
+        callback.invoke(readerFragment)
       }
-      if (server.isAlive) {
-        // // Add your own resources here
-        // server.loadCustomResource(assets.open("scripts/test.js"), "test.js")
-        // server.loadCustomResource(assets.open("styles/test.css"), "test.css")
-        // server.loadCustomFont(assets.open("fonts/test.otf"), applicationContext, "test.otf")
-
-        isServerStarted = true
+      .onFailure {
+        RNLog.w(
+          reactContext,
+          "Error executing ReaderService.openPublication: ${it.message}"
+        )
+        // TODO: implement failure event
       }
-    }
   }
 
   sealed class Event {

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

@@ -1,95 +1,24 @@
 package com.reactnativereadium.reader
 
-import android.graphics.Color
+import android.graphics.PointF
+import android.graphics.RectF
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
 import androidx.lifecycle.viewModelScope
-import androidx.paging.*
-import com.reactnativereadium.search.SearchPagingSource
 import com.reactnativereadium.utils.EventChannel
 import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.*
-import kotlinx.coroutines.launch
 import org.readium.r2.navigator.Decoration
-import org.readium.r2.navigator.ExperimentalDecorator
 import org.readium.r2.shared.publication.Locator
-import org.readium.r2.shared.publication.LocatorCollection
 import org.readium.r2.shared.publication.Publication
-import org.readium.r2.shared.publication.services.search.search
-import org.readium.r2.shared.publication.services.search.SearchIterator
-import org.readium.r2.shared.publication.services.search.SearchTry
-import org.readium.r2.shared.Search
-import org.readium.r2.shared.UserException
 import org.readium.r2.shared.publication.Link
-import org.readium.r2.shared.util.Try
+import org.readium.r2.shared.publication.Metadata
 
-@OptIn(Search::class, ExperimentalDecorator::class)
 class ReaderViewModel(
   val publication: Publication,
   val initialLocation: Locator?
 ) : ViewModel() {
     val channel = EventChannel(Channel<Event>(Channel.BUFFERED), viewModelScope)
 
-    fun search(query: String) = viewModelScope.launch {
-        if (query == lastSearchQuery) return@launch
-        lastSearchQuery = query
-        _searchLocators.value = emptyList()
-        searchIterator = publication.search(query)
-            .onFailure { channel.send(Event.Failure(it)) }
-            .getOrNull()
-        pagingSourceFactory.invalidate()
-        channel.send(Event.StartNewSearch)
-    }
-
-    fun cancelSearch() = viewModelScope.launch {
-        _searchLocators.value = emptyList()
-        searchIterator?.close()
-        searchIterator = null
-        pagingSourceFactory.invalidate()
-    }
-
-    val searchLocators: StateFlow<List<Locator>> get() = _searchLocators
-    private var _searchLocators = MutableStateFlow<List<Locator>>(emptyList())
-
-    /**
-     * Maps the current list of search result locators into a list of [Decoration] objects to
-     * underline the results in the navigator.
-     */
-    val searchDecorations: Flow<List<Decoration>> by lazy {
-        searchLocators.map {
-            it.mapIndexed { index, locator ->
-                Decoration(
-                    // The index in the search result list is a suitable Decoration ID, as long as
-                    // we clear the search decorations between two searches.
-                    id = index.toString(),
-                    locator = locator,
-                    style = Decoration.Style.Underline(tint = Color.RED)
-                )
-            }
-        }
-    }
-
-    private var lastSearchQuery: String? = null
-
-    private var searchIterator: SearchIterator? = null
-
-    private val pagingSourceFactory = InvalidatingPagingSourceFactory {
-        SearchPagingSource(listener = PagingSourceListener())
-    }
-
-    inner class PagingSourceListener : SearchPagingSource.Listener {
-        override suspend fun next(): SearchTry<LocatorCollection?> {
-            val iterator = searchIterator ?: return Try.success(null)
-            return iterator.next().onSuccess {
-                _searchLocators.value += (it?.locators ?: emptyList())
-            }
-        }
-    }
-
-    val searchResult: Flow<PagingData<Locator>> =
-        Pager(PagingConfig(pageSize = 20), pagingSourceFactory = pagingSourceFactory)
-            .flow.cachedIn(viewModelScope)
-
     class Factory(
       private val publication: Publication,
       private val initialLocation: Locator?
@@ -107,16 +36,26 @@ class ReaderViewModel(
     }
 
     sealed class Event {
-        object OpenOutlineRequested : Event()
-        object OpenDrmManagementRequested : Event()
-        object StartNewSearch : Event()
-        class Failure(val error: UserException) : Event()
         class LocatorUpdate(val locator: Locator) : Event()
-        class TableOfContentsLoaded(val toc: List<Link>) : Event()
-    }
-
-    sealed class FeedbackEvent {
-        object BookmarkSuccessfullyAdded : FeedbackEvent()
-        object BookmarkFailed : FeedbackEvent()
+        class PublicationReady(
+            val tableOfContents: List<Link>,
+            val positions: List<Locator>,
+            val metadata: Metadata
+        ) : Event()
+        class DecorationActivated(
+            val decoration: Decoration,
+            val group: String,
+            val rect: RectF?,
+            val point: PointF?
+        ) : Event()
+        class SelectionChanged(
+            val locator: Locator?,
+            val selectedText: String?
+        ) : Event()
+        class SelectionAction(
+            val actionId: String,
+            val locator: Locator,
+            val selectedText: String
+        ) : Event()
     }
 }

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

@@ -13,14 +13,15 @@ import android.view.ViewGroup
 import android.view.WindowInsets
 import android.widget.FrameLayout
 import androidx.fragment.app.Fragment
-import org.readium.r2.navigator.DecorableNavigator
-import org.readium.r2.navigator.ExperimentalDecorator
+import androidx.lifecycle.lifecycleScope
 import com.reactnativereadium.R
 import com.reactnativereadium.databinding.FragmentReaderBinding
 import com.reactnativereadium.utils.clearPadding
 import com.reactnativereadium.utils.hideSystemUi
 import com.reactnativereadium.utils.padSystemUi
 import com.reactnativereadium.utils.showSystemUi
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
 
 /*
  * Adds fullscreen support to the BaseReaderFragment
@@ -32,6 +33,8 @@ abstract class VisualReaderFragment : BaseReaderFragment() {
     private var _binding: FragmentReaderBinding? = null
     val binding get() = _binding!!
 
+    private var positionLabelManager: PositionLabelManager? = null
+
     override fun onCreateView(
         inflater: LayoutInflater,
         container: ViewGroup?,
@@ -45,6 +48,23 @@ abstract class VisualReaderFragment : BaseReaderFragment() {
         super.onViewCreated(view, savedInstanceState)
         navigatorFragment = navigator as Fragment
 
+        // Initialize position label manager - simple overlay, matching iOS approach
+        positionLabelManager = PositionLabelManager(
+            containerView = binding.fragmentReaderContainer,
+            publication = model.publication,
+            lifecycleScope = viewLifecycleOwner.lifecycleScope
+        )
+
+        // Update position label when navigator location changes
+        navigator.currentLocator
+            .onEach { locator ->
+                positionLabelManager?.update(
+                    position = locator.locations.position,
+                    totalProgression = locator.locations.totalProgression
+                )
+            }
+            .launchIn(viewLifecycleOwner.lifecycleScope)
+
         childFragmentManager.addOnBackStackChangedListener {
             updateSystemUiVisibility()
         }
@@ -55,10 +75,20 @@ abstract class VisualReaderFragment : BaseReaderFragment() {
     }
 
     override fun onDestroyView() {
+        positionLabelManager?.cleanup()
+        positionLabelManager = null
         _binding = null
         super.onDestroyView()
     }
 
+    /**
+     * Update the text color of the position label.
+     * @param color Android color integer
+     */
+    fun setPositionLabelColor(color: Int) {
+        positionLabelManager?.setTextColor(color)
+    }
+
     fun updateSystemUiVisibility() {
         if (navigatorFragment.isHidden)
             requireActivity().showSystemUi()

package/android/src/main/java/com/reactnativereadium/utils/DecorationSerializer.kt

@@ -0,0 +1,175 @@
+package com.reactnativereadium.utils
+
+import android.graphics.Color
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import org.json.JSONObject
+import org.readium.r2.navigator.Decoration
+import org.readium.r2.shared.publication.Locator
+import java.util.UUID
+
+object DecorationSerializer {
+  /**
+   * Deserialize JSON string to a map of decoration groups
+   */
+  fun deserialize(json: String?): Map<String, List<Decoration>> {
+    if (json == null) return emptyMap()
+
+    try {
+      val jsonObject = JSONObject(json)
+      val groups = mutableMapOf<String, List<Decoration>>()
+
+      jsonObject.keys().forEach { groupName ->
+        val decorationsArray = jsonObject.getJSONArray(groupName)
+        val decorations = mutableListOf<Decoration>()
+
+        for (i in 0 until decorationsArray.length()) {
+          val decorationJson = decorationsArray.getJSONObject(i)
+          deserializeDecoration(decorationJson)?.let { decorations.add(it) }
+        }
+
+        groups[groupName] = decorations
+      }
+
+      return groups
+    } catch (e: Exception) {
+      android.util.Log.e("DecorationSerializer", "Failed to deserialize decorations: ${e.message}", e)
+      return emptyMap()
+    }
+  }
+
+  /**
+   * Deserialize a single decoration from JSON
+   */
+  private fun deserializeDecoration(json: JSONObject): Decoration? {
+    try {
+      val id = json.getString("id")
+      val locatorJson = json.getJSONObject("locator")
+      val styleJson = json.getJSONObject("style")
+      val extrasJson = if (json.has("extras")) json.getJSONObject("extras") else null
+      val locator = Locator.fromJSON(locatorJson) ?: return null
+      val style = deserializeStyle(styleJson) ?: return null
+
+      val extras = mutableMapOf<String, Any>()
+      extrasJson?.keys()?.forEach { key ->
+        extras[key] = extrasJson.get(key)
+      }
+
+      return Decoration(
+        id = id,
+        locator = locator,
+        style = style,
+        extras = extras
+      )
+    } catch (e: Exception) {
+      android.util.Log.e("DecorationSerializer", "Failed to deserialize decoration: ${e.message}", e)
+      return null
+    }
+  }
+
+  /**
+   * Deserialize a decoration style from JSON
+   */
+  private fun deserializeStyle(json: JSONObject): Decoration.Style? {
+    return when (json.getString("type")) {
+      "highlight" -> {
+        val tint = parseColor(json.getString("tint"))
+        val isActive = json.optBoolean("isActive", false)
+        Decoration.Style.Highlight(tint = tint, isActive = isActive)
+      }
+      "underline" -> {
+        val tint = parseColor(json.getString("tint"))
+        val isActive = json.optBoolean("isActive", false)
+        Decoration.Style.Underline(tint = tint, isActive = isActive)
+      }
+      // TODO: Add support for custom styles
+      else -> null
+    }
+  }
+
+  /**
+   * Parse a CSS color string to Android Color int
+   * Supports: hex (#RRGGBB, #AARRGGBB), rgb(r,g,b), rgba(r,g,b,a), named colors
+   */
+  private fun parseColor(colorString: String): Int {
+    return try {
+      when {
+        colorString.startsWith("#") -> Color.parseColor(colorString)
+        colorString.startsWith("rgb(") -> {
+          val values = colorString.substringAfter("(").substringBefore(")").split(",")
+          val r = values[0].trim().toInt()
+          val g = values[1].trim().toInt()
+          val b = values[2].trim().toInt()
+          Color.rgb(r, g, b)
+        }
+        colorString.startsWith("rgba(") -> {
+          val values = colorString.substringAfter("(").substringBefore(")").split(",")
+          val r = values[0].trim().toInt()
+          val g = values[1].trim().toInt()
+          val b = values[2].trim().toInt()
+          val a = (values[3].trim().toFloat() * 255).toInt()
+          Color.argb(a, r, g, b)
+        }
+        else -> Color.parseColor(colorString) // Try named color
+      }
+    } catch (e: Exception) {
+      android.util.Log.w("DecorationSerializer", "Failed to parse color '$colorString', using default", e)
+      Color.YELLOW // Default color
+    }
+  }
+}
+
+/**
+ * Extension function to convert Decoration to WritableMap for React Native
+ */
+fun Decoration.toWritableMap(): WritableMap {
+  return Arguments.createMap().apply {
+    putString("id", this@toWritableMap.id)
+    putMap("locator", this@toWritableMap.locator.toWritableMap())
+    putMap("style", styleToWritableMap(this@toWritableMap.style))
+
+    if (this@toWritableMap.extras.isNotEmpty()) {
+      val extrasMap = Arguments.createMap()
+      this@toWritableMap.extras.forEach { (key, value) ->
+        when (value) {
+          is String -> extrasMap.putString(key, value)
+          is Int -> extrasMap.putInt(key, value)
+          is Double -> extrasMap.putDouble(key, value)
+          is Boolean -> extrasMap.putBoolean(key, value)
+          else -> extrasMap.putString(key, value.toString())
+        }
+      }
+      putMap("extras", extrasMap)
+    }
+  }
+}
+
+/**
+ * Convert Decoration.Style to WritableMap
+ */
+private fun styleToWritableMap(style: Decoration.Style): WritableMap {
+  return Arguments.createMap().apply {
+    when (style) {
+      is Decoration.Style.Highlight -> {
+        putString("type", "highlight")
+        putString("tint", colorToHex(style.tint))
+        putBoolean("isActive", style.isActive)
+      }
+      is Decoration.Style.Underline -> {
+        putString("type", "underline")
+        putString("tint", colorToHex(style.tint))
+        putBoolean("isActive", style.isActive)
+      }
+      else -> {
+        putString("type", "custom")
+      }
+    }
+  }
+}
+
+/**
+ * Convert Android Color int to hex string
+ */
+private fun colorToHex(color: Int): String {
+  return String.format("#%08X", color)
+}

package/android/src/main/java/com/reactnativereadium/utils/EventChannel.kt

@@ -50,12 +50,3 @@ class FlowObserver<T> (
         job = null
     }
 }
-
-
-inline fun <reified T> Flow<T>.observeWhenStarted(
-    lifecycleOwner: LifecycleOwner,
-    noinline collector: suspend (T) -> Unit
-) {
-    val observer = FlowObserver(lifecycleOwner, this, collector)
-    lifecycleOwner.lifecycle.addObserver(observer)
-}