diff --git a/android/app/src/main/AndroidManifest.xml b/android/app/src/main/AndroidManifest.xml index 86d61e42d..2e9ca04c8 100644 --- a/android/app/src/main/AndroidManifest.xml +++ b/android/app/src/main/AndroidManifest.xml @@ -220,6 +220,15 @@ android:name="android.support.FILE_PROVIDER_PATHS" android:resource="@xml/file_paths" /> + + + diff --git a/android/app/src/main/kotlin/com/zarz/mornye/CoverContentProvider.kt b/android/app/src/main/kotlin/com/zarz/mornye/CoverContentProvider.kt new file mode 100644 index 000000000..ba2830a53 --- /dev/null +++ b/android/app/src/main/kotlin/com/zarz/mornye/CoverContentProvider.kt @@ -0,0 +1,73 @@ +package com.zarz.mornye + +import android.content.ContentProvider +import android.content.ContentResolver +import android.content.ContentValues +import android.content.Context +import android.database.Cursor +import android.net.Uri +import android.os.ParcelFileDescriptor +import java.io.File +import java.io.FileNotFoundException + +/** + * Cover images for media browsers such as Android Auto, which run in + * another process and load list artwork from the item's URI. A car cannot + * hold a permission, so the provider is exported, and in exchange it only + * reads: regular image files directly in the folders [CoverProviderFiles] + * allows, named as `content:////`, with no + * listing and no writes. + */ +class CoverContentProvider : ContentProvider() { + private val folders: Map by lazy { coverFolders(requireNotNull(context)) } + + override fun onCreate() = true + + override fun openFile(uri: Uri, mode: String): ParcelFileDescriptor { + if (mode != "r") throw SecurityException("Covers are read-only") + val file = coverFile(uri) ?: throw FileNotFoundException("No cover at this URI") + return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY) + } + + override fun getType(uri: Uri): String? = coverFile(uri)?.let(CoverProviderFiles::imageType) + + override fun query( + uri: Uri, + projection: Array?, + selection: String?, + selectionArgs: Array?, + sortOrder: String?, + ): Cursor? = null + + override fun insert(uri: Uri, values: ContentValues?): Uri? = readOnly() + + override fun update( + uri: Uri, + values: ContentValues?, + selection: String?, + selectionArgs: Array?, + ): Int = readOnly() + + override fun delete(uri: Uri, selection: String?, selectionArgs: Array?): Int = readOnly() + + private fun readOnly(): Nothing = throw UnsupportedOperationException("Covers are read-only") + + private fun coverFile(uri: Uri): File? { + val context = context ?: return null + if (uri.scheme != ContentResolver.SCHEME_CONTENT || uri.authority != authority(context)) return null + return CoverProviderFiles.resolve(folders, uri.pathSegments) + } + + companion object { + private fun authority(context: Context) = "${context.packageName}.covers" + + private fun coverFolders(context: Context) = + CoverProviderFiles.folders(context.filesDir, context.cacheDir) + + /** The authority and folder paths Dart builds cover URIs from. */ + fun describe(context: Context): Map = mapOf( + "authority" to authority(context), + "folders" to coverFolders(context).mapValues { it.value.path }, + ) + } +} diff --git a/android/app/src/main/kotlin/com/zarz/mornye/CoverProviderFiles.kt b/android/app/src/main/kotlin/com/zarz/mornye/CoverProviderFiles.kt new file mode 100644 index 000000000..3f90887cf --- /dev/null +++ b/android/app/src/main/kotlin/com/zarz/mornye/CoverProviderFiles.kt @@ -0,0 +1,78 @@ +package com.zarz.mornye + +import java.io.File +import java.io.IOException +import java.io.RandomAccessFile + +/** + * Which file a [CoverContentProvider] URI names. Its path is two segments: + * the name of an allowed folder, then the name of a regular image file + * directly in that folder. Anything else names nothing, including a name + * that leaves the folder through `..`, an encoded `/` or a symbolic link. + */ +internal object CoverProviderFiles { + /** + * The app's cover folders that media browser lists name: covers the + * cover store fetched, Library thumbnails, and embedded artwork read + * from downloaded songs. + */ + fun folders(files: File, cache: File): Map = mapOf( + "covers" to File(files, "covers"), + "library_covers" to File(files, "library_covers"), + "embedded_cover_previews" to File(cache, "embedded_cover_previews"), + ) + + /** The image file [segments] name in [folders], or null. */ + fun resolve(folders: Map, segments: List): File? { + if (segments.size != 2) return null + val folder = folders[segments[0]] ?: return null + val name = segments[1] + if (name.isEmpty() || name.startsWith('.') || name.any { it == '/' || it == '\u0000' }) { + return null + } + return try { + val root = folder.canonicalFile + val file = File(root, name).canonicalFile + file.takeIf { it.parentFile == root && it.isFile && imageType(it) != null } + } catch (_: IOException) { + null + } catch (_: SecurityException) { + null + } + } + + /** The MIME type of the image [file] holds, or null when it holds none. */ + fun imageType(file: File): String? = try { + RandomAccessFile(file, "r").use { input -> + val head = ByteArray(12) + val count = input.read(head) + imageType(if (count > 0) head.copyOf(count) else ByteArray(0)) + } + } catch (_: IOException) { + null + } + + /** The MIME type of the image whose first 12 bytes are [head], or null. */ + fun imageType(head: ByteArray): String? { + fun has(offset: Int, magic: String) = + head.size >= offset + magic.length && + magic.indices.all { head[offset + it] == magic[it].code.toByte() } + return when { + has(0, "ÿØÿ") -> "image/jpeg" + has(0, "\u0089PNG\r\n\u001A\n") -> "image/png" + has(0, "GIF8") -> "image/gif" + has(0, "RIFF") && has(8, "WEBP") -> "image/webp" + has(0, "BM") -> "image/bmp" + has(4, "ftyp") && head.size >= 12 -> when (String(head, 8, 4, Charsets.ISO_8859_1)) { + "avif", "avis" -> "image/avif" + in heifBrands -> "image/heif" + else -> null + } + else -> null + } + } + + private val heifBrands = setOf( + "heic", "heim", "heis", "heix", "hevc", "hevm", "hevs", "hevx", "mif1", "msf1", + ) +} diff --git a/android/app/src/main/kotlin/com/zarz/mornye/SharedEngineChannels.kt b/android/app/src/main/kotlin/com/zarz/mornye/SharedEngineChannels.kt index 897511efd..ff5a6ffe1 100644 --- a/android/app/src/main/kotlin/com/zarz/mornye/SharedEngineChannels.kt +++ b/android/app/src/main/kotlin/com/zarz/mornye/SharedEngineChannels.kt @@ -23,6 +23,13 @@ internal object SharedEngineChannels { engine.plugins.add(MusicHapticsPlugin()) PlayerWidgetBridge.attach(context, engine) registerPlaybackBackend(context, MethodChannel(engine.dartExecutor.binaryMessenger, BACKEND_CHANNEL)) + MethodChannel(engine.dartExecutor.binaryMessenger, COVERS_CHANNEL).setMethodCallHandler { call, result -> + if (call.method == "provider") { + result.success(CoverContentProvider.describe(context)) + } else { + result.notImplemented() + } + } } /** @@ -50,4 +57,5 @@ internal object SharedEngineChannels { } private const val BACKEND_CHANNEL = "com.zarz.mornye/backend" + private const val COVERS_CHANNEL = "com.zarz.mornye/covers" } diff --git a/android/app/src/test/kotlin/com/zarz/mornye/CoverProviderFilesTest.kt b/android/app/src/test/kotlin/com/zarz/mornye/CoverProviderFilesTest.kt new file mode 100644 index 000000000..61eede923 --- /dev/null +++ b/android/app/src/test/kotlin/com/zarz/mornye/CoverProviderFilesTest.kt @@ -0,0 +1,131 @@ +package com.zarz.mornye + +import java.io.File +import java.nio.file.Files +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Before +import org.junit.Test + +class CoverProviderFilesTest { + private lateinit var app: File + private lateinit var folders: Map + private val jpeg = byteArrayOf(0xFF.toByte(), 0xD8.toByte(), 0xFF.toByte(), 0xE0.toByte(), 0, 16) + + @Before + fun createFolders() { + app = Files.createTempDirectory("cover-provider-test").toFile().canonicalFile + folders = CoverProviderFiles.folders(File(app, "files"), File(app, "cache")) + folders.values.forEach { it.mkdirs() } + } + + @After + fun deleteFolders() { + app.deleteRecursively() + } + + private fun write(path: String, bytes: ByteArray = jpeg) = + File(app, path).also { + it.parentFile!!.mkdirs() + it.writeBytes(bytes) + } + + private fun resolve(vararg segments: String) = CoverProviderFiles.resolve(folders, segments.toList()) + + @Test + fun servesTheCoverFoldersBrowseListsName() { + assertEquals( + mapOf( + "covers" to File(app, "files/covers"), + "library_covers" to File(app, "files/library_covers"), + "embedded_cover_previews" to File(app, "cache/embedded_cover_previews"), + ), + folders, + ) + val stored = write("files/covers/0123_abcd.image") + val thumbnail = write("files/library_covers/thumb.jpg") + val embedded = write("cache/embedded_cover_previews/v1_hash_0.jpg") + + assertEquals(stored, resolve("covers", "0123_abcd.image")) + assertEquals(thumbnail, resolve("library_covers", "thumb.jpg")) + assertEquals(embedded, resolve("embedded_cover_previews", "v1_hash_0.jpg")) + } + + @Test + fun namesNothingOutsideItsFolders() { + write("files/shared_prefs/settings.jpg") + write("files/playlist_covers/list.jpg") + write("files/library_covers/sub/nested.jpg") + + assertNull(resolve("playlist_covers", "list.jpg")) + assertNull(resolve("files", "covers")) + assertNull(resolve("library_covers")) + assertNull(resolve("library_covers", "sub", "nested.jpg")) + assertNull(resolve("library_covers", "sub/nested.jpg")) + assertNull(resolve("library_covers", "../shared_prefs/settings.jpg")) + assertNull(resolve("library_covers", "..")) + assertNull(resolve("library_covers", ".")) + assertNull(resolve("library_covers", "")) + assertNull(resolve("library_covers", "sub")) + assertNull(resolve("library_covers", "missing.jpg")) + assertNull(resolve("library_covers", "thumb.jpg\u0000.png")) + } + + @Test + fun followsNoLinkOutOfAFolder() { + val secret = write("files/shared_prefs/settings.jpg") + val thumbnail = write("files/library_covers/thumb.jpg") + Files.createSymbolicLink(File(app, "files/library_covers/link.jpg").toPath(), secret.toPath()) + Files.createSymbolicLink(File(app, "files/covers/linked.jpg").toPath(), thumbnail.toPath()) + Files.createSymbolicLink(File(app, "files/library_covers/folder").toPath(), secret.parentFile!!.toPath()) + + assertNull(resolve("library_covers", "link.jpg")) + assertNull(resolve("covers", "linked.jpg")) + assertNull(resolve("library_covers", "folder")) + } + + @Test + fun servesOnlyImagesThatAreNotHidden() { + write("files/library_covers/.staged.jpg") + write("files/library_covers/notes.txt", "not an image".toByteArray()) + write("files/library_covers/empty.jpg", ByteArray(0)) + write("files/library_covers/regenerate.marker", "2026-10-30T00:00:00".toByteArray()) + + assertNull(resolve("library_covers", ".staged.jpg")) + assertNull(resolve("library_covers", "notes.txt")) + assertNull(resolve("library_covers", "empty.jpg")) + assertNull(resolve("library_covers", "regenerate.marker")) + } + + @Test + fun aFolderReachedThroughALinkStillServesItsOwnFiles() { + val real = File(app, "real").also { it.mkdirs() } + val cover = File(real, "thumb.jpg").also { it.writeBytes(jpeg) } + val linked = File(app, "linked_files") + Files.createSymbolicLink(linked.toPath(), real.toPath()) + + assertEquals( + cover, + CoverProviderFiles.resolve(mapOf("library_covers" to linked), listOf("library_covers", "thumb.jpg")), + ) + } + + @Test + fun recognizesTheImageFormatsTheCoverStoreKeeps() { + fun type(vararg bytes: Int) = CoverProviderFiles.imageType(ByteArray(bytes.size) { bytes[it].toByte() }) + fun type(text: String) = CoverProviderFiles.imageType(text.toByteArray(Charsets.ISO_8859_1)) + + assertEquals("image/jpeg", type(0xFF, 0xD8, 0xFF, 0xDB)) + assertEquals("image/png", type(0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A)) + assertEquals("image/gif", type("GIF89a")) + assertEquals("image/webp", type("RIFF\u0000\u0000\u0000\u0000WEBP")) + assertEquals("image/bmp", type("BM\u0000\u0000")) + assertEquals("image/avif", type("\u0000\u0000\u0000 ftypavif")) + assertEquals("image/heif", type("\u0000\u0000\u0000 ftypheic")) + assertNull(type("\u0000\u0000\u0000 ftypisom")) + assertNull(type("