mirror of
https://github.com/tachiyomiorg/tachiyomi-extensions-inspector.git
synced 2025-01-12 16:59:08 +01:00
Remove unused code
This commit is contained in:
arkon
parent
4647bc12c7
commit
3883b1d254
@ -22,18 +22,9 @@ open class App : Application() {
|
||||
super.onCreate()
|
||||
Injekt = InjektScope(DefaultRegistrar())
|
||||
Injekt.importModule(AppModule(this))
|
||||
|
||||
// if (BuildConfig.DEBUG) Timber.plant(Timber.DebugTree())
|
||||
}
|
||||
|
||||
override fun attachBaseContext(base: Context) {
|
||||
super.attachBaseContext(base)
|
||||
// if (BuildConfig.DEBUG) {
|
||||
// MultiDex.install(this)
|
||||
// }
|
||||
}
|
||||
|
||||
// override fun onConfigurationChanged(newConfig: Configuration) {
|
||||
// super.onConfigurationChanged(newConfig)
|
||||
// }
|
||||
}
|
||||
|
||||
@ -33,42 +33,14 @@ class AppModule(val app: Application) : InjektModule {
|
||||
|
||||
addSingleton(app)
|
||||
|
||||
// addSingletonFactory { PreferencesHelper(app) }
|
||||
//
|
||||
// addSingletonFactory { DatabaseHelper(app) }
|
||||
//
|
||||
// addSingletonFactory { ChapterCache(app) }
|
||||
//
|
||||
// addSingletonFactory { CoverCache(app) }
|
||||
|
||||
addSingletonFactory { NetworkHelper(app) }
|
||||
|
||||
// addSingletonFactory { SourceManager(app).also { get<ExtensionManager>().init(it) } }
|
||||
//
|
||||
// addSingletonFactory { ExtensionManager(app) }
|
||||
//
|
||||
// addSingletonFactory { DownloadManager(app) }
|
||||
//
|
||||
// addSingletonFactory { TrackManager(app) }
|
||||
//
|
||||
// addSingletonFactory { LibrarySyncManager(app) }
|
||||
|
||||
addSingletonFactory { Gson() }
|
||||
|
||||
addSingletonFactory { Json { ignoreUnknownKeys = true } }
|
||||
|
||||
// Asynchronously init expensive components for a faster cold start
|
||||
|
||||
// rxAsync { get<PreferencesHelper>() }
|
||||
|
||||
rxAsync { get<NetworkHelper>() }
|
||||
|
||||
rxAsync {
|
||||
// get<SourceManager>()
|
||||
// get<DownloadManager>()
|
||||
}
|
||||
|
||||
// rxAsync { get<DatabaseHelper>() }
|
||||
}
|
||||
|
||||
private fun rxAsync(block: () -> Unit) {
|
||||
|
||||
@ -7,171 +7,14 @@ package eu.kanade.tachiyomi.network
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
||||
|
||||
// import android.annotation.SuppressLint
|
||||
// import android.content.Context
|
||||
// import android.os.Build
|
||||
// import android.os.Handler
|
||||
// import android.os.Looper
|
||||
// import android.webkit.WebSettings
|
||||
// import android.webkit.WebView
|
||||
// import android.widget.Toast
|
||||
// import eu.kanade.tachiyomi.R
|
||||
// import eu.kanade.tachiyomi.util.lang.launchUI
|
||||
// import eu.kanade.tachiyomi.util.system.WebViewClientCompat
|
||||
// import eu.kanade.tachiyomi.util.system.WebViewUtil
|
||||
// import eu.kanade.tachiyomi.util.system.isOutdated
|
||||
// import eu.kanade.tachiyomi.util.system.setDefaultSettings
|
||||
// import eu.kanade.tachiyomi.util.system.toast
|
||||
import okhttp3.Interceptor
|
||||
import okhttp3.Response
|
||||
// import uy.kohesive.injekt.injectLazy
|
||||
|
||||
class CloudflareInterceptor() : Interceptor {
|
||||
|
||||
// private val handler = Handler(Looper.getMainLooper())
|
||||
|
||||
// private val networkHelper = NetworkHelper()
|
||||
|
||||
/**
|
||||
* When this is called, it initializes the WebView if it wasn't already. We use this to avoid
|
||||
* blocking the main thread too much. If used too often we could consider moving it to the
|
||||
* Application class.
|
||||
*/
|
||||
// private val initWebView by lazy {
|
||||
// WebSettings.getDefaultUserAgent(context)
|
||||
// }
|
||||
|
||||
@Synchronized
|
||||
override fun intercept(chain: Interceptor.Chain): Response {
|
||||
val originalRequest = chain.request()
|
||||
return chain.proceed(originalRequest)
|
||||
|
||||
// if (!WebViewUtil.supportsWebView(context)) {
|
||||
// launchUI {
|
||||
// context.toast(R.string.information_webview_required, Toast.LENGTH_LONG)
|
||||
// }
|
||||
// return chain.proceed(originalRequest)
|
||||
// }
|
||||
//
|
||||
// initWebView
|
||||
//
|
||||
// val response = chain.proceed(originalRequest)
|
||||
//
|
||||
// // Check if Cloudflare anti-bot is on
|
||||
// if (response.code != 503 || response.header("Server") !in SERVER_CHECK) {
|
||||
// return response
|
||||
// }
|
||||
//
|
||||
// try {
|
||||
// response.close()
|
||||
// networkHelper.cookieManager.remove(originalRequest.url, COOKIE_NAMES, 0)
|
||||
// val oldCookie = networkHelper.cookieManager.get(originalRequest.url)
|
||||
// .firstOrNull { it.name == "cf_clearance" }
|
||||
// resolveWithWebView(originalRequest, oldCookie)
|
||||
//
|
||||
// return chain.proceed(originalRequest)
|
||||
// } catch (e: Exception) {
|
||||
// // Because OkHttp's enqueue only handles IOExceptions, wrap the exception so that
|
||||
// // we don't crash the entire app
|
||||
// throw IOException(e)
|
||||
// }
|
||||
}
|
||||
//
|
||||
// // @SuppressLint("SetJavaScriptEnabled")
|
||||
// private fun resolveWithWebView(request: Request, oldCookie: Cookie?) {
|
||||
// // We need to lock this thread until the WebView finds the challenge solution url, because
|
||||
// // OkHttp doesn't support asynchronous interceptors.
|
||||
// val latch = CountDownLatch(1)
|
||||
//
|
||||
// var webView: WebView? = null
|
||||
//
|
||||
// var challengeFound = false
|
||||
// var cloudflareBypassed = false
|
||||
// var isWebViewOutdated = false
|
||||
//
|
||||
// val origRequestUrl = request.url.toString()
|
||||
// val headers = request.headers.toMultimap().mapValues { it.value.getOrNull(0) ?: "" }.toMutableMap()
|
||||
// headers["X-Requested-With"] = WebViewUtil.REQUESTED_WITH
|
||||
//
|
||||
// handler.post {
|
||||
// val webview = WebView(context)
|
||||
// webView = webview
|
||||
// webview.setDefaultSettings()
|
||||
//
|
||||
// // Avoid sending empty User-Agent, Chromium WebView will reset to default if empty
|
||||
// webview.settings.userAgentString = request.header("User-Agent")
|
||||
// ?: HttpSource.DEFAULT_USERAGENT
|
||||
//
|
||||
// webview.webViewClient = object : WebViewClientCompat() {
|
||||
// override fun onPageFinished(view: WebView, url: String) {
|
||||
// fun isCloudFlareBypassed(): Boolean {
|
||||
// return networkHelper.cookieManager.get(origRequestUrl.toHttpUrl())
|
||||
// .firstOrNull { it.name == "cf_clearance" }
|
||||
// .let { it != null && it != oldCookie }
|
||||
// }
|
||||
//
|
||||
// if (isCloudFlareBypassed()) {
|
||||
// cloudflareBypassed = true
|
||||
// latch.countDown()
|
||||
// }
|
||||
//
|
||||
// // HTTP error codes are only received since M
|
||||
// if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M &&
|
||||
// url == origRequestUrl && !challengeFound
|
||||
// ) {
|
||||
// // The first request didn't return the challenge, abort.
|
||||
// latch.countDown()
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// override fun onReceivedErrorCompat(
|
||||
// view: WebView,
|
||||
// errorCode: Int,
|
||||
// description: String?,
|
||||
// failingUrl: String,
|
||||
// isMainFrame: Boolean
|
||||
// ) {
|
||||
// if (isMainFrame) {
|
||||
// if (errorCode == 503) {
|
||||
// // Found the Cloudflare challenge page.
|
||||
// challengeFound = true
|
||||
// } else {
|
||||
// // Unlock thread, the challenge wasn't found.
|
||||
// latch.countDown()
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// webView?.loadUrl(origRequestUrl, headers)
|
||||
// }
|
||||
//
|
||||
// // Wait a reasonable amount of time to retrieve the solution. The minimum should be
|
||||
// // around 4 seconds but it can take more due to slow networks or server issues.
|
||||
// latch.await(12, TimeUnit.SECONDS)
|
||||
//
|
||||
// handler.post {
|
||||
// if (!cloudflareBypassed) {
|
||||
// isWebViewOutdated = webView?.isOutdated() == true
|
||||
// }
|
||||
//
|
||||
// webView?.stopLoading()
|
||||
// webView?.destroy()
|
||||
// }
|
||||
//
|
||||
// // Throw exception if we failed to bypass Cloudflare
|
||||
// if (!cloudflareBypassed) {
|
||||
// // Prompt user to update WebView if it seems too outdated
|
||||
// if (isWebViewOutdated) {
|
||||
// context.toast(R.string.information_webview_outdated, Toast.LENGTH_LONG)
|
||||
// }
|
||||
//
|
||||
// throw Exception(context.getString(R.string.information_cloudflare_bypass_failure))
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// companion object {
|
||||
// private val SERVER_CHECK = arrayOf("cloudflare-nginx", "cloudflare")
|
||||
// private val COOKIE_NAMES = listOf("__cfduid", "cf_clearance")
|
||||
// }
|
||||
}
|
||||
|
||||
@ -7,9 +7,6 @@ package eu.kanade.tachiyomi.network
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
||||
|
||||
// import android.content.Context
|
||||
// import eu.kanade.tachiyomi.BuildConfig
|
||||
// import eu.kanade.tachiyomi.data.preference.PreferencesHelper
|
||||
import android.content.Context
|
||||
// import okhttp3.HttpUrl.Companion.toHttpUrl
|
||||
import okhttp3.OkHttpClient
|
||||
@ -20,53 +17,14 @@ import java.util.concurrent.TimeUnit
|
||||
|
||||
class NetworkHelper(context: Context) {
|
||||
|
||||
// private val preferences: PreferencesHelper by injectLazy()
|
||||
|
||||
// private val cacheDir = File(context.cacheDir, "network_cache")
|
||||
|
||||
private val cacheSize = 5L * 1024 * 1024 // 5 MiB
|
||||
|
||||
val cookieManager = MemoryCookieJar()
|
||||
|
||||
val client by lazy {
|
||||
val builder = OkHttpClient.Builder()
|
||||
.cookieJar(cookieManager)
|
||||
// .cache(Cache(cacheDir, cacheSize))
|
||||
.connectTimeout(30, TimeUnit.SECONDS)
|
||||
.readTimeout(5, TimeUnit.MINUTES)
|
||||
.writeTimeout(5, TimeUnit.MINUTES)
|
||||
// .dispatcher(Dispatcher(Executors.newFixedThreadPool(1)))
|
||||
|
||||
// .addInterceptor(UserAgentInterceptor())
|
||||
|
||||
// if (BuildConfig.DEBUG) {
|
||||
// val httpLoggingInterceptor = HttpLoggingInterceptor().apply {
|
||||
// level = HttpLoggingInterceptor.Level.HEADERS
|
||||
// }
|
||||
// builder.addInterceptor(httpLoggingInterceptor)
|
||||
// }
|
||||
|
||||
// if (preferences.enableDoh()) {
|
||||
// builder.dns(
|
||||
// DnsOverHttps.Builder().client(builder.build())
|
||||
// .url("https://cloudflare-dns.com/dns-query".toHttpUrl())
|
||||
// .bootstrapDnsHosts(
|
||||
// listOf(
|
||||
// InetAddress.getByName("162.159.36.1"),
|
||||
// InetAddress.getByName("162.159.46.1"),
|
||||
// InetAddress.getByName("1.1.1.1"),
|
||||
// InetAddress.getByName("1.0.0.1"),
|
||||
// InetAddress.getByName("162.159.132.53"),
|
||||
// InetAddress.getByName("2606:4700:4700::1111"),
|
||||
// InetAddress.getByName("2606:4700:4700::1001"),
|
||||
// InetAddress.getByName("2606:4700:4700::0064"),
|
||||
// InetAddress.getByName("2606:4700:4700::6400")
|
||||
// )
|
||||
// )
|
||||
// .build()
|
||||
// )
|
||||
// }
|
||||
|
||||
builder.build()
|
||||
}
|
||||
|
||||
|
||||
@ -1,6 +1,5 @@
|
||||
package eu.kanade.tachiyomi.network
|
||||
|
||||
// import kotlinx.coroutines.suspendCancellableCoroutine
|
||||
import okhttp3.Call
|
||||
import okhttp3.OkHttpClient
|
||||
import okhttp3.Request
|
||||
@ -47,38 +46,6 @@ fun Call.asObservable(): Observable<Response> {
|
||||
}
|
||||
}
|
||||
|
||||
// Based on https://github.com/gildor/kotlin-coroutines-okhttp
|
||||
// suspend fun Call.await(assertSuccess: Boolean = false): Response {
|
||||
// return suspendCancellableCoroutine { continuation ->
|
||||
// enqueue(
|
||||
// object : Callback {
|
||||
// override fun onResponse(call: Call, response: Response) {
|
||||
// if (assertSuccess && !response.isSuccessful) {
|
||||
// continuation.resumeWithException(Exception("HTTP error ${response.code}"))
|
||||
// return
|
||||
// }
|
||||
//
|
||||
// continuation.resume(response)
|
||||
// }
|
||||
//
|
||||
// override fun onFailure(call: Call, e: IOException) {
|
||||
// // Don't bother with resuming the continuation if it is already cancelled.
|
||||
// if (continuation.isCancelled) return
|
||||
// continuation.resumeWithException(e)
|
||||
// }
|
||||
// }
|
||||
// )
|
||||
//
|
||||
// continuation.invokeOnCancellation {
|
||||
// try {
|
||||
// cancel()
|
||||
// } catch (ex: Throwable) {
|
||||
// // Ignore cancel exception
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
|
||||
fun Call.asObservableSuccess(): Observable<Response> {
|
||||
return asObservable()
|
||||
.doOnNext { response ->
|
||||
@ -89,29 +56,8 @@ fun Call.asObservableSuccess(): Observable<Response> {
|
||||
}
|
||||
}
|
||||
|
||||
// fun OkHttpClient.newCallWithProgress(request: Request, listener: ProgressListener): Call {
|
||||
// val progressClient = newBuilder()
|
||||
// .cache(nasObservableSuccessull)
|
||||
// .addNetworkInterceptor { chain ->
|
||||
// val originalResponse = chain.proceed(chain.request())
|
||||
// originalResponse.newBuilder()
|
||||
// .body(ProgressResponseBody(originalResponse.body!!, listener))
|
||||
// .build()
|
||||
// }
|
||||
// .build()
|
||||
//
|
||||
// return progressClient.newCall(request)
|
||||
// }
|
||||
|
||||
fun OkHttpClient.newCallWithProgress(request: Request, listener: ProgressListener): Call {
|
||||
val progressClient = newBuilder()
|
||||
// .cache(null)
|
||||
// .addNetworkInterceptor { chain ->
|
||||
// val originalResponse = chain.proceed(chain.request())
|
||||
// originalResponse.newBuilder()
|
||||
// .body(ProgressResponseBody(originalResponse.body!!, listener))
|
||||
// .build()
|
||||
// }
|
||||
.build()
|
||||
|
||||
return progressClient.newCall(request)
|
||||
|
||||
@ -8,63 +8,9 @@ import eu.kanade.tachiyomi.source.model.SChapter
|
||||
import eu.kanade.tachiyomi.source.model.SManga
|
||||
import rx.Observable
|
||||
|
||||
// import com.github.junrar.Archive
|
||||
// import com.google.gson.JsonParser
|
||||
// import eu.kanade.tachiyomi.R
|
||||
// import eu.kanade.tachiyomi.source.model.Filter
|
||||
// import eu.kanade.tachiyomi.source.model.FilterList
|
||||
// import eu.kanade.tachiyomi.source.model.MangasPage
|
||||
// import eu.kanade.tachiyomi.source.model.Page
|
||||
// import eu.kanade.tachiyomi.source.model.SChapter
|
||||
// import eu.kanade.tachiyomi.source.model.SManga
|
||||
// import eu.kanade.tachiyomi.util.chapter.ChapterRecognition
|
||||
// import eu.kanade.tachiyomi.util.lang.compareToCaseInsensitiveNaturalOrder
|
||||
// import eu.kanade.tachiyomi.util.storage.DiskUtil
|
||||
// import eu.kanade.tachiyomi.util.storage.EpubFile
|
||||
// import eu.kanade.tachiyomi.util.system.ImageUtil
|
||||
// import rx.Observable
|
||||
// import timber.log.Timber
|
||||
// import java.io.File
|
||||
// import java.io.FileInputStream
|
||||
// import java.io.InputStream
|
||||
// import java.util.Locale
|
||||
// import java.util.concurrent.TimeUnit
|
||||
// import java.util.zip.ZipFile
|
||||
|
||||
class LocalSource(private val context: Context) : CatalogueSource {
|
||||
companion object {
|
||||
const val ID = 0L
|
||||
// const val HELP_URL = "https://tachiyomi.org/help/guides/reading-local-manga/"
|
||||
//
|
||||
// private const val COVER_NAME = "cover.jpg"
|
||||
// private val SUPPORTED_ARCHIVE_TYPES = setOf("zip", "rar", "cbr", "cbz", "epub")
|
||||
//
|
||||
// private val POPULAR_FILTERS = FilterList(OrderBy())
|
||||
// private val LATEST_FILTERS = FilterList(OrderBy().apply { state = Filter.Sort.Selection(1, false) })
|
||||
// private val LATEST_THRESHOLD = TimeUnit.MILLISECONDS.convert(7, TimeUnit.DAYS)
|
||||
//
|
||||
// fun updateCover(context: Context, manga: SManga, input: InputStream): File? {
|
||||
// val dir = getBaseDirectories(context).firstOrNull()
|
||||
// if (dir == null) {
|
||||
// input.close()
|
||||
// return null
|
||||
// }
|
||||
// val cover = File("${dir.absolutePath}/${manga.url}", COVER_NAME)
|
||||
//
|
||||
// // It might not exist if using the external SD card
|
||||
// cover.parentFile?.mkdirs()
|
||||
// input.use {
|
||||
// cover.outputStream().use {
|
||||
// input.copyTo(it)
|
||||
// }
|
||||
// }
|
||||
// return cover
|
||||
// }
|
||||
//
|
||||
// private fun getBaseDirectories(context: Context): List<File> {
|
||||
// val c = context.getString(R.string.app_name) + File.separator + "local"
|
||||
// return DiskUtil.getExternalStorages(context).map { File(it.absolutePath, c) }
|
||||
// }
|
||||
}
|
||||
|
||||
override val id = ID
|
||||
@ -98,261 +44,4 @@ class LocalSource(private val context: Context) : CatalogueSource {
|
||||
override fun getFilterList(): FilterList {
|
||||
TODO("Not yet implemented")
|
||||
}
|
||||
//
|
||||
// override fun toString() = context.getString(R.string.local_source)
|
||||
//
|
||||
// override fun fetchPopularManga(page: Int) = fetchSearchManga(page, "", POPULAR_FILTERS)
|
||||
//
|
||||
// override fun fetchSearchManga(page: Int, query: String, filters: FilterList): Observable<MangasPage> {
|
||||
// val baseDirs = getBaseDirectories(context)
|
||||
//
|
||||
// val time = if (filters === LATEST_FILTERS) System.currentTimeMillis() - LATEST_THRESHOLD else 0L
|
||||
// var mangaDirs = baseDirs
|
||||
// .asSequence()
|
||||
// .mapNotNull { it.listFiles()?.toList() }
|
||||
// .flatten()
|
||||
// .filter { it.isDirectory }
|
||||
// .filterNot { it.name.startsWith('.') }
|
||||
// .filter { if (time == 0L) it.name.contains(query, ignoreCase = true) else it.lastModified() >= time }
|
||||
// .distinctBy { it.name }
|
||||
//
|
||||
// val state = ((if (filters.isEmpty()) POPULAR_FILTERS else filters)[0] as OrderBy).state
|
||||
// when (state?.index) {
|
||||
// 0 -> {
|
||||
// mangaDirs = if (state.ascending) {
|
||||
// mangaDirs.sortedBy { it.name.toLowerCase(Locale.ENGLISH) }
|
||||
// } else {
|
||||
// mangaDirs.sortedByDescending { it.name.toLowerCase(Locale.ENGLISH) }
|
||||
// }
|
||||
// }
|
||||
// 1 -> {
|
||||
// mangaDirs = if (state.ascending) {
|
||||
// mangaDirs.sortedBy(File::lastModified)
|
||||
// } else {
|
||||
// mangaDirs.sortedByDescending(File::lastModified)
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// val mangas = mangaDirs.map { mangaDir ->
|
||||
// SManga.create().apply {
|
||||
// title = mangaDir.name
|
||||
// url = mangaDir.name
|
||||
//
|
||||
// // Try to find the cover
|
||||
// for (dir in baseDirs) {
|
||||
// val cover = File("${dir.absolutePath}/$url", COVER_NAME)
|
||||
// if (cover.exists()) {
|
||||
// thumbnail_url = cover.absolutePath
|
||||
// break
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// val chapters = fetchChapterList(this).toBlocking().first()
|
||||
// if (chapters.isNotEmpty()) {
|
||||
// val chapter = chapters.last()
|
||||
// val format = getFormat(chapter)
|
||||
// if (format is Format.Epub) {
|
||||
// EpubFile(format.file).use { epub ->
|
||||
// epub.fillMangaMetadata(this)
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// // Copy the cover from the first chapter found.
|
||||
// if (thumbnail_url == null) {
|
||||
// try {
|
||||
// val dest = updateCover(chapter, this)
|
||||
// thumbnail_url = dest?.absolutePath
|
||||
// } catch (e: Exception) {
|
||||
// Timber.e(e)
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// return Observable.just(MangasPage(mangas.toList(), false))
|
||||
// }
|
||||
//
|
||||
// override fun fetchLatestUpdates(page: Int) = fetchSearchManga(page, "", LATEST_FILTERS)
|
||||
//
|
||||
// override fun fetchMangaDetails(manga: SManga): Observable<SManga> {
|
||||
// getBaseDirectories(context)
|
||||
// .asSequence()
|
||||
// .mapNotNull { File(it, manga.url).listFiles()?.toList() }
|
||||
// .flatten()
|
||||
// .firstOrNull { it.extension == "json" }
|
||||
// ?.apply {
|
||||
// val reader = this.inputStream().bufferedReader()
|
||||
// val json = JsonParser.parseReader(reader).asJsonObject
|
||||
//
|
||||
// manga.title = json["title"]?.asString ?: manga.title
|
||||
// manga.author = json["author"]?.asString ?: manga.author
|
||||
// manga.artist = json["artist"]?.asString ?: manga.artist
|
||||
// manga.description = json["description"]?.asString ?: manga.description
|
||||
// manga.genre = json["genre"]?.asJsonArray?.joinToString(", ") { it.asString }
|
||||
// ?: manga.genre
|
||||
// manga.status = json["status"]?.asInt ?: manga.status
|
||||
// }
|
||||
//
|
||||
// return Observable.just(manga)
|
||||
// }
|
||||
//
|
||||
// override fun fetchChapterList(manga: SManga): Observable<List<SChapter>> {
|
||||
// val chapters = getBaseDirectories(context)
|
||||
// .asSequence()
|
||||
// .mapNotNull { File(it, manga.url).listFiles()?.toList() }
|
||||
// .flatten()
|
||||
// .filter { it.isDirectory || isSupportedFile(it.extension) }
|
||||
// .map { chapterFile ->
|
||||
// SChapter.create().apply {
|
||||
// url = "${manga.url}/${chapterFile.name}"
|
||||
// name = if (chapterFile.isDirectory) {
|
||||
// chapterFile.name
|
||||
// } else {
|
||||
// chapterFile.nameWithoutExtension
|
||||
// }
|
||||
// date_upload = chapterFile.lastModified()
|
||||
//
|
||||
// val format = getFormat(this)
|
||||
// if (format is Format.Epub) {
|
||||
// EpubFile(format.file).use { epub ->
|
||||
// epub.fillChapterMetadata(this)
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// val chapNameCut = stripMangaTitle(name, manga.title)
|
||||
// if (chapNameCut.isNotEmpty()) name = chapNameCut
|
||||
// ChapterRecognition.parseChapterNumber(this, manga)
|
||||
// }
|
||||
// }
|
||||
// .sortedWith(
|
||||
// Comparator { c1, c2 ->
|
||||
// val c = c2.chapter_number.compareTo(c1.chapter_number)
|
||||
// if (c == 0) c2.name.compareToCaseInsensitiveNaturalOrder(c1.name) else c
|
||||
// }
|
||||
// )
|
||||
// .toList()
|
||||
//
|
||||
// return Observable.just(chapters)
|
||||
// }
|
||||
//
|
||||
// /**
|
||||
// * Strips the manga title from a chapter name, matching only based on alphanumeric and whitespace
|
||||
// * characters.
|
||||
// */
|
||||
// private fun stripMangaTitle(chapterName: String, mangaTitle: String): String {
|
||||
// var chapterNameIndex = 0
|
||||
// var mangaTitleIndex = 0
|
||||
// while (chapterNameIndex < chapterName.length && mangaTitleIndex < mangaTitle.length) {
|
||||
// val chapterChar = chapterName[chapterNameIndex]
|
||||
// val mangaChar = mangaTitle[mangaTitleIndex]
|
||||
// if (!chapterChar.equals(mangaChar, true)) {
|
||||
// val invalidChapterChar = !chapterChar.isLetterOrDigit() && !chapterChar.isWhitespace()
|
||||
// val invalidMangaChar = !mangaChar.isLetterOrDigit() && !mangaChar.isWhitespace()
|
||||
//
|
||||
// if (!invalidChapterChar && !invalidMangaChar) {
|
||||
// return chapterName
|
||||
// }
|
||||
//
|
||||
// if (invalidChapterChar) {
|
||||
// chapterNameIndex++
|
||||
// }
|
||||
//
|
||||
// if (invalidMangaChar) {
|
||||
// mangaTitleIndex++
|
||||
// }
|
||||
// } else {
|
||||
// chapterNameIndex++
|
||||
// mangaTitleIndex++
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// return chapterName.substring(chapterNameIndex).trimStart(' ', '-', '_', ',', ':')
|
||||
// }
|
||||
//
|
||||
// override fun fetchPageList(chapter: SChapter): Observable<List<Page>> {
|
||||
// return Observable.error(Exception("Unused"))
|
||||
// }
|
||||
//
|
||||
// private fun isSupportedFile(extension: String): Boolean {
|
||||
// return extension.toLowerCase() in SUPPORTED_ARCHIVE_TYPES
|
||||
// }
|
||||
//
|
||||
// fun getFormat(chapter: SChapter): Format {
|
||||
// val baseDirs = getBaseDirectories(context)
|
||||
//
|
||||
// for (dir in baseDirs) {
|
||||
// val chapFile = File(dir, chapter.url)
|
||||
// if (!chapFile.exists()) continue
|
||||
//
|
||||
// return getFormat(chapFile)
|
||||
// }
|
||||
// throw Exception("Chapter not found")
|
||||
// }
|
||||
//
|
||||
// private fun getFormat(file: File): Format {
|
||||
// val extension = file.extension
|
||||
// return if (file.isDirectory) {
|
||||
// Format.Directory(file)
|
||||
// } else if (extension.equals("zip", true) || extension.equals("cbz", true)) {
|
||||
// Format.Zip(file)
|
||||
// } else if (extension.equals("rar", true) || extension.equals("cbr", true)) {
|
||||
// Format.Rar(file)
|
||||
// } else if (extension.equals("epub", true)) {
|
||||
// Format.Epub(file)
|
||||
// } else {
|
||||
// throw Exception("Invalid chapter format")
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// private fun updateCover(chapter: SChapter, manga: SManga): File? {
|
||||
// return when (val format = getFormat(chapter)) {
|
||||
// is Format.Directory -> {
|
||||
// val entry = format.file.listFiles()
|
||||
// ?.sortedWith { f1, f2 -> f1.name.compareToCaseInsensitiveNaturalOrder(f2.name) }
|
||||
// ?.find { !it.isDirectory && ImageUtil.isImage(it.name) { FileInputStream(it) } }
|
||||
//
|
||||
// entry?.let { updateCover(context, manga, it.inputStream()) }
|
||||
// }
|
||||
// is Format.Zip -> {
|
||||
// ZipFile(format.file).use { zip ->
|
||||
// val entry = zip.entries().toList()
|
||||
// .sortedWith { f1, f2 -> f1.name.compareToCaseInsensitiveNaturalOrder(f2.name) }
|
||||
// .find { !it.isDirectory && ImageUtil.isImage(it.name) { zip.getInputStream(it) } }
|
||||
//
|
||||
// entry?.let { updateCover(context, manga, zip.getInputStream(it)) }
|
||||
// }
|
||||
// }
|
||||
// is Format.Rar -> {
|
||||
// Archive(format.file).use { archive ->
|
||||
// val entry = archive.fileHeaders
|
||||
// .sortedWith { f1, f2 -> f1.fileName.compareToCaseInsensitiveNaturalOrder(f2.fileName) }
|
||||
// .find { !it.isDirectory && ImageUtil.isImage(it.fileName) { archive.getInputStream(it) } }
|
||||
//
|
||||
// entry?.let { updateCover(context, manga, archive.getInputStream(it)) }
|
||||
// }
|
||||
// }
|
||||
// is Format.Epub -> {
|
||||
// EpubFile(format.file).use { epub ->
|
||||
// val entry = epub.getImagesFromPages()
|
||||
// .firstOrNull()
|
||||
// ?.let { epub.getEntry(it) }
|
||||
//
|
||||
// entry?.let { updateCover(context, manga, epub.getInputStream(it)) }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// private class OrderBy : Filter.Sort("Order by", arrayOf("Title", "Date"), Selection(0, true))
|
||||
//
|
||||
// override fun getFilterList() = FilterList(OrderBy())
|
||||
//
|
||||
// sealed class Format {
|
||||
// data class Directory(val file: File) : Format()
|
||||
// data class Zip(val file: File) : Format()
|
||||
// data class Rar(val file: File) : Format()
|
||||
// data class Epub(val file: File) : Format()
|
||||
// }
|
||||
}
|
||||
|
||||
@ -41,7 +41,3 @@ interface Source {
|
||||
*/
|
||||
fun fetchPageList(chapter: SChapter): Observable<List<Page>>
|
||||
}
|
||||
|
||||
// fun Source.icon(): Drawable? = Injekt.get<ExtensionManager>().getAppIconForSource(this)
|
||||
|
||||
// fun Source.getPreferenceKey(): String = "source_$id"
|
||||
|
||||
@ -70,7 +70,6 @@ open class SourceManager(private val context: Context) {
|
||||
}
|
||||
|
||||
private fun getSourceNotInstalledException(): Exception {
|
||||
// return Exception(context.getString(R.string.source_not_installed, id.toString()))
|
||||
return Exception("source not found")
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user