|
|
|
|
@ -31,21 +31,20 @@ import eu.kanade.tachiyomi.data.preference.PreferencesHelper
|
|
|
|
|
import eu.kanade.tachiyomi.data.preference.getOrDefault
|
|
|
|
|
import eu.kanade.tachiyomi.data.track.TrackManager
|
|
|
|
|
import eu.kanade.tachiyomi.source.SourceManager
|
|
|
|
|
import eu.kanade.tachiyomi.source.model.SChapter
|
|
|
|
|
import eu.kanade.tachiyomi.source.model.SManga
|
|
|
|
|
import eu.kanade.tachiyomi.source.online.HttpSource
|
|
|
|
|
import eu.kanade.tachiyomi.ui.main.MainActivity
|
|
|
|
|
import eu.kanade.tachiyomi.util.chapter.syncChaptersWithSource
|
|
|
|
|
import eu.kanade.tachiyomi.util.lang.chop
|
|
|
|
|
import eu.kanade.tachiyomi.util.system.executeOnIO
|
|
|
|
|
import eu.kanade.tachiyomi.util.system.notification
|
|
|
|
|
import eu.kanade.tachiyomi.util.system.notificationManager
|
|
|
|
|
import kotlinx.coroutines.CoroutineExceptionHandler
|
|
|
|
|
import kotlinx.coroutines.CoroutineStart
|
|
|
|
|
import kotlinx.coroutines.Dispatchers
|
|
|
|
|
import kotlinx.coroutines.GlobalScope
|
|
|
|
|
import kotlinx.coroutines.Job
|
|
|
|
|
import kotlinx.coroutines.launch
|
|
|
|
|
import eu.kanade.tachiyomi.util.chapter.syncChaptersWithSource
|
|
|
|
|
import eu.kanade.tachiyomi.util.lang.chop
|
|
|
|
|
import eu.kanade.tachiyomi.util.system.isServiceRunning
|
|
|
|
|
import eu.kanade.tachiyomi.util.system.notification
|
|
|
|
|
import eu.kanade.tachiyomi.util.system.notificationManager
|
|
|
|
|
import kotlinx.coroutines.withContext
|
|
|
|
|
import rx.Observable
|
|
|
|
|
import rx.Subscription
|
|
|
|
|
import rx.schedulers.Schedulers
|
|
|
|
|
@ -66,11 +65,11 @@ import java.util.concurrent.atomic.AtomicInteger
|
|
|
|
|
* destroyed.
|
|
|
|
|
*/
|
|
|
|
|
class LibraryUpdateService(
|
|
|
|
|
val db: DatabaseHelper = Injekt.get(),
|
|
|
|
|
val sourceManager: SourceManager = Injekt.get(),
|
|
|
|
|
val preferences: PreferencesHelper = Injekt.get(),
|
|
|
|
|
val downloadManager: DownloadManager = Injekt.get(),
|
|
|
|
|
val trackManager: TrackManager = Injekt.get()
|
|
|
|
|
val db: DatabaseHelper = Injekt.get(),
|
|
|
|
|
val sourceManager: SourceManager = Injekt.get(),
|
|
|
|
|
val preferences: PreferencesHelper = Injekt.get(),
|
|
|
|
|
val downloadManager: DownloadManager = Injekt.get(),
|
|
|
|
|
val trackManager: TrackManager = Injekt.get()
|
|
|
|
|
) : Service() {
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
@ -83,7 +82,6 @@ class LibraryUpdateService(
|
|
|
|
|
*/
|
|
|
|
|
private var subscription: Subscription? = null
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Pending intent of action that cancels the library update
|
|
|
|
|
*/
|
|
|
|
|
@ -98,19 +96,31 @@ class LibraryUpdateService(
|
|
|
|
|
BitmapFactory.decodeResource(resources, R.mipmap.ic_launcher)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private var job:Job? = null
|
|
|
|
|
private var job: Job? = null
|
|
|
|
|
|
|
|
|
|
private val mangaToUpdate = mutableListOf<LibraryManga>()
|
|
|
|
|
|
|
|
|
|
private val categoryIds = mutableSetOf<Int>()
|
|
|
|
|
|
|
|
|
|
// List containing new updates
|
|
|
|
|
private val newUpdates = mutableMapOf<LibraryManga, Array<Chapter>>()
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Cached progress notification to avoid creating a lot.
|
|
|
|
|
*/
|
|
|
|
|
private val progressNotification by lazy { NotificationCompat.Builder(this, Notifications.CHANNEL_LIBRARY)
|
|
|
|
|
private val progressNotification by lazy {
|
|
|
|
|
NotificationCompat.Builder(this, Notifications.CHANNEL_LIBRARY)
|
|
|
|
|
.setContentTitle(getString(R.string.app_name))
|
|
|
|
|
.setSmallIcon(R.drawable.ic_refresh_white_24dp_img)
|
|
|
|
|
.setLargeIcon(notificationBitmap)
|
|
|
|
|
.setOngoing(true)
|
|
|
|
|
.setOnlyAlertOnce(true)
|
|
|
|
|
.setColor(ContextCompat.getColor(this, R.color.colorAccent))
|
|
|
|
|
.addAction(R.drawable.ic_clear_grey_24dp_img, getString(android.R.string.cancel), cancelIntent)
|
|
|
|
|
.addAction(
|
|
|
|
|
R.drawable.ic_clear_grey_24dp_img,
|
|
|
|
|
getString(android.R.string.cancel),
|
|
|
|
|
cancelIntent
|
|
|
|
|
)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
@ -118,8 +128,8 @@ class LibraryUpdateService(
|
|
|
|
|
*/
|
|
|
|
|
enum class Target {
|
|
|
|
|
CHAPTERS, // Manga chapters
|
|
|
|
|
DETAILS, // Manga metadata
|
|
|
|
|
TRACKING // Tracking metadata
|
|
|
|
|
DETAILS, // Manga metadata
|
|
|
|
|
TRACKING // Tracking metadata
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
companion object {
|
|
|
|
|
@ -129,11 +139,8 @@ class LibraryUpdateService(
|
|
|
|
|
*/
|
|
|
|
|
const val KEY_CATEGORY = "category"
|
|
|
|
|
|
|
|
|
|
private val mangaToUpdate = mutableListOf<LibraryManga>()
|
|
|
|
|
|
|
|
|
|
private val categoryIds = mutableSetOf<Int>()
|
|
|
|
|
|
|
|
|
|
fun categoryInQueue(id: Int?) = categoryIds.contains(id)
|
|
|
|
|
fun categoryInQueue(id: Int?) = instance?.categoryIds?.contains(id) ?: false
|
|
|
|
|
private var instance: LibraryUpdateService? = null
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Key that defines what should be updated.
|
|
|
|
|
@ -143,11 +150,10 @@ class LibraryUpdateService(
|
|
|
|
|
/**
|
|
|
|
|
* Returns the status of the service.
|
|
|
|
|
*
|
|
|
|
|
* @param context the application context.
|
|
|
|
|
* @return true if the service is running, false otherwise.
|
|
|
|
|
*/
|
|
|
|
|
fun isRunning(context: Context): Boolean {
|
|
|
|
|
return context.isServiceRunning(LibraryUpdateService::class.java)
|
|
|
|
|
fun isRunning(): Boolean {
|
|
|
|
|
return instance != null
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
@ -159,12 +165,11 @@ class LibraryUpdateService(
|
|
|
|
|
* @param target defines what should be updated.
|
|
|
|
|
*/
|
|
|
|
|
fun start(context: Context, category: Category? = null, target: Target = Target.CHAPTERS) {
|
|
|
|
|
if (!isRunning(context)) {
|
|
|
|
|
if (!isRunning()) {
|
|
|
|
|
val intent = Intent(context, LibraryUpdateService::class.java).apply {
|
|
|
|
|
putExtra(KEY_TARGET, target)
|
|
|
|
|
category?.id?.let { id ->
|
|
|
|
|
putExtra(KEY_CATEGORY, id)
|
|
|
|
|
categoryIds.add(id)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
|
|
|
|
|
@ -172,67 +177,83 @@ class LibraryUpdateService(
|
|
|
|
|
} else {
|
|
|
|
|
context.startForegroundService(intent)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
} else {
|
|
|
|
|
if (target == Target.CHAPTERS) category?.id?.let {
|
|
|
|
|
categoryIds.add(it)
|
|
|
|
|
val preferences: PreferencesHelper = Injekt.get()
|
|
|
|
|
val selectedScheme = preferences.libraryUpdatePrioritization().getOrDefault()
|
|
|
|
|
addManga(getMangaToUpdate(it, target).sortedWith(
|
|
|
|
|
rankingScheme[selectedScheme]
|
|
|
|
|
))
|
|
|
|
|
instance?.addCategory(it)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private fun addManga(mangaToAdd: List<LibraryManga>) {
|
|
|
|
|
for (manga in mangaToAdd) {
|
|
|
|
|
if (mangaToUpdate.none { it.id == manga.id }) mangaToUpdate.add(manga)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Stops the service.
|
|
|
|
|
*
|
|
|
|
|
* @param context the application context.
|
|
|
|
|
*/
|
|
|
|
|
fun stop(context: Context) {
|
|
|
|
|
instance?.job?.cancel()
|
|
|
|
|
context.stopService(Intent(context, LibraryUpdateService::class.java))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Returns the list of manga to be updated.
|
|
|
|
|
*
|
|
|
|
|
* @param intent the update intent.
|
|
|
|
|
* @param target the target to update.
|
|
|
|
|
* @return a list of manga to update
|
|
|
|
|
*/
|
|
|
|
|
private fun getMangaToUpdate(categoryId: Int, target: Target): List<LibraryManga> {
|
|
|
|
|
val preferences: PreferencesHelper = Injekt.get()
|
|
|
|
|
val db: DatabaseHelper = Injekt.get()
|
|
|
|
|
var listToUpdate = if (categoryId != -1)
|
|
|
|
|
db.getLibraryMangas().executeAsBlocking().filter { it.category == categoryId }
|
|
|
|
|
else {
|
|
|
|
|
val categoriesToUpdate = preferences.libraryUpdateCategories().getOrDefault().map(String::toInt)
|
|
|
|
|
categoryIds.addAll(categoriesToUpdate)
|
|
|
|
|
if (categoriesToUpdate.isNotEmpty())
|
|
|
|
|
db.getLibraryMangas().executeAsBlocking()
|
|
|
|
|
.filter { it.category in categoriesToUpdate }
|
|
|
|
|
.distinctBy { it.id }
|
|
|
|
|
else
|
|
|
|
|
db.getLibraryMangas().executeAsBlocking().distinctBy { it.id }
|
|
|
|
|
}
|
|
|
|
|
if (target == Target.CHAPTERS && preferences.updateOnlyNonCompleted()) {
|
|
|
|
|
listToUpdate = listToUpdate.filter { it.status != SManga.COMPLETED }
|
|
|
|
|
}
|
|
|
|
|
private var listener: LibraryServiceListener? = null
|
|
|
|
|
|
|
|
|
|
fun setListener(listener: LibraryServiceListener) {
|
|
|
|
|
this.listener = listener
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fun removeListener(listener: LibraryServiceListener) {
|
|
|
|
|
if (this.listener == listener)
|
|
|
|
|
this.listener = null
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return listToUpdate
|
|
|
|
|
private fun addManga(mangaToAdd: List<LibraryManga>) {
|
|
|
|
|
for (manga in mangaToAdd) {
|
|
|
|
|
if (mangaToUpdate.none { it.id == manga.id }) mangaToUpdate.add(manga)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private fun addCategory(categoryId: Int) {
|
|
|
|
|
val selectedScheme = preferences.libraryUpdatePrioritization().getOrDefault()
|
|
|
|
|
val mangas =
|
|
|
|
|
getMangaToUpdate(categoryId, Target.CHAPTERS).sortedWith(
|
|
|
|
|
rankingScheme[selectedScheme]
|
|
|
|
|
)
|
|
|
|
|
categoryIds.add(categoryId)
|
|
|
|
|
addManga(mangas)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private fun getMangaToUpdate(intent: Intent, target: Target): List<LibraryManga> {
|
|
|
|
|
val categoryId = intent.getIntExtra(KEY_CATEGORY, -1)
|
|
|
|
|
return getMangaToUpdate(categoryId, target)
|
|
|
|
|
/**
|
|
|
|
|
* Returns the list of manga to be updated.
|
|
|
|
|
*
|
|
|
|
|
* @param intent the update intent.
|
|
|
|
|
* @param target the target to update.
|
|
|
|
|
* @return a list of manga to update
|
|
|
|
|
*/
|
|
|
|
|
private fun getMangaToUpdate(categoryId: Int, target: Target): List<LibraryManga> {
|
|
|
|
|
var listToUpdate = if (categoryId != -1) {
|
|
|
|
|
categoryIds.add(categoryId)
|
|
|
|
|
db.getLibraryMangas().executeAsBlocking().filter { it.category == categoryId }
|
|
|
|
|
} else {
|
|
|
|
|
val categoriesToUpdate =
|
|
|
|
|
preferences.libraryUpdateCategories().getOrDefault().map(String::toInt)
|
|
|
|
|
categoryIds.addAll(categoriesToUpdate)
|
|
|
|
|
if (categoriesToUpdate.isNotEmpty())
|
|
|
|
|
db.getLibraryMangas().executeAsBlocking()
|
|
|
|
|
.filter { it.category in categoriesToUpdate }
|
|
|
|
|
.distinctBy { it.id }
|
|
|
|
|
else
|
|
|
|
|
db.getLibraryMangas().executeAsBlocking().distinctBy { it.id }
|
|
|
|
|
}
|
|
|
|
|
if (target == Target.CHAPTERS && preferences.updateOnlyNonCompleted()) {
|
|
|
|
|
listToUpdate = listToUpdate.filter { it.status != SManga.COMPLETED }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return listToUpdate
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private fun getMangaToUpdate(intent: Intent, target: Target): List<LibraryManga> {
|
|
|
|
|
val categoryId = intent.getIntExtra(KEY_CATEGORY, -1)
|
|
|
|
|
return getMangaToUpdate(categoryId, target)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
@ -243,26 +264,24 @@ class LibraryUpdateService(
|
|
|
|
|
super.onCreate()
|
|
|
|
|
startForeground(Notifications.ID_LIBRARY_PROGRESS, progressNotification.build())
|
|
|
|
|
wakeLock = (getSystemService(Context.POWER_SERVICE) as PowerManager).newWakeLock(
|
|
|
|
|
PowerManager.PARTIAL_WAKE_LOCK, "LibraryUpdateService:WakeLock")
|
|
|
|
|
PowerManager.PARTIAL_WAKE_LOCK, "LibraryUpdateService:WakeLock"
|
|
|
|
|
)
|
|
|
|
|
wakeLock.acquire(TimeUnit.MINUTES.toMillis(30))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
override fun stopService(name: Intent?): Boolean {
|
|
|
|
|
job?.cancel()
|
|
|
|
|
return super.stopService(name)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Method called when the service is destroyed. It destroys subscriptions and releases the wake
|
|
|
|
|
* lock.
|
|
|
|
|
*/
|
|
|
|
|
override fun onDestroy() {
|
|
|
|
|
job?.cancel()
|
|
|
|
|
if (instance == this)
|
|
|
|
|
instance = null
|
|
|
|
|
subscription?.unsubscribe()
|
|
|
|
|
mangaToUpdate.clear()
|
|
|
|
|
categoryIds.clear()
|
|
|
|
|
if (wakeLock.isHeld) {
|
|
|
|
|
wakeLock.release()
|
|
|
|
|
}
|
|
|
|
|
listener?.onUpdateManga(LibraryManga())
|
|
|
|
|
super.onDestroy()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@ -283,93 +302,78 @@ class LibraryUpdateService(
|
|
|
|
|
*/
|
|
|
|
|
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
|
|
|
|
|
if (intent == null) return START_NOT_STICKY
|
|
|
|
|
val target = intent.getSerializableExtra(KEY_TARGET) as? Target ?: return START_NOT_STICKY
|
|
|
|
|
val target = intent.getSerializableExtra(KEY_TARGET) as? Target
|
|
|
|
|
?: return START_NOT_STICKY
|
|
|
|
|
|
|
|
|
|
// Unsubscribe from any previous subscription if needed.
|
|
|
|
|
subscription?.unsubscribe()
|
|
|
|
|
instance = this
|
|
|
|
|
|
|
|
|
|
val handler = CoroutineExceptionHandler { _, exception ->
|
|
|
|
|
Timber.e(exception)
|
|
|
|
|
stopSelf(startId)
|
|
|
|
|
}
|
|
|
|
|
val selectedScheme = preferences.libraryUpdatePrioritization().getOrDefault()
|
|
|
|
|
if (target == Target.CHAPTERS) {
|
|
|
|
|
updateChapters(
|
|
|
|
|
getMangaToUpdate(intent, target).sortedWith(rankingScheme[selectedScheme]), startId
|
|
|
|
|
)
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
val mangaList =
|
|
|
|
|
getMangaToUpdate(intent, target).sortedWith(rankingScheme[selectedScheme])
|
|
|
|
|
// Update favorite manga. Destroy service when completed or in case of an error.
|
|
|
|
|
if (target == Target.DETAILS) {
|
|
|
|
|
// Update either chapter list or manga details.
|
|
|
|
|
// Update favorite manga. Destroy service when completed or in case of an error.
|
|
|
|
|
val mangaList =
|
|
|
|
|
getMangaToUpdate(intent, target).sortedWith(rankingScheme[selectedScheme])
|
|
|
|
|
subscription = Observable.defer {
|
|
|
|
|
when (target) {
|
|
|
|
|
Target.DETAILS -> updateDetails(mangaList)
|
|
|
|
|
else -> updateTrackings(mangaList)
|
|
|
|
|
}
|
|
|
|
|
updateDetails(mangaList)
|
|
|
|
|
}.subscribeOn(Schedulers.io()).subscribe({}, {
|
|
|
|
|
Timber.e(it)
|
|
|
|
|
stopSelf(startId)
|
|
|
|
|
}, {
|
|
|
|
|
stopSelf(startId)
|
|
|
|
|
})
|
|
|
|
|
} else {
|
|
|
|
|
launchTarget(target, mangaList, startId)
|
|
|
|
|
}
|
|
|
|
|
return START_REDELIVER_INTENT
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private fun updateChapters(mangaToAdd: List<LibraryManga>, startId: Int) {
|
|
|
|
|
addManga(mangaToAdd)
|
|
|
|
|
|
|
|
|
|
if (job == null) {
|
|
|
|
|
job = GlobalScope.launch(Dispatchers.IO, CoroutineStart.DEFAULT) {
|
|
|
|
|
updateChaptersJob()
|
|
|
|
|
mangaToUpdate.clear()
|
|
|
|
|
categoryIds.clear()
|
|
|
|
|
stopSelf(startId)
|
|
|
|
|
private fun launchTarget(target: Target, mangaToAdd: List<LibraryManga>, startId: Int) {
|
|
|
|
|
val handler = CoroutineExceptionHandler { _, exception ->
|
|
|
|
|
Timber.e(exception)
|
|
|
|
|
stopSelf(startId)
|
|
|
|
|
}
|
|
|
|
|
if (target == Target.CHAPTERS) {
|
|
|
|
|
job = GlobalScope.launch(handler) {
|
|
|
|
|
updateChaptersJob(mangaToAdd)
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
job = GlobalScope.launch(handler) {
|
|
|
|
|
updateTrackings(mangaToAdd)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
job?.invokeOnCompletion { stopSelf(startId) }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private fun updateChaptersJob() {
|
|
|
|
|
// Initialize the variables holding the progress of the updates.
|
|
|
|
|
var count = 0
|
|
|
|
|
// List containing new updates
|
|
|
|
|
val newUpdates = ArrayList<Pair<LibraryManga, Array<Chapter>>>()
|
|
|
|
|
// list containing failed updates
|
|
|
|
|
val failedUpdates = ArrayList<Manga>()
|
|
|
|
|
private suspend fun updateChaptersJob(mangaToAdd: List<LibraryManga>) {
|
|
|
|
|
// List containing categories that get included in downloads.
|
|
|
|
|
val categoriesToDownload = preferences.downloadNewCategories().getOrDefault().map(String::toInt)
|
|
|
|
|
val categoriesToDownload =
|
|
|
|
|
preferences.downloadNewCategories().getOrDefault().map(String::toInt)
|
|
|
|
|
// Boolean to determine if user wants to automatically download new chapters.
|
|
|
|
|
val downloadNew = preferences.downloadNew().getOrDefault()
|
|
|
|
|
// Boolean to determine if DownloadManager has downloads
|
|
|
|
|
var hasDownloads = false
|
|
|
|
|
// Initialize the variables holding the progress of the updates.
|
|
|
|
|
var count = 0
|
|
|
|
|
|
|
|
|
|
mangaToUpdate.addAll(mangaToAdd)
|
|
|
|
|
while (count < mangaToUpdate.size) {
|
|
|
|
|
if (job?.isCancelled == true || job == null) break
|
|
|
|
|
val manga = mangaToUpdate[count]
|
|
|
|
|
showProgressNotification(manga, count++, mangaToUpdate.size)
|
|
|
|
|
val source = sourceManager.get(manga.source) as? HttpSource ?: continue
|
|
|
|
|
val fetchedChapters = try { source.fetchChapterList(manga).toBlocking().single() }
|
|
|
|
|
catch(e: java.lang.Exception) {
|
|
|
|
|
failedUpdates.add(manga)
|
|
|
|
|
emptyList<SChapter>() }
|
|
|
|
|
if (fetchedChapters.isNotEmpty()) {
|
|
|
|
|
val newChapters = syncChaptersWithSource(db, fetchedChapters, manga, source).first
|
|
|
|
|
if (newChapters.isNotEmpty()) {
|
|
|
|
|
if (downloadNew && (categoriesToDownload.isEmpty() || manga.category in categoriesToDownload)) {
|
|
|
|
|
downloadChapters(manga, newChapters.sortedBy { it.chapter_number })
|
|
|
|
|
hasDownloads = true
|
|
|
|
|
}
|
|
|
|
|
newUpdates.add(manga to newChapters.sortedBy { it.chapter_number }.toTypedArray())
|
|
|
|
|
}
|
|
|
|
|
val shouldDownload = (downloadNew && (categoriesToDownload.isEmpty() ||
|
|
|
|
|
mangaToUpdate[count].category in categoriesToDownload ||
|
|
|
|
|
db.getCategoriesForManga(mangaToUpdate[count]).executeOnIO()
|
|
|
|
|
.any { (it.id ?: -1) in categoriesToDownload }))
|
|
|
|
|
if (updateMangaChapters(mangaToUpdate[count], count, shouldDownload)) {
|
|
|
|
|
hasDownloads = true
|
|
|
|
|
}
|
|
|
|
|
count++
|
|
|
|
|
}
|
|
|
|
|
if (newUpdates.isNotEmpty()) {
|
|
|
|
|
showResultNotification(newUpdates)
|
|
|
|
|
|
|
|
|
|
if (preferences.refreshCoversToo().getOrDefault()) {
|
|
|
|
|
updateDetails(newUpdates.map { it.first }).observeOn(Schedulers.io())
|
|
|
|
|
if (preferences.refreshCoversToo().getOrDefault() && job?.isCancelled == false) {
|
|
|
|
|
updateDetails(newUpdates.map { it.key }).observeOn(Schedulers.io())
|
|
|
|
|
.doOnCompleted {
|
|
|
|
|
cancelProgressNotification()
|
|
|
|
|
if (downloadNew && hasDownloads) {
|
|
|
|
|
@ -377,19 +381,51 @@ class LibraryUpdateService(
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
.subscribeOn(Schedulers.io()).subscribe {}
|
|
|
|
|
}
|
|
|
|
|
else if (downloadNew && hasDownloads) {
|
|
|
|
|
} else if (downloadNew && hasDownloads) {
|
|
|
|
|
DownloadService.start(this)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (failedUpdates.isNotEmpty()) {
|
|
|
|
|
Timber.e("Failed updating: ${failedUpdates.map { it.title }}")
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cancelProgressNotification()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private suspend fun updateMangaChapters(
|
|
|
|
|
manga: LibraryManga,
|
|
|
|
|
progess: Int,
|
|
|
|
|
shouldDownload: Boolean
|
|
|
|
|
):
|
|
|
|
|
Boolean {
|
|
|
|
|
try {
|
|
|
|
|
var hasDownloads = false
|
|
|
|
|
if (job?.isCancelled == true) {
|
|
|
|
|
throw java.lang.Exception("Job was cancelled")
|
|
|
|
|
}
|
|
|
|
|
showProgressNotification(manga, progess, mangaToUpdate.size)
|
|
|
|
|
val source = sourceManager.get(manga.source) as? HttpSource ?: return false
|
|
|
|
|
val fetchedChapters = withContext(Dispatchers.IO) {
|
|
|
|
|
source.fetchChapterList(manga).toBlocking().single()
|
|
|
|
|
} ?: emptyList()
|
|
|
|
|
if (fetchedChapters.isNotEmpty()) {
|
|
|
|
|
val newChapters = syncChaptersWithSource(db, fetchedChapters, manga, source)
|
|
|
|
|
if (newChapters.first.isNotEmpty()) {
|
|
|
|
|
if (shouldDownload) {
|
|
|
|
|
downloadChapters(manga, newChapters.first.sortedBy { it.chapter_number })
|
|
|
|
|
hasDownloads = true
|
|
|
|
|
}
|
|
|
|
|
newUpdates[manga] =
|
|
|
|
|
newChapters.first.sortedBy { it.chapter_number }.toTypedArray()
|
|
|
|
|
}
|
|
|
|
|
if (newChapters.first.size + newChapters.second.size > 0) listener?.onUpdateManga(
|
|
|
|
|
manga
|
|
|
|
|
)
|
|
|
|
|
}
|
|
|
|
|
return hasDownloads
|
|
|
|
|
} catch (e: Exception) {
|
|
|
|
|
Timber.e("Failed updating: ${manga.title}: $e")
|
|
|
|
|
return false
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fun downloadChapters(manga: Manga, chapters: List<Chapter>) {
|
|
|
|
|
// we need to get the chapters from the db so we have chapter ids
|
|
|
|
|
val mangaChapters = db.getChapters(manga).executeAsBlocking()
|
|
|
|
|
@ -410,7 +446,7 @@ class LibraryUpdateService(
|
|
|
|
|
fun updateManga(manga: Manga): Observable<Pair<List<Chapter>, List<Chapter>>> {
|
|
|
|
|
val source = sourceManager.get(manga.source) as? HttpSource ?: return Observable.empty()
|
|
|
|
|
return source.fetchChapterList(manga)
|
|
|
|
|
.map { syncChaptersWithSource(db, it, manga, source) }
|
|
|
|
|
.map { syncChaptersWithSource(db, it, manga, source) }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
@ -426,61 +462,57 @@ class LibraryUpdateService(
|
|
|
|
|
|
|
|
|
|
// Emit each manga and update it sequentially.
|
|
|
|
|
return Observable.from(mangaToUpdate)
|
|
|
|
|
// Notify manga that will update.
|
|
|
|
|
.doOnNext { showProgressNotification(it, count.andIncrement, mangaToUpdate.size) }
|
|
|
|
|
// Update the details of the manga.
|
|
|
|
|
.concatMap { manga ->
|
|
|
|
|
val source = sourceManager.get(manga.source) as? HttpSource
|
|
|
|
|
?: return@concatMap Observable.empty<LibraryManga>()
|
|
|
|
|
|
|
|
|
|
source.fetchMangaDetails(manga)
|
|
|
|
|
.map { networkManga ->
|
|
|
|
|
manga.copyFrom(networkManga)
|
|
|
|
|
db.insertManga(manga).executeAsBlocking()
|
|
|
|
|
MangaImpl.setLastCoverFetch(manga.id!!, Date().time)
|
|
|
|
|
manga
|
|
|
|
|
}
|
|
|
|
|
.onErrorReturn { manga }
|
|
|
|
|
}
|
|
|
|
|
.doOnCompleted {
|
|
|
|
|
cancelProgressNotification()
|
|
|
|
|
}
|
|
|
|
|
// Notify manga that will update.
|
|
|
|
|
.doOnNext { showProgressNotification(it, count.andIncrement, mangaToUpdate.size) }
|
|
|
|
|
// Update the details of the manga.
|
|
|
|
|
.concatMap { manga ->
|
|
|
|
|
val source = sourceManager.get(manga.source) as? HttpSource
|
|
|
|
|
?: return@concatMap Observable.empty<LibraryManga>()
|
|
|
|
|
source.fetchMangaDetails(manga)
|
|
|
|
|
.map { networkManga ->
|
|
|
|
|
val thumbnailUrl = manga.thumbnail_url
|
|
|
|
|
manga.copyFrom(networkManga)
|
|
|
|
|
db.insertManga(manga).executeAsBlocking()
|
|
|
|
|
if (thumbnailUrl != networkManga.thumbnail_url)
|
|
|
|
|
MangaImpl.setLastCoverFetch(manga.id!!, Date().time)
|
|
|
|
|
manga
|
|
|
|
|
}
|
|
|
|
|
.onErrorReturn { manga }
|
|
|
|
|
}
|
|
|
|
|
.doOnCompleted {
|
|
|
|
|
cancelProgressNotification()
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Method that updates the metadata of the connected tracking services. It's called in a
|
|
|
|
|
* background thread, so it's safe to do heavy operations or network calls here.
|
|
|
|
|
*/
|
|
|
|
|
private fun updateTrackings(mangaToUpdate: List<LibraryManga>): Observable<LibraryManga> {
|
|
|
|
|
|
|
|
|
|
private suspend fun updateTrackings(mangaToUpdate: List<LibraryManga>) {
|
|
|
|
|
// Initialize the variables holding the progress of the updates.
|
|
|
|
|
var count = 0
|
|
|
|
|
|
|
|
|
|
val loggedServices = trackManager.services.filter { it.isLogged }
|
|
|
|
|
|
|
|
|
|
// Emit each manga and update it sequentially.
|
|
|
|
|
return Observable.from(mangaToUpdate)
|
|
|
|
|
// Notify manga that will update.
|
|
|
|
|
.doOnNext { showProgressNotification(it, count++, mangaToUpdate.size) }
|
|
|
|
|
// Update the tracking details.
|
|
|
|
|
.concatMap { manga ->
|
|
|
|
|
val tracks = db.getTracks(manga).executeAsBlocking()
|
|
|
|
|
|
|
|
|
|
Observable.from(tracks)
|
|
|
|
|
.concatMap { track ->
|
|
|
|
|
val service = trackManager.getService(track.sync_id)
|
|
|
|
|
if (service != null && service in loggedServices) {
|
|
|
|
|
service.refresh(track)
|
|
|
|
|
.doOnNext { db.insertTrack(it).executeAsBlocking() }
|
|
|
|
|
.onErrorReturn { track }
|
|
|
|
|
} else {
|
|
|
|
|
Observable.empty()
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
.map { manga }
|
|
|
|
|
}
|
|
|
|
|
.doOnCompleted {
|
|
|
|
|
cancelProgressNotification()
|
|
|
|
|
mangaToUpdate.forEach { manga ->
|
|
|
|
|
showProgressNotification(manga, count++, mangaToUpdate.size)
|
|
|
|
|
|
|
|
|
|
val tracks = db.getTracks(manga).executeAsBlocking()
|
|
|
|
|
|
|
|
|
|
tracks.forEach { track ->
|
|
|
|
|
val service = trackManager.getService(track.sync_id)
|
|
|
|
|
if (service != null && service in loggedServices) {
|
|
|
|
|
try {
|
|
|
|
|
service.refresh(track)
|
|
|
|
|
db.insertTrack(track).executeAsBlocking()
|
|
|
|
|
} catch (e: Exception) {
|
|
|
|
|
Timber.e(e)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
cancelProgressNotification()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
@ -491,10 +523,12 @@ class LibraryUpdateService(
|
|
|
|
|
* @param total the total progress.
|
|
|
|
|
*/
|
|
|
|
|
private fun showProgressNotification(manga: Manga, current: Int, total: Int) {
|
|
|
|
|
notificationManager.notify(Notifications.ID_LIBRARY_PROGRESS, progressNotification
|
|
|
|
|
.setContentTitle(manga.currentTitle())
|
|
|
|
|
notificationManager.notify(
|
|
|
|
|
Notifications.ID_LIBRARY_PROGRESS, progressNotification
|
|
|
|
|
.setContentTitle(manga.title)
|
|
|
|
|
.setProgress(total, current, false)
|
|
|
|
|
.build())
|
|
|
|
|
.build()
|
|
|
|
|
)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
@ -502,11 +536,11 @@ class LibraryUpdateService(
|
|
|
|
|
*
|
|
|
|
|
* @param updates a list of manga with new updates.
|
|
|
|
|
*/
|
|
|
|
|
private fun showResultNotification(updates: List<Pair<Manga, Array<Chapter>>>) {
|
|
|
|
|
private fun showResultNotification(updates: Map<LibraryManga, Array<Chapter>>) {
|
|
|
|
|
val notifications = ArrayList<Pair<Notification, Int>>()
|
|
|
|
|
updates.forEach {
|
|
|
|
|
val manga = it.first
|
|
|
|
|
val chapters = it.second
|
|
|
|
|
val manga = it.key
|
|
|
|
|
val chapters = it.value
|
|
|
|
|
val chapterNames = chapters.map { chapter -> chapter.name }
|
|
|
|
|
notifications.add(Pair(notification(Notifications.CHANNEL_NEW_CHAPTERS) {
|
|
|
|
|
setSmallIcon(R.drawable.ic_tachi)
|
|
|
|
|
@ -515,15 +549,17 @@ class LibraryUpdateService(
|
|
|
|
|
.asBitmap().load(manga).dontTransform().centerCrop().circleCrop()
|
|
|
|
|
.override(256, 256).submit().get()
|
|
|
|
|
setLargeIcon(icon)
|
|
|
|
|
} catch (e: Exception) {
|
|
|
|
|
}
|
|
|
|
|
catch (e: Exception) { }
|
|
|
|
|
setGroupAlertBehavior(GROUP_ALERT_SUMMARY)
|
|
|
|
|
setContentTitle(manga.currentTitle())
|
|
|
|
|
setContentTitle(manga.title)
|
|
|
|
|
color = ContextCompat.getColor(this@LibraryUpdateService, R.color.colorAccent)
|
|
|
|
|
val chaptersNames = if (chapterNames.size > 5) {
|
|
|
|
|
"${chapterNames.take(4).joinToString(", ")}, " +
|
|
|
|
|
resources.getQuantityString(R.plurals.notification_and_n_more,
|
|
|
|
|
(chapterNames.size - 4), (chapterNames.size - 4))
|
|
|
|
|
resources.getQuantityString(
|
|
|
|
|
R.plurals.notification_and_n_more,
|
|
|
|
|
(chapterNames.size - 4), (chapterNames.size - 4)
|
|
|
|
|
)
|
|
|
|
|
} else chapterNames.joinToString(", ")
|
|
|
|
|
setContentText(chaptersNames)
|
|
|
|
|
setStyle(NotificationCompat.BigTextStyle().bigText(chaptersNames))
|
|
|
|
|
@ -534,41 +570,57 @@ class LibraryUpdateService(
|
|
|
|
|
this@LibraryUpdateService, manga, chapters.first()
|
|
|
|
|
)
|
|
|
|
|
)
|
|
|
|
|
addAction(R.drawable.ic_glasses_black_24dp, getString(R.string.action_mark_as_read),
|
|
|
|
|
NotificationReceiver.markAsReadPendingBroadcast(this@LibraryUpdateService,
|
|
|
|
|
manga, chapters, Notifications.ID_NEW_CHAPTERS))
|
|
|
|
|
addAction(R.drawable.ic_book_white_24dp, getString(R.string.action_view_chapters),
|
|
|
|
|
NotificationReceiver.openChapterPendingActivity(this@LibraryUpdateService,
|
|
|
|
|
manga, Notifications.ID_NEW_CHAPTERS))
|
|
|
|
|
addAction(
|
|
|
|
|
R.drawable.ic_glasses_black_24dp, getString(R.string.mark_as_read),
|
|
|
|
|
NotificationReceiver.markAsReadPendingBroadcast(
|
|
|
|
|
this@LibraryUpdateService,
|
|
|
|
|
manga, chapters, Notifications.ID_NEW_CHAPTERS
|
|
|
|
|
)
|
|
|
|
|
)
|
|
|
|
|
addAction(
|
|
|
|
|
R.drawable.ic_book_white_24dp, getString(R.string.view_chapters),
|
|
|
|
|
NotificationReceiver.openChapterPendingActivity(
|
|
|
|
|
this@LibraryUpdateService,
|
|
|
|
|
manga, Notifications.ID_NEW_CHAPTERS
|
|
|
|
|
)
|
|
|
|
|
)
|
|
|
|
|
setAutoCancel(true)
|
|
|
|
|
}, manga.id.hashCode()))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
NotificationManagerCompat.from(this).apply {
|
|
|
|
|
|
|
|
|
|
notify(Notifications.ID_NEW_CHAPTERS, notification(Notifications.CHANNEL_NEW_CHAPTERS) {
|
|
|
|
|
setSmallIcon(R.drawable.ic_tachi)
|
|
|
|
|
setLargeIcon(notificationBitmap)
|
|
|
|
|
setContentTitle(getString(R.string.notification_new_chapters))
|
|
|
|
|
color = ContextCompat.getColor(applicationContext, R.color.colorAccent)
|
|
|
|
|
if (updates.size > 1) {
|
|
|
|
|
setContentText(resources.getQuantityString(R.plurals
|
|
|
|
|
.notification_new_chapters_text,
|
|
|
|
|
updates.size, updates.size))
|
|
|
|
|
setStyle(NotificationCompat.BigTextStyle().bigText(updates.joinToString("\n") {
|
|
|
|
|
it.first.currentTitle().chop(45)
|
|
|
|
|
}))
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
setContentText(updates.first().first.currentTitle().chop(45))
|
|
|
|
|
}
|
|
|
|
|
priority = NotificationCompat.PRIORITY_HIGH
|
|
|
|
|
setGroup(Notifications.GROUP_NEW_CHAPTERS)
|
|
|
|
|
setGroupAlertBehavior(GROUP_ALERT_SUMMARY)
|
|
|
|
|
setGroupSummary(true)
|
|
|
|
|
setContentIntent(getNotificationIntent())
|
|
|
|
|
setAutoCancel(true)
|
|
|
|
|
})
|
|
|
|
|
notify(
|
|
|
|
|
Notifications.ID_NEW_CHAPTERS,
|
|
|
|
|
notification(Notifications.CHANNEL_NEW_CHAPTERS) {
|
|
|
|
|
setSmallIcon(R.drawable.ic_tachi)
|
|
|
|
|
setLargeIcon(notificationBitmap)
|
|
|
|
|
setContentTitle(getString(R.string.new_chapters_found))
|
|
|
|
|
color = ContextCompat.getColor(applicationContext, R.color.colorAccent)
|
|
|
|
|
if (updates.size > 1) {
|
|
|
|
|
setContentText(
|
|
|
|
|
resources.getQuantityString(
|
|
|
|
|
R.plurals
|
|
|
|
|
.for_n_titles,
|
|
|
|
|
updates.size, updates.size
|
|
|
|
|
)
|
|
|
|
|
)
|
|
|
|
|
setStyle(
|
|
|
|
|
NotificationCompat.BigTextStyle()
|
|
|
|
|
.bigText(updates.keys.joinToString("\n") {
|
|
|
|
|
it.title.chop(45)
|
|
|
|
|
})
|
|
|
|
|
)
|
|
|
|
|
} else {
|
|
|
|
|
setContentText(updates.keys.first().title.chop(45))
|
|
|
|
|
}
|
|
|
|
|
priority = NotificationCompat.PRIORITY_HIGH
|
|
|
|
|
setGroup(Notifications.GROUP_NEW_CHAPTERS)
|
|
|
|
|
setGroupAlertBehavior(GROUP_ALERT_SUMMARY)
|
|
|
|
|
setGroupSummary(true)
|
|
|
|
|
setContentIntent(getNotificationIntent())
|
|
|
|
|
setAutoCancel(true)
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
notifications.forEach {
|
|
|
|
|
notify(it.second, it.first)
|
|
|
|
|
@ -592,5 +644,8 @@ class LibraryUpdateService(
|
|
|
|
|
intent.action = MainActivity.SHORTCUT_RECENTLY_UPDATED
|
|
|
|
|
return PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
interface LibraryServiceListener {
|
|
|
|
|
fun onUpdateManga(manga: LibraryManga)
|
|
|
|
|
}
|
|
|
|
|
|
Jays2Kings
5 years ago
committed by