425 lines
15 KiB
Kotlin
425 lines
15 KiB
Kotlin
/*
|
|
* Pupil, Hitomi.la viewer for Android
|
|
* Copyright (C) 2020 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.services
|
|
|
|
import android.annotation.SuppressLint
|
|
import android.app.PendingIntent
|
|
import android.app.Service
|
|
import android.content.Context
|
|
import android.content.Intent
|
|
import androidx.core.app.NotificationCompat
|
|
import androidx.core.app.NotificationManagerCompat
|
|
import androidx.core.app.TaskStackBuilder
|
|
import androidx.core.content.ContextCompat
|
|
import kotlinx.coroutines.CoroutineScope
|
|
import kotlinx.coroutines.Dispatchers
|
|
import kotlinx.coroutines.Job
|
|
import kotlinx.coroutines.launch
|
|
import okhttp3.Call
|
|
import okhttp3.Callback
|
|
import okhttp3.Response
|
|
import okhttp3.ResponseBody
|
|
import okio.*
|
|
import xyz.quaver.pupil.*
|
|
import xyz.quaver.pupil.ui.ReaderActivity
|
|
import xyz.quaver.pupil.util.cleanCache
|
|
import xyz.quaver.pupil.util.downloader.Cache
|
|
import xyz.quaver.pupil.util.downloader.DownloadManager
|
|
import xyz.quaver.pupil.util.ellipsize
|
|
import xyz.quaver.pupil.util.normalizeID
|
|
import xyz.quaver.pupil.util.requestBuilders
|
|
import java.io.IOException
|
|
import java.util.*
|
|
import java.util.concurrent.ConcurrentHashMap
|
|
import kotlin.math.ceil
|
|
import kotlin.math.log10
|
|
|
|
private typealias ProgressListener = (DownloadService.Tag, Long, Long, Boolean) -> Unit
|
|
class DownloadService : Service() {
|
|
data class Tag(val galleryID: Int, val index: Int, val startId: Int? = null)
|
|
|
|
//region Notification
|
|
private val notificationManager by lazy {
|
|
NotificationManagerCompat.from(this)
|
|
}
|
|
|
|
private val serviceNotification by lazy {
|
|
NotificationCompat.Builder(this, "downloader")
|
|
.setContentTitle(getString(R.string.downloader_running))
|
|
.setProgress(0, 0, false)
|
|
.setSmallIcon(R.drawable.ic_notification)
|
|
.setOngoing(true)
|
|
}
|
|
|
|
private val notification = ConcurrentHashMap<Int, NotificationCompat.Builder?>()
|
|
|
|
private fun initNotification(galleryID: Int) {
|
|
val intent = Intent(this, ReaderActivity::class.java)
|
|
.putExtra("galleryID", galleryID)
|
|
|
|
val pendingIntent = TaskStackBuilder.create(this).run {
|
|
addNextIntentWithParentStack(intent)
|
|
getPendingIntent(galleryID, PendingIntent.FLAG_UPDATE_CURRENT)
|
|
}
|
|
val action =
|
|
NotificationCompat.Action.Builder(0, getText(android.R.string.cancel),
|
|
PendingIntent.getService(
|
|
this,
|
|
R.id.notification_download_cancel_action.normalizeID(),
|
|
Intent(this, DownloadService::class.java)
|
|
.putExtra(KEY_COMMAND, COMMAND_CANCEL)
|
|
.putExtra(KEY_ID, galleryID),
|
|
PendingIntent.FLAG_UPDATE_CURRENT),
|
|
).build()
|
|
|
|
notification[galleryID] = NotificationCompat.Builder(this, "download").apply {
|
|
setContentTitle(getString(R.string.reader_loading))
|
|
setContentText(getString(R.string.reader_notification_text))
|
|
setSmallIcon(R.drawable.ic_notification)
|
|
setContentIntent(pendingIntent)
|
|
addAction(action)
|
|
setProgress(0, 0, true)
|
|
setOngoing(true)
|
|
}
|
|
|
|
notify(galleryID)
|
|
}
|
|
|
|
@SuppressLint("RestrictedApi")
|
|
private fun notify(galleryID: Int) {
|
|
val max = progress[galleryID]?.size ?: 0
|
|
val progress = progress[galleryID]?.count { it == Float.POSITIVE_INFINITY } ?: 0
|
|
|
|
val notification = notification[galleryID] ?: return
|
|
|
|
if (isCompleted(galleryID)) {
|
|
notification
|
|
.setContentText(getString(R.string.reader_notification_complete))
|
|
.setProgress(0, 0, false)
|
|
.setOngoing(false)
|
|
.mActions.clear()
|
|
|
|
notificationManager.cancel(galleryID)
|
|
} else
|
|
notification
|
|
.setProgress(max, progress, false)
|
|
.setContentText("$progress/$max")
|
|
|
|
if (DownloadManager.getInstance(this).getDownloadFolder(galleryID) != null || galleryID == priority)
|
|
notification.let { notificationManager.notify(galleryID, it.build()) }
|
|
else
|
|
notificationManager.cancel(galleryID)
|
|
}
|
|
//endregion
|
|
|
|
//region ProgressListener
|
|
@Suppress("UNCHECKED_CAST")
|
|
private val progressListener: ProgressListener = { (galleryID, index), bytesRead, contentLength, done ->
|
|
if (!done && progress[galleryID]?.get(index)?.isFinite() == true)
|
|
progress[galleryID]?.set(index, bytesRead * 100F / contentLength)
|
|
}
|
|
|
|
private class ProgressResponseBody(
|
|
val tag: Any?,
|
|
val responseBody: ResponseBody,
|
|
val progressListener : ProgressListener
|
|
) : ResponseBody() {
|
|
private var bufferedSource : BufferedSource? = null
|
|
|
|
override fun contentLength() = responseBody.contentLength()
|
|
override fun contentType() = responseBody.contentType()
|
|
|
|
override fun source(): BufferedSource {
|
|
if (bufferedSource == null)
|
|
bufferedSource = Okio.buffer(source(responseBody.source()))
|
|
|
|
return bufferedSource!!
|
|
}
|
|
|
|
private fun source(source: Source) = object: ForwardingSource(source) {
|
|
var totalBytesRead = 0L
|
|
|
|
override fun read(sink: Buffer, byteCount: Long): Long {
|
|
val bytesRead = super.read(sink, byteCount)
|
|
|
|
totalBytesRead += if (bytesRead == -1L) 0L else bytesRead
|
|
progressListener.invoke(tag as Tag, totalBytesRead, responseBody.contentLength(), bytesRead == -1L)
|
|
|
|
return bytesRead
|
|
}
|
|
}
|
|
}
|
|
|
|
private val interceptor: PupilInterceptor = { chain ->
|
|
val request = chain.request()
|
|
var response = chain.proceed(request)
|
|
|
|
var retry = 5
|
|
while (!response.isSuccessful && retry > 0) {
|
|
response = chain.proceed(request)
|
|
retry--
|
|
}
|
|
|
|
response.newBuilder()
|
|
.body(response.body()?.let {
|
|
ProgressResponseBody(request.tag(), it, progressListener)
|
|
}).build()
|
|
}
|
|
//endregion
|
|
|
|
//region Downloader
|
|
/**
|
|
* KEY
|
|
* primary galleryID
|
|
* secondary index
|
|
* PRIMARY VALUE
|
|
* MutableList -> Download in progress
|
|
* null -> Loading / Gallery doesn't exist
|
|
* SECONDARY VALUE
|
|
* 0 <= value < 100 -> Download in progress
|
|
* Float.POSITIVE_INFINITY -> Download completed
|
|
*/
|
|
val progress = ConcurrentHashMap<Int, MutableList<Float>>()
|
|
var priority = 0
|
|
|
|
fun isCompleted(galleryID: Int) = progress[galleryID]?.toList()?.all { it == Float.POSITIVE_INFINITY } == true
|
|
|
|
private val callback = object: Callback {
|
|
|
|
override fun onFailure(call: Call, e: IOException) {
|
|
if (e.message?.contains("cancel", true) == false) {
|
|
val galleryID = (call.request().tag() as Tag).galleryID
|
|
|
|
// Retry
|
|
cancel(galleryID)
|
|
download(galleryID)
|
|
}
|
|
}
|
|
|
|
override fun onResponse(call: Call, response: Response) {
|
|
val (galleryID, index, startId) = call.request().tag() as Tag
|
|
val ext = call.request().url().encodedPath().split('.').last()
|
|
|
|
kotlin.runCatching {
|
|
val image = response.also { if (it.code() != 200) throw IOException() }.body()?.use { it.bytes() } ?: throw Exception()
|
|
val padding = ceil(progress[galleryID]?.size?.let { log10(it.toFloat()) } ?: 0F).toInt()
|
|
|
|
CoroutineScope(Dispatchers.IO).launch {
|
|
kotlin.runCatching {
|
|
Cache.getInstance(this@DownloadService, galleryID).putImage(index, "${index.toString().padStart(padding, '0')}.$ext", image)
|
|
}.onSuccess {
|
|
progress[galleryID]?.set(index, Float.POSITIVE_INFINITY)
|
|
notify(galleryID)
|
|
|
|
if (isCompleted(galleryID)) {
|
|
if (DownloadManager.getInstance(this@DownloadService)
|
|
.getDownloadFolder(galleryID) != null)
|
|
Cache.getInstance(this@DownloadService, galleryID).moveToDownload()
|
|
|
|
startId?.let { stopSelf(it) }
|
|
}
|
|
}.onFailure {
|
|
cancel(galleryID)
|
|
download(galleryID)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fun cancel(startId: Int? = null) {
|
|
client.dispatcher().queuedCalls().filter {
|
|
it.request().tag() is Tag
|
|
}.forEach {
|
|
(it.request().tag() as? Tag)?.startId?.let { stopSelf(it) }
|
|
it.cancel()
|
|
}
|
|
client.dispatcher().runningCalls().filter {
|
|
it.request().tag() is Tag
|
|
}.forEach {
|
|
(it.request().tag() as? Tag)?.startId?.let { stopSelf(it) }
|
|
it.cancel()
|
|
}
|
|
|
|
progress.clear()
|
|
notification.clear()
|
|
notificationManager.cancelAll()
|
|
|
|
startId?.let { stopSelf(it) }
|
|
}
|
|
|
|
fun cancel(galleryID: Int, startId: Int? = null) {
|
|
client.dispatcher().queuedCalls().filter {
|
|
(it.request().tag() as? Tag)?.galleryID == galleryID
|
|
}.forEach {
|
|
(it.request().tag() as? Tag)?.startId?.let { stopSelf(it) }
|
|
it.cancel()
|
|
}
|
|
client.dispatcher().runningCalls().filter {
|
|
(it.request().tag() as? Tag)?.galleryID == galleryID
|
|
}.forEach {
|
|
(it.request().tag() as? Tag)?.startId?.let { stopSelf(it) }
|
|
it.cancel()
|
|
}
|
|
|
|
progress.remove(galleryID)
|
|
notification.remove(galleryID)
|
|
notificationManager.cancel(galleryID)
|
|
|
|
startId?.let { stopSelf(it) }
|
|
}
|
|
|
|
fun delete(galleryID: Int, startId: Int? = null) = CoroutineScope(Dispatchers.IO).launch {
|
|
cancel(galleryID)
|
|
DownloadManager.getInstance(this@DownloadService).deleteDownloadFolder(galleryID)
|
|
Cache.delete(this@DownloadService, galleryID)
|
|
|
|
startId?.let { stopSelf(it) }
|
|
}
|
|
|
|
fun download(galleryID: Int, priority: Boolean = false, startId: Int? = null): Job = CoroutineScope(Dispatchers.IO).launch {
|
|
if (DownloadManager.getInstance(this@DownloadService).isDownloading(galleryID))
|
|
return@launch
|
|
|
|
cleanCache(this@DownloadService)
|
|
|
|
val cache = Cache.getInstance(this@DownloadService, galleryID)
|
|
|
|
initNotification(galleryID)
|
|
|
|
val reader = cache.getReader()
|
|
|
|
// Gallery doesn't exist
|
|
if (reader == null) {
|
|
delete(galleryID)
|
|
progress[galleryID] = mutableListOf()
|
|
return@launch
|
|
}
|
|
|
|
histories.add(galleryID)
|
|
|
|
progress[galleryID] = MutableList(reader.galleryInfo.files.size) { 0F }
|
|
|
|
cache.metadata.imageList?.let {
|
|
it.forEachIndexed { index, image ->
|
|
progress[galleryID]?.set(index, if (image != null) Float.POSITIVE_INFINITY else 0F)
|
|
}
|
|
}
|
|
|
|
if (isCompleted(galleryID)) {
|
|
if (DownloadManager.getInstance(this@DownloadService)
|
|
.getDownloadFolder(galleryID) != null )
|
|
Cache.getInstance(this@DownloadService, galleryID).moveToDownload()
|
|
|
|
notificationManager.cancel(galleryID)
|
|
startId?.let { stopSelf(it) }
|
|
return@launch
|
|
}
|
|
|
|
notification[galleryID]?.setContentTitle(reader.galleryInfo.title?.ellipsize(30))
|
|
notify(galleryID)
|
|
|
|
val queued = mutableSetOf<Int>()
|
|
|
|
if (priority) {
|
|
client.dispatcher().queuedCalls().forEach {
|
|
val queuedID = (it.request().tag() as? Tag)?.galleryID ?: return@forEach
|
|
|
|
if (queued.add(queuedID))
|
|
cancel(queuedID)
|
|
}
|
|
}
|
|
|
|
reader.requestBuilders.forEachIndexed { index, it ->
|
|
if (progress[galleryID]?.get(index)?.isInfinite() == false) {
|
|
val request = it.tag(Tag(galleryID, index, startId)).build()
|
|
client.newCall(request).enqueue(callback)
|
|
}
|
|
}
|
|
|
|
queued.forEach { download(it) }
|
|
}
|
|
//endregion
|
|
|
|
companion object {
|
|
const val KEY_COMMAND = "COMMAND" // String
|
|
const val KEY_ID = "ID" // Int
|
|
const val KEY_PRIORITY = "PRIORITY" // Boolean
|
|
|
|
const val COMMAND_DOWNLOAD = "DOWNLOAD"
|
|
const val COMMAND_CANCEL = "CANCEL"
|
|
const val COMMAND_DELETE = "DELETE"
|
|
|
|
private fun command(context: Context, extras: Intent.() -> Unit) {
|
|
ContextCompat.startForegroundService(context, Intent(context, DownloadService::class.java).apply(extras))
|
|
}
|
|
|
|
fun download(context: Context, galleryID: Int, priority: Boolean = false) {
|
|
command(context) {
|
|
putExtra(KEY_COMMAND, COMMAND_DOWNLOAD)
|
|
putExtra(KEY_PRIORITY, priority)
|
|
putExtra(KEY_ID, galleryID)
|
|
}
|
|
}
|
|
|
|
fun cancel(context: Context, galleryID: Int? = null) {
|
|
command(context) {
|
|
putExtra(KEY_COMMAND, COMMAND_CANCEL)
|
|
galleryID?.let { putExtra(KEY_ID, it) }
|
|
}
|
|
}
|
|
|
|
fun delete(context: Context, galleryID: Int) {
|
|
command(context) {
|
|
putExtra(KEY_COMMAND, COMMAND_DELETE)
|
|
putExtra(KEY_ID, galleryID)
|
|
}
|
|
}
|
|
}
|
|
|
|
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
|
|
startForeground(R.id.downloader_notification_id, serviceNotification.build())
|
|
|
|
when (intent?.getStringExtra(KEY_COMMAND)) {
|
|
COMMAND_DOWNLOAD -> intent.getIntExtra(KEY_ID, -1).let { if (it > 0)
|
|
download(it, intent.getBooleanExtra(KEY_PRIORITY, false), startId)
|
|
}
|
|
COMMAND_CANCEL -> intent.getIntExtra(KEY_ID, -1).let { if (it > 0) cancel(it, startId) else cancel(startId = startId) }
|
|
COMMAND_DELETE -> intent.getIntExtra(KEY_ID, -1).let { if (it > 0) delete(it, startId) }
|
|
}
|
|
|
|
return START_NOT_STICKY
|
|
}
|
|
|
|
inner class Binder : android.os.Binder() {
|
|
val service = this@DownloadService
|
|
}
|
|
|
|
private val binder = Binder()
|
|
override fun onBind(p0: Intent?) = binder
|
|
|
|
override fun onCreate() {
|
|
startForeground(R.id.downloader_notification_id, serviceNotification.build())
|
|
interceptors[Tag::class] = interceptor
|
|
}
|
|
|
|
override fun onDestroy() {
|
|
interceptors.remove(Tag::class)
|
|
}
|
|
} |