react-native-readium 4.0.1 → 5.0.0-rc.0

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/FragmentFactory.kt

@@ -2,7 +2,6 @@ package com.reactnativereadium.utils
 
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentFactory
-import org.readium.r2.shared.extensions.tryOrNull
 
 /**
  * Creates a [FragmentFactory] for a single type of [Fragment] using the result of the given
@@ -36,8 +35,8 @@ class CompositeFragmentFactory(private val factories: List<FragmentFactory>) : F
 
     override fun instantiate(classLoader: ClassLoader, className: String): Fragment {
         for (factory in factories) {
-            tryOrNull { factory.instantiate(classLoader, className) }
-                ?.let { return it }
+            runCatching { factory.instantiate(classLoader, className) }
+                .getOrNull()?.let { return it }
         }
 
         return super.instantiate(classLoader, className)

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

@@ -0,0 +1,61 @@
+package com.reactnativereadium.utils
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import org.json.JSONArray
+import org.json.JSONObject
+import org.readium.r2.shared.publication.Link
+import org.readium.r2.shared.publication.Locator
+
+internal fun Locator.toWritableMap(): WritableMap =
+  toJSON().toWritableMap()
+
+internal fun Link.toWritableMap(): WritableMap =
+  toJSON().toWritableMap()
+
+internal fun List<Link>.toWritableArray(): WritableArray =
+  Arguments.createArray().apply {
+    forEach { pushMap(it.toWritableMap()) }
+  }
+
+internal fun JSONObject.toWritableMap(): WritableMap {
+  val map = Arguments.createMap()
+  val iterator = keys()
+  while (iterator.hasNext()) {
+    val key = iterator.next()
+    when (val value = opt(key)) {
+      JSONObject.NULL -> map.putNull(key)
+      is JSONObject -> map.putMap(key, value.toWritableMap())
+      is JSONArray -> map.putArray(key, value.toWritableArray())
+      is String -> map.putString(key, value)
+      is Boolean -> map.putBoolean(key, value)
+      is Int -> map.putInt(key, value)
+      is Long -> map.putDouble(key, value.toDouble())
+      is Double -> map.putDouble(key, value)
+      is Float -> map.putDouble(key, value.toDouble())
+      else -> map.putString(key, value?.toString() ?: "")
+    }
+  }
+  return map
+}
+
+internal fun JSONArray.toWritableArray(): WritableArray {
+  val array = Arguments.createArray()
+  for (index in 0 until length()) {
+    when (val value = opt(index)) {
+      JSONObject.NULL -> array.pushNull()
+      is JSONObject -> array.pushMap(value.toWritableMap())
+      is JSONArray -> array.pushArray(value.toWritableArray())
+      is String -> array.pushString(value)
+      is Boolean -> array.pushBoolean(value)
+      is Int -> array.pushInt(value)
+      is Long -> array.pushDouble(value.toDouble())
+      is Double -> array.pushDouble(value)
+      is Float -> array.pushDouble(value.toDouble())
+      null -> array.pushNull()
+      else -> array.pushString(value.toString())
+    }
+  }
+  return array
+}

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

@@ -0,0 +1,183 @@
+package com.reactnativereadium.utils
+
+import com.facebook.react.bridge.*
+import org.readium.r2.shared.publication.Metadata
+import org.readium.r2.shared.publication.LocalizedString
+import org.readium.r2.shared.publication.Contributor
+import org.readium.r2.shared.publication.Subject
+
+/**
+ * Normalizes metadata to ensure consistent structure per RWPM spec.
+ *
+ * This normalizer works directly with Readium's native Kotlin types (Metadata, LocalizedString,
+ * Contributor, Subject) and converts them to normalized, spec-compliant structures.
+ *
+ * This approach is:
+ * - More efficient (no intermediate WritableMap conversion)
+ * - More type-safe (working with actual Kotlin types)
+ * - Based on the stable RWPM specification
+ *
+ * https://readium.org/webpub-manifest/
+ */
+object MetadataNormalizer {
+
+    /**
+     * Normalizes a Metadata object to a consistent React Native-compatible format.
+     * Works directly with Readium native types for efficiency and type safety.
+     */
+    fun normalize(metadata: Metadata): WritableMap {
+        // Build typed NormalizedMetadata object from Readium's native types
+        val normalized = NormalizedMetadata(
+            // Required fields (provide default empty string if null)
+            title = normalizeLocalizedString(metadata.localizedTitle) ?: "",
+
+            // Optional localized string fields
+            sortAs = normalizeLocalizedString(metadata.localizedSortAs),
+            subtitle = normalizeLocalizedString(metadata.localizedSubtitle),
+
+            // Simple string fields
+            identifier = metadata.identifier,
+            description = metadata.description,
+            readingProgression = metadata.readingProgression?.name?.lowercase(),
+
+            // Date fields (convert Instant to ISO string)
+            modified = metadata.modified?.toString(),
+            published = metadata.published?.toString(),
+
+            // Layout is not directly on Metadata - would need Publication.metadata.presentation
+            // For now, pass null and extract from JSON if needed
+            layout = null,
+
+            // Array fields
+            language = if (metadata.languages.isNotEmpty()) metadata.languages else null,
+            conformsTo = metadata.conformsTo.map { it.uri }.takeIf { it.isNotEmpty() },
+
+            // Numeric fields
+            duration = metadata.duration,
+            numberOfPages = metadata.numberOfPages,
+
+            // Normalize contributors (all types)
+            author = normalizeContributors(metadata.authors),
+            translator = normalizeContributors(metadata.translators),
+            editor = normalizeContributors(metadata.editors),
+            artist = normalizeContributors(metadata.artists),
+            illustrator = normalizeContributors(metadata.illustrators),
+            letterer = normalizeContributors(metadata.letterers),
+            penciler = normalizeContributors(metadata.pencilers),
+            colorist = normalizeContributors(metadata.colorists),
+            inker = normalizeContributors(metadata.inkers),
+            narrator = normalizeContributors(metadata.narrators),
+            contributor = normalizeContributors(metadata.contributors),
+            publisher = normalizeContributors(metadata.publishers),
+            imprint = normalizeContributors(metadata.imprints),
+
+            // Normalize subjects
+            subject = normalizeSubjects(metadata.subjects),
+
+            // Complex objects - these need special handling
+            // For now, convert via JSON if they exist
+            accessibility = metadata.accessibility?.let { convertAccessibilityToWritableMap(it) },
+            belongsTo = if (metadata.belongsTo.isNotEmpty()) convertBelongsToToWritableMap(metadata.belongsTo) else null
+        )
+
+        // Convert to WritableMap for React Native
+        return normalized.toWritableMap()
+    }
+
+    /**
+     * Normalizes a LocalizedString per RWPM spec.
+     *
+     * Per RWPM spec, we extract a single string from the localized string using priority:
+     * 1. null key (undefined/undetermined language)
+     * 2. "en" (English fallback)
+     * 3. First available translation
+     *
+     * https://readium.org/webpub-manifest/contexts/default/
+     */
+    private fun normalizeLocalizedString(value: LocalizedString?): String? {
+        if (value == null) return null
+
+        // Priority: null key (undefined) -> "en" -> first available
+        return value.translations[null]?.string
+            ?: value.translations["en"]?.string
+            ?: value.translations.values.firstOrNull()?.string
+    }
+
+    /**
+     * Normalizes contributors per RWPM spec.
+     *
+     * Converts Readium's Contributor objects to our normalized format.
+     * https://readium.org/webpub-manifest/schema/contributor-object.schema.json
+     */
+    private fun normalizeContributors(contributors: List<Contributor>): List<NormalizedContributor>? {
+        if (contributors.isEmpty()) return null
+
+        return contributors.mapNotNull { contributor ->
+            val name = normalizeLocalizedString(contributor.localizedName) ?: return@mapNotNull null
+
+            NormalizedContributor(
+                name = name,
+                sortAs = normalizeLocalizedString(contributor.localizedSortAs),
+                identifier = contributor.identifier,
+                role = contributor.roles.firstOrNull(),
+                position = contributor.position?.toInt()
+            )
+        }.takeIf { it.isNotEmpty() }
+    }
+
+    /**
+     * Normalizes subjects per RWPM spec.
+     *
+     * Converts Readium's Subject objects to our normalized format.
+     * https://readium.org/webpub-manifest/schema/subject.schema.json
+     */
+    private fun normalizeSubjects(subjects: List<Subject>): List<NormalizedSubject>? {
+        if (subjects.isEmpty()) return null
+
+        return subjects.mapNotNull { subject ->
+            val name = normalizeLocalizedString(subject.localizedName) ?: return@mapNotNull null
+
+            NormalizedSubject(
+                name = name,
+                sortAs = normalizeLocalizedString(subject.localizedSortAs),
+                code = subject.code,
+                scheme = subject.scheme
+            )
+        }.takeIf { it.isNotEmpty() }
+    }
+
+    /**
+     * Converts Readium's Accessibility object to WritableMap.
+     * This is a complex nested structure that we pass through as-is.
+     */
+    private fun convertAccessibilityToWritableMap(accessibility: org.readium.r2.shared.publication.Accessibility): WritableMap? {
+        return try {
+            // Use Readium's built-in JSON serialization
+            val json = accessibility.toJSON()
+            json.toWritableMap()
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    /**
+     * Converts Readium's belongsTo map to WritableMap.
+     * This is a complex nested structure that we pass through as-is.
+     */
+    private fun convertBelongsToToWritableMap(belongsTo: Map<String, List<org.readium.r2.shared.publication.Collection>>): WritableMap? {
+        return try {
+            Arguments.createMap().apply {
+                belongsTo.forEach { (key, collections) ->
+                    val array = Arguments.createArray().apply {
+                        collections.forEach { collection ->
+                            collection.toJSON().toWritableMap()?.let { pushMap(it) }
+                        }
+                    }
+                    putArray(key, array)
+                }
+            }
+        } catch (e: Exception) {
+            null
+        }
+    }
+}

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

@@ -0,0 +1,179 @@
+package com.reactnativereadium.utils
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+
+/**
+ * Normalized metadata data classes that mirror the TypeScript PublicationMetadata interface.
+ * These provide type safety and structure enforcement during metadata normalization.
+ */
+
+/**
+ * Contributor information for publication metadata
+ */
+data class NormalizedContributor(
+    val name: String,
+    val sortAs: String? = null,
+    val identifier: String? = null,
+    val role: String? = null,
+    val position: Int? = null
+) {
+    fun toWritableMap(): WritableMap {
+        return Arguments.createMap().apply {
+            putString("name", name)
+            sortAs?.let { putString("sortAs", it) }
+            identifier?.let { putString("identifier", it) }
+            role?.let { putString("role", it) }
+            position?.let { putInt("position", it) }
+        }
+    }
+}
+
+/**
+ * Subject/tag information
+ */
+data class NormalizedSubject(
+    val name: String,
+    val sortAs: String? = null,
+    val code: String? = null,
+    val scheme: String? = null
+) {
+    fun toWritableMap(): WritableMap {
+        return Arguments.createMap().apply {
+            putString("name", name)
+            sortAs?.let { putString("sortAs", it) }
+            code?.let { putString("code", it) }
+            scheme?.let { putString("scheme", it) }
+        }
+    }
+}
+
+/**
+ * Normalized publication metadata following the RWPM spec
+ * @see https://readium.org/webpub-manifest/
+ */
+data class NormalizedMetadata(
+    // Required fields
+    val title: String,
+
+    // Optional localized string fields
+    val sortAs: String? = null,
+    val subtitle: String? = null,
+
+    // Simple fields
+    val identifier: String? = null,
+    val description: String? = null,
+    val readingProgression: String? = null,
+    val layout: String? = null,
+    val modified: String? = null,
+    val published: String? = null,
+
+    // Array fields
+    val language: List<String>? = null,
+    val conformsTo: List<String>? = null,
+
+    // Numeric fields
+    val duration: Double? = null,
+    val numberOfPages: Int? = null,
+
+    // Contributors (all types)
+    val author: List<NormalizedContributor>? = null,
+    val translator: List<NormalizedContributor>? = null,
+    val editor: List<NormalizedContributor>? = null,
+    val artist: List<NormalizedContributor>? = null,
+    val illustrator: List<NormalizedContributor>? = null,
+    val letterer: List<NormalizedContributor>? = null,
+    val penciler: List<NormalizedContributor>? = null,
+    val colorist: List<NormalizedContributor>? = null,
+    val inker: List<NormalizedContributor>? = null,
+    val narrator: List<NormalizedContributor>? = null,
+    val contributor: List<NormalizedContributor>? = null,
+    val publisher: List<NormalizedContributor>? = null,
+    val imprint: List<NormalizedContributor>? = null,
+
+    // Subjects
+    val subject: List<NormalizedSubject>? = null,
+
+    // Complex objects (preserved as-is from source)
+    val accessibility: WritableMap? = null,
+    val belongsTo: WritableMap? = null
+) {
+    /**
+     * Converts this normalized metadata to a WritableMap for React Native
+     */
+    fun toWritableMap(): WritableMap {
+        return Arguments.createMap().apply {
+            // Required fields
+            putString("title", title)
+
+            // Optional localized fields
+            sortAs?.let { putString("sortAs", it) }
+            subtitle?.let { putString("subtitle", it) }
+
+            // Simple fields
+            identifier?.let { putString("identifier", it) }
+            description?.let { putString("description", it) }
+            readingProgression?.let { putString("readingProgression", it) }
+            layout?.let { putString("layout", it) }
+            modified?.let { putString("modified", it) }
+            published?.let { putString("published", it) }
+
+            // Array fields
+            language?.let {
+                putArray("language", Arguments.createArray().apply {
+                    it.forEach { lang -> pushString(lang) }
+                })
+            }
+            conformsTo?.let {
+                putArray("conformsTo", Arguments.createArray().apply {
+                    it.forEach { item -> pushString(item) }
+                })
+            }
+
+            // Numeric fields
+            duration?.let { putDouble("duration", it) }
+            numberOfPages?.let { putInt("numberOfPages", it) }
+
+            // Contributors
+            author?.let { putArray("author", it.toContributorWritableArray()) }
+            translator?.let { putArray("translator", it.toContributorWritableArray()) }
+            editor?.let { putArray("editor", it.toContributorWritableArray()) }
+            artist?.let { putArray("artist", it.toContributorWritableArray()) }
+            illustrator?.let { putArray("illustrator", it.toContributorWritableArray()) }
+            letterer?.let { putArray("letterer", it.toContributorWritableArray()) }
+            penciler?.let { putArray("penciler", it.toContributorWritableArray()) }
+            colorist?.let { putArray("colorist", it.toContributorWritableArray()) }
+            inker?.let { putArray("inker", it.toContributorWritableArray()) }
+            narrator?.let { putArray("narrator", it.toContributorWritableArray()) }
+            contributor?.let { putArray("contributor", it.toContributorWritableArray()) }
+            publisher?.let { putArray("publisher", it.toContributorWritableArray()) }
+            imprint?.let { putArray("imprint", it.toContributorWritableArray()) }
+
+            // Subjects
+            subject?.let { putArray("subject", it.toSubjectWritableArray()) }
+
+            // Complex objects
+            accessibility?.let { putMap("accessibility", it) }
+            belongsTo?.let { putMap("belongsTo", it) }
+        }
+    }
+}
+
+/**
+ * Extension function to convert a list of contributors to WritableArray
+ */
+private fun List<NormalizedContributor>.toContributorWritableArray(): WritableArray {
+    return Arguments.createArray().apply {
+        this@toContributorWritableArray.forEach { pushMap(it.toWritableMap()) }
+    }
+}
+
+/**
+ * Extension function to convert a list of subjects to WritableArray
+ */
+private fun List<NormalizedSubject>.toSubjectWritableArray(): WritableArray {
+    return Arguments.createArray().apply {
+        this@toSubjectWritableArray.forEach { pushMap(it.toWritableMap()) }
+    }
+}

package/android/src/main/java/com/reactnativereadium/utils/extensions/InputStream.kt

@@ -2,11 +2,8 @@ package com.reactnativereadium.utils.extensions
 
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
-import org.readium.r2.shared.extensions.tryOrNull
 import java.io.File
 import java.io.InputStream
-import java.util.*
-
 
 suspend fun InputStream.toFile(path: String) {
     withContext(Dispatchers.IO) {
@@ -15,9 +12,3 @@ suspend fun InputStream.toFile(path: String) {
         }
     }
 }
-
-suspend fun InputStream.copyToTempFile(dir: String): File? = tryOrNull {
-    val filename = UUID.randomUUID().toString()
-    File(dir + filename)
-        .also { toFile(it.path) }
-}

package/ios/App/AppModule.swift

@@ -1,8 +1,7 @@
 import Combine
 import Foundation
 import UIKit
-import R2Shared
-import R2Streamer
+import ReadiumShared
 
 
 /// Base module delegate, that sub-modules' delegate can extend.
@@ -22,15 +21,10 @@ final class AppModule {
   var reader: ReaderModuleAPI! = nil
 
   init() throws {
-    guard let server = PublicationServer() else {
-      /// FIXME: we should recover properly if the publication server can't start, maybe this should only forbid opening a publication?
-      fatalError("Can't start publication server")
-    }
-
     reader = ReaderModule(delegate: self)
 
-    // Set Readium 2's logging minimum level.
-    R2EnableLog(withMinimumSeverityLevel: .debug)
+    // Set Readium logging minimum level for debugging
+    ReadiumEnableLog(withMinimumSeverityLevel: .debug)
   }
 }
 

package/ios/Common/Toolkit/Extensions/Locator.swift

@@ -1,5 +1,5 @@
 import Foundation
-import R2Shared
+import ReadiumShared
 
 extension Locator: Codable {
   public init(from decoder: Decoder) throws {

package/ios/Data/Bookmark.swift

@@ -1,6 +1,6 @@
 import Combine
 import Foundation
-import R2Shared
+import ReadiumShared
 
 struct Bookmark {
   let id: String?