react-native-readium 1.0.0-alpha.1

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

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2021 Readium Foundation. All rights reserved.
+ * Use of this source code is governed by the BSD-style license
+ * available in the top-level LICENSE file of the project.
+ */
+
+package com.reactnativereadium.reader
+
+import android.graphics.PointF
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.commitNow
+import androidx.lifecycle.ViewModelProvider
+import org.readium.r2.navigator.Navigator
+import org.readium.r2.navigator.image.ImageNavigatorFragment
+import org.readium.r2.shared.publication.Publication
+import com.reactnativereadium.R
+import com.reactnativereadium.utils.toggleSystemUi
+
+class ImageReaderFragment : VisualReaderFragment(), ImageNavigatorFragment.Listener {
+
+    override lateinit var model: ReaderViewModel
+    override lateinit var navigator: Navigator
+    private lateinit var publication: Publication
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        ViewModelProvider(requireActivity()).get(ReaderViewModel::class.java).let {
+            model = it
+            publication = it.publication
+        }
+
+        childFragmentManager.fragmentFactory =
+            ImageNavigatorFragment.createFactory(publication, model.initialLocation, this)
+
+        super.onCreate(savedInstanceState)
+    }
+
+    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
+        val view =  super.onCreateView(inflater, container, savedInstanceState)
+        if (savedInstanceState == null) {
+            childFragmentManager.commitNow {
+                add(R.id.fragment_reader_container, ImageNavigatorFragment::class.java, Bundle(), NAVIGATOR_FRAGMENT_TAG)
+            }
+        }
+        navigator = childFragmentManager.findFragmentByTag(NAVIGATOR_FRAGMENT_TAG)!! as Navigator
+        return view
+    }
+
+    override fun onTap(point: PointF): Boolean {
+        val viewWidth = requireView().width
+        val leftRange = 0.0..(0.2 * viewWidth)
+
+        when {
+            leftRange.contains(point.x) -> navigator.goBackward(animated = true)
+            leftRange.contains(viewWidth - point.x) -> navigator.goForward(animated = true)
+            else -> requireActivity().toggleSystemUi()
+        }
+
+        return true
+    }
+
+    companion object {
+
+        const val NAVIGATOR_FRAGMENT_TAG = "navigator"
+    }
+}

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

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2021 Readium Foundation. All rights reserved.
+ * Use of this source code is governed by the BSD-style license
+ * available in the top-level LICENSE file of the project.
+ */
+
+package com.reactnativereadium.reader
+
+import android.graphics.PointF
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.Toast
+import androidx.fragment.app.commitNow
+import androidx.lifecycle.ViewModelProvider
+import org.readium.r2.navigator.Navigator
+import org.readium.r2.navigator.pdf.PdfNavigatorFragment
+import org.readium.r2.shared.fetcher.Resource
+import org.readium.r2.shared.publication.Link
+import org.readium.r2.shared.publication.Publication
+import com.reactnativereadium.R
+import com.reactnativereadium.utils.toggleSystemUi
+
+class PdfReaderFragment : VisualReaderFragment(), PdfNavigatorFragment.Listener {
+
+    override lateinit var model: ReaderViewModel
+    override lateinit var navigator: Navigator
+    private lateinit var publication: Publication
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        ViewModelProvider(requireActivity()).get(ReaderViewModel::class.java).let {
+            model = it
+            publication = it.publication
+        }
+
+        childFragmentManager.fragmentFactory =
+            PdfNavigatorFragment.createFactory(publication, model.initialLocation, this)
+
+        super.onCreate(savedInstanceState)
+    }
+
+    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
+        val view = super.onCreateView(inflater, container, savedInstanceState)
+        if (savedInstanceState == null) {
+            childFragmentManager.commitNow {
+                add(R.id.fragment_reader_container, PdfNavigatorFragment::class.java, Bundle(), NAVIGATOR_FRAGMENT_TAG)
+            }
+        }
+        navigator = childFragmentManager.findFragmentByTag(NAVIGATOR_FRAGMENT_TAG)!! as Navigator
+        return view
+    }
+
+    override fun onResourceLoadFailed(link: Link, error: Resource.Exception) {
+        val message = when (error) {
+            is Resource.Exception.OutOfMemory -> "The PDF is too large to be rendered on this device"
+            else -> "Failed to render this PDF"
+        }
+        Toast.makeText(requireActivity(), message, Toast.LENGTH_LONG).show()
+
+        // There's nothing we can do to recover, so we quit the Activity.
+        requireActivity().finish()
+    }
+
+    override fun onTap(point: PointF): Boolean {
+        val viewWidth = requireView().width
+        val leftRange = 0.0..(0.2 * viewWidth)
+
+        when {
+            leftRange.contains(point.x) -> navigator.goBackward()
+            leftRange.contains(viewWidth - point.x) -> navigator.goForward()
+            else -> requireActivity().toggleSystemUi()
+        }
+
+        return true
+    }
+
+    companion object {
+
+        const val NAVIGATOR_FRAGMENT_TAG = "navigator"
+    }
+}

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

@@ -0,0 +1,116 @@
+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 java.io.File
+import java.io.IOException
+import java.net.ServerSocket
+import java.net.URL
+import org.readium.r2.shared.extensions.mediaType
+import org.readium.r2.shared.extensions.tryOrNull
+import org.readium.r2.shared.Injectable
+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
+
+
+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()
+  }
+
+  suspend fun openPublication(
+    fileName: String,
+    initialLocation: Locator?,
+    callback: suspend (fragment: BaseReaderFragment) -> Unit
+  ) {
+    val file = File(fileName)
+    val asset = FileAsset(file, file.mediaType())
+
+    streamer.open(
+      asset,
+      allowUserInteraction = false,
+      sender = reactContext
+    )
+      .onSuccess {
+        val url = prepareToServe(it)
+        if (url != null) {
+          val readerFragment = EpubReaderFragment.newInstance(url)
+          readerFragment.initFactory(it, initialLocation)
+          callback.invoke(readerFragment)
+        }
+      }
+      .onFailure {
+        tryOrNull { asset.file.delete() }
+        RNLog.w(reactContext, "Error executing ReaderService.openPublication")
+        // TODO: implement failure event
+      }
+  }
+
+  private fun prepareToServe(publication: Publication): URL? {
+    val userProperties =
+      reactContext.filesDir.path + "/" + Injectable.Style.rawValue + "/UserProperties.json"
+    return server.addPublication(
+      publication,
+      userPropertiesFile = File(userProperties)
+    )
+  }
+
+  private fun startServer() {
+    if (!server.isAlive) {
+      try {
+        server.start()
+      } catch (e: IOException) {
+        RNLog.e(reactContext, "Unable to start the Readium server.")
+      }
+      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
+      }
+    }
+  }
+
+  sealed class Event {
+
+    class ImportPublicationFailed(val errorMessage: String?) : Event()
+
+    object UnableToMovePublication : Event()
+
+    object ImportPublicationSuccess : Event()
+
+    object ImportDatabaseFailed : Event()
+
+    class OpenBookError(val errorMessage: String?) : Event()
+  }
+}

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

@@ -0,0 +1,120 @@
+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.util.Try
+
+@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?
+    ) : ViewModelProvider.NewInstanceFactory() {
+        override fun <T : ViewModel?> create(modelClass: Class<T>): T =
+            modelClass
+              .getDeclaredConstructor(
+                Publication::class.java,
+                Locator::class.java
+              )
+              .newInstance(
+                publication,
+                initialLocation
+              )
+    }
+
+    sealed class Event {
+        object OpenOutlineRequested : Event()
+        object OpenDrmManagementRequested : Event()
+        object StartNewSearch : Event()
+        class Failure(val error: UserException) : Event()
+        class LocatorUpdate(val locator: Locator) : Event()
+    }
+
+    sealed class FeedbackEvent {
+        object BookmarkSuccessfullyAdded : FeedbackEvent()
+        object BookmarkFailed : FeedbackEvent()
+    }
+}

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

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2021 Readium Foundation. All rights reserved.
+ * Use of this source code is governed by the BSD-style license
+ * available in the top-level LICENSE file of the project.
+ */
+
+package com.reactnativereadium.reader
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+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 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
+
+/*
+ * Adds fullscreen support to the BaseReaderFragment
+ */
+abstract class VisualReaderFragment : BaseReaderFragment() {
+
+    private lateinit var navigatorFragment: Fragment
+
+    private var _binding: FragmentReaderBinding? = null
+    val binding get() = _binding!!
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        _binding = FragmentReaderBinding.inflate(inflater, container, false)
+        return binding.root
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+        navigatorFragment = navigator as Fragment
+
+        childFragmentManager.addOnBackStackChangedListener {
+            updateSystemUiVisibility()
+        }
+        binding.fragmentReaderContainer.setOnApplyWindowInsetsListener { container, insets ->
+            updateSystemUiPadding(container, insets)
+            insets
+        }
+    }
+
+    override fun onDestroyView() {
+        _binding = null
+        super.onDestroyView()
+    }
+
+    fun updateSystemUiVisibility() {
+        if (navigatorFragment.isHidden)
+            requireActivity().showSystemUi()
+        else
+            requireActivity().hideSystemUi()
+
+        requireView().requestApplyInsets()
+    }
+
+    private fun updateSystemUiPadding(container: View, insets: WindowInsets) {
+        if (navigatorFragment.isHidden) {
+            container.padSystemUi(insets, requireActivity())
+        } else {
+            container.clearPadding()
+        }
+    }
+}

package/android/src/main/java/com/reactnativereadium/search/SearchFragment.kt

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2021 Readium Foundation. All rights reserved.
+ * Use of this source code is governed by the BSD-style license
+ * available in the top-level LICENSE file of the project.
+ */
+
+package com.reactnativereadium.search
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.core.view.isVisible
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.activityViewModels
+import androidx.fragment.app.setFragmentResult
+import androidx.lifecycle.lifecycleScope
+import androidx.recyclerview.widget.DividerItemDecoration
+import androidx.recyclerview.widget.LinearLayoutManager
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import org.readium.r2.shared.publication.Locator
+import com.reactnativereadium.R
+import com.reactnativereadium.databinding.FragmentSearchBinding
+import com.reactnativereadium.reader.ReaderViewModel
+import com.reactnativereadium.utils.SectionDecoration
+
+class SearchFragment : Fragment(R.layout.fragment_search) {
+
+    private val viewModel: ReaderViewModel by activityViewModels()
+
+    private var _binding: FragmentSearchBinding? = null
+    private val binding get() = _binding!!
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+
+        val viewScope = viewLifecycleOwner.lifecycleScope
+
+        val searchAdapter = SearchResultAdapter(object : SearchResultAdapter.Listener {
+            override fun onItemClicked(v: View, locator: Locator) {
+                val result = Bundle().apply {
+                    putParcelable(SearchFragment::class.java.name, locator)
+                }
+                setFragmentResult(SearchFragment::class.java.name, result)
+            }
+        })
+
+        viewModel.searchResult
+            .onEach { searchAdapter.submitData(it) }
+            .launchIn(viewScope)
+
+        viewModel.searchLocators
+            .onEach { binding.noResultLabel.isVisible = it.isEmpty() }
+            .launchIn(viewScope)
+
+        viewModel.channel
+            .receive(viewLifecycleOwner) { event ->
+                when (event) {
+                    ReaderViewModel.Event.StartNewSearch ->
+                        binding.searchRecyclerView.scrollToPosition(0)
+                    else -> {}
+                }
+            }
+
+        binding.searchRecyclerView.apply {
+            adapter = searchAdapter
+            layoutManager = LinearLayoutManager(activity)
+            addItemDecoration(SectionDecoration(context, object : SectionDecoration.Listener {
+                override fun isStartOfSection(itemPos: Int): Boolean =
+                    viewModel.searchLocators.value.run {
+                        when {
+                            itemPos == 0 -> true
+                            itemPos < 0 -> false
+                            itemPos >= size -> false
+                            else -> getOrNull(itemPos)?.title != getOrNull(itemPos-1)?.title
+                        }
+                    }
+
+                override fun sectionTitle(itemPos: Int): String =
+                    viewModel.searchLocators.value.getOrNull(itemPos)?.title ?: ""
+            }))
+            addItemDecoration(DividerItemDecoration(context, DividerItemDecoration.VERTICAL))
+        }
+    }
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        _binding = FragmentSearchBinding.inflate(inflater, container, false)
+        return binding.root
+    }
+
+    override fun onDestroyView() {
+        super.onDestroyView()
+        _binding = null
+    }
+}

package/android/src/main/java/com/reactnativereadium/search/SearchPagingSource.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2021 Readium Foundation. All rights reserved.
+ * Use of this source code is governed by the BSD-style license
+ * available in the top-level LICENSE file of the project.
+ */
+
+package com.reactnativereadium.search
+
+import androidx.paging.PagingSource
+import androidx.paging.PagingState
+import org.readium.r2.shared.Search
+import org.readium.r2.shared.publication.Locator
+import org.readium.r2.shared.publication.LocatorCollection
+import org.readium.r2.shared.publication.services.search.SearchIterator
+import org.readium.r2.shared.publication.services.search.SearchTry
+
+@OptIn(Search::class)
+class SearchPagingSource(
+    private val listener: Listener?
+) : PagingSource<Unit, Locator>() {
+
+    interface Listener {
+        suspend fun next(): SearchTry<LocatorCollection?>
+    }
+
+    override val keyReuseSupported: Boolean get() = true
+
+    override fun getRefreshKey(state: PagingState<Unit, Locator>): Unit? = null
+
+    override suspend fun load(params: LoadParams<Unit>): LoadResult<Unit, Locator> {
+        listener ?: return LoadResult.Page(data = emptyList(), prevKey = null, nextKey = null)
+
+        return try {
+            val page = listener.next().getOrThrow()
+            LoadResult.Page(
+                data = page?.locators ?: emptyList(),
+                prevKey = null,
+                nextKey = if (page == null) null else Unit
+            )
+        } catch (e: Exception) {
+            LoadResult.Error(e)
+        }
+    }
+}

package/android/src/main/java/com/reactnativereadium/search/SearchResultAdapter.kt

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2021 Readium Foundation. All rights reserved.
+ * Use of this source code is governed by the BSD-style license
+ * available in the top-level LICENSE file of the project.
+ */
+
+package com.reactnativereadium.search
+
+import android.os.Build
+import android.text.Html
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.paging.PagingDataAdapter
+import androidx.recyclerview.widget.DiffUtil
+import androidx.recyclerview.widget.RecyclerView
+import org.readium.r2.shared.publication.Locator
+import com.reactnativereadium.databinding.ItemRecycleSearchBinding
+import com.reactnativereadium.utils.singleClick
+
+/**
+ * This class is an adapter for Search results' recycler view.
+ */
+class SearchResultAdapter(private var listener: Listener) :
+    PagingDataAdapter<Locator, SearchResultAdapter.ViewHolder>(ItemCallback()) {
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        return ViewHolder(
+            ItemRecycleSearchBinding.inflate(
+                LayoutInflater.from(parent.context), parent, false
+            )
+        )
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        val locator = getItem(position) ?: return
+        val html =
+            "${locator.text.before}<span style=\"background:yellow;\"><b>${locator.text.highlight}</b></span>${locator.text.after}"
+        holder.textView.text = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            Html.fromHtml(html, Html.FROM_HTML_MODE_COMPACT)
+        } else {
+            @Suppress("DEPRECATION")
+            Html.fromHtml(html)
+        }
+
+        holder.itemView.singleClick { v ->
+            listener.onItemClicked(v, locator)
+        }
+    }
+
+    inner class ViewHolder(val binding: ItemRecycleSearchBinding) :
+        RecyclerView.ViewHolder(binding.root) {
+        val textView = binding.text
+    }
+
+    interface Listener {
+        fun onItemClicked(v: View, locator: Locator)
+    }
+
+    private class ItemCallback : DiffUtil.ItemCallback<Locator>() {
+
+        override fun areItemsTheSame(oldItem: Locator, newItem: Locator): Boolean =
+            oldItem == newItem
+
+        override fun areContentsTheSame(oldItem: Locator, newItem: Locator): Boolean =
+            oldItem == newItem
+    }
+}