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

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

@@ -6,49 +6,50 @@
 
 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 com.reactnativereadium.R
-import com.reactnativereadium.utils.toggleSystemUi
-import java.net.URL
-import kotlinx.coroutines.delay
 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 {
+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 lateinit var navigatorFactory: EpubNavigatorFactory
+    private val preferencesSerializer = EpubPreferencesSerializer()
     private var initialPreferencesJsonString: String? = null
 
-    private lateinit var menuScreenReader: MenuItem
-    private lateinit var menuSearch: MenuItem
-    lateinit var menuSearchView: SearchView
-
     private lateinit var userPreferences: EpubPreferences
-    private var isScreenReaderVisible = false
-    private var isSearchViewIconified = true
 
     // Accessibility
     private var isExploreByTouchEnabled = false
 
+    private fun ensureUserPreferencesInitialized() {
+      if (this::userPreferences.isInitialized) return
+      userPreferences = initialPreferencesJsonString?.let {
+        preferencesSerializer.deserialize(it)
+      } ?: EpubPreferences()
+    }
+
+    private fun applyPendingPreferencesIfNeeded() {
+      if (!this::navigator.isInitialized) return
+      initialPreferencesJsonString?.let { updatePreferencesFromJsonString(it) }
+    }
+
     fun initFactory(
       publication: Publication,
       initialLocation: Locator?
@@ -57,29 +58,36 @@ 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)
-        }
+      userPreferences = preferencesSerializer.deserialize(serialisedPreferences)
+
+      if (this::navigator.isInitialized && navigator is EpubNavigatorFragment) {
+        (navigator as EpubNavigatorFragment).submitPreferences(userPreferences)
         initialPreferencesJsonString = null
+
+        // Update position label color to match theme, similar to iOS implementation
+        updatePositionLabelColor()
       } else {
         initialPreferencesJsonString = serialisedPreferences
       }
     }
 
-    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)
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+      check(::navigatorFactory.isInitialized) { "EpubReaderFragment factory was not initialized" }
 
         ViewModelProvider(this, factory)
           .get(ReaderViewModel::class.java)
@@ -88,18 +96,12 @@ 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,
             )
 
         setHasOptionsMenu(true)
@@ -119,58 +121,40 @@ 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))
         }
-    }
-
-    override fun onSaveInstanceState(outState: Bundle) {
-        super.onSaveInstanceState(outState)
-        outState.putBoolean(IS_SCREEN_READER_VISIBLE_KEY, isScreenReaderVisible)
-        outState.putBoolean(IS_SEARCH_VIEW_ICONIFIED, isSearchViewIconified)
-    }
-
-    override fun onTap(point: PointF): Boolean {
-        return true
+        (navigator as? EpubNavigatorFragment)?.submitPreferences(userPreferences)
     }
 
     companion object {
 
-        private const val SEARCH_FRAGMENT_TAG = "search"
-
-        private const val IS_SCREEN_READER_VISIBLE_KEY = "isScreenReaderVisible"
-
-        private const val IS_SEARCH_VIEW_ICONIFIED = "isSearchViewIconified"
-
         fun newInstance(): EpubReaderFragment {
             return EpubReaderFragment()
         }

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,21 @@
 package com.reactnativereadium.reader
 
-import android.graphics.Color
 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 +33,11 @@ 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()
     }
 }