react-native-readium 1.0.0-alpha.1

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

@@ -0,0 +1,156 @@
+package com.reactnativereadium.utils
+
+import android.content.ContentUris
+import android.content.Context
+import android.net.Uri
+import android.provider.DocumentsContract
+import android.provider.MediaStore
+import android.text.TextUtils
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import com.reactnativereadium.utils.extensions.toFile
+import java.io.File
+import java.io.FileNotFoundException
+import java.io.InputStream
+import java.net.URL
+
+object ContentResolverUtil {
+
+    suspend fun getContentInputStream(context: Context, uri: Uri, publicationPath: String) {
+        withContext(Dispatchers.IO) {
+            try {
+                val path = getRealPath(context, uri)
+                if (path != null) {
+                    File(path).copyTo(File(publicationPath))
+                } else {
+                    val input = URL(uri.toString()).openStream()
+                    input.toFile(publicationPath)
+                }
+            } catch (e: Exception) {
+                val input = getInputStream(context, uri)
+                input?.let {
+                    input.toFile(publicationPath)
+                }
+            }
+        }
+    }
+
+    private fun getInputStream(context: Context, uri: Uri): InputStream? {
+        return try {
+            context.contentResolver.openInputStream(uri)
+        } catch (e: FileNotFoundException) {
+            e.printStackTrace()
+            null
+        }
+    }
+
+    private fun getRealPath(context: Context, uri: Uri): String? {
+        // DocumentProvider
+        if (DocumentsContract.isDocumentUri(context, uri)) {
+            // ExternalStorageProvider
+            if (isExternalStorageDocument(uri)) {
+                val docId = DocumentsContract.getDocumentId(uri)
+                val split = docId.split(":".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+                val type = split[0]
+                if ("primary".equals(type, ignoreCase = true)) {
+                    return context.getExternalFilesDir(null).toString() + "/" + split[1]
+                }
+                // TODO handle non-primary volumes
+
+            } else if (isDownloadsDocument(uri)) {
+                val id = DocumentsContract.getDocumentId(uri)
+                if (!TextUtils.isEmpty(id)) {
+                    if (id.startsWith("raw:")) {
+                        return id.replaceFirst("raw:".toRegex(), "")
+                    }
+                    return try {
+                        val contentUri = ContentUris.withAppendedId(
+                                Uri.parse("content://downloads/public_downloads"), java.lang.Long.valueOf(id))
+                        getDataColumn(context, contentUri, null, null)
+                    } catch (e: NumberFormatException) {
+                        null
+                    }
+
+                }
+            } else if (isMediaDocument(uri)) {
+                val docId = DocumentsContract.getDocumentId(uri)
+                val split = docId.split(":".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+                val type = split[0]
+
+                var contentUri: Uri? = null
+                when (type) {
+                    "image" -> contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI
+                    "video" -> contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI
+                    "audio" -> contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI
+                }
+
+                val selection = "_id=?"
+                val selectionArgs = arrayOf(split[1])
+
+                return getDataColumn(context, contentUri, selection, selectionArgs)
+            }
+        } else if ("content".equals(uri.scheme!!, ignoreCase = true)) {
+
+            // Return the remote address
+            return getDataColumn(context, uri, null, null)
+
+        } else if ("file".equals(uri.scheme!!, ignoreCase = true)) {
+            return uri.path
+        }
+
+        return null
+    }
+
+    /**
+     * Get the value of the data column for this Uri. This is useful for
+     * MediaStore Uris, and other file-based ContentProviders.
+     *
+     * @param context       The context.
+     * @param uri           The Uri to query.
+     * @param selection     (Optional) Filter used in the query.
+     * @param selectionArgs (Optional) Selection arguments used in the query.
+     * @return The value of the _data column, which is typically a file path.
+     */
+    private fun getDataColumn(context: Context, uri: Uri?, selection: String?,
+                              selectionArgs: Array<String>?): String? {
+
+        val column = "_data"
+        val projection = arrayOf(column)
+        context.contentResolver.query(uri!!, projection, selection, selectionArgs, null).use { cursor ->
+            cursor?.let {
+                if (cursor.moveToFirst()) {
+                    val index = cursor.getColumnIndexOrThrow(column)
+                    return cursor.getString(index)
+                }
+            }
+        }
+        return null
+    }
+
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is ExternalStorageProvider.
+     */
+    private fun isExternalStorageDocument(uri: Uri): Boolean {
+        return "com.android.externalstorage.documents" == uri.authority
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is DownloadsProvider.
+     */
+    private fun isDownloadsDocument(uri: Uri): Boolean {
+        return "com.android.providers.downloads.documents" == uri.authority
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is MediaProvider.
+     */
+    private fun isMediaDocument(uri: Uri): Boolean {
+        return "com.android.providers.media.documents" == uri.authority
+    }
+
+
+}

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

@@ -0,0 +1,6 @@
+package com.reactnativereadium.utils
+
+class Dimensions (
+  var width: Int = 0,
+  var height: Int = 0
+) {}

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

@@ -0,0 +1,61 @@
+package com.reactnativereadium.utils
+
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleObserver
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.OnLifecycleEvent
+import androidx.lifecycle.lifecycleScope
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.flow.receiveAsFlow
+import kotlinx.coroutines.launch
+
+class EventChannel<T>(private val channel: Channel<T>, private val sendScope: CoroutineScope) {
+
+    fun send(event: T) {
+        sendScope.launch {
+            channel.send(event)
+        }
+    }
+
+    fun receive(lifecycleOwner: LifecycleOwner, callback: suspend (T) -> Unit) {
+        val observer = FlowObserver(lifecycleOwner, channel.receiveAsFlow(), callback)
+        lifecycleOwner.lifecycle.addObserver(observer)
+    }
+}
+
+class FlowObserver<T> (
+    private val lifecycleOwner: LifecycleOwner,
+    private val flow: Flow<T>,
+    private val collector: suspend (T) -> Unit
+) : LifecycleObserver {
+
+    private var job: Job? = null
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_START)
+    fun onStart() {
+        if (job == null) {
+            job = lifecycleOwner.lifecycleScope.launch {
+                flow.collect { collector(it) }
+            }
+        }
+    }
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
+    fun onStop() {
+        job?.cancel()
+        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)
+}

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

@@ -0,0 +1,46 @@
+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
+ * [factory] closure.
+ */
+inline fun <reified T : Fragment> createFragmentFactory(crossinline factory: () -> T): FragmentFactory = object : FragmentFactory() {
+
+    override fun instantiate(classLoader: ClassLoader, className: String): Fragment {
+        return when (className) {
+            T::class.java.name -> factory()
+            else -> super.instantiate(classLoader, className)
+        }
+    }
+
+}
+
+/**
+ * A [FragmentFactory] which will iterate over a provided list of [factories] until finding one
+ * instantiating successfully the requested [Fragment].
+ *
+ * ```
+ * supportFragmentManager.fragmentFactory = CompositeFragmentFactory(
+ *     EpubNavigatorFragment.createFactory(publication, baseUrl, initialLocator, this),
+ *     PdfNavigatorFragment.createFactory(publication, initialLocator, this)
+ * )
+ * ```
+ */
+class CompositeFragmentFactory(private val factories: List<FragmentFactory>) : FragmentFactory() {
+
+    constructor(vararg factories: FragmentFactory) : this(factories.toList())
+
+    override fun instantiate(classLoader: ClassLoader, className: String): Fragment {
+        for (factory in factories) {
+            tryOrNull { factory.instantiate(classLoader, className) }
+                ?.let { return it }
+        }
+
+        return super.instantiate(classLoader, className)
+    }
+
+}

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

@@ -0,0 +1,45 @@
+package com.reactnativereadium.utils
+
+import android.app.Activity
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+//import com.reactnativereadium.MainActivity
+import timber.log.Timber
+
+class R2DispatcherActivity : Activity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        dispatchIntent(intent)
+        finish()
+    }
+
+    private fun dispatchIntent(intent: Intent) {
+        val uri = uriFromIntent(intent)
+                ?: run {
+                    Timber.d("Got an empty intent.")
+                    return
+                }
+//      FIXME: MainActivity
+//        val newIntent = Intent(this, MainActivity::class.java).apply {
+//            addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+//            data = uri
+//        }
+//        startActivity(newIntent)
+    }
+
+    private fun uriFromIntent(intent: Intent): Uri? =
+        when (intent.action) {
+            Intent.ACTION_SEND -> {
+                if ("text/plain" == intent.type) {
+                    intent.getStringExtra(Intent.EXTRA_TEXT).let { Uri.parse(it) }
+                } else {
+                    intent.getParcelableExtra(Intent.EXTRA_STREAM)
+                }
+            }
+            else -> {
+                intent.data
+            }
+        }
+}

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

@@ -0,0 +1,98 @@
+package com.reactnativereadium.utils
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Rect
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.TextView
+import androidx.core.view.children
+import androidx.recyclerview.widget.RecyclerView
+import androidx.recyclerview.widget.RecyclerView.NO_POSITION
+/* import com.reactnativereadium.databinding.SectionHeaderBinding */
+
+class SectionDecoration(
+    private val context: Context,
+    private val listener: Listener
+) : RecyclerView.ItemDecoration() {
+
+    interface Listener {
+        fun isStartOfSection(itemPos: Int): Boolean
+        fun sectionTitle(itemPos: Int): String
+    }
+
+    private lateinit var headerView: View
+    private lateinit var sectionTitleView: TextView
+
+    override fun getItemOffsets(
+        outRect: Rect,
+        view: View,
+        parent: RecyclerView,
+        state: RecyclerView.State
+    ) {
+        super.getItemOffsets(outRect, view, parent, state)
+        val pos = parent.getChildAdapterPosition(view)
+        initHeaderViewIfNeeded(parent)
+        if (listener.sectionTitle(pos) != "" && listener.isStartOfSection(pos)) {
+            sectionTitleView.text = listener.sectionTitle(pos)
+            fixLayoutSize(headerView, parent)
+            outRect.top = headerView.height
+        }
+    }
+
+    override fun onDrawOver(c: Canvas, parent: RecyclerView, state: RecyclerView.State) {
+        super.onDrawOver(c, parent, state)
+        initHeaderViewIfNeeded(parent)
+
+        val children = parent.children.toList()
+        children.forEach { child ->
+            val pos = parent.getChildAdapterPosition(child)
+            if (pos != NO_POSITION && listener.sectionTitle(pos) != "" &&
+                (listener.isStartOfSection(pos) || isTopChild(child, children))) {
+                sectionTitleView.text = listener.sectionTitle(pos)
+                fixLayoutSize(headerView, parent)
+                drawHeader(c, child, headerView)
+            }
+        }
+    }
+
+    private fun initHeaderViewIfNeeded(parent: RecyclerView) {
+        if (::headerView.isInitialized) return
+        /* FIXME: databinding.SectionHeaderBinding */
+        /* SectionHeaderBinding.inflate(
+            LayoutInflater.from(context),
+            parent,
+            false
+        ).apply {
+            headerView = root
+            sectionTitleView = header
+        } */
+    }
+
+    private fun fixLayoutSize(v: View, parent: ViewGroup) {
+        val widthSpec = View.MeasureSpec.makeMeasureSpec(parent.width, View.MeasureSpec.EXACTLY)
+        val heightSpec = View.MeasureSpec.makeMeasureSpec(parent.height, View.MeasureSpec.UNSPECIFIED)
+        val childWidth = ViewGroup.getChildMeasureSpec(widthSpec, parent.paddingStart + parent.paddingEnd, v.layoutParams.width)
+        val childHeight = ViewGroup.getChildMeasureSpec(heightSpec, parent.paddingTop + parent.paddingBottom, v.layoutParams.height)
+        v.measure(childWidth, childHeight)
+        v.layout(0, 0, v.measuredWidth, v.measuredHeight)
+    }
+
+    private fun drawHeader(c: Canvas, child: View, headerView: View) {
+        c.run {
+            save()
+            translate(0F, maxOf(0, child.top - headerView.height).toFloat())
+            headerView.draw(this)
+            restore()
+        }
+    }
+
+    private fun isTopChild(child: View, children: List<View>): Boolean {
+        var tmp = child.top
+        children.forEach { c ->
+            tmp = minOf(c.top, tmp)
+        }
+        return child.top == tmp
+    }
+}

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

@@ -0,0 +1,32 @@
+package com.reactnativereadium.utils
+
+import android.view.View
+
+
+/**
+ * Prevents from double clicks on a view, which could otherwise lead to unpredictable states. Useful
+ * while transitioning to another activity for instance.
+ */
+class SingleClickListener(private val click: (v: View) -> Unit) : View.OnClickListener {
+
+    companion object {
+        private const val DOUBLE_CLICK_TIMEOUT = 2500
+    }
+
+    private var lastClick: Long = 0
+
+    override fun onClick(v: View) {
+        if (getLastClickTimeout() > DOUBLE_CLICK_TIMEOUT) {
+            lastClick = System.currentTimeMillis()
+            click(v)
+        }
+    }
+
+    private fun getLastClickTimeout(): Long {
+        return System.currentTimeMillis() - lastClick
+    }
+}
+
+fun View.singleClick(l: (View) -> Unit) {
+    setOnClickListener(SingleClickListener(l))
+}

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

@@ -0,0 +1,63 @@
+package com.reactnativereadium.utils
+
+import android.app.Activity
+import android.view.View
+import android.view.WindowInsets
+import androidx.core.view.WindowInsetsCompat
+
+// Using ViewCompat and WindowInsetsCompat does not work properly in all versions of Android
+@Suppress("DEPRECATION")
+/** Returns `true` if fullscreen or immersive mode is not set. */
+private fun Activity.isSystemUiVisible(): Boolean {
+    return this.window.decorView.systemUiVisibility and View.SYSTEM_UI_FLAG_FULLSCREEN == 0
+}
+
+// Using ViewCompat and WindowInsetsCompat does not work properly in all versions of Android
+@Suppress("DEPRECATION")
+/** Enable fullscreen or immersive mode. */
+fun Activity.hideSystemUi() {
+    this.window.decorView.systemUiVisibility = (
+            View.SYSTEM_UI_FLAG_IMMERSIVE
+                    or View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+                    or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+                    or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+                    or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
+                    or View.SYSTEM_UI_FLAG_FULLSCREEN
+            )
+}
+
+// Using ViewCompat and WindowInsetsCompat does not work properly in all versions of Android
+@Suppress("DEPRECATION")
+/** Disable fullscreen or immersive mode. */
+fun Activity.showSystemUi() {
+    this.window.decorView.systemUiVisibility = (
+            View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+                    or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+                    or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+            )
+}
+
+/** Toggle fullscreen or immersive mode. */
+fun Activity.toggleSystemUi() {
+    if (this.isSystemUiVisible()) {
+        this.hideSystemUi()
+    } else {
+        this.showSystemUi()
+    }
+}
+
+/** Set padding around view so that content doesn't overlap system UI */
+fun View.padSystemUi(insets: WindowInsets, activity: Activity) =
+    WindowInsetsCompat.toWindowInsetsCompat(insets, this)
+        .getInsets(WindowInsetsCompat.Type.systemBars()).apply {
+            setPadding(
+                left,
+                top,
+                right,
+                bottom
+            )
+        }
+
+/** Clear padding around view */
+fun View.clearPadding() =
+    setPadding(0, 0, 0, 0)

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

@@ -0,0 +1,23 @@
+package com.reactnativereadium.utils.extensions
+
+import android.graphics.Bitmap
+import android.util.Base64
+import timber.log.Timber
+import java.io.ByteArrayOutputStream
+
+/**
+ * Converts the receiver bitmap into a data URL ready to be used in HTML or CSS.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
+ */
+fun Bitmap.toDataUrl(): String? =
+    try {
+        val stream = ByteArrayOutputStream()
+        compress(Bitmap.CompressFormat.PNG, 100, stream)
+            .also { success -> if (!success) throw Exception("Can't compress image to PNG") }
+        val b64 = Base64.encodeToString(stream.toByteArray(), Base64.DEFAULT)
+        "data:image/png;base64,$b64"
+    } catch (e: Exception) {
+        Timber.e(e)
+        null
+    }

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

@@ -0,0 +1,16 @@
+package com.reactnativereadium.utils.extensions
+
+import android.content.Context
+import androidx.annotation.ColorInt
+import androidx.annotation.ColorRes
+import androidx.core.content.ContextCompat
+
+
+/**
+ * Extensions
+ */
+
+@ColorInt
+fun Context.color(@ColorRes id: Int): Int {
+    return ContextCompat.getColor(this, id)
+}

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

@@ -0,0 +1,22 @@
+package com.reactnativereadium.utils.extensions
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.File
+import java.io.FileFilter
+import java.io.IOException
+
+suspend fun File.moveTo(target: File) = withContext(Dispatchers.IO) {
+    if (!this@moveTo.renameTo(target))
+        throw IOException()
+}
+
+
+/**
+ * As there are cases where [File.listFiles] returns null even though it is a directory, we return
+ * an empty list instead.
+ */
+fun File.listFilesSafely(filter: FileFilter? = null): List<File> {
+    val array: Array<File>? = if (filter == null) listFiles() else listFiles(filter)
+    return array?.toList() ?: emptyList()
+}

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

@@ -0,0 +1,23 @@
+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) {
+        use { input ->
+            File(path).outputStream().use { input.copyTo(it) }
+        }
+    }
+}
+
+suspend fun InputStream.copyToTempFile(dir: String): File? = tryOrNull {
+    val filename = UUID.randomUUID().toString()
+    File(dir + filename)
+        .also { toFile(it.path) }
+}

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

@@ -0,0 +1,6 @@
+package com.reactnativereadium.utils.extensions
+
+import org.readium.r2.shared.publication.Link
+
+val Link.outlineTitle: String
+    get() = title ?: href

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

@@ -0,0 +1,6 @@
+package com.reactnativereadium.utils.extensions
+
+import org.readium.r2.shared.publication.Metadata
+
+val Metadata.authorName: String get() =
+    authors.firstOrNull()?.name ?: ""

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

@@ -0,0 +1,29 @@
+package com.reactnativereadium.utils.extensions
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.readium.r2.shared.extensions.extension
+import org.readium.r2.shared.extensions.tryOr
+import org.readium.r2.shared.extensions.tryOrNull
+import java.io.File
+import java.io.FileOutputStream
+import java.net.URL
+import java.util.*
+
+suspend fun URL.download(path: String): File? = tryOr(null) {
+    val file = File(path)
+    withContext(Dispatchers.IO) {
+        openStream().use { input ->
+            FileOutputStream(file).use { output ->
+                input.copyTo(output)
+            }
+        }
+    }
+    file
+}
+
+suspend fun URL.copyToTempFile(dir: String): File? = tryOrNull {
+    val filename = UUID.randomUUID().toString()
+    val path = "$dir$filename.$extension"
+    download(path)
+}

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

@@ -0,0 +1,17 @@
+package com.reactnativereadium.utils.extensions
+
+import android.content.Context
+import android.net.Uri
+import org.readium.r2.shared.extensions.tryOrNull
+import org.readium.r2.shared.util.mediatype.MediaType
+import com.reactnativereadium.utils.ContentResolverUtil
+import java.io.File
+import java.util.*
+
+suspend fun Uri.copyToTempFile(context: Context, dir: String): File? = tryOrNull {
+    val filename = UUID.randomUUID().toString()
+    val mediaType = MediaType.ofUri(this, context.contentResolver)
+    val path = "$dir$filename.${mediaType?.fileExtension ?: "tmp"}"
+    ContentResolverUtil.getContentInputStream(context, this, path)
+    return@tryOrNull File(path)
+}

package/android/src/main/res/drawable/background_action_mode.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle" android:padding = "10dp">
+    <solid android:color="#000" />
+    <corners android:radius="8dp" />
+</shape>