151 lines
4.8 KiB
Kotlin
151 lines
4.8 KiB
Kotlin
/*
|
|
* Pupil, Hitomi.la viewer for Android
|
|
* Copyright (C) 2019 tom5079
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package xyz.quaver.pupil.util
|
|
|
|
import android.content.Context
|
|
import android.net.Uri
|
|
import androidx.core.content.FileProvider
|
|
import androidx.documentfile.provider.DocumentFile
|
|
import androidx.preference.PreferenceManager
|
|
import java.io.File
|
|
import java.net.URL
|
|
import java.nio.charset.Charset
|
|
import java.util.*
|
|
|
|
fun getCachedGallery(context: Context, galleryID: Int) =
|
|
getDownloadDirectory(context).findFile(galleryID.toString()) ?:
|
|
DocumentFile.fromFile(File(context.cacheDir, "imageCache/$galleryID"))
|
|
|
|
fun getDownloadDirectory(context: Context) : DocumentFile {
|
|
val uri = PreferenceManager.getDefaultSharedPreferences(context).getString("dl_location", null).let {
|
|
if (it != null)
|
|
Uri.parse(it)
|
|
else
|
|
Uri.fromFile(context.getExternalFilesDir(null))
|
|
}
|
|
|
|
return if (uri.toString().startsWith("file"))
|
|
DocumentFile.fromFile(File(uri.path!!))
|
|
else
|
|
DocumentFile.fromTreeUri(context, uri) ?: DocumentFile.fromFile(context.getExternalFilesDir(null)!!)
|
|
}
|
|
|
|
fun convertUpdateUri(context: Context, uri: Uri) : Uri =
|
|
if (uri.toString().startsWith("file"))
|
|
FileProvider.getUriForFile(context, context.applicationContext.packageName + ".provider", File(uri.path!!.substringAfter("file:///")))
|
|
else
|
|
uri
|
|
|
|
fun URL.download(context: Context, to: DocumentFile, onDownloadProgress: ((Long, Long) -> Unit)? = null) {
|
|
context.contentResolver.openOutputStream(to.uri).use { out ->
|
|
out!!
|
|
|
|
with(openConnection()) {
|
|
val fileSize = contentLength.toLong()
|
|
|
|
getInputStream().use {
|
|
|
|
var bytesCopied: Long = 0
|
|
val buffer = ByteArray(DEFAULT_BUFFER_SIZE)
|
|
|
|
var bytes = it.read(buffer)
|
|
while (bytes >= 0) {
|
|
out.write(buffer, 0, bytes)
|
|
bytesCopied += bytes
|
|
onDownloadProgress?.invoke(bytesCopied, fileSize)
|
|
bytes = it.read(buffer)
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
fun DocumentFile.isParentOf(file: DocumentFile?) : Boolean {
|
|
var parent = file?.parentFile
|
|
while (parent != null) {
|
|
if (this.uri.path == parent.uri.path)
|
|
return true
|
|
|
|
parent = parent.parentFile
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
fun DocumentFile.reader(context: Context, charset: Charset = Charsets.UTF_8) = context.contentResolver.openInputStream(uri)!!.reader(charset)
|
|
fun DocumentFile.readBytes(context: Context) = context.contentResolver.openInputStream(uri)!!.readBytes()
|
|
fun DocumentFile.readText(context: Context, charset: Charset = Charsets.UTF_8) = reader(context, charset).use { it.readText() }
|
|
|
|
fun DocumentFile.writeBytes(context: Context, array: ByteArray) = context.contentResolver.openOutputStream(uri)!!.write(array)
|
|
fun DocumentFile.writeText(context: Context, text: String, charset: Charset = Charsets.UTF_8) = writeBytes(context, text.toByteArray(charset))
|
|
|
|
fun DocumentFile.copyRecursively(
|
|
context: Context,
|
|
target: DocumentFile
|
|
) {
|
|
if (!exists())
|
|
throw Exception("The source file doesn't exist.")
|
|
|
|
if (this.isFile) {
|
|
target.let {
|
|
if (it.findFile(name!!) != null)
|
|
it
|
|
else
|
|
createFile("null", name!!)!!
|
|
}.writeBytes(
|
|
context,
|
|
readBytes(context)
|
|
)
|
|
} else if (this.isDirectory) {
|
|
target.createDirectory(name!!).also { newTarget ->
|
|
listFiles().forEach { child ->
|
|
child.copyRecursively(context, newTarget!!)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fun DocumentFile.deleteRecursively() {
|
|
|
|
if (this.isDirectory)
|
|
listFiles().forEach {
|
|
it.deleteRecursively()
|
|
}
|
|
|
|
this.delete()
|
|
}
|
|
|
|
fun DocumentFile.walk(state: LinkedList<DocumentFile> = LinkedList()) : Queue<DocumentFile> {
|
|
if (state.isEmpty())
|
|
state.push(this)
|
|
|
|
listFiles().forEach {
|
|
state.push(it)
|
|
|
|
if (it.isDirectory) {
|
|
it.walk(state)
|
|
}
|
|
}
|
|
|
|
return state
|
|
}
|
|
|
|
fun File.copyTo(context: Context, target: DocumentFile) = target.writeBytes(context, this.readBytes()) |