Migrate to MVVM

2020-11-17 21:47:22 +02:00
parent eaac271143
commit 7d24286c55
273 changed files with 1926 additions and 2115 deletions
--- a/app/src/main/java/org/koitharu/kotatsu/local/LocalModule.kt
+++ b/app/src/main/java/org/koitharu/kotatsu/local/LocalModule.kt
@@ -0,0 +1,17 @@
+package org.koitharu.kotatsu.local
+
+import org.koin.android.ext.koin.androidContext
+import org.koin.android.viewmodel.dsl.viewModel
+import org.koin.dsl.bind
+import org.koin.dsl.module
+import org.koitharu.kotatsu.core.parser.MangaRepository
+import org.koitharu.kotatsu.local.domain.LocalMangaRepository
+import org.koitharu.kotatsu.local.ui.LocalListViewModel
+
+val localModule
+	get() = module {
+
+		single { LocalMangaRepository(androidContext()) } bind MangaRepository::class
+
+		viewModel { LocalListViewModel(get(), get(), get(), androidContext()) }
+	}
--- a/app/src/main/java/org/koitharu/kotatsu/local/data/Cache.kt
+++ b/app/src/main/java/org/koitharu/kotatsu/local/data/Cache.kt
@@ -0,0 +1,7 @@
+package org.koitharu.kotatsu.local.data
+
+enum class Cache(val dir: String) {
+
+	THUMBS("image_cache"),
+	PAGES("pages");
+}
--- a/app/src/main/java/org/koitharu/kotatsu/local/data/CbzFetcher.kt
+++ b/app/src/main/java/org/koitharu/kotatsu/local/data/CbzFetcher.kt
@@ -0,0 +1,38 @@
+package org.koitharu.kotatsu.local.data
+
+import android.net.Uri
+import android.webkit.MimeTypeMap
+import coil.bitmap.BitmapPool
+import coil.decode.DataSource
+import coil.decode.Options
+import coil.fetch.FetchResult
+import coil.fetch.Fetcher
+import coil.fetch.SourceResult
+import coil.size.Size
+import okio.buffer
+import okio.source
+import java.util.zip.ZipFile
+
+class CbzFetcher : Fetcher<Uri> {
+
+	@Suppress("BlockingMethodInNonBlockingContext")
+	override suspend fun fetch(
+		pool: BitmapPool,
+		data: Uri,
+		size: Size,
+		options: Options
+	): FetchResult {
+		val zip = ZipFile(data.schemeSpecificPart)
+		val entry = zip.getEntry(data.fragment)
+		val ext = MimeTypeMap.getFileExtensionFromUrl(entry.name)
+		return SourceResult(
+			source = zip.getInputStream(entry).source().buffer(),
+			mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(ext),
+			dataSource = DataSource.DISK
+		)
+	}
+
+	override fun key(data: Uri): String? = data.toString()
+
+	override fun handles(data: Uri) = data.scheme == "cbz"
+}
--- a/app/src/main/java/org/koitharu/kotatsu/local/data/CbzFilter.kt
+++ b/app/src/main/java/org/koitharu/kotatsu/local/data/CbzFilter.kt
@@ -0,0 +1,13 @@
+package org.koitharu.kotatsu.local.data
+
+import java.io.File
+import java.io.FilenameFilter
+import java.util.*
+
+class CbzFilter : FilenameFilter {
+
+	override fun accept(dir: File, name: String): Boolean {
+		val ext = name.substringAfterLast('.', "").toLowerCase(Locale.ROOT)
+		return ext == "cbz" || ext == "zip"
+	}
+}
--- a/app/src/main/java/org/koitharu/kotatsu/local/data/MangaIndex.kt
+++ b/app/src/main/java/org/koitharu/kotatsu/local/data/MangaIndex.kt
@@ -0,0 +1,111 @@
+package org.koitharu.kotatsu.local.data
+
+import org.json.JSONArray
+import org.json.JSONObject
+import org.koitharu.kotatsu.BuildConfig
+import org.koitharu.kotatsu.core.model.Manga
+import org.koitharu.kotatsu.core.model.MangaChapter
+import org.koitharu.kotatsu.core.model.MangaSource
+import org.koitharu.kotatsu.core.model.MangaTag
+import org.koitharu.kotatsu.utils.ext.getStringOrNull
+import org.koitharu.kotatsu.utils.ext.mapToSet
+import org.koitharu.kotatsu.utils.ext.safe
+
+class MangaIndex(source: String?) {
+
+	private val json: JSONObject = source?.let(::JSONObject) ?: JSONObject()
+
+	fun setMangaInfo(manga: Manga, append: Boolean) {
+		json.put("id", manga.id)
+		json.put("title", manga.title)
+		json.put("title_alt", manga.altTitle)
+		json.put("url", manga.url)
+		json.put("cover", manga.coverUrl)
+		json.put("description", manga.description)
+		json.put("rating", manga.rating)
+		json.put("source", manga.source.name)
+		json.put("cover_large", manga.largeCoverUrl)
+		json.put("tags", JSONArray().also { a ->
+			for (tag in manga.tags) {
+				val jo = JSONObject()
+				jo.put("key", tag.key)
+				jo.put("title", tag.title)
+				a.put(jo)
+			}
+		})
+		if (!append || !json.has("chapters")) {
+			json.put("chapters", JSONObject())
+		}
+		json.put("app_id", BuildConfig.APPLICATION_ID)
+		json.put("app_version", BuildConfig.VERSION_CODE)
+	}
+
+	fun getMangaInfo(): Manga? = if (json.length() == 0) null else safe {
+		val source = MangaSource.valueOf(json.getString("source"))
+		Manga(
+			id = json.getLong("id"),
+			title = json.getString("title"),
+			altTitle = json.getStringOrNull("title_alt"),
+			url = json.getString("url"),
+			source = source,
+			rating = json.getDouble("rating").toFloat(),
+			coverUrl = json.getString("cover"),
+			description = json.getStringOrNull("description"),
+			tags = json.getJSONArray("tags").mapToSet { x ->
+				MangaTag(
+					title = x.getString("title"),
+					key = x.getString("key"),
+					source = source
+				)
+			},
+			chapters = getChapters(json.getJSONObject("chapters"), source)
+		)
+	}
+
+	fun getCoverEntry(): String? = json.optString("cover_entry")
+
+	fun addChapter(chapter: MangaChapter) {
+		val chapters = json.getJSONObject("chapters")
+		if (!chapters.has(chapter.id.toString())) {
+			val jo = JSONObject()
+			jo.put("number", chapter.number)
+			jo.put("url", chapter.url)
+			jo.put("name", chapter.name)
+			jo.put("entries", "%03d\\d{3}".format(chapter.number))
+			chapters.put(chapter.id.toString(), jo)
+		}
+	}
+
+	fun setCoverEntry(name: String) {
+		json.put("cover_entry", name)
+	}
+
+	fun getChapterNamesPattern(chapter: MangaChapter) = Regex(
+		json.getJSONObject("chapters")
+			.getJSONObject(chapter.id.toString())
+			.getString("entries")
+	)
+
+	private fun getChapters(json: JSONObject, source: MangaSource): List<MangaChapter> {
+		val chapters = ArrayList<MangaChapter>(json.length())
+		for (k in json.keys()) {
+			val v = json.getJSONObject(k)
+			chapters.add(
+				MangaChapter(
+					id = k.toLong(),
+					name = v.getString("name"),
+					url = v.getString("url"),
+					number = v.getInt("number"),
+					source = source
+				)
+			)
+		}
+		return chapters.sortedBy { it.number }
+	}
+
+	override fun toString(): String = if (BuildConfig.DEBUG) {
+		json.toString(4)
+	} else {
+		json.toString()
+	}
+}
--- a/app/src/main/java/org/koitharu/kotatsu/local/data/MangaZip.kt
+++ b/app/src/main/java/org/koitharu/kotatsu/local/data/MangaZip.kt
@@ -0,0 +1,70 @@
+package org.koitharu.kotatsu.local.data
+
+import androidx.annotation.CheckResult
+import androidx.annotation.WorkerThread
+import org.koitharu.kotatsu.core.model.Manga
+import org.koitharu.kotatsu.core.model.MangaChapter
+import org.koitharu.kotatsu.utils.ext.takeIfReadable
+import org.koitharu.kotatsu.utils.ext.toFileNameSafe
+import java.io.File
+
+@WorkerThread
+class MangaZip(val file: File) {
+
+	private val writableCbz = WritableCbzFile(file)
+
+	private var index = MangaIndex(null)
+
+	suspend fun prepare(manga: Manga) {
+		writableCbz.prepare()
+		index = MangaIndex(writableCbz[INDEX_ENTRY].takeIfReadable()?.readText())
+		index.setMangaInfo(manga, append = true)
+	}
+
+	suspend fun cleanup() {
+		writableCbz.cleanup()
+	}
+
+	@CheckResult
+	suspend fun compress(): Boolean {
+		writableCbz[INDEX_ENTRY].writeText(index.toString())
+		return writableCbz.flush()
+	}
+
+	fun addCover(file: File, ext: String) {
+		val name = buildString {
+			append(FILENAME_PATTERN.format(0, 0))
+			if (ext.isNotEmpty() && ext.length <= 4) {
+				append('.')
+				append(ext)
+			}
+		}
+		writableCbz[name] = file
+		index.setCoverEntry(name)
+	}
+
+	fun addPage(chapter: MangaChapter, file: File, pageNumber: Int, ext: String) {
+		val name = buildString {
+			append(FILENAME_PATTERN.format(chapter.number, pageNumber))
+			if (ext.isNotEmpty() && ext.length <= 4) {
+				append('.')
+				append(ext)
+			}
+		}
+		writableCbz[name] = file
+		index.addChapter(chapter)
+	}
+
+	companion object {
+
+		private const val FILENAME_PATTERN = "%03d%03d"
+
+		const val INDEX_ENTRY = "index.json"
+
+		fun findInDir(root: File, manga: Manga): MangaZip {
+			val name = manga.title.toFileNameSafe() + ".cbz"
+			val file = File(root, name)
+			return MangaZip(file)
+		}
+	}
+}
--- a/app/src/main/java/org/koitharu/kotatsu/local/data/PagesCache.kt
+++ b/app/src/main/java/org/koitharu/kotatsu/local/data/PagesCache.kt
@@ -0,0 +1,29 @@
+package org.koitharu.kotatsu.local.data
+
+import android.content.Context
+import com.tomclaw.cache.DiskLruCache
+import org.koitharu.kotatsu.utils.FileSizeUtils
+import org.koitharu.kotatsu.utils.ext.longHashCode
+import org.koitharu.kotatsu.utils.ext.sub
+import org.koitharu.kotatsu.utils.ext.takeIfReadable
+import java.io.File
+import java.io.OutputStream
+
+class PagesCache(context: Context) {
+
+	private val cacheDir = context.externalCacheDir ?: context.cacheDir
+	private val lruCache =
+		DiskLruCache.create(cacheDir.sub(Cache.PAGES.dir), FileSizeUtils.mbToBytes(200))
+
+	operator fun get(url: String): File? {
+		return lruCache.get(url)?.takeIfReadable()
+	}
+
+	fun put(url: String, writer: (OutputStream) -> Unit): File {
+		val file = cacheDir.sub(url.longHashCode().toString())
+		file.outputStream().use(writer)
+		val res = lruCache.put(url, file)
+		file.delete()
+		return res
+	}
+}
--- a/app/src/main/java/org/koitharu/kotatsu/local/data/WritableCbzFile.kt
+++ b/app/src/main/java/org/koitharu/kotatsu/local/data/WritableCbzFile.kt
@@ -0,0 +1,96 @@
+package org.koitharu.kotatsu.local.data
+
+import androidx.annotation.CheckResult
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.util.zip.ZipEntry
+import java.util.zip.ZipInputStream
+import java.util.zip.ZipOutputStream
+
+class WritableCbzFile(private val file: File) {
+
+	private val dir = File(file.parentFile, file.nameWithoutExtension)
+
+	@Suppress("BlockingMethodInNonBlockingContext")
+	suspend fun prepare() = withContext(Dispatchers.IO) {
+		check(dir.list().isNullOrEmpty()) {
+			"Dir ${dir.name} is not empty"
+		}
+		if (!dir.exists()) {
+			dir.mkdir()
+		}
+		if (!file.exists()) {
+			return@withContext
+		}
+		ZipInputStream(FileInputStream(file)).use { zip ->
+			var entry = zip.nextEntry
+			while (entry != null) {
+				val target = File(dir.path + File.separator + entry.name)
+				target.parentFile?.mkdirs()
+				target.outputStream().use { out ->
+					zip.copyTo(out)
+				}
+				zip.closeEntry()
+				entry = zip.nextEntry
+			}
+		}
+	}
+
+	suspend fun cleanup() = withContext(Dispatchers.IO) {
+		dir.deleteRecursively()
+	}
+
+	@CheckResult
+	@Suppress("BlockingMethodInNonBlockingContext")
+	suspend fun flush() = withContext(Dispatchers.IO) {
+		val tempFile = File(file.path + ".tmp")
+		if (tempFile.exists()) {
+			tempFile.delete()
+		}
+		try {
+			ZipOutputStream(FileOutputStream(tempFile)).use { zip ->
+				dir.listFiles()?.forEach {
+					zipFile(it, it.name, zip)
+				}
+				zip.flush()
+			}
+			tempFile.renameTo(file)
+		} finally {
+			if (tempFile.exists()) {
+				tempFile.delete()
+			}
+		}
+	}
+
+	operator fun get(name: String) = File(dir, name)
+
+	operator fun set(name: String, file: File) {
+		file.copyTo(this[name], overwrite = true)
+	}
+
+	companion object {
+
+		private fun zipFile(fileToZip: File, fileName: String, zipOut: ZipOutputStream) {
+			if (fileToZip.isDirectory) {
+				if (fileName.endsWith("/")) {
+					zipOut.putNextEntry(ZipEntry(fileName))
+				} else {
+					zipOut.putNextEntry(ZipEntry("$fileName/"))
+				}
+				zipOut.closeEntry()
+				fileToZip.listFiles()?.forEach { childFile ->
+					zipFile(childFile, "$fileName/${childFile.name}", zipOut)
+				}
+			} else {
+				FileInputStream(fileToZip).use { fis ->
+					val zipEntry = ZipEntry(fileName)
+					zipOut.putNextEntry(zipEntry)
+					fis.copyTo(zipOut)
+				}
+			}
+		}
+	}
+}
--- a/app/src/main/java/org/koitharu/kotatsu/local/domain/LocalMangaRepository.kt
+++ b/app/src/main/java/org/koitharu/kotatsu/local/domain/LocalMangaRepository.kt
@@ -0,0 +1,185 @@
+package org.koitharu.kotatsu.local.domain
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.net.Uri
+import android.webkit.MimeTypeMap
+import androidx.collection.ArraySet
+import androidx.core.net.toFile
+import androidx.core.net.toUri
+import org.koitharu.kotatsu.core.model.*
+import org.koitharu.kotatsu.core.parser.MangaRepository
+import org.koitharu.kotatsu.local.data.CbzFilter
+import org.koitharu.kotatsu.local.data.MangaIndex
+import org.koitharu.kotatsu.local.data.MangaZip
+import org.koitharu.kotatsu.utils.AlphanumComparator
+import org.koitharu.kotatsu.utils.ext.longHashCode
+import org.koitharu.kotatsu.utils.ext.readText
+import org.koitharu.kotatsu.utils.ext.safe
+import org.koitharu.kotatsu.utils.ext.sub
+import java.io.File
+import java.util.*
+import java.util.zip.ZipEntry
+import java.util.zip.ZipFile
+
+class LocalMangaRepository(private val context: Context) : MangaRepository {
+
+	private val filenameFilter = CbzFilter()
+
+	override suspend fun getList(
+		offset: Int,
+		query: String?,
+		sortOrder: SortOrder?,
+		tag: MangaTag?
+	): List<Manga> {
+		require(offset == 0) {
+			"LocalMangaRepository does not support pagination"
+		}
+		val files = getAvailableStorageDirs(context)
+			.flatMap { x -> x.listFiles(filenameFilter)?.toList().orEmpty() }
+		return files.mapNotNull { x -> safe { getFromFile(x) } }
+	}
+
+	override suspend fun getDetails(manga: Manga) = if (manga.chapters == null) {
+		getFromFile(Uri.parse(manga.url).toFile())
+	} else manga
+
+	@Suppress("BlockingMethodInNonBlockingContext")
+	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
+		val uri = Uri.parse(chapter.url)
+		val file = uri.toFile()
+		val zip = ZipFile(file)
+		val index = zip.getEntry(MangaZip.INDEX_ENTRY)?.let(zip::readText)?.let(::MangaIndex)
+		var entries = zip.entries().asSequence()
+		entries = if (index != null) {
+			val pattern = index.getChapterNamesPattern(chapter)
+			entries.filter { x -> !x.isDirectory && x.name.substringBefore('.').matches(pattern) }
+		} else {
+			val parent = uri.fragment.orEmpty()
+			entries.filter { x ->
+				!x.isDirectory && x.name.substringBeforeLast(
+					File.separatorChar,
+					""
+				) == parent
+			}
+		}
+		return entries
+			.toList()
+			.sortedWith(compareBy(AlphanumComparator()) { x -> x.name })
+			.map { x ->
+				val entryUri = zipUri(file, x.name)
+				MangaPage(
+					id = entryUri.longHashCode(),
+					url = entryUri,
+					source = MangaSource.LOCAL
+				)
+			}
+	}
+
+	fun delete(manga: Manga): Boolean {
+		val file = Uri.parse(manga.url).toFile()
+		return file.delete()
+	}
+
+	@SuppressLint("DefaultLocale")
+	fun getFromFile(file: File): Manga = ZipFile(file).use { zip ->
+		val fileUri = file.toUri().toString()
+		val entry = zip.getEntry(MangaZip.INDEX_ENTRY)
+		val index = entry?.let(zip::readText)?.let(::MangaIndex)
+		val info = index?.getMangaInfo()
+		if (index != null && info != null) {
+			return info.copy(
+				source = MangaSource.LOCAL,
+				url = fileUri,
+				coverUrl = zipUri(
+					file,
+					entryName = index.getCoverEntry()
+						?: findFirstEntry(zip.entries(), isImage = true)?.name.orEmpty()
+				),
+				chapters = info.chapters?.map { c -> c.copy(url = fileUri) }
+			)
+		}
+		// fallback
+		val title = file.nameWithoutExtension.replace("_", " ").capitalize()
+		val chapters = ArraySet<String>()
+		for (x in zip.entries()) {
+			if (!x.isDirectory) {
+				chapters += x.name.substringBeforeLast(File.separatorChar, "")
+			}
+		}
+		val uriBuilder = file.toUri().buildUpon()
+		Manga(
+			id = file.absolutePath.longHashCode(),
+			title = title,
+			url = fileUri,
+			source = MangaSource.LOCAL,
+			coverUrl = zipUri(file, findFirstEntry(zip.entries(), isImage = true)?.name.orEmpty()),
+			chapters = chapters.sortedWith(AlphanumComparator()).mapIndexed { i, s ->
+				MangaChapter(
+					id = "$i$s".longHashCode(),
+					name = if (s.isEmpty()) title else s,
+					number = i + 1,
+					source = MangaSource.LOCAL,
+					url = uriBuilder.fragment(s).build().toString()
+				)
+			}
+		)
+	}
+
+	fun getRemoteManga(localManga: Manga): Manga? {
+		val file = safe {
+			Uri.parse(localManga.url).toFile()
+		} ?: return null
+		val zip = ZipFile(file)
+		val entry = zip.getEntry(MangaZip.INDEX_ENTRY)
+		val index = entry?.let(zip::readText)?.let(::MangaIndex) ?: return null
+		return index.getMangaInfo()
+	}
+
+	private fun zipUri(file: File, entryName: String) =
+		Uri.fromParts("cbz", file.path, entryName).toString()
+
+	private fun findFirstEntry(entries: Enumeration<out ZipEntry>, isImage: Boolean): ZipEntry? {
+		val list = entries.toList()
+			.filterNot { it.isDirectory }
+			.sortedWith(compareBy(AlphanumComparator()) { x -> x.name })
+		return if (isImage) {
+			val map = MimeTypeMap.getSingleton()
+			list.firstOrNull {
+				map.getMimeTypeFromExtension(it.name.substringAfterLast('.'))
+					?.startsWith("image/") == true
+			}
+		} else {
+			list.firstOrNull()
+		}
+	}
+
+	override val sortOrders = emptySet<SortOrder>()
+
+	override suspend fun getPageFullUrl(page: MangaPage) = page.url
+
+	override suspend fun getTags() = emptySet<MangaTag>()
+
+	companion object {
+
+		private const val DIR_NAME = "manga"
+
+		fun isFileSupported(name: String): Boolean {
+			val ext = name.substringAfterLast('.').toLowerCase(Locale.ROOT)
+			return ext == "cbz" || ext == "zip"
+		}
+
+		fun getAvailableStorageDirs(context: Context): List<File> {
+			val result = ArrayList<File>(5)
+			result += context.filesDir.sub(DIR_NAME)
+			result += context.getExternalFilesDirs(DIR_NAME)
+			return result.distinctBy { it.canonicalPath }.filter { it.exists() || it.mkdir() }
+		}
+
+		fun getFallbackStorageDir(context: Context): File? {
+			return context.getExternalFilesDir(DIR_NAME) ?: context.filesDir.sub(DIR_NAME).takeIf {
+				(it.exists() || it.mkdir()) && it.canWrite()
+			}
+		}
+	}
+}
--- a/app/src/main/java/org/koitharu/kotatsu/local/ui/LocalListFragment.kt
+++ b/app/src/main/java/org/koitharu/kotatsu/local/ui/LocalListFragment.kt
@@ -0,0 +1,115 @@
+package org.koitharu.kotatsu.local.ui
+
+import android.content.ActivityNotFoundException
+import android.net.Uri
+import android.os.Bundle
+import android.view.Menu
+import android.view.MenuInflater
+import android.view.MenuItem
+import android.view.View
+import androidx.activity.result.ActivityResultCallback
+import androidx.activity.result.contract.ActivityResultContracts
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import com.google.android.material.snackbar.Snackbar
+import kotlinx.android.synthetic.main.fragment_list.*
+import org.koin.android.viewmodel.ext.android.viewModel
+import org.koitharu.kotatsu.BuildConfig
+import org.koitharu.kotatsu.R
+import org.koitharu.kotatsu.core.model.Manga
+import org.koitharu.kotatsu.list.ui.MangaListFragment
+import org.koitharu.kotatsu.utils.ext.ellipsize
+
+class LocalListFragment : MangaListFragment(), ActivityResultCallback<Uri> {
+
+	override val viewModel by viewModel<LocalListViewModel>()
+	private val importCall = registerForActivityResult(
+		ActivityResultContracts.OpenDocument(),
+		this
+	)
+
+	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+		super.onViewCreated(view, savedInstanceState)
+		viewModel.onMangaRemoved.observe(viewLifecycleOwner, ::onItemRemoved)
+	}
+
+	override fun onRequestMoreItems(offset: Int) {
+		if (offset == 0) {
+			viewModel.onRefresh()
+		}
+	}
+
+	override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
+		inflater.inflate(R.menu.opt_local, menu)
+		super.onCreateOptionsMenu(menu, inflater)
+	}
+
+	override fun onOptionsItemSelected(item: MenuItem): Boolean {
+		return when (item.itemId) {
+			R.id.action_import -> {
+				try {
+					importCall.launch(arrayOf("*/*"))
+				} catch (e: ActivityNotFoundException) {
+					if (BuildConfig.DEBUG) {
+						e.printStackTrace()
+					}
+					Snackbar.make(
+						recyclerView, R.string.operation_not_supported, Snackbar.LENGTH_SHORT
+					).show()
+				}
+				true
+			}
+			else -> super.onOptionsItemSelected(item)
+		}
+	}
+
+	override fun getTitle(): CharSequence? {
+		return getString(R.string.local_storage)
+	}
+
+	override fun setUpEmptyListHolder() {
+		textView_holder.setText(R.string.text_local_holder)
+		textView_holder.setCompoundDrawablesRelativeWithIntrinsicBounds(0, 0, 0, 0)
+	}
+
+	override fun onActivityResult(result: Uri?) {
+		if (result != null) {
+			viewModel.importFile(result)
+		}
+	}
+
+	override fun onCreatePopupMenu(inflater: MenuInflater, menu: Menu, data: Manga) {
+		super.onCreatePopupMenu(inflater, menu, data)
+		inflater.inflate(R.menu.popup_local, menu)
+	}
+
+	override fun onPopupMenuItemSelected(item: MenuItem, data: Manga): Boolean {
+		return when (item.itemId) {
+			R.id.action_delete -> {
+				MaterialAlertDialogBuilder(context ?: return false)
+					.setTitle(R.string.delete_manga)
+					.setMessage(getString(R.string.text_delete_local_manga, data.title))
+					.setPositiveButton(R.string.delete) { _, _ ->
+						viewModel.delete(data)
+					}
+					.setNegativeButton(android.R.string.cancel, null)
+					.show()
+				true
+			}
+			else -> super.onPopupMenuItemSelected(item, data)
+		}
+	}
+
+	private fun onItemRemoved(item: Manga) {
+		Snackbar.make(
+			recyclerView, getString(
+				R.string._s_deleted_from_local_storage,
+				item.title.ellipsize(16)
+			), Snackbar.LENGTH_SHORT
+		).show()
+	}
+
+	companion object {
+
+		fun newInstance() = LocalListFragment()
+	}
+}
--- a/app/src/main/java/org/koitharu/kotatsu/local/ui/LocalListViewModel.kt
+++ b/app/src/main/java/org/koitharu/kotatsu/local/ui/LocalListViewModel.kt
@@ -0,0 +1,84 @@
+package org.koitharu.kotatsu.local.ui
+
+import android.content.Context
+import android.net.Uri
+import android.os.Build
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.koitharu.kotatsu.core.exceptions.UnsupportedFileException
+import org.koitharu.kotatsu.core.model.Manga
+import org.koitharu.kotatsu.core.prefs.AppSettings
+import org.koitharu.kotatsu.history.domain.HistoryRepository
+import org.koitharu.kotatsu.list.ui.MangaListViewModel
+import org.koitharu.kotatsu.local.domain.LocalMangaRepository
+import org.koitharu.kotatsu.utils.MangaShortcut
+import org.koitharu.kotatsu.utils.MediaStoreCompat
+import org.koitharu.kotatsu.utils.SingleLiveEvent
+import org.koitharu.kotatsu.utils.ext.safe
+import org.koitharu.kotatsu.utils.ext.sub
+import java.io.IOException
+
+class LocalListViewModel(
+	private val repository: LocalMangaRepository,
+	private val historyRepository: HistoryRepository,
+	private val settings: AppSettings,
+	private val context: Context
+) : MangaListViewModel() {
+
+	val onMangaRemoved = SingleLiveEvent<Manga>()
+
+	init {
+		loadList()
+	}
+
+	fun onRefresh() {
+		loadList()
+	}
+
+	fun importFile(uri: Uri) {
+		launchLoadingJob {
+			val contentResolver = context.contentResolver
+			val list = withContext(Dispatchers.Default) {
+				val name = MediaStoreCompat.getName(contentResolver, uri)
+					?: throw IOException("Cannot fetch name from uri: $uri")
+				if (!LocalMangaRepository.isFileSupported(name)) {
+					throw UnsupportedFileException("Unsupported file on $uri")
+				}
+				val dest = settings.getStorageDir(context)?.sub(name)
+					?: throw IOException("External files dir unavailable")
+				contentResolver.openInputStream(uri)?.use { source ->
+					dest.outputStream().use { output ->
+						source.copyTo(output)
+					}
+				} ?: throw IOException("Cannot open input stream: $uri")
+				repository.getList(0)
+			}
+			content.value = list
+		}
+	}
+
+	fun delete(manga: Manga) {
+		launchJob {
+			withContext(Dispatchers.Default) {
+				val original = repository.getRemoteManga(manga)
+				repository.delete(manga) || throw IOException("Unable to delete file")
+				safe {
+					historyRepository.deleteOrSwap(manga, original)
+				}
+			}
+			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1) {
+				MangaShortcut(manga).removeAppShortcut(context)
+			}
+			onMangaRemoved.call(manga)
+		}
+	}
+
+	private fun loadList() {
+		launchLoadingJob {
+			val list = withContext(Dispatchers.Default) {
+				repository.getList(0)
+			}
+			content.value = list
+		}
+	}
+}