Abstract the toolkit over publication source

readium/lcp/src/main/java/org/readium/r2/lcp/LcpContentProtection.kt

@@ -6,36 +6,102 @@
 
 package org.readium.r2.lcp
 
+import android.content.ContentResolver
+import java.io.File
+import org.readium.r2.lcp.auth.LcpDumbAuthentication
 import org.readium.r2.lcp.auth.LcpPassphraseAuthentication
+import org.readium.r2.lcp.license.model.LicenseDocument
 import org.readium.r2.lcp.service.LcpLicensedAsset
+import org.readium.r2.shared.fetcher.Fetcher
 import org.readium.r2.shared.fetcher.TransformingFetcher
 import org.readium.r2.shared.publication.ContentProtection
 import org.readium.r2.shared.publication.Publication
+import org.readium.r2.shared.publication.asset.AssetFactory
 import org.readium.r2.shared.publication.asset.FileAsset
 import org.readium.r2.shared.publication.asset.PublicationAsset
-import org.readium.r2.shared.publication.asset.RemoteAsset
+import org.readium.r2.shared.publication.asset.SimpleAsset
 import org.readium.r2.shared.publication.services.contentProtectionServiceFactory
 import org.readium.r2.shared.util.Try
+import org.readium.r2.shared.util.Url
+import org.readium.r2.shared.util.mediatype.AssetType
+import org.readium.r2.shared.util.mediatype.MediaType
 
 internal class LcpContentProtection(
     private val lcpService: LcpService,
-    private val authentication: LcpAuthenticating
+    private val authentication: LcpAuthenticating,
+    private val assetFactory: AssetFactory
 ) : ContentProtection {
 
+    override suspend fun open(
+        url: Url,
+        mediaType: MediaType,
+        assetType: AssetType,
+        credentials: String?,
+        allowUserInteraction: Boolean,
+        sender: Any?
+    ): Try<ContentProtection.ProtectedAsset, Publication.OpeningException>? {
+        if (url.scheme != ContentResolver.SCHEME_FILE || mediaType != MediaType.LCP_LICENSE_DOCUMENT) {
+            return null
+        }
+
+        val licenseFile = File(url.path)
+
+        val asset = try {
+            remoteAssetForLicenseThrowing(licenseFile)
+        } catch (e: Exception) {
+            // FIXME: random choice of exception
+            val exception = Publication.OpeningException.ParsingFailed(LcpException.wrap(e))
+            return Try.failure(exception)
+        }
+
+        return open(asset, credentials, allowUserInteraction, sender)
+    }
+
     override suspend fun open(
         asset: PublicationAsset,
         credentials: String?,
         allowUserInteraction: Boolean,
         sender: Any?
     ): Try<ContentProtection.ProtectedAsset, Publication.OpeningException>? {
-        val license = retrieveLicense(asset, credentials, allowUserInteraction, sender)
+        val license = retrieveLicense(asset, asset.fetcher, credentials, allowUserInteraction, sender)
             ?: return null
-        return createProtectedAsset(asset, license)
+        return createProtectedAsset(asset, asset.fetcher, license)
+    }
+
+    private suspend fun remoteAssetForLicenseThrowing(licenseFile: File): PublicationAsset {
+        // Update the license file to get a fresh publication URL.
+        val license = lcpService.retrieveLicense(licenseFile, LcpDumbAuthentication(), false)
+            .getOrNull()
+
+        val licenseDoc = license?.license
+            ?: LicenseDocument(licenseFile.readBytes())
+
+        val link = checkNotNull(licenseDoc.link(LicenseDocument.Rel.publication))
+        val url = try {
+            Url(link.url.toString()) ?: throw IllegalStateException()
+        } catch (e: Exception) {
+            throw LcpException.Parsing.Url(rel = LicenseDocument.Rel.publication.rawValue)
+        }
+
+        val asset = assetFactory.createAsset(
+            url,
+            link.mediaType,
+            AssetType.Archive
+        ).getOrThrow()
+
+        return LcpLicensedAsset(
+            url,
+            link.mediaType,
+            licenseFile,
+            license,
+            asset.fetcher
+        )
     }
 
     /* Returns null if the publication is not protected by LCP. */
     private suspend fun retrieveLicense(
         asset: PublicationAsset,
+        fetcher: Fetcher,
         credentials: String?,
         allowUserInteraction: Boolean,
         sender: Any?
@@ -48,45 +114,33 @@ internal class LcpContentProtection(
         val license = when (asset) {
             is FileAsset ->
                 lcpService.retrieveLicense(asset.file, authentication, allowUserInteraction, sender)
-            is RemoteAsset ->
-                lcpService.retrieveLicense(asset.fetcher, asset.mediaType, authentication, allowUserInteraction, sender)
             is LcpLicensedAsset ->
                 asset.license
                     ?.let { Try.success(it) }
                     ?: lcpService.retrieveLicense(asset.licenseFile, authentication, allowUserInteraction, sender)
             else ->
-                null
+                lcpService.retrieveLicense(fetcher, asset.mediaType, authentication, allowUserInteraction, sender)
         }
 
-        return license?.takeUnless { result ->
+        return license.takeUnless { result ->
             result is Try.Failure<*, *> && result.exception is LcpException.Container
         }
     }
 
     private fun createProtectedAsset(
-        originalAsset: PublicationAsset,
+        asset: PublicationAsset,
+        fetcher: Fetcher,
         license: Try<LcpLicense, LcpException>,
     ): Try<ContentProtection.ProtectedAsset, Publication.OpeningException> {
         val serviceFactory = LcpContentProtectionService
             .createFactory(license.getOrNull(), license.exceptionOrNull())
 
         val newFetcher = TransformingFetcher(
-            originalAsset.fetcher,
+            fetcher,
             LcpDecryptor(license.getOrNull())::transform
         )
 
-        val newAsset = when (originalAsset) {
-            is FileAsset -> {
-                originalAsset.copy(fetcher = newFetcher)
-            }
-            is RemoteAsset -> {
-                originalAsset.copy(fetcher = newFetcher)
-            }
-            is LcpLicensedAsset -> {
-                originalAsset.copy(fetcher = newFetcher)
-            }
-            else -> throw IllegalStateException()
-        }
+        val newAsset = SimpleAsset(asset.name, asset.mediaType, newFetcher)
 
         val protectedFile = ContentProtection.ProtectedAsset(
             asset = newAsset,

readium/lcp/src/main/java/org/readium/r2/lcp/LcpService.kt

@@ -25,13 +25,11 @@ import org.readium.r2.lcp.service.PassphrasesRepository
 import org.readium.r2.lcp.service.PassphrasesService
 import org.readium.r2.shared.fetcher.Fetcher
 import org.readium.r2.shared.publication.ContentProtection
-import org.readium.r2.shared.publication.asset.PublicationAsset
+import org.readium.r2.shared.publication.asset.AssetFactory
+import org.readium.r2.shared.publication.asset.DefaultAssetFactory
 import org.readium.r2.shared.util.Try
-import org.readium.r2.shared.util.archive.ArchiveFactory
-import org.readium.r2.shared.util.archive.DefaultArchiveFactory
-import org.readium.r2.shared.util.http.DefaultHttpClient
-import org.readium.r2.shared.util.http.HttpClient
 import org.readium.r2.shared.util.mediatype.MediaType
+import org.readium.r2.shared.util.mediatype.MediaTypeRetriever
 
 /**
  * Service used to acquire and open publications protected with LCP.
@@ -114,13 +112,9 @@ interface LcpService {
      * LCP license. The default implementation [LcpDialogAuthentication] presents a dialog to the
      * user to enter their passphrase.
      */
-    fun contentProtection(authentication: LcpAuthenticating = LcpDialogAuthentication()): ContentProtection =
-        LcpContentProtection(this, authentication)
-
-    /**
-     * Builds a [PublicationAsset] to open a LCP-protected publication from its license file.
-     */
-    suspend fun remoteAssetForLicense(license: File): Try<PublicationAsset, LcpException>
+    fun contentProtection(
+        authentication: LcpAuthenticating = LcpDialogAuthentication(),
+    ): ContentProtection
 
     /**
      * Information about an acquired publication protected with LCP.
@@ -145,8 +139,8 @@ interface LcpService {
          */
         operator fun invoke(
             context: Context,
-            archiveFactory: ArchiveFactory = DefaultArchiveFactory(),
-            httpClient: HttpClient = DefaultHttpClient()
+            assetFactory: AssetFactory = DefaultAssetFactory(),
+            mediaTypeRetriever: MediaTypeRetriever = MediaTypeRetriever()
         ): LcpService? {
             if (!LcpClient.isAvailable())
                 return null
@@ -166,8 +160,8 @@ interface LcpService {
                 network = network,
                 passphrases = passphrases,
                 context = context,
-                archiveFactory = archiveFactory,
-                httpClient = httpClient
+                assetFactory = assetFactory,
+                mediaTypeRetriever = mediaTypeRetriever
             )
         }
 

readium/lcp/src/main/java/org/readium/r2/lcp/license/container/ArchiveLicenseContainer.kt

@@ -9,13 +9,13 @@ package org.readium.r2.lcp.license.container
 import kotlinx.coroutines.runBlocking
 import org.readium.r2.lcp.LcpException
 import org.readium.r2.lcp.license.model.LicenseDocument
-import org.readium.r2.shared.util.archive.Archive
+import org.readium.r2.shared.util.archive.Package
 
 /**
  * Access to a License Document stored in a read-only ZIP archive.
  */
 internal class ArchiveLicenseContainer(
-    private val archive: Archive,
+    private val archive: Package,
     private val entryPath: String,
 ) : LicenseContainer {
 

readium/lcp/src/main/java/org/readium/r2/lcp/license/container/LicenseContainer.kt

@@ -14,6 +14,7 @@ import org.readium.r2.lcp.license.model.LicenseDocument
 import org.readium.r2.shared.extensions.addPrefix
 import org.readium.r2.shared.fetcher.Fetcher
 import org.readium.r2.shared.util.mediatype.MediaType
+import org.readium.r2.shared.util.mediatype.MediaTypeRetriever
 
 private const val LICENSE_IN_EPUB = "META-INF/license.lcpl"
 
@@ -30,9 +31,10 @@ internal interface LicenseContainer {
 
 internal suspend fun createLicenseContainer(
     filepath: String,
-    mediaTypes: List<String> = emptyList()
+    mediaTypes: List<String> = emptyList(),
+    mediaTypeRetriever: MediaTypeRetriever
 ): LicenseContainer {
-    val mediaType = MediaType.ofFile(filepath, mediaTypes = mediaTypes, fileExtensions = emptyList())
+    val mediaType = mediaTypeRetriever.ofFile(filepath, mediaTypes = mediaTypes, fileExtensions = emptyList())
         ?: throw LcpException.Container.OpenFailed
     return createLicenseContainer(filepath, mediaType)
 }

readium/lcp/src/main/java/org/readium/r2/lcp/service/LcpLicensedAsset.kt

@@ -10,12 +10,17 @@ import java.io.File
 import org.readium.r2.lcp.LcpLicense
 import org.readium.r2.shared.fetcher.Fetcher
 import org.readium.r2.shared.publication.asset.PublicationAsset
+import org.readium.r2.shared.util.Url
 import org.readium.r2.shared.util.mediatype.MediaType
 
 data class LcpLicensedAsset(
-    override val name: String,
+    val url: Url,
     override val mediaType: MediaType,
-    override val fetcher: Fetcher,
     val licenseFile: File,
-    val license: LcpLicense?
-) : PublicationAsset
+    val license: LcpLicense?,
+    override val fetcher: Fetcher
+) : PublicationAsset {
+
+    override val name: String =
+        url.file
+}

readium/lcp/src/main/java/org/readium/r2/lcp/service/LicensesService.kt

@@ -13,25 +13,19 @@ import android.content.Context
 import java.io.File
 import kotlin.coroutines.resume
 import kotlinx.coroutines.*
-import org.readium.r2.lcp.LcpAuthenticating
-import org.readium.r2.lcp.LcpException
-import org.readium.r2.lcp.LcpLicense
-import org.readium.r2.lcp.LcpService
-import org.readium.r2.lcp.auth.LcpDumbAuthentication
+import org.readium.r2.lcp.*
 import org.readium.r2.lcp.license.License
 import org.readium.r2.lcp.license.LicenseValidation
 import org.readium.r2.lcp.license.container.LicenseContainer
 import org.readium.r2.lcp.license.container.createLicenseContainer
 import org.readium.r2.lcp.license.model.LicenseDocument
 import org.readium.r2.shared.extensions.tryOr
 import org.readium.r2.shared.fetcher.Fetcher
-import org.readium.r2.shared.publication.asset.PublicationAsset
-import org.readium.r2.shared.publication.asset.RemoteAsset
+import org.readium.r2.shared.publication.ContentProtection
+import org.readium.r2.shared.publication.asset.AssetFactory
 import org.readium.r2.shared.util.Try
-import org.readium.r2.shared.util.Url
-import org.readium.r2.shared.util.archive.ArchiveFactory
-import org.readium.r2.shared.util.http.HttpClient
 import org.readium.r2.shared.util.mediatype.MediaType
+import org.readium.r2.shared.util.mediatype.MediaTypeRetriever
 import timber.log.Timber
 
 internal class LicensesService(
@@ -41,50 +35,20 @@ internal class LicensesService(
     private val network: NetworkService,
     private val passphrases: PassphrasesService,
     private val context: Context,
-    private val archiveFactory: ArchiveFactory,
-    private val httpClient: HttpClient
+    private val assetFactory: AssetFactory,
+    private val mediaTypeRetriever: MediaTypeRetriever
 ) : LcpService, CoroutineScope by MainScope() {
 
     override suspend fun isLcpProtected(file: File): Boolean =
         tryOr(false) {
-            createLicenseContainer(file.path).read()
+            createLicenseContainer(file.path, mediaTypeRetriever  = mediaTypeRetriever).read()
             true
         }
 
-    override suspend fun remoteAssetForLicense(license: File): Try<PublicationAsset, LcpException> {
-        return try {
-            Try.success(remoteAssetForLicenseThrowing(license))
-        } catch (e: Exception) {
-            Try.failure(LcpException.wrap(e))
-        }
-    }
-
-    private suspend fun remoteAssetForLicenseThrowing(licenseFile: File): PublicationAsset {
-        // Update the license file to get a fresh publication URL.
-        val license = retrieveLicense(licenseFile, LcpDumbAuthentication(), false)
-            .getOrNull()
-
-        val licenseDoc = license?.license
-            ?: LicenseDocument(licenseFile.readBytes())
-
-        val link = checkNotNull(licenseDoc.link(LicenseDocument.Rel.publication))
-        val url = try {
-            Url(link.url.toString()) ?: throw IllegalStateException()
-        } catch (e: Exception) {
-            throw LcpException.Parsing.Url(rel = LicenseDocument.Rel.publication.rawValue)
-        }
-        val baseAsset = RemoteAsset.Factory(archiveFactory, httpClient)
-            .createAsset(url, link.mediaType)
-            .getOrThrow()
-
-        return LcpLicensedAsset(
-            baseAsset.name,
-            baseAsset.mediaType,
-            baseAsset.fetcher,
-            licenseFile,
-            license
-        )
-    }
+    override fun contentProtection(
+        authentication: LcpAuthenticating,
+    ): ContentProtection =
+        LcpContentProtection(this, authentication, assetFactory)
 
     override suspend fun acquirePublication(lcpl: ByteArray, onProgress: (Double) -> Unit): Try<LcpService.AcquiredPublication, LcpException> =
         try {
@@ -102,7 +66,7 @@ internal class LicensesService(
         sender: Any?
     ): Try<LcpLicense, LcpException> =
         try {
-            val container = createLicenseContainer(file.path)
+            val container = createLicenseContainer(file.path, mediaTypeRetriever = mediaTypeRetriever)
             val license = retrieveLicense(container, authentication, allowUserInteraction, true, sender)
             Try.success(license)
         } catch (e: Exception) {
@@ -238,7 +202,9 @@ internal class LicensesService(
         }
         Timber.i("LCP destination $destination")
 
-        val mediaType = network.download(url, destination, mediaType = link.type, onProgress = onProgress) ?: MediaType.of(mediaType = link.type) ?: MediaType.EPUB
+        val mediaType = network.download(url, destination, mediaType = link.type, onProgress = onProgress)
+            ?: mediaTypeRetriever.of(mediaType = link.type)
+            ?: MediaType.EPUB
 
         // Saves the License Document into the downloaded publication
         val container = createLicenseContainer(destination.path, mediaType)