Merge branch 'rebelonion:dev' into dev

.github/workflows/beta.yml

@@ -77,25 +77,20 @@ jobs:
   
     - name: List files in the directory
       run: ls -l
-  
+      
     - name: Make gradlew executable
       run: chmod +x ./gradlew
   
     - name: Build with Gradle
       run: ./gradlew assembleGoogleAlpha -Pandroid.injected.signing.store.file=$GITHUB_WORKSPACE/key.keystore -Pandroid.injected.signing.store.password=${{ secrets.KEYSTORE_PASSWORD }} -Pandroid.injected.signing.key.alias=${{ secrets.KEY_ALIAS }} -Pandroid.injected.signing.key.password=${{ secrets.KEY_PASSWORD }}
 
-    - name: Upload Build Artifacts
-      uses: actions/upload-artifact@v4.3.1
+    - name: Upload a Build Artifact
+      uses: actions/upload-artifact@v4
       with:
-          name: Dantotsu-Split
+          name: Dantotsu
           retention-days: 5
           compression-level: 9
-          path: | 
-            app/build/outputs/apk/google/alpha/app-google-universal-alpha.apk
-            app/build/outputs/apk/google/alpha/app-google-armeabi-v7a-alpha.apk
-            app/build/outputs/apk/google/alpha/app-google-arm64-v8a-alpha.apk
-            app/build/outputs/apk/google/alpha/app-google-x86-alpha.apk
-            app/build/outputs/apk/google/alpha/app-google-x86_64-alpha.apk
+          path: "app/build/outputs/apk/google/alpha/app-google-alpha.apk"
             
     - name: Upload APK to Discord and Telegram
       if: ${{ github.repository == 'rebelonion/Dantotsu' }}
@@ -109,31 +104,12 @@ jobs:
           commit_messages="${commit_messages:0:$max_length}... (truncated)"
         fi
         contentbody=$( jq -nc --arg msg "Alpha-Build: <@&1225347048321191996> **$VERSION**:" --arg commits "$commit_messages" '{"content": ($msg + "\n" + $commits)}' )
-        curl -F "payload_json=${contentbody}" -F "dantotsu_debug=@app/build/outputs/apk/google/alpha/app-google-universal-alpha.apk" ${{ secrets.DISCORD_WEBHOOK }}
-        curl -F "dantotsu_debug=@app/build/outputs/apk/google/alpha/app-google-armeabi-v7a-alpha.apk" ${{ secrets.DISCORD_WEBHOOK }}
-        curl -F "dantotsu_debug=@app/build/outputs/apk/google/alpha/app-google-arm64-v8a-alpha.apk" ${{ secrets.DISCORD_WEBHOOK }}
-        curl -F "dantotsu_debug=@app/build/outputs/apk/google/alpha/app-google-x86-alpha.apk" ${{ secrets.DISCORD_WEBHOOK }}
-        curl -F "dantotsu_debug=@app/build/outputs/apk/google/alpha/app-google-x86_64-alpha.apk" ${{ secrets.DISCORD_WEBHOOK }}
-     
+        curl -F "payload_json=${contentbody}" -F "dantotsu_debug=@app/build/outputs/apk/google/alpha/app-google-alpha.apk" ${{ secrets.DISCORD_WEBHOOK }}
+        
         #Telegram
-        curl -X POST \
-          -d chat_id=${{ secrets.TELEGRAM_CHANNEL_ID }} \
-          -d text="Alpha-Build: ${VERSION}: ${commit_messages}" \
-          https://api.telegram.org/bot${{ secrets.TELEGRAM_BOT_TOKEN }}/sendMessage
         curl -F "chat_id=${{ secrets.TELEGRAM_CHANNEL_ID }}" \
-          -F "document=@app/build/outputs/apk/google/alpha/app-google-armeabi-v7a-alpha.apk" \
-          https://api.telegram.org/bot${{ secrets.TELEGRAM_BOT_TOKEN }}/sendDocument
-        curl -F "chat_id=${{ secrets.TELEGRAM_CHANNEL_ID }}" \
-          -F "document=@app/build/outputs/apk/google/alpha/app-google-arm64-v8a-alpha.apk" \
-          https://api.telegram.org/bot${{ secrets.TELEGRAM_BOT_TOKEN }}/sendDocument
-        curl -F "chat_id=${{ secrets.TELEGRAM_CHANNEL_ID }}" \
-          -F "document=@app/build/outputs/apk/google/alpha/app-google-x86-alpha.apk" \
-          https://api.telegram.org/bot${{ secrets.TELEGRAM_BOT_TOKEN }}/sendDocument
-        curl -F "chat_id=${{ secrets.TELEGRAM_CHANNEL_ID }}" \
-          -F "document=@app/build/outputs/apk/google/alpha/app-google-x86_64-alpha.apk" \
-          https://api.telegram.org/bot${{ secrets.TELEGRAM_BOT_TOKEN }}/sendDocument
-        curl -F "chat_id=${{ secrets.TELEGRAM_CHANNEL_ID }}" \
-          -F "document=@app/build/outputs/apk/google/alpha/app-google-universal-alpha.apk" \
+          -F "document=@app/build/outputs/apk/google/alpha/app-google-alpha.apk" \
+          -F "caption=Alpha-Build: ${VERSION}: ${commit_messages}" \
          https://api.telegram.org/bot${{ secrets.TELEGRAM_BOT_TOKEN }}/sendDocument
 
       env:
@@ -141,23 +117,13 @@ jobs:
         VERSION: ${{ env.VERSION }}
 
     - name: Upload Current SHA as Artifact
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       with:
         name: last-sha
         path: last_sha.txt
 
     - name: Upload Commit log as Artifact
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       with:
         name: commit-log
         path: commit_log.txt
-
-    - name: Delete Old Pre-Releases
-      id: delete-pre-releases
-      uses: sgpublic/delete-release-action@master
-      with:
-        pre-release-drop: true
-        pre-release-keep-count: 3
-        pre-release-drop-tag: true
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -31,3 +31,6 @@ output.json
 
 #other
 scripts/
+
+#crowdin
+crowdin.yml

app/build.gradle

@@ -21,14 +21,7 @@ android {
         versionName "3.0.0"
         versionCode 300000000
         signingConfig signingConfigs.debug
-        splits {
-            abi {
-                enable true
-                reset()
-                include 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'
-                universalApk true
-            }
-        }
+
     }
 
     flavorDimensions += "store"
@@ -142,13 +135,13 @@ dependencies {
 
 //  Markwon
     ext.markwon_version = '4.6.2'
-    implementation  "io.noties.markwon:core:$markwon_version"
-    implementation  "io.noties.markwon:editor:$markwon_version"
-    implementation  "io.noties.markwon:ext-strikethrough:$markwon_version"
-    implementation  "io.noties.markwon:ext-tables:$markwon_version"
-    implementation  "io.noties.markwon:ext-tasklist:$markwon_version"
-    implementation  "io.noties.markwon:html:$markwon_version"
-    implementation  "io.noties.markwon:image-glide:$markwon_version"
+    implementation "io.noties.markwon:core:$markwon_version"
+    implementation "io.noties.markwon:editor:$markwon_version"
+    implementation "io.noties.markwon:ext-strikethrough:$markwon_version"
+    implementation "io.noties.markwon:ext-tables:$markwon_version"
+    implementation "io.noties.markwon:ext-tasklist:$markwon_version"
+    implementation "io.noties.markwon:html:$markwon_version"
+    implementation "io.noties.markwon:image-glide:$markwon_version"
 
 //  Groupie
     ext.groupie_version = '2.10.1'
@@ -158,9 +151,6 @@ dependencies {
 //  String Matching
     implementation 'me.xdrop:fuzzywuzzy:1.4.0'
 
-    implementation group: 'com.arthenica', name: 'ffmpeg-kit-full-gpl', version: '6.0-2.LTS'
-    //implementation 'com.github.yausername.youtubedl-android:library:0.15.0'
-
 //  Aniyomi
     implementation 'io.reactivex:rxjava:1.3.8'
     implementation 'io.reactivex:rxandroid:1.2.1'

app/src/google/java/ani/dantotsu/connections/crashlytics/FirebaseCrashlytics.kt

@@ -5,12 +5,12 @@ import com.google.firebase.FirebaseApp
 import com.google.firebase.crashlytics.FirebaseCrashlytics
 import com.google.firebase.crashlytics.ktx.crashlytics
 import com.google.firebase.ktx.Firebase
-import com.google.firebase.ktx.app
 
 class FirebaseCrashlytics : CrashlyticsInterface {
     override fun initialize(context: Context) {
         FirebaseApp.initializeApp(context)
     }
+
     override fun logException(e: Throwable) {
         FirebaseCrashlytics.getInstance().recordException(e)
     }

app/src/google/java/ani/dantotsu/others/AppUpdater.kt

@@ -8,7 +8,6 @@ import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
 import android.net.Uri
-import android.os.Build
 import android.os.Environment
 import android.widget.TextView
 import androidx.core.content.ContextCompat
@@ -88,11 +87,12 @@ object AppUpdater {
                             try {
                                 val apks =
                                     client.get("https://api.github.com/repos/$repo/releases/tags/v$version")
-                                        .parsed<GithubResponse>().assets?.filter { it.browserDownloadURL.endsWith(".apk") }
-                                val apkToDownload =
-                                    apks?.find { it.browserDownloadURL.contains(getCurrentABI()) }
-                                        ?: apks?.find { it.browserDownloadURL.contains("universal") }
-                                        ?: apks?.first()
+                                        .parsed<GithubResponse>().assets?.filter {
+                                            it.browserDownloadURL.endsWith(
+                                                ".apk"
+                                            )
+                                        }
+                                val apkToDownload = apks?.first()
                                 apkToDownload?.browserDownloadURL.apply {
                                     if (this != null) activity.downloadUpdate(version, this)
                                     else openLinkInBrowser("https://github.com/repos/$repo/releases/tag/v$version")
@@ -115,16 +115,6 @@ object AppUpdater {
         }
     }
 
-    /**
-     * Returns the ABI that the app is most likely running on.
-     * @return The primary ABI for the device.
-     */
-    private fun getCurrentABI(): String {
-        return if (Build.SUPPORTED_ABIS.isNotEmpty()) {
-            Build.SUPPORTED_ABIS[0]
-        } else "Unknown"
-    }
-
     private fun compareVersion(version: String): Boolean {
         return when (BuildConfig.BUILD_TYPE) {
             "debug" -> BuildConfig.VERSION_NAME != version

app/src/main/AndroidManifest.xml

@@ -2,6 +2,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
 
+    <uses-sdk tools:overrideLibrary="go.server.gojni" />
+
     <uses-feature
         android:name="android.software.leanback"
         android:required="false" />
@@ -42,8 +44,10 @@
     <uses-feature
         android:name="android.hardware.bluetooth"
         android:required="false" />
-    <uses-permission android:name="android.permission.BLUETOOTH"
-        android:maxSdkVersion="30"/>
+
+    <uses-permission
+        android:name="android.permission.BLUETOOTH"
+        android:maxSdkVersion="30" />
     <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
     <!-- ExoPlayer: Bluetooth Headsets -->
 
@@ -88,7 +92,7 @@
                 <action android:name="android.appwidget.action.APPWIDGET_CONFIGURE" />
             </intent-filter>
         </activity>
-        
+
         <receiver
             android:name=".widgets.statistics.ProfileStatsWidget"
             android:exported="false">
@@ -147,6 +151,9 @@
         <activity
             android:name=".settings.SettingsExtensionsActivity"
             android:parentActivityName=".MainActivity" />
+        <activity
+            android:name=".settings.SettingsAddonActivity"
+            android:parentActivityName=".MainActivity" />
         <activity
             android:name=".settings.SettingsMangaActivity"
             android:parentActivityName=".MainActivity" />
@@ -164,7 +171,7 @@
             android:name=".widgets.statistics.ProfileStatsConfigure"
             android:exported="true">
             <intent-filter>
-                <action android:name="android.appwidget.action.APPWIDGET_CONFIGURE"/>
+                <action android:name="android.appwidget.action.APPWIDGET_CONFIGURE" />
             </intent-filter>
         </activity>
 
@@ -427,6 +434,11 @@
             android:name="androidx.media3.exoplayer.scheduler.PlatformScheduler$PlatformSchedulerService"
             android:exported="true"
             android:permission="android.permission.BIND_JOB_SERVICE" />
+        <service
+            android:name=".addons.torrent.ServerService"
+            android:exported="false"
+            android:foregroundServiceType="dataSync"
+            android:stopWithTask="true" />
 
         <meta-data
             android:name="com.google.android.gms.cast.framework.OPTIONS_PROVIDER_CLASS_NAME"

app/src/main/java/ani/dantotsu/App.kt

@@ -6,6 +6,8 @@ import android.content.Context
 import android.os.Bundle
 import androidx.multidex.MultiDex
 import androidx.multidex.MultiDexApplication
+import ani.dantotsu.addons.download.DownloadAddonManager
+import ani.dantotsu.addons.torrent.TorrentAddonManager
 import ani.dantotsu.aniyomi.anime.custom.AppModule
 import ani.dantotsu.aniyomi.anime.custom.PreferenceModule
 import ani.dantotsu.connections.comments.CommentsAPI
@@ -41,6 +43,9 @@ class App : MultiDexApplication() {
     private lateinit var animeExtensionManager: AnimeExtensionManager
     private lateinit var mangaExtensionManager: MangaExtensionManager
     private lateinit var novelExtensionManager: NovelExtensionManager
+    private lateinit var torrentAddonManager: TorrentAddonManager
+    private lateinit var downloadAddonManager: DownloadAddonManager
+
     override fun attachBaseContext(base: Context?) {
         super.attachBaseContext(base)
         MultiDex.install(this)
@@ -96,6 +101,8 @@ class App : MultiDexApplication() {
         animeExtensionManager = Injekt.get()
         mangaExtensionManager = Injekt.get()
         novelExtensionManager = Injekt.get()
+        torrentAddonManager = Injekt.get()
+        downloadAddonManager = Injekt.get()
 
         val animeScope = CoroutineScope(Dispatchers.Default)
         animeScope.launch {
@@ -115,6 +122,11 @@ class App : MultiDexApplication() {
             Logger.log("Novel Extensions: ${novelExtensionManager.installedExtensionsFlow.first()}")
             NovelSources.init(novelExtensionManager.installedExtensionsFlow)
         }
+        val addonScope = CoroutineScope(Dispatchers.Default)
+        addonScope.launch {
+            torrentAddonManager.init()
+            downloadAddonManager.init()
+        }
         val commentsScope = CoroutineScope(Dispatchers.Default)
         commentsScope.launch {
             CommentsAPI.fetchAuthToken()

app/src/main/java/ani/dantotsu/Functions.kt

@@ -16,7 +16,6 @@ import android.content.DialogInterface
 import android.content.Intent
 import android.content.pm.PackageManager
 import android.content.res.Configuration
-import android.content.res.Resources
 import android.content.res.Resources.getSystem
 import android.graphics.Bitmap
 import android.graphics.Color
@@ -68,12 +67,9 @@ import android.widget.FrameLayout
 import android.widget.ImageView
 import android.widget.TextView
 import android.widget.Toast
-import androidx.appcompat.app.AppCompatActivity
 import androidx.appcompat.app.AppCompatDelegate
-import androidx.core.app.ActivityCompat
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
-import androidx.core.content.ContextCompat
 import androidx.core.content.ContextCompat.getSystemService
 import androidx.core.content.FileProvider
 import androidx.core.math.MathUtils.clamp
@@ -189,9 +185,10 @@ fun currActivity(): Activity? {
 var loadMedia: Int? = null
 var loadIsMAL = false
 
-val Int.toPx get() = TypedValue.applyDimension(
-    TypedValue.COMPLEX_UNIT_DIP, this.toFloat(), Resources.getSystem().displayMetrics
-).toInt()
+val Int.toPx
+    get() = TypedValue.applyDimension(
+        TypedValue.COMPLEX_UNIT_DIP, this.toFloat(), getSystem().displayMetrics
+    ).toInt()
 
 fun initActivity(a: Activity) {
     val window = a.window
@@ -220,7 +217,8 @@ fun initActivity(a: Activity) {
             window.decorView
         ).hide(WindowInsetsCompat.Type.statusBars())
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P && statusBarHeight == 0
-            && a.resources.configuration.orientation == Configuration.ORIENTATION_PORTRAIT) {
+            && a.resources.configuration.orientation == Configuration.ORIENTATION_PORTRAIT
+        ) {
             window.decorView.rootWindowInsets?.displayCutout?.apply {
                 if (boundingRects.size > 0) {
                     statusBarHeight = min(boundingRects[0].width(), boundingRects[0].height())
@@ -296,7 +294,12 @@ fun ViewGroup.setBaseline(navBar: AnimatedBottomBar, overlayView: View) {
     navBar.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED)
     overlayView.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED)
     clipToPadding = false
-    setPadding(paddingLeft, paddingTop, paddingRight, navBarHeight + navBar.measuredHeight + overlayView.measuredHeight)
+    setPadding(
+        paddingLeft,
+        paddingTop,
+        paddingRight,
+        navBarHeight + navBar.measuredHeight + overlayView.measuredHeight
+    )
 }
 
 fun Activity.reloadActivity() {
@@ -306,23 +309,19 @@ fun Activity.reloadActivity() {
     initActivity(this)
 }
 
-fun Context.restartApp(view: View) {
+fun Activity.restartApp() {
     val mainIntent = Intent.makeRestartActivityTask(
         packageManager.getLaunchIntentForPackage(this.packageName)!!.component
     )
-    val component = ComponentName(this@restartApp.packageName, this@restartApp::class.qualifiedName!!)
-    Snackbar.make(view, R.string.restart_app, Snackbar.LENGTH_INDEFINITE).apply {
-        setAction(R.string.do_it) {
-            this.dismiss()
-            try {
-                startActivity(Intent().setComponent(component))
-            } catch (anything: Exception) {
-                startActivity(mainIntent)
-            }
-            Runtime.getRuntime().exit(0)
-        }
-        show()
+    val component =
+        ComponentName(this@restartApp.packageName, this@restartApp::class.qualifiedName!!)
+    try {
+        startActivity(Intent().setComponent(component))
+    } catch (e: Exception) {
+        startActivity(mainIntent)
     }
+    finishAndRemoveTask()
+    PrefManager.setCustomVal("reload", true)
 }
 
 open class BottomSheetDialogFragment : BottomSheetDialogFragment() {
@@ -469,7 +468,7 @@ class InputFilterMinMax(
 }
 
 
-class ZoomOutPageTransformer() :
+class ZoomOutPageTransformer :
     ViewPager2.PageTransformer {
     override fun transformPage(view: View, position: Float) {
         if (position == 0.0f && PrefManager.getVal(PrefName.LayoutAnimations)) {
@@ -637,6 +636,23 @@ fun ImageView.loadImage(file: FileUrl?, size: Int = 0) {
     }
 }
 
+fun ImageView.loadImage(file: FileUrl?, width: Int = 0, height: Int = 0) {
+    file?.url = PrefManager.getVal<String>(PrefName.ImageUrl).ifEmpty { file?.url ?: "" }
+    if (file?.url?.isNotEmpty() == true) {
+        tryWith {
+            if (file.url.startsWith("content://")) {
+                Glide.with(this.context).load(Uri.parse(file.url)).transition(withCrossFade())
+                    .override(width, height).into(this)
+            } else {
+                val glideUrl = GlideUrl(file.url) { file.headers }
+                Glide.with(this.context).load(glideUrl).transition(withCrossFade()).override(width, height)
+                    .into(this)
+            }
+        }
+    }
+}
+
+
 fun ImageView.loadLocalImage(file: File?, size: Int = 0) {
     if (file?.exists() == true) {
         tryWith {
@@ -958,7 +974,8 @@ fun copyToClipboard(string: String, toast: Boolean = true) {
 
 fun countDown(media: Media, view: ViewGroup) {
     if (media.anime?.nextAiringEpisode != null && media.anime.nextAiringEpisodeTime != null
-        && (media.anime.nextAiringEpisodeTime!! - System.currentTimeMillis() / 1000) <= 86400 * 28.toLong()) {
+        && (media.anime.nextAiringEpisodeTime!! - System.currentTimeMillis() / 1000) <= 86400 * 28.toLong()
+    ) {
         val v = ItemCountDownBinding.inflate(LayoutInflater.from(view.context), view, false)
         view.addView(v.root, 0)
         v.mediaCountdownText.text =
@@ -1030,7 +1047,7 @@ fun displayTimer(media: Media, view: ViewGroup) {
     when {
         media.anime != null -> countDown(media, view)
         media.format == "MANGA" || media.format == "ONE_SHOT" -> sinceWhen(media, view)
-        else -> { } // No timer yet
+        else -> {} // No timer yet
     }
 }
 

app/src/main/java/ani/dantotsu/MainActivity.kt

@@ -3,7 +3,6 @@ package ani.dantotsu
 import android.animation.ObjectAnimator
 import android.annotation.SuppressLint
 import android.app.AlertDialog
-import android.content.Context
 import android.content.Intent
 import android.content.res.Configuration
 import android.graphics.drawable.Animatable
@@ -20,7 +19,6 @@ import android.view.ViewGroup
 import android.view.animation.AnticipateInterpolator
 import android.widget.TextView
 import androidx.activity.addCallback
-import androidx.activity.result.contract.ActivityResultContracts
 import androidx.activity.viewModels
 import androidx.annotation.OptIn
 import androidx.appcompat.app.AppCompatActivity
@@ -35,14 +33,15 @@ import androidx.fragment.app.FragmentManager
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.lifecycleScope
 import androidx.media3.common.util.UnstableApi
-import androidx.media3.exoplayer.offline.Download
 import androidx.viewpager2.adapter.FragmentStateAdapter
 import androidx.work.OneTimeWorkRequest
+import ani.dantotsu.addons.torrent.ServerService
+import ani.dantotsu.addons.torrent.TorrentAddonManager
 import ani.dantotsu.connections.anilist.Anilist
 import ani.dantotsu.connections.anilist.AnilistHomeViewModel
 import ani.dantotsu.databinding.ActivityMainBinding
+import ani.dantotsu.databinding.DialogUserAgentBinding
 import ani.dantotsu.databinding.SplashScreenBinding
-import ani.dantotsu.download.video.Helper
 import ani.dantotsu.home.AnimeFragment
 import ani.dantotsu.home.HomeFragment
 import ani.dantotsu.home.LoginFragment
@@ -70,11 +69,13 @@ import com.google.android.material.textfield.TextInputEditText
 import eu.kanade.domain.source.service.SourcePreferences
 import io.noties.markwon.Markwon
 import io.noties.markwon.SoftBreakAddsNewLinePlugin
+import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import nl.joery.animatedbottombar.AnimatedBottomBar
+import tachiyomi.core.util.lang.launchIO
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 import java.io.Serializable
@@ -87,6 +88,7 @@ class MainActivity : AppCompatActivity() {
     private var load = false
 
 
+    @kotlin.OptIn(DelicateCoroutinesApi::class)
     @SuppressLint("InternalInsetResource", "DiscouragedApi")
     @OptIn(UnstableApi::class)
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -453,16 +455,26 @@ class MainActivity : AppCompatActivity() {
                 }
             }
         }
-        /*lifecycleScope.launch(Dispatchers.IO) {  //simple cleanup
-            val index = Helper.downloadManager(this@MainActivity).downloadIndex
-            val downloadCursor = index.getDownloads()
-            while (downloadCursor.moveToNext()) {
-                val download = downloadCursor.download
-                if (download.state == Download.STATE_FAILED) {
-                    Helper.downloadManager(this@MainActivity).removeDownload(download.request.id)
+
+        val torrentManager = Injekt.get<TorrentAddonManager>()
+        fun startTorrent() {
+            if (torrentManager.isAvailable() && PrefManager.getVal(PrefName.TorrentEnabled)) {
+                launchIO {
+                    if (!ServerService.isRunning()) {
+                        ServerService.start()
+                    }
                 }
             }
-        }*/ //TODO: remove this
+        }
+        if (torrentManager.isInitialized.value == false) {
+            torrentManager.isInitialized.observe(this) {
+                if (it) {
+                    startTorrent()
+                }
+            }
+        } else {
+            startTorrent()
+        }
     }
 
     override fun onRestart() {
@@ -473,7 +485,7 @@ class MainActivity : AppCompatActivity() {
     override fun onConfigurationChanged(newConfig: Configuration) {
         super.onConfigurationChanged(newConfig)
         val margin = if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) 8 else 32
-        val params : ViewGroup.MarginLayoutParams =
+        val params: ViewGroup.MarginLayoutParams =
             binding.includedNavbar.navbar.layoutParams as ViewGroup.MarginLayoutParams
         params.updateMargins(bottom = margin.toPx)
     }
@@ -482,16 +494,14 @@ class MainActivity : AppCompatActivity() {
         val password = CharArray(16).apply { fill('0') }
 
         // Inflate the dialog layout
-        val dialogView =
-            LayoutInflater.from(this).inflate(R.layout.dialog_user_agent, null)
-        dialogView.findViewById<TextInputEditText>(R.id.userAgentTextBox)?.hint = "Password"
-        val subtitleTextView = dialogView.findViewById<TextView>(R.id.subtitle)
-        subtitleTextView?.visibility = View.VISIBLE
-        subtitleTextView?.text = getString(R.string.enter_password_to_decrypt_file)
+        val dialogView = DialogUserAgentBinding.inflate(layoutInflater)
+        dialogView.userAgentTextBox.hint = "Password"
+        dialogView.subtitle.visibility = View.VISIBLE
+        dialogView.subtitle.text = getString(R.string.enter_password_to_decrypt_file)
 
         val dialog = AlertDialog.Builder(this, R.style.MyPopup)
             .setTitle("Enter Password")
-            .setView(dialogView)
+            .setView(dialogView.root)
             .setPositiveButton("OK", null)
             .setNegativeButton("Cancel") { dialog, _ ->
                 password.fill('0')

app/src/main/java/ani/dantotsu/addons/Addon.kt

@@ -0,0 +1,15 @@
+package ani.dantotsu.addons
+
+abstract class Addon {
+    abstract val name: String
+    abstract val pkgName: String
+    abstract val versionName: String
+    abstract val versionCode: Long
+
+    abstract class Installed(
+        override val name: String,
+        override val pkgName: String,
+        override val versionName: String,
+        override val versionCode: Long,
+    ) : Addon()
+}

app/src/main/java/ani/dantotsu/addons/AddonDownloader.kt

@@ -0,0 +1,128 @@
+package ani.dantotsu.addons
+
+import android.app.Activity
+import android.app.NotificationManager
+import android.content.Context
+import android.os.Build
+import ani.dantotsu.Mapper
+import ani.dantotsu.R
+import ani.dantotsu.client
+import ani.dantotsu.logError
+import ani.dantotsu.openLinkInBrowser
+import ani.dantotsu.others.AppUpdater
+import ani.dantotsu.settings.InstallerSteps
+import ani.dantotsu.toast
+import ani.dantotsu.util.Logger
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.launch
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.decodeFromJsonElement
+import rx.android.schedulers.AndroidSchedulers
+
+class AddonDownloader {
+    companion object {
+        private suspend fun check(repo: String): Pair<String, String> {
+            return try {
+                val res = client.get("https://api.github.com/repos/$repo/releases")
+                    .parsed<JsonArray>().map {
+                        Mapper.json.decodeFromJsonElement<AppUpdater.GithubResponse>(it)
+                    }
+                val r = res.maxByOrNull {
+                    it.timeStamp()
+                } ?: throw Exception("No Pre Release Found")
+                val v = r.tagName.substringAfter("v", "")
+                val md = r.body ?: ""
+                val version = v.ifEmpty { throw Exception("Weird Version : ${r.tagName}") }
+
+                Logger.log("Git Version : $version")
+                Pair(md, version)
+            } catch (e: Exception) {
+                Logger.log("Error checking for update")
+                Logger.log(e)
+                Pair("", "")
+            }
+        }
+
+        suspend fun hasUpdate(repo: String, currentVersion: String): Boolean {
+            val (_, version) = check(repo)
+            return compareVersion(version, currentVersion)
+        }
+
+        suspend fun update(
+            activity: Activity,
+            manager: AddonManager<*>,
+            repo: String,
+            currentVersion: String
+        ) {
+            val (_, version) = check(repo)
+            if (!compareVersion(version, currentVersion)) {
+                toast(activity.getString(R.string.no_update_found))
+                return
+            }
+            MainScope().launch(Dispatchers.IO) {
+                try {
+                    val apks =
+                        client.get("https://api.github.com/repos/$repo/releases/tags/v$version")
+                            .parsed<AppUpdater.GithubResponse>().assets?.filter {
+                                it.browserDownloadURL.endsWith(
+                                    ".apk"
+                                )
+                            }
+                    val apkToDownload =
+                        apks?.find { it.browserDownloadURL.contains(getCurrentABI()) }
+                            ?: apks?.find { it.browserDownloadURL.contains("universal") }
+                            ?: apks?.first()
+                    apkToDownload?.browserDownloadURL.apply {
+                        if (this != null) {
+                            val notificationManager =
+                                activity.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+                            val installerSteps = InstallerSteps(notificationManager, activity)
+                            manager.install(this)
+                                .observeOn(AndroidSchedulers.mainThread())
+                                .subscribe(
+                                    { installStep -> installerSteps.onInstallStep(installStep) {} },
+                                    { error -> installerSteps.onError(error) {} },
+                                    { installerSteps.onComplete {} }
+                                )
+                        } else openLinkInBrowser("https://github.com/repos/$repo/releases/tag/v$version")
+                    }
+                } catch (e: Exception) {
+                    logError(e)
+                }
+            }
+        }
+
+        /**
+         * Returns the ABI that the app is most likely running on.
+         * @return The primary ABI for the device.
+         */
+        private fun getCurrentABI(): String {
+            return if (Build.SUPPORTED_ABIS.isNotEmpty()) {
+                Build.SUPPORTED_ABIS[0]
+            } else "Unknown"
+        }
+
+        private fun compareVersion(newVersion: String, oldVersion: String): Boolean {
+            fun toDouble(list: List<String>): Double {
+                return try {
+                    list.mapIndexed { i: Int, s: String ->
+                        when (i) {
+                            0 -> s.toDouble() * 100
+                            1 -> s.toDouble() * 10
+                            2 -> s.toDouble()
+                            else -> s.toDoubleOrNull() ?: 0.0
+                        }
+                    }.sum()
+                } catch (e: NumberFormatException) {
+                    0.0
+                }
+            }
+
+            val new = toDouble(newVersion.split("."))
+            val curr = toDouble(oldVersion.split("."))
+            return new > curr
+        }
+
+    }
+}

app/src/main/java/ani/dantotsu/addons/AddonInstallReceiver.kt

@@ -0,0 +1,131 @@
+package ani.dantotsu.addons
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import androidx.core.content.ContextCompat
+import ani.dantotsu.addons.download.DownloadAddonManager
+import ani.dantotsu.addons.torrent.TorrentAddonManager
+import ani.dantotsu.media.AddonType
+import eu.kanade.tachiyomi.extension.util.ExtensionInstallReceiver
+import eu.kanade.tachiyomi.extension.util.ExtensionInstallReceiver.Companion.filter
+import eu.kanade.tachiyomi.extension.util.ExtensionInstallReceiver.Companion.getPackageNameFromIntent
+import kotlinx.coroutines.DelicateCoroutinesApi
+import tachiyomi.core.util.lang.launchNow
+
+internal class AddonInstallReceiver : BroadcastReceiver() {
+    private var listener: AddonListener? = null
+    private var type: AddonType? = null
+
+    /**
+     * Registers this broadcast receiver
+     */
+    fun register(context: Context) {
+        ContextCompat.registerReceiver(context, this, filter, ContextCompat.RECEIVER_EXPORTED)
+    }
+
+    fun setListener(listener: AddonListener, type: AddonType): AddonInstallReceiver {
+        this.listener = listener
+        this.type = type
+        return this
+    }
+
+    /**
+     * Called when one of the events of the [filter] is received. When the package is an extension,
+     * it's loaded in background and it notifies the [listener] when finished.
+     */
+    @OptIn(DelicateCoroutinesApi::class)
+    override fun onReceive(context: Context, intent: Intent?) {
+        if (intent == null) return
+
+        when (intent.action) {
+            Intent.ACTION_PACKAGE_ADDED -> {
+                if (ExtensionInstallReceiver.isReplacing(intent)) return
+                launchNow {
+                    when (type) {
+                        AddonType.DOWNLOAD -> {
+                            getPackageNameFromIntent(intent)?.let { packageName ->
+                                if (packageName != DownloadAddonManager.DOWNLOAD_PACKAGE) return@launchNow
+                                listener?.onAddonInstalled(
+                                    AddonLoader.loadFromPkgName(
+                                        context,
+                                        packageName,
+                                        AddonType.DOWNLOAD
+                                    )
+                                )
+                            }
+                        }
+
+                        AddonType.TORRENT -> {
+                            getPackageNameFromIntent(intent)?.let { packageName ->
+                                if (packageName != TorrentAddonManager.TORRENT_PACKAGE) return@launchNow
+                                listener?.onAddonInstalled(
+                                    AddonLoader.loadFromPkgName(
+                                        context,
+                                        packageName,
+                                        AddonType.TORRENT
+                                    )
+                                )
+                            }
+                        }
+
+                        else -> {}
+                    }
+                }
+            }
+
+            Intent.ACTION_PACKAGE_REPLACED -> {
+                launchNow {
+                    when (type) {
+                        AddonType.DOWNLOAD -> {
+                            getPackageNameFromIntent(intent)?.let { packageName ->
+                                if (packageName != DownloadAddonManager.DOWNLOAD_PACKAGE) return@launchNow
+                                listener?.onAddonUpdated(
+                                    AddonLoader.loadFromPkgName(
+                                        context,
+                                        packageName,
+                                        AddonType.DOWNLOAD
+                                    )
+                                )
+                            }
+                        }
+
+                        AddonType.TORRENT -> {
+                            getPackageNameFromIntent(intent)?.let { packageName ->
+                                if (packageName != TorrentAddonManager.TORRENT_PACKAGE) return@launchNow
+                                listener?.onAddonUpdated(
+                                    AddonLoader.loadFromPkgName(
+                                        context,
+                                        packageName,
+                                        AddonType.TORRENT
+                                    )
+                                )
+                            }
+                        }
+
+                        else -> {}
+                    }
+                }
+            }
+
+            Intent.ACTION_PACKAGE_REMOVED -> {
+                if (ExtensionInstallReceiver.isReplacing(intent)) return
+                getPackageNameFromIntent(intent)?.let { packageName ->
+                    when (type) {
+                        AddonType.DOWNLOAD -> {
+                            if (packageName != DownloadAddonManager.DOWNLOAD_PACKAGE) return
+                            listener?.onAddonUninstalled(packageName)
+                        }
+
+                        AddonType.TORRENT -> {
+                            if (packageName != TorrentAddonManager.TORRENT_PACKAGE) return
+                            listener?.onAddonUninstalled(packageName)
+                        }
+
+                        else -> {}
+                    }
+                }
+            }
+        }
+    }
+}

app/src/main/java/ani/dantotsu/addons/AddonListener.kt

@@ -0,0 +1,11 @@
+package ani.dantotsu.addons
+
+interface AddonListener {
+    fun onAddonInstalled(result: LoadResult?)
+    fun onAddonUpdated(result: LoadResult?)
+    fun onAddonUninstalled(pkgName: String)
+
+    enum class ListenerAction {
+        INSTALL, UPDATE, UNINSTALL
+    }
+}

app/src/main/java/ani/dantotsu/addons/AddonLoader.kt

@@ -0,0 +1,143 @@
+package ani.dantotsu.addons
+
+import android.content.Context
+import android.content.pm.PackageInfo
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.content.pm.PackageInfoCompat
+import ani.dantotsu.addons.download.DownloadAddon
+import ani.dantotsu.addons.download.DownloadAddonApi
+import ani.dantotsu.addons.download.DownloadAddonManager
+import ani.dantotsu.addons.download.DownloadLoadResult
+import ani.dantotsu.addons.torrent.TorrentAddon
+import ani.dantotsu.addons.torrent.TorrentAddonApi
+import ani.dantotsu.addons.torrent.TorrentAddonManager
+import ani.dantotsu.addons.torrent.TorrentLoadResult
+import ani.dantotsu.media.AddonType
+import ani.dantotsu.util.Logger
+import dalvik.system.PathClassLoader
+import eu.kanade.tachiyomi.extension.util.ExtensionLoader
+import eu.kanade.tachiyomi.util.system.getApplicationIcon
+
+class AddonLoader {
+    companion object {
+        fun loadExtension(
+            context: Context,
+            packageName: String,
+            className: String,
+            type: AddonType
+        ): LoadResult? {
+            val pkgManager = context.packageManager
+
+            val installedPkgs = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                pkgManager.getInstalledPackages(PackageManager.PackageInfoFlags.of(ExtensionLoader.PACKAGE_FLAGS.toLong()))
+            } else {
+                pkgManager.getInstalledPackages(ExtensionLoader.PACKAGE_FLAGS)
+            }
+
+            val extPkgs = installedPkgs.filter {
+                isPackageAnExtension(
+                    packageName,
+                    it
+                )
+            }
+
+            if (extPkgs.isEmpty()) return null
+            if (extPkgs.size > 1) throw IllegalStateException("Multiple extensions with the same package name found")
+
+            val pkgName = extPkgs.first().packageName
+            val pkgInfo = extPkgs.first()
+
+            val appInfo = try {
+                pkgManager.getApplicationInfo(pkgName, PackageManager.GET_META_DATA)
+            } catch (error: PackageManager.NameNotFoundException) {
+                // Unlikely, but the package may have been uninstalled at this point
+                Logger.log(error)
+                throw error
+            }
+
+            val extName =
+                pkgManager.getApplicationLabel(appInfo).toString().substringAfter("Dantotsu: ")
+            val versionName = pkgInfo.versionName
+            val versionCode = PackageInfoCompat.getLongVersionCode(pkgInfo)
+
+            if (versionName.isNullOrEmpty()) {
+                Logger.log("Missing versionName for extension $extName")
+                throw IllegalStateException("Missing versionName for extension $extName")
+            }
+            val classLoader =
+                PathClassLoader(appInfo.sourceDir, appInfo.nativeLibraryDir, context.classLoader)
+            val loadedClass = try {
+                Class.forName(className, false, classLoader)
+            } catch (e: ClassNotFoundException) {
+                Logger.log("Extension load error: $extName ($className)")
+                Logger.log(e)
+                throw e
+            } catch (e: NoClassDefFoundError) {
+                Logger.log("Extension load error: $extName ($className)")
+                Logger.log(e)
+                throw e
+            } catch (e: Exception) {
+                Logger.log("Extension load error: $extName ($className)")
+                Logger.log(e)
+                throw e
+            }
+            val instance = loadedClass.getDeclaredConstructor().newInstance()
+
+            return when (type) {
+                AddonType.TORRENT -> {
+                    val extension = instance as? TorrentAddonApi
+                        ?: throw IllegalStateException("Extension is not a TorrentAddonApi")
+                    TorrentLoadResult.Success(
+                        TorrentAddon.Installed(
+                            name = extName,
+                            pkgName = pkgName,
+                            versionName = versionName,
+                            versionCode = versionCode,
+                            extension = extension,
+                            icon = context.getApplicationIcon(pkgName),
+                        )
+                    )
+                }
+
+                AddonType.DOWNLOAD -> {
+                    val extension = instance as? DownloadAddonApi
+                        ?: throw IllegalStateException("Extension is not a DownloadAddonApi")
+                    DownloadLoadResult.Success(
+                        DownloadAddon.Installed(
+                            name = extName,
+                            pkgName = pkgName,
+                            versionName = versionName,
+                            versionCode = versionCode,
+                            extension = extension,
+                            icon = context.getApplicationIcon(pkgName),
+                        )
+                    )
+                }
+            }
+        }
+
+        fun loadFromPkgName(context: Context, packageName: String, type: AddonType): LoadResult? {
+            return when (type) {
+                AddonType.TORRENT -> loadExtension(
+                    context,
+                    packageName,
+                    TorrentAddonManager.TORRENT_CLASS,
+                    type
+                )
+
+                AddonType.DOWNLOAD -> loadExtension(
+                    context,
+                    packageName,
+                    DownloadAddonManager.DOWNLOAD_CLASS,
+                    type
+                )
+            }
+        }
+
+        private fun isPackageAnExtension(type: String, pkgInfo: PackageInfo): Boolean {
+            return pkgInfo.packageName.equals(type)
+        }
+    }
+
+}

app/src/main/java/ani/dantotsu/addons/AddonManager.kt

@@ -0,0 +1,46 @@
+package ani.dantotsu.addons
+
+import android.content.Context
+import ani.dantotsu.media.AddonType
+import eu.kanade.tachiyomi.extension.InstallStep
+import eu.kanade.tachiyomi.extension.util.ExtensionInstaller
+import rx.Observable
+
+abstract class AddonManager<T : Addon.Installed>(
+    private val context: Context
+) {
+    abstract var extension: T?
+    abstract var name: String
+    abstract var type: AddonType
+    protected val installer by lazy { ExtensionInstaller(context) }
+    var hasUpdate: Boolean = false
+        protected set
+
+    protected var onListenerAction: ((AddonListener.ListenerAction) -> Unit)? = null
+
+    abstract suspend fun init()
+    abstract fun isAvailable(): Boolean
+    abstract fun getVersion(): String?
+    abstract fun getPackageName(): String?
+    abstract fun hadError(context: Context): String?
+    abstract fun updateInstallStep(id: Long, step: InstallStep)
+    abstract fun setInstalling(id: Long)
+
+    fun uninstall() {
+        getPackageName()?.let {
+            installer.uninstallApk(it)
+        }
+    }
+
+    fun addListenerAction(action: (AddonListener.ListenerAction) -> Unit) {
+        onListenerAction = action
+    }
+
+    fun removeListenerAction() {
+        onListenerAction = null
+    }
+
+    fun install(url: String): Observable<InstallStep> {
+        return installer.downloadAndInstall(url, getPackageName() ?: "", name, type)
+    }
+}

app/src/main/java/ani/dantotsu/addons/LoadResult.kt

@@ -0,0 +1,8 @@
+package ani.dantotsu.addons
+
+abstract class LoadResult {
+
+    abstract class Success : LoadResult()
+
+
+}

app/src/main/java/ani/dantotsu/addons/download/DownloadAddon.kt

@@ -0,0 +1,18 @@
+package ani.dantotsu.addons.download
+
+import android.graphics.drawable.Drawable
+import ani.dantotsu.addons.Addon
+
+sealed class DownloadAddon : Addon() {
+
+    data class Installed(
+        override val name: String,
+        override val pkgName: String,
+        override val versionName: String,
+        override val versionCode: Long,
+        val extension: DownloadAddonApi,
+        val icon: Drawable?,
+        val hasUpdate: Boolean = false,
+    ) : Addon.Installed(name, pkgName, versionName, versionCode)
+
+}

app/src/main/java/ani/dantotsu/addons/download/DownloadAddonApi.kt

@@ -0,0 +1,21 @@
+package ani.dantotsu.addons.download
+
+import android.content.Context
+import android.net.Uri
+
+interface DownloadAddonApi {
+
+    fun cancelDownload(sessionId: Long)
+
+    fun setDownloadPath(context: Context, uri: Uri): String
+
+    suspend fun executeFFProbe(request: String, logCallback: (String) -> Unit)
+
+    suspend fun executeFFMpeg(request: String, statCallback: (Double) -> Unit): Long
+
+    fun getState(sessionId: Long): String
+
+    fun getStackTrace(sessionId: Long): String?
+
+    fun hadError(sessionId: Long): Boolean
+}

app/src/main/java/ani/dantotsu/addons/download/DownloadAddonManager.kt

@@ -0,0 +1,134 @@
+package ani.dantotsu.addons.download
+
+import android.content.Context
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import ani.dantotsu.R
+import ani.dantotsu.addons.AddonDownloader
+import ani.dantotsu.addons.AddonInstallReceiver
+import ani.dantotsu.addons.AddonListener
+import ani.dantotsu.addons.AddonLoader
+import ani.dantotsu.addons.AddonManager
+import ani.dantotsu.addons.LoadResult
+import ani.dantotsu.media.AddonType
+import ani.dantotsu.util.Logger
+import eu.kanade.tachiyomi.extension.InstallStep
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+class DownloadAddonManager(
+    private val context: Context
+) : AddonManager<DownloadAddon.Installed>(context) {
+
+    override var extension: DownloadAddon.Installed? = null
+    override var name: String = "Download Addon"
+    override var type = AddonType.DOWNLOAD
+
+    private val _isInitialized = MutableLiveData<Boolean>().apply { value = false }
+    val isInitialized: LiveData<Boolean> = _isInitialized
+
+    private var error: String? = null
+
+    override suspend fun init() {
+        extension = null
+        error = null
+        hasUpdate = false
+        withContext(Dispatchers.Main) {
+            _isInitialized.value = false
+        }
+
+        AddonInstallReceiver()
+            .setListener(InstallationListener(), type)
+            .register(context)
+        try {
+            val result = AddonLoader.loadExtension(
+                context,
+                DOWNLOAD_PACKAGE,
+                DOWNLOAD_CLASS,
+                AddonType.DOWNLOAD
+            ) as? DownloadLoadResult
+            result?.let {
+                if (it is DownloadLoadResult.Success) {
+                    extension = it.extension
+                    hasUpdate = AddonDownloader.hasUpdate(REPO, it.extension.versionName)
+                }
+            }
+            withContext(Dispatchers.Main) {
+                _isInitialized.value = true
+            }
+        } catch (e: Exception) {
+            Logger.log("Error initializing Download extension")
+            Logger.log(e)
+            error = e.message
+        }
+    }
+
+    override fun isAvailable(): Boolean {
+        return extension?.extension != null
+    }
+
+    override fun getVersion(): String? {
+        return extension?.versionName
+    }
+
+    override fun getPackageName(): String? {
+        return extension?.pkgName
+    }
+
+    override fun hadError(context: Context): String? {
+        return if (isInitialized.value == true) {
+            if (error != null) {
+                error
+            } else if (extension != null) {
+                context.getString(R.string.loaded_successfully)
+            } else {
+                null
+            }
+        } else {
+            null
+        }
+    }
+
+    private inner class InstallationListener : AddonListener {
+        override fun onAddonInstalled(result: LoadResult?) {
+            if (result is DownloadLoadResult.Success) {
+                extension = result.extension
+                hasUpdate = false
+                onListenerAction?.invoke(AddonListener.ListenerAction.INSTALL)
+            }
+        }
+
+        override fun onAddonUpdated(result: LoadResult?) {
+            if (result is DownloadLoadResult.Success) {
+                extension = result.extension
+                hasUpdate = false
+                onListenerAction?.invoke(AddonListener.ListenerAction.UPDATE)
+            }
+        }
+
+        override fun onAddonUninstalled(pkgName: String) {
+            if (extension?.pkgName == pkgName) {
+                extension = null
+                hasUpdate = false
+                onListenerAction?.invoke(AddonListener.ListenerAction.UNINSTALL)
+            }
+        }
+
+    }
+
+    override fun updateInstallStep(id: Long, step: InstallStep) {
+        installer.updateInstallStep(id, step)
+    }
+
+    override fun setInstalling(id: Long) {
+        installer.updateInstallStep(id, InstallStep.Installing)
+    }
+
+
+    companion object {
+
+        const val DOWNLOAD_PACKAGE = "dantotsu.downloadAddon"
+        const val DOWNLOAD_CLASS = "ani.dantotsu.downloadAddon.DownloadAddon"
+        const val REPO = "rebelonion/Dantotsu-Download-Addon"
+    }
+}

app/src/main/java/ani/dantotsu/addons/download/DownloadLoadResult.kt

@@ -0,0 +1,7 @@
+package ani.dantotsu.addons.download
+
+import ani.dantotsu.addons.LoadResult
+
+open class DownloadLoadResult : LoadResult() {
+    class Success(val extension: DownloadAddon.Installed) : DownloadLoadResult()
+}

app/src/main/java/ani/dantotsu/addons/torrent/TorrentAddon.kt

@@ -0,0 +1,16 @@
+package ani.dantotsu.addons.torrent
+
+import android.graphics.drawable.Drawable
+import ani.dantotsu.addons.Addon
+
+sealed class TorrentAddon : Addon() {
+    data class Installed(
+        override val name: String,
+        override val pkgName: String,
+        override val versionName: String,
+        override val versionCode: Long,
+        val extension: TorrentAddonApi,
+        val icon: Drawable?,
+        val hasUpdate: Boolean = false,
+    ) : Addon.Installed(name, pkgName, versionName, versionCode)
+}

app/src/main/java/ani/dantotsu/addons/torrent/TorrentAddonApi.kt

@@ -0,0 +1,24 @@
+package ani.dantotsu.addons.torrent
+
+import eu.kanade.tachiyomi.data.torrentServer.model.Torrent
+
+interface TorrentAddonApi {
+
+    fun startServer(path: String)
+
+    fun stopServer()
+
+    fun echo(): String
+
+    fun removeTorrent(torrent: String)
+
+    fun addTorrent(
+        link: String,
+        title: String,
+        poster: String,
+        data: String,
+        save: Boolean,
+    ): Torrent
+
+    fun getLink(torrent: Torrent, index: Int): String
+}

app/src/main/java/ani/dantotsu/addons/torrent/TorrentAddonManager.kt

@@ -0,0 +1,137 @@
+package ani.dantotsu.addons.torrent
+
+import android.content.Context
+import android.os.Build
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import ani.dantotsu.R
+import ani.dantotsu.addons.AddonDownloader.Companion.hasUpdate
+import ani.dantotsu.addons.AddonListener
+import ani.dantotsu.addons.AddonLoader
+import ani.dantotsu.addons.AddonManager
+import ani.dantotsu.addons.LoadResult
+import ani.dantotsu.addons.AddonInstallReceiver
+import ani.dantotsu.media.AddonType
+import ani.dantotsu.util.Logger
+import eu.kanade.tachiyomi.extension.InstallStep
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+class TorrentAddonManager(
+    private val context: Context
+) : AddonManager<TorrentAddon.Installed>(context) {
+    override var extension: TorrentAddon.Installed? = null
+    override var name: String = "Torrent Addon"
+    override var type: AddonType = AddonType.TORRENT
+    var torrentHash: String? = null
+
+    private val _isInitialized = MutableLiveData<Boolean>().apply { value = false }
+    val isInitialized: LiveData<Boolean> = _isInitialized
+
+    private var error: String? = null
+
+    override suspend fun init() {
+        extension = null
+        error = null
+        hasUpdate = false
+        withContext(Dispatchers.Main) {
+            _isInitialized.value = false
+        }
+        if (Build.VERSION.SDK_INT < 23) {
+            Logger.log("Torrent extension is not supported on this device.")
+            error = context.getString(R.string.torrent_extension_not_supported)
+            return
+        }
+
+        AddonInstallReceiver()
+            .setListener(InstallationListener(), type)
+            .register(context)
+        try {
+            val result = AddonLoader.loadExtension(
+                context,
+                TORRENT_PACKAGE,
+                TORRENT_CLASS,
+                type
+            ) as TorrentLoadResult?
+            result?.let {
+                if (it is TorrentLoadResult.Success) {
+                    extension = it.extension
+                    hasUpdate = hasUpdate(REPO, it.extension.versionName)
+                }
+            }
+            withContext(Dispatchers.Main) {
+                _isInitialized.value = true
+            }
+        } catch (e: Exception) {
+            Logger.log("Error initializing torrent extension")
+            Logger.log(e)
+            error = e.message
+        }
+    }
+
+    override fun isAvailable(): Boolean {
+        return extension?.extension != null
+    }
+
+    override fun getVersion(): String? {
+        return extension?.versionName
+    }
+
+    override fun getPackageName(): String? {
+        return extension?.pkgName
+    }
+
+    override fun hadError(context: Context): String? {
+        return if (isInitialized.value == true) {
+            if (error != null) {
+                error
+            } else if (extension != null) {
+                context.getString(R.string.loaded_successfully)
+            } else {
+                null
+            }
+        } else {
+            null
+        }
+    }
+
+    private inner class InstallationListener : AddonListener {
+        override fun onAddonInstalled(result: LoadResult?) {
+            if (result is TorrentLoadResult.Success) {
+                extension = result.extension
+                hasUpdate = false
+                onListenerAction?.invoke(AddonListener.ListenerAction.INSTALL)
+            }
+        }
+
+        override fun onAddonUpdated(result: LoadResult?) {
+            if (result is TorrentLoadResult.Success) {
+                extension = result.extension
+                hasUpdate = false
+                onListenerAction?.invoke(AddonListener.ListenerAction.UPDATE)
+            }
+        }
+
+        override fun onAddonUninstalled(pkgName: String) {
+            if (pkgName == TORRENT_PACKAGE) {
+                extension = null
+                hasUpdate = false
+                onListenerAction?.invoke(AddonListener.ListenerAction.UNINSTALL)
+            }
+        }
+    }
+
+    override fun updateInstallStep(id: Long, step: InstallStep) {
+        installer.updateInstallStep(id, step)
+    }
+
+    override fun setInstalling(id: Long) {
+        installer.updateInstallStep(id, InstallStep.Installing)
+    }
+
+    companion object {
+        const val TORRENT_PACKAGE = "dantotsu.torrentAddon"
+        const val TORRENT_CLASS = "ani.dantotsu.torrentAddon.TorrentAddon"
+        const val REPO = "rebelonion/Dantotsu-Torrent-Addon"
+    }
+}

app/src/main/java/ani/dantotsu/addons/torrent/TorrentLoadResult.kt

@@ -0,0 +1,7 @@
+package ani.dantotsu.addons.torrent
+
+import ani.dantotsu.addons.LoadResult
+
+open class TorrentLoadResult : LoadResult() {
+    class Success(val extension: TorrentAddon.Installed) : TorrentLoadResult()
+}

app/src/main/java/ani/dantotsu/addons/torrent/TorrentService.kt

@@ -0,0 +1,168 @@
+package ani.dantotsu.addons.torrent
+
+import android.app.ActivityManager
+import android.app.Application
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ServiceInfo
+import android.os.Build
+import android.os.IBinder
+import ani.dantotsu.R
+import ani.dantotsu.util.Logger
+import eu.kanade.tachiyomi.data.notification.Notifications.CHANNEL_TORRENT_SERVER
+import eu.kanade.tachiyomi.data.notification.Notifications.ID_TORRENT_SERVER
+import eu.kanade.tachiyomi.util.system.cancelNotification
+import eu.kanade.tachiyomi.util.system.notificationBuilder
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import kotlin.coroutines.EmptyCoroutineContext
+
+
+class ServerService : Service() {
+    private val serviceScope = CoroutineScope(EmptyCoroutineContext)
+    private val applicationContext = Injekt.get<Application>()
+    private val extension = Injekt.get<TorrentAddonManager>().extension!!.extension
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    override fun onStartCommand(
+        intent: Intent?,
+        flags: Int,
+        startId: Int,
+    ): Int {
+        intent?.let {
+            if (it.action != null) {
+                when (it.action) {
+                    ACTION_START -> {
+                        startServer()
+                        notification(applicationContext)
+                        return START_STICKY
+                    }
+
+                    ACTION_STOP -> {
+                        stopServer()
+                        return START_NOT_STICKY
+                    }
+                }
+            }
+        }
+        return START_NOT_STICKY
+    }
+
+    private fun startServer() {
+        serviceScope.launch {
+            val echo = extension.echo()
+            if (echo == "") {
+                extension.startServer(filesDir.absolutePath)
+            }
+        }
+    }
+
+    private fun stopServer() {
+        serviceScope.launch {
+            extension.stopServer()
+            applicationContext.cancelNotification(ID_TORRENT_SERVER)
+            stopSelf()
+        }
+    }
+
+    private fun notification(context: Context) {
+        val exitPendingIntent =
+            PendingIntent.getService(
+                applicationContext,
+                0,
+                Intent(applicationContext, ServerService::class.java).apply {
+                    action = ACTION_STOP
+                },
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+            )
+        val builder = context.notificationBuilder(CHANNEL_TORRENT_SERVER) {
+            setSmallIcon(R.drawable.notification_icon)
+            setContentText("Torrent Server")
+            setContentTitle("Server is running…")
+            setAutoCancel(false)
+            setOngoing(true)
+            setUsesChronometer(true)
+            addAction(
+                R.drawable.ic_circle_cancel,
+                "Stop",
+                exitPendingIntent,
+            )
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            startForeground(
+                ID_TORRENT_SERVER,
+                builder.build(),
+                ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+            )
+        } else {
+            startForeground(ID_TORRENT_SERVER, builder.build())
+        }
+    }
+
+    companion object {
+        const val ACTION_START = "start_torrent_server"
+        const val ACTION_STOP = "stop_torrent_server"
+
+        fun isRunning(): Boolean {
+            with(Injekt.get<Application>().getSystemService(ACTIVITY_SERVICE) as ActivityManager) {
+                @Suppress("DEPRECATION") // We only need our services
+                getRunningServices(Int.MAX_VALUE).forEach {
+                    if (ServerService::class.java.name.equals(it.service.className)) {
+                        return true
+                    }
+                }
+            }
+            return false
+        }
+
+        fun start() {
+            try {
+                val intent =
+                    Intent(Injekt.get<Application>(), ServerService::class.java).apply {
+                        action = ACTION_START
+                    }
+                Injekt.get<Application>().startService(intent)
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+        }
+
+
+        fun stop() {
+            try {
+                val intent =
+                    Intent(Injekt.get<Application>(), ServerService::class.java).apply {
+                        action = ACTION_STOP
+                    }
+                Injekt.get<Application>().startService(intent)
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+        }
+
+        fun wait(timeout: Int = -1): Boolean {
+            var count = 0
+            if (timeout < 0) {
+                count = -20
+            }
+            var echo = Injekt.get<TorrentAddonManager>().extension?.extension?.echo()
+            while (echo == "") {
+                Thread.sleep(1000)
+                count++
+                if (count > timeout) {
+                    return false
+                }
+                echo = Injekt.get<TorrentAddonManager>().extension?.extension?.echo()
+            }
+            Logger.log("ServerService: Server started: $echo")
+            return true
+        }
+
+    }
+}

app/src/main/java/ani/dantotsu/aniyomi/anime/custom/InjektModules.kt

@@ -6,6 +6,8 @@ import androidx.annotation.OptIn
 import androidx.core.content.ContextCompat
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.database.StandaloneDatabaseProvider
+import ani.dantotsu.addons.download.DownloadAddonManager
+import ani.dantotsu.addons.torrent.TorrentAddonManager
 import ani.dantotsu.connections.crashlytics.CrashlyticsInterface
 import ani.dantotsu.download.DownloadsManager
 import ani.dantotsu.media.manga.MangaCache
@@ -38,10 +40,13 @@ class AppModule(val app: Application) : InjektModule {
         addSingletonFactory { DownloadsManager(app) }
 
         addSingletonFactory { NetworkHelper(app) }
+        addSingletonFactory { NetworkHelper(app).client }
 
         addSingletonFactory { AnimeExtensionManager(app) }
         addSingletonFactory { MangaExtensionManager(app) }
         addSingletonFactory { NovelExtensionManager(app) }
+        addSingletonFactory { TorrentAddonManager(app) }
+        addSingletonFactory { DownloadAddonManager(app) }
 
         addSingletonFactory<AnimeSourceManager> { AndroidAnimeSourceManager(app, get()) }
         addSingletonFactory<MangaSourceManager> { AndroidMangaSourceManager(app, get()) }

app/src/main/java/ani/dantotsu/connections/anilist/Anilist.kt

@@ -3,7 +3,6 @@ package ani.dantotsu.connections.anilist
 import android.content.ActivityNotFoundException
 import android.content.Context
 import android.net.Uri
-import android.util.Log
 import androidx.browser.customtabs.CustomTabsIntent
 import ani.dantotsu.R
 import ani.dantotsu.client
@@ -14,7 +13,6 @@ import ani.dantotsu.settings.saving.PrefManager
 import ani.dantotsu.settings.saving.PrefName
 import ani.dantotsu.snackString
 import ani.dantotsu.toast
-import ani.dantotsu.tryWithSuspend
 import ani.dantotsu.util.Logger
 import java.util.Calendar
 
@@ -201,7 +199,9 @@ object Anilist {
                     toast("Rate limited. Try after $retry seconds")
                     throw Exception("Rate limited after $retry seconds")
                 }
-                if (!json.text.startsWith("{")) {throw Exception(currContext()?.getString(R.string.anilist_down))}
+                if (!json.text.startsWith("{")) {
+                    throw Exception(currContext()?.getString(R.string.anilist_down))
+                }
                 if (show) Logger.log("Anilist Response: ${json.text}")
                 json.parsed()
             } else null

app/src/main/java/ani/dantotsu/connections/anilist/AnilistQueries.kt

@@ -1061,21 +1061,32 @@ query (${"$"}page: Int = 1, ${"$"}id: Int, ${"$"}type: MediaType, ${"$"}isAdult:
         }
         return null
     }
-    private val onListAnime = (if(PrefManager.getVal(PrefName.IncludeAnimeList)) "" else "onList:false").replace("\"", "")
-    private val isAdult = (if (PrefManager.getVal(PrefName.AdultOnly)) "isAdult:true" else "").replace("\"", "")
-    private fun recentAnimeUpdates(page: Int): String{
+
+    private val onListAnime =
+        (if (PrefManager.getVal(PrefName.IncludeAnimeList)) "" else "onList:false").replace(
+            "\"",
+            ""
+        )
+    private val isAdult =
+        (if (PrefManager.getVal(PrefName.AdultOnly)) "isAdult:true" else "").replace("\"", "")
+
+    private fun recentAnimeUpdates(page: Int): String {
         return """Page(page:$page,perPage:50){pageInfo{hasNextPage total}airingSchedules(airingAt_greater:0 airingAt_lesser:${System.currentTimeMillis() / 1000 - 10000} sort:TIME_DESC){episode airingAt media{id idMal status chapters episodes nextAiringEpisode{episode} isAdult type meanScore isFavourite format bannerImage countryOfOrigin coverImage{large} title{english romaji userPreferred} mediaListEntry{progress private score(format:POINT_100) status}}}}"""
     }
-    private fun trendingMovies(page: Int): String{
+
+    private fun trendingMovies(page: Int): String {
         return """Page(page:$page,perPage:50){pageInfo{hasNextPage total}media(sort:POPULARITY_DESC, type: ANIME, format: MOVIE, $onListAnime, $isAdult){id idMal status chapters episodes nextAiringEpisode{episode}isAdult type meanScore isFavourite format bannerImage countryOfOrigin coverImage{large}title{english romaji userPreferred}mediaListEntry{progress private score(format:POINT_100)status}}}"""
     }
-    private fun topRatedAnime(page: Int): String{
+
+    private fun topRatedAnime(page: Int): String {
         return """Page(page:$page,perPage:50){pageInfo{hasNextPage total}media(sort: SCORE_DESC, type: ANIME, $onListAnime, $isAdult){id idMal status chapters episodes nextAiringEpisode{episode}isAdult type meanScore isFavourite format bannerImage countryOfOrigin coverImage{large}title{english romaji userPreferred}mediaListEntry{progress private score(format:POINT_100)status}}}"""
     }
-    private fun mostFavAnime(page: Int): String{
+
+    private fun mostFavAnime(page: Int): String {
         return """Page(page:$page,perPage:50){pageInfo{hasNextPage total}media(sort:FAVOURITES_DESC,type: ANIME, $onListAnime, $isAdult){id idMal status chapters episodes nextAiringEpisode{episode}isAdult type meanScore isFavourite format bannerImage countryOfOrigin coverImage{large}title{english romaji userPreferred}mediaListEntry{progress private score(format:POINT_100)status}}}"""
     }
-    suspend fun loadAnimeList(): Map<String, ArrayList<Media>>{
+
+    suspend fun loadAnimeList(): Map<String, ArrayList<Media>> {
         val list = mutableMapOf<String, ArrayList<Media>>()
         fun query(): String {
             return """{
@@ -1136,26 +1147,37 @@ query (${"$"}page: Int = 1, ${"$"}id: Int, ${"$"}type: MediaType, ${"$"}isAdult:
         }
         return list
     }
-    private val onListManga = (if(PrefManager.getVal(PrefName.IncludeMangaList)) "" else "onList:false").replace("\"", "")
-    private fun trendingManga(page: Int): String{
+
+    private val onListManga =
+        (if (PrefManager.getVal(PrefName.IncludeMangaList)) "" else "onList:false").replace(
+            "\"",
+            ""
+        )
+
+    private fun trendingManga(page: Int): String {
         return """Page(page:$page,perPage:50){pageInfo{hasNextPage total}media(sort:POPULARITY_DESC, type: MANGA,countryOfOrigin:JP, $onListManga, $isAdult){id idMal status chapters episodes nextAiringEpisode{episode}isAdult type meanScore isFavourite format bannerImage countryOfOrigin coverImage{large}title{english romaji userPreferred}mediaListEntry{progress private score(format:POINT_100)status}}}"""
     }
-    private fun trendingManhwa(page: Int): String{
+
+    private fun trendingManhwa(page: Int): String {
         return """Page(page:$page,perPage:50){pageInfo{hasNextPage total}media(sort:POPULARITY_DESC, type: MANGA, countryOfOrigin:KR, $onListManga, $isAdult){id idMal status chapters episodes nextAiringEpisode{episode}isAdult type meanScore isFavourite format bannerImage countryOfOrigin coverImage{large}title{english romaji userPreferred}mediaListEntry{progress private score(format:POINT_100)status}}}"""
     }
-    private fun trendingNovel(page: Int): String{
+
+    private fun trendingNovel(page: Int): String {
         return """Page(page:$page,perPage:50){pageInfo{hasNextPage total}media(sort:POPULARITY_DESC, type: MANGA, format: NOVEL, countryOfOrigin:JP, $onListManga, $isAdult){id idMal status chapters episodes nextAiringEpisode{episode}isAdult type meanScore isFavourite format bannerImage countryOfOrigin coverImage{large}title{english romaji userPreferred}mediaListEntry{progress private score(format:POINT_100)status}}}"""
     }
-    private fun topRatedManga(page: Int): String{
+
+    private fun topRatedManga(page: Int): String {
         return """Page(page:$page,perPage:50){pageInfo{hasNextPage total}media(sort: SCORE_DESC, type: MANGA, $onListManga, $isAdult){id idMal status chapters episodes nextAiringEpisode{episode}isAdult type meanScore isFavourite format bannerImage countryOfOrigin coverImage{large}title{english romaji userPreferred}mediaListEntry{progress private score(format:POINT_100)status}}}"""
     }
-    private fun mostFavManga(page: Int): String{
+
+    private fun mostFavManga(page: Int): String {
         return """Page(page:$page,perPage:50){pageInfo{hasNextPage total}media(sort:FAVOURITES_DESC,type: MANGA, $onListManga, $isAdult){id idMal status chapters episodes nextAiringEpisode{episode}isAdult type meanScore isFavourite format bannerImage countryOfOrigin coverImage{large}title{english romaji userPreferred}mediaListEntry{progress private score(format:POINT_100)status}}}"""
     }
-    suspend fun loadMangaList(): Map<String, ArrayList<Media>>{
+
+    suspend fun loadMangaList(): Map<String, ArrayList<Media>> {
         val list = mutableMapOf<String, ArrayList<Media>>()
-        fun query(): String{
-           return """{
+        fun query(): String {
+            return """{
                 trendingManga:${trendingManga(1)}
                 trendingManga2:${trendingManga(2)}
                 trendingManhwa:${trendingManhwa(1)}
@@ -1169,7 +1191,7 @@ query (${"$"}page: Int = 1, ${"$"}id: Int, ${"$"}type: MediaType, ${"$"}isAdult:
             }""".trimIndent()
         }
 
-        executeQuery<Query.MangaList>(query() , force = true)?.data?.apply {
+        executeQuery<Query.MangaList>(query(), force = true)?.data?.apply {
             list["trendingManga"] = trendingManga?.media?.map { Media(it) } as ArrayList<Media>
             list["trendingManhwa"] = trendingManhwa?.media?.map { Media(it) } as ArrayList<Media>
             list["trendingNovel"] = trendingNovel?.media?.map { Media(it) } as ArrayList<Media>
@@ -1185,10 +1207,11 @@ query (${"$"}page: Int = 1, ${"$"}id: Int, ${"$"}type: MediaType, ${"$"}isAdult:
 
         return list
     }
+
     suspend fun recentlyUpdated(
         greater: Long = 0,
         lesser: Long = System.currentTimeMillis() / 1000 - 10000
-    ): MutableList<Media>? {
+    ): MutableList<Media> {
         suspend fun execute(page: Int = 1): Page? {
             val query = """{
 Page(page:$page,perPage:50) {
@@ -1235,25 +1258,26 @@ Page(page:$page,perPage:50) {
         }""".replace("\n", " ").replace("""  """, "")
             return executeQuery<Query.Page>(query, force = true)?.data?.page
         }
-            var i = 1
-            val list = mutableListOf<Media>()
-            var res: Page? = null
-            suspend fun next() {
-                res = execute(i)
-                list.addAll(res?.airingSchedules?.mapNotNull { j ->
-                    j.media?.let {
-                        if (it.countryOfOrigin == "JP" && (if (!Anilist.adult) it.isAdult == false else true)) {
-                            Media(it).apply { relation = "${j.episode},${j.airingAt}" }
-                        } else null
-                    }
-                } ?: listOf())
-            }
+
+        var i = 1
+        val list = mutableListOf<Media>()
+        var res: Page? = null
+        suspend fun next() {
+            res = execute(i)
+            list.addAll(res?.airingSchedules?.mapNotNull { j ->
+                j.media?.let {
+                    if (it.countryOfOrigin == "JP" && (if (!Anilist.adult) it.isAdult == false else true)) {
+                        Media(it).apply { relation = "${j.episode},${j.airingAt}" }
+                    } else null
+                }
+            } ?: listOf())
+        }
+        next()
+        while (res?.pageInfo?.hasNextPage == true) {
             next()
-            while (res?.pageInfo?.hasNextPage == true) {
-                next()
-                i++
-            }
-            return list.reversed().toMutableList()
+            i++
+        }
+        return list.reversed().toMutableList()
     }
 
     suspend fun getCharacterDetails(character: Character): Character {
@@ -1468,7 +1492,8 @@ Page(page:$page,perPage:50) {
         val characters = arrayListOf<Character>()
         while (hasNextPage) {
             page++
-            val query = executeQuery<Query.Author>(query(page), force = true
+            val query = executeQuery<Query.Author>(
+                query(page), force = true
             )?.data?.author
             hasNextPage = query?.staffMedia?.let {
                 it.edges?.forEach { i ->
@@ -1487,7 +1512,16 @@ Page(page:$page,perPage:50) {
             } ?: false
             query?.characters?.let {
                 it.nodes?.forEach { i ->
-                    characters.add(Character(i.id, i.name?.userPreferred, i.image?.large, i.image?.medium, "", false))
+                    characters.add(
+                        Character(
+                            i.id,
+                            i.name?.userPreferred,
+                            i.image?.large,
+                            i.image?.medium,
+                            "",
+                            false
+                        )
+                    )
                 }
             }
         }
@@ -1501,6 +1535,7 @@ Page(page:$page,perPage:50) {
         author.yearMedia = yearMedia
         return author
     }
+
     suspend fun toggleFollow(id: Int): Query.ToggleFollow? {
         return executeQuery<Query.ToggleFollow>(
             """mutation{ToggleFollow(userId:$id){id, isFollowing, isFollower}}"""
@@ -1568,7 +1603,11 @@ Page(page:$page,perPage:50) {
     }
 
 
-    suspend fun getNotifications(id: Int, page: Int = 1, resetNotification: Boolean = true): NotificationResponse? {
+    suspend fun getNotifications(
+        id: Int,
+        page: Int = 1,
+        resetNotification: Boolean = true
+    ): NotificationResponse? {
         val reset = if (resetNotification) "true" else "false"
         val res = executeQuery<NotificationResponse>(
             """{User(id:$id){unreadNotificationCount}Page(page:$page,perPage:$ITEMS_PER_PAGE){pageInfo{currentPage,hasNextPage}notifications(resetNotificationCount:$reset){__typename...on AiringNotification{id,type,animeId,episode,contexts,createdAt,media{id,title{romaji,english,native,userPreferred}bannerImage,coverImage{medium,large}},}...on FollowingNotification{id,userId,type,context,createdAt,user{id,name,bannerImage,avatar{medium,large,}}}...on ActivityMessageNotification{id,userId,type,activityId,context,createdAt,message{id}user{id,name,bannerImage,avatar{medium,large,}}}...on ActivityMentionNotification{id,userId,type,activityId,context,createdAt,activity{__typename}user{id,name,bannerImage,avatar{medium,large,}}}...on ActivityReplyNotification{id,userId,type,activityId,context,createdAt,activity{__typename}user{id,name,bannerImage,avatar{medium,large,}}}...on ActivityReplySubscribedNotification{id,userId,type,activityId,context,createdAt,activity{__typename}user{id,name,bannerImage,avatar{medium,large,}}}...on ActivityLikeNotification{id,userId,type,activityId,context,createdAt,activity{__typename}user{id,name,bannerImage,avatar{medium,large,}}}...on ActivityReplyLikeNotification{id,userId,type,activityId,context,createdAt,activity{__typename}user{id,name,bannerImage,avatar{medium,large,}}}...on ThreadCommentMentionNotification{id,userId,type,commentId,context,createdAt,thread{id}comment{id}user{id,name,bannerImage,avatar{medium,large,}}}...on ThreadCommentReplyNotification{id,userId,type,commentId,context,createdAt,thread{id}comment{id}user{id,name,bannerImage,avatar{medium,large,}}}...on ThreadCommentSubscribedNotification{id,userId,type,commentId,context,createdAt,thread{id}comment{id}user{id,name,bannerImage,avatar{medium,large,}}}...on ThreadCommentLikeNotification{id,userId,type,commentId,context,createdAt,thread{id}comment{id}user{id,name,bannerImage,avatar{medium,large,}}}...on ThreadLikeNotification{id,userId,type,threadId,context,createdAt,thread{id}comment{id}user{id,name,bannerImage,avatar{medium,large,}}}...on RelatedMediaAdditionNotification{id,type,context,createdAt,media{id,title{romaji,english,native,userPreferred}bannerImage,coverImage{medium,large}}}...on MediaDataChangeNotification{id,type,mediaId,context,reason,createdAt,media{id,title{romaji,english,native,userPreferred}bannerImage,coverImage{medium,large}}}...on MediaMergeNotification{id,type,mediaId,deletedMediaTitles,context,reason,createdAt,media{id,title{romaji,english,native,userPreferred}bannerImage,coverImage{medium,large}}}...on MediaDeletionNotification{id,type,deletedMediaTitle,context,reason,createdAt,}}}}""",
@@ -1583,7 +1622,12 @@ Page(page:$page,perPage:50) {
         return res
     }
 
-    suspend fun getFeed(userId: Int?, global: Boolean = false, page: Int = 1, activityId: Int? = null): FeedResponse? {
+    suspend fun getFeed(
+        userId: Int?,
+        global: Boolean = false,
+        page: Int = 1,
+        activityId: Int? = null
+    ): FeedResponse? {
         val filter = if (activityId != null) "id:$activityId,"
         else if (userId != null) "userId:$userId,"
         else if (global) "isFollowing:false,hasRepliesOrTypeText:true,"
@@ -1612,14 +1656,26 @@ Page(page:$page,perPage:50) {
             .filter { it.timeUntilAiring != null }
     }
 
-    suspend fun isUserFav(favType: AnilistMutations.FavType, id: Int): Boolean {   //anilist isFavourite is broken, so we need to check it manually
-        val res = getUserProfile(Anilist.userid?: return false)
+    suspend fun isUserFav(
+        favType: AnilistMutations.FavType,
+        id: Int
+    ): Boolean {   //anilist isFavourite is broken, so we need to check it manually
+        val res = getUserProfile(Anilist.userid ?: return false)
         return when (favType) {
-            AnilistMutations.FavType.ANIME -> res?.data?.user?.favourites?.anime?.nodes?.any { it.id == id } ?: false
-            AnilistMutations.FavType.MANGA -> res?.data?.user?.favourites?.manga?.nodes?.any { it.id == id } ?: false
-            AnilistMutations.FavType.CHARACTER -> res?.data?.user?.favourites?.characters?.nodes?.any { it.id == id } ?: false
-            AnilistMutations.FavType.STAFF -> res?.data?.user?.favourites?.staff?.nodes?.any { it.id == id } ?: false
-            AnilistMutations.FavType.STUDIO -> res?.data?.user?.favourites?.studios?.nodes?.any { it.id == id } ?: false
+            AnilistMutations.FavType.ANIME -> res?.data?.user?.favourites?.anime?.nodes?.any { it.id == id }
+                ?: false
+
+            AnilistMutations.FavType.MANGA -> res?.data?.user?.favourites?.manga?.nodes?.any { it.id == id }
+                ?: false
+
+            AnilistMutations.FavType.CHARACTER -> res?.data?.user?.favourites?.characters?.nodes?.any { it.id == id }
+                ?: false
+
+            AnilistMutations.FavType.STAFF -> res?.data?.user?.favourites?.staff?.nodes?.any { it.id == id }
+                ?: false
+
+            AnilistMutations.FavType.STUDIO -> res?.data?.user?.favourites?.studios?.nodes?.any { it.id == id }
+                ?: false
         }
     }
 

app/src/main/java/ani/dantotsu/connections/anilist/AnilistViewModel.kt

@@ -5,9 +5,6 @@ import androidx.fragment.app.FragmentActivity
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.ViewModel
-import androidx.webkit.internal.ApiFeature.M
-import androidx.webkit.internal.ApiFeature.P
-import androidx.webkit.internal.StartupApiFeature
 import ani.dantotsu.BuildConfig
 import ani.dantotsu.R
 import ani.dantotsu.connections.discord.Discord
@@ -190,21 +187,25 @@ class AnilistAnimeViewModel : ViewModel() {
     var loaded: Boolean = false
     private val updated: MutableLiveData<MutableList<Media>> =
         MutableLiveData<MutableList<Media>>(null)
+
     fun getUpdated(): LiveData<MutableList<Media>> = updated
 
     private val popularMovies: MutableLiveData<MutableList<Media>> =
         MutableLiveData<MutableList<Media>>(null)
+
     fun getMovies(): LiveData<MutableList<Media>> = popularMovies
 
     private val topRatedAnime: MutableLiveData<MutableList<Media>> =
         MutableLiveData<MutableList<Media>>(null)
+
     fun getTopRated(): LiveData<MutableList<Media>> = topRatedAnime
 
     private val mostFavAnime: MutableLiveData<MutableList<Media>> =
         MutableLiveData<MutableList<Media>>(null)
+
     fun getMostFav(): LiveData<MutableList<Media>> = mostFavAnime
     suspend fun loadAll() {
-        val list= Anilist.query.loadAnimeList()
+        val list = Anilist.query.loadAnimeList()
         updated.postValue(list["recentUpdates"])
         popularMovies.postValue(list["trendingMovies"])
         topRatedAnime.postValue(list["topRated"])
@@ -283,22 +284,27 @@ class AnilistMangaViewModel : ViewModel() {
 
     private val popularManga: MutableLiveData<MutableList<Media>> =
         MutableLiveData<MutableList<Media>>(null)
+
     fun getPopularManga(): LiveData<MutableList<Media>> = popularManga
 
     private val popularManhwa: MutableLiveData<MutableList<Media>> =
         MutableLiveData<MutableList<Media>>(null)
+
     fun getPopularManhwa(): LiveData<MutableList<Media>> = popularManhwa
 
     private val popularNovel: MutableLiveData<MutableList<Media>> =
         MutableLiveData<MutableList<Media>>(null)
+
     fun getPopularNovel(): LiveData<MutableList<Media>> = popularNovel
 
     private val topRatedManga: MutableLiveData<MutableList<Media>> =
         MutableLiveData<MutableList<Media>>(null)
+
     fun getTopRated(): LiveData<MutableList<Media>> = topRatedManga
 
     private val mostFavManga: MutableLiveData<MutableList<Media>> =
         MutableLiveData<MutableList<Media>>(null)
+
     fun getMostFav(): LiveData<MutableList<Media>> = mostFavManga
     suspend fun loadAll() {
         val list = Anilist.query.loadMangaList()

app/src/main/java/ani/dantotsu/connections/anilist/Login.kt

@@ -4,7 +4,6 @@ import android.net.Uri
 import android.os.Bundle
 import androidx.appcompat.app.AppCompatActivity
 import ani.dantotsu.logError
-import ani.dantotsu.util.Logger
 import ani.dantotsu.settings.saving.PrefManager
 import ani.dantotsu.settings.saving.PrefName
 import ani.dantotsu.startMainActivity

app/src/main/java/ani/dantotsu/connections/anilist/SearchResults.kt

@@ -11,7 +11,7 @@ data class SearchResults(
     var onList: Boolean? = null,
     var perPage: Int? = null,
     var search: String? = null,
-    var countryOfOrigin :String? = null,
+    var countryOfOrigin: String? = null,
     var sort: String? = null,
     var genres: MutableList<String>? = null,
     var excludedGenres: MutableList<String>? = null,

app/src/main/java/ani/dantotsu/connections/anilist/api/Data.kt

@@ -149,8 +149,10 @@ class Query {
         @Serializable
         data class Data(
             @SerialName("favoriteAnime") val favoriteAnime: ani.dantotsu.connections.anilist.api.User?,
-            @SerialName("favoriteManga") val favoriteManga: ani.dantotsu.connections.anilist.api.User?)
+            @SerialName("favoriteManga") val favoriteManga: ani.dantotsu.connections.anilist.api.User?
+        )
     }
+
     @Serializable
     data class AnimeList(
         @SerialName("data")
@@ -168,6 +170,7 @@ class Query {
             @SerialName("mostFav2") val mostFav2: ani.dantotsu.connections.anilist.api.Page?,
         )
     }
+
     @Serializable
     data class MangaList(
         @SerialName("data")
@@ -187,6 +190,7 @@ class Query {
             @SerialName("mostFav2") val mostFav2: ani.dantotsu.connections.anilist.api.Page?,
         )
     }
+
     @Serializable
     data class ToggleFollow(
         @SerialName("data")
@@ -317,13 +321,13 @@ class Query {
         val statistics: NNUserStatisticTypes,
         @SerialName("siteUrl")
         val siteUrl: String,
-    ): java.io.Serializable
+    ) : java.io.Serializable
 
     @Serializable
     data class NNUserStatisticTypes(
         @SerialName("anime") var anime: NNUserStatistics,
         @SerialName("manga") var manga: NNUserStatistics
-    ): java.io.Serializable
+    ) : java.io.Serializable
 
     @Serializable
     data class NNUserStatistics(
@@ -334,7 +338,7 @@ class Query {
         @SerialName("episodesWatched") var episodesWatched: Int,
         @SerialName("chaptersRead") var chaptersRead: Int,
         @SerialName("volumesRead") var volumesRead: Int,
-    ): java.io.Serializable
+    ) : java.io.Serializable
 
     @Serializable
     data class UserFavourites(
@@ -348,13 +352,13 @@ class Query {
         val staff: UserStaffFavouritesCollection,
         @SerialName("studios")
         val studios: UserStudioFavouritesCollection,
-    ): java.io.Serializable
+    ) : java.io.Serializable
 
     @Serializable
     data class UserMediaFavouritesCollection(
         @SerialName("nodes")
         val nodes: List<UserMediaImageFavorite>,
-    ): java.io.Serializable
+    ) : java.io.Serializable
 
     @Serializable
     data class UserMediaImageFavorite(
@@ -362,13 +366,13 @@ class Query {
         val id: Int,
         @SerialName("coverImage")
         val coverImage: MediaCoverImage
-    ): java.io.Serializable
+    ) : java.io.Serializable
 
     @Serializable
     data class UserCharacterFavouritesCollection(
         @SerialName("nodes")
         val nodes: List<UserCharacterImageFavorite>,
-    ): java.io.Serializable
+    ) : java.io.Serializable
 
     @Serializable
     data class UserCharacterImageFavorite(
@@ -380,19 +384,19 @@ class Query {
         val image: CharacterImage,
         @SerialName("isFavourite")
         val isFavourite: Boolean
-    ): java.io.Serializable
+    ) : java.io.Serializable
 
     @Serializable
     data class UserStaffFavouritesCollection(
         @SerialName("nodes")
         val nodes: List<UserCharacterImageFavorite>, //downstream it's the same as character
-    ): java.io.Serializable
+    ) : java.io.Serializable
 
     @Serializable
     data class UserStudioFavouritesCollection(
         @SerialName("nodes")
         val nodes: List<UserStudioFavorite>,
-    ): java.io.Serializable
+    ) : java.io.Serializable
 
     @Serializable
     data class UserStudioFavorite(
@@ -400,7 +404,7 @@ class Query {
         val id: Int,
         @SerialName("name")
         val name: String,
-    ): java.io.Serializable
+    ) : java.io.Serializable
 
     //----------------------------------------
     // Statistics
@@ -409,12 +413,12 @@ class Query {
     data class StatisticsResponse(
         @SerialName("data")
         val data: Data
-    ): java.io.Serializable {
+    ) : java.io.Serializable {
         @Serializable
         data class Data(
             @SerialName("User")
             val user: StatisticsUser?
-        ): java.io.Serializable
+        ) : java.io.Serializable
     }
 
     @Serializable

app/src/main/java/ani/dantotsu/connections/anilist/api/Notification.kt

@@ -21,6 +21,7 @@ enum class NotificationType(val value: String) {
     MEDIA_DATA_CHANGE("MEDIA_DATA_CHANGE"),
     MEDIA_MERGE("MEDIA_MERGE"),
     MEDIA_DELETION("MEDIA_DELETION"),
+
     //custom
     COMMENT_REPLY("COMMENT_REPLY"),
 }
@@ -84,9 +85,9 @@ data class Notification(
     @SerialName("createdAt")
     val createdAt: Int,
     @SerialName("media")
-    val media: ani.dantotsu.connections.anilist.api.Media? = null,
+    val media: Media? = null,
     @SerialName("user")
-    val user: ani.dantotsu.connections.anilist.api.User? = null,
+    val user: User? = null,
     @SerialName("message")
     val message: MessageActivity? = null,
     @SerialName("activity")

app/src/main/java/ani/dantotsu/connections/anilist/api/Staff.kt

@@ -93,6 +93,7 @@ data class StaffConnection(
     // The pagination information
     // @SerialName("pageInfo") var pageInfo: PageInfo?,
 )
+
 @Serializable
 data class StaffImage(
     // The character's image of media at its largest size
@@ -101,6 +102,7 @@ data class StaffImage(
     // The character's image of media at medium size
     @SerialName("medium") var medium: String?,
 ) : java.io.Serializable
+
 @Serializable
 data class StaffEdge(
     var role: String?,

app/src/main/java/ani/dantotsu/connections/anilist/api/User.kt

@@ -111,7 +111,7 @@ data class UserAvatar(
 
     // The avatar of user at medium size
     @SerialName("medium") var medium: String?,
-): java.io.Serializable
+) : java.io.Serializable
 
 @Serializable
 data class UserStatisticTypes(

app/src/main/java/ani/dantotsu/connections/bakaupdates/MangaUpdates.kt

@@ -24,7 +24,7 @@ class MangaUpdates {
 
     private val apiUrl = "https://api.mangaupdates.com/v1/releases/search"
 
-    suspend fun search(title: String, startDate: FuzzyDate?) : MangaUpdatesResponse.Results? {
+    suspend fun search(title: String, startDate: FuzzyDate?): MangaUpdatesResponse.Results? {
         return tryWithSuspend {
             val query = JSONObject().apply {
                 try {
@@ -96,6 +96,7 @@ class MangaUpdates {
                 @SerialName("release_date")
                 val releaseDate: String
             )
+
             @Serializable
             data class MetaData(
                 val series: Series

app/src/main/java/ani/dantotsu/connections/comments/CommentsAPI.kt

@@ -32,7 +32,12 @@ object CommentsAPI {
     var isMod: Boolean = false
     var totalVotes: Int = 0
 
-    suspend fun getCommentsForId(id: Int, page: Int = 1, tag: Int?, sort: String?): CommentResponse? {
+    suspend fun getCommentsForId(
+        id: Int,
+        page: Int = 1,
+        tag: Int?,
+        sort: String?
+    ): CommentResponse? {
         var url = "$ADDRESS/comments/$id/$page"
         val request = requestBuilder()
         tag?.let {
@@ -399,7 +404,7 @@ object CommentsAPI {
             null
         }
         val message = parsed?.message ?: reason ?: error
-        val fullMessage = if(code == 500) message else "$code: $message"
+        val fullMessage = if (code == 500) message else "$code: $message"
 
         toast(fullMessage)
     }

app/src/main/java/ani/dantotsu/connections/crashlytics/CrashlyticsStub.kt

@@ -7,6 +7,7 @@ class CrashlyticsStub : CrashlyticsInterface {
     override fun initialize(context: Context) {
         //no-op
     }
+
     override fun logException(e: Throwable) {
         Logger.log(e)
     }

app/src/main/java/ani/dantotsu/connections/discord/DiscordService.kt

@@ -63,7 +63,7 @@ class DiscordService : Service() {
             PowerManager.PARTIAL_WAKE_LOCK,
             "discordRPC:backgroundPresence"
         )
-        wakeLock.acquire(30*60*1000L /*30 minutes*/)
+        wakeLock.acquire(30 * 60 * 1000L /*30 minutes*/)
         log("WakeLock Acquired")
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             val serviceChannel = NotificationChannel(
@@ -402,7 +402,8 @@ class DiscordService : Service() {
                 Thread.sleep(heartbeat.toLong())
                 heartbeatSend(webSocket, sequence)
                 log("WebSocket: Heartbeat Sent")
-            } catch (ignored: InterruptedException) { }
+            } catch (ignored: InterruptedException) {
+            }
         }
     }
 

app/src/main/java/ani/dantotsu/connections/discord/RPC.kt

@@ -71,7 +71,7 @@ open class RPC(val token: String, val coroutineContext: CoroutineContext) {
                             assets = Activity.Assets(
                                 largeImage = data.largeImage?.url?.discordUrl(),
                                 largeText = data.largeImage?.label,
-                                smallImage = if (PrefManager.getVal(PrefName.ShowAniListIcon))  Discord.small_Image_AniList.discordUrl() else Discord.small_Image.discordUrl(),
+                                smallImage = if (PrefManager.getVal(PrefName.ShowAniListIcon)) Discord.small_Image_AniList.discordUrl() else Discord.small_Image.discordUrl(),
                                 smallText = if (PrefManager.getVal(PrefName.ShowAniListIcon)) "Anilist" else "Dantotsu",
                             ),
                             buttons = data.buttons.map { it.label },

app/src/main/java/ani/dantotsu/connections/github/Forks.kt

@@ -1,9 +1,7 @@
 package ani.dantotsu.connections.github
 
 import ani.dantotsu.Mapper
-import ani.dantotsu.R
 import ani.dantotsu.client
-import ani.dantotsu.getAppString
 import ani.dantotsu.settings.Developer
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runBlocking
@@ -17,10 +15,11 @@ class Forks {
     fun getForks(): Array<Developer> {
         var forks = arrayOf<Developer>()
         runBlocking(Dispatchers.IO) {
-            val res = client.get("https://api.github.com/repos/rebelonion/Dantotsu/forks?sort=stargazers")
-                .parsed<JsonArray>().map {
-                    Mapper.json.decodeFromJsonElement<GithubResponse>(it)
-                }
+            val res =
+                client.get("https://api.github.com/repos/rebelonion/Dantotsu/forks?sort=stargazers")
+                    .parsed<JsonArray>().map {
+                        Mapper.json.decodeFromJsonElement<GithubResponse>(it)
+                    }
             res.forEach {
                 forks = forks.plus(
                     Developer(

app/src/main/java/ani/dantotsu/download/DownloadCompat.kt

@@ -0,0 +1,381 @@
+package ani.dantotsu.download
+
+import android.content.Context
+import android.net.Uri
+import android.os.Environment
+import android.widget.Toast
+import ani.dantotsu.R
+import ani.dantotsu.connections.crashlytics.CrashlyticsInterface
+import ani.dantotsu.currActivity
+import ani.dantotsu.currContext
+import ani.dantotsu.download.anime.OfflineAnimeModel
+import ani.dantotsu.download.manga.OfflineMangaModel
+import ani.dantotsu.media.Media
+import ani.dantotsu.media.MediaNameAdapter
+import ani.dantotsu.media.MediaType
+import ani.dantotsu.parsers.Episode
+import ani.dantotsu.parsers.MangaChapter
+import ani.dantotsu.parsers.MangaImage
+import ani.dantotsu.parsers.Subtitle
+import ani.dantotsu.parsers.SubtitleType
+import ani.dantotsu.util.Logger
+import com.google.gson.GsonBuilder
+import com.google.gson.InstanceCreator
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.animesource.model.SAnimeImpl
+import eu.kanade.tachiyomi.animesource.model.SEpisode
+import eu.kanade.tachiyomi.animesource.model.SEpisodeImpl
+import eu.kanade.tachiyomi.source.model.SChapter
+import eu.kanade.tachiyomi.source.model.SChapterImpl
+import eu.kanade.tachiyomi.source.model.SManga
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.io.File
+import java.util.Locale
+
+@Deprecated("external storage is deprecated, use SAF instead")
+class DownloadCompat {
+    companion object {
+        @Deprecated("external storage is deprecated, use SAF instead")
+        fun loadMediaCompat(downloadedType: DownloadedType): Media? {
+            val type = when (downloadedType.type) {
+                MediaType.MANGA -> "Manga"
+                MediaType.ANIME -> "Anime"
+                else -> "Novel"
+            }
+            val directory = File(
+                currContext()?.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS),
+                "Dantotsu/$type/${downloadedType.titleName}"
+            )
+            //load media.json and convert to media class with gson
+            return try {
+                val gson = GsonBuilder()
+                    .registerTypeAdapter(SChapter::class.java, InstanceCreator<SChapter> {
+                        SChapterImpl() // Provide an instance of SChapterImpl
+                    })
+                    .registerTypeAdapter(SAnime::class.java, InstanceCreator<SAnime> {
+                        SAnimeImpl() // Provide an instance of SAnimeImpl
+                    })
+                    .registerTypeAdapter(SEpisode::class.java, InstanceCreator<SEpisode> {
+                        SEpisodeImpl() // Provide an instance of SEpisodeImpl
+                    })
+                    .create()
+                val media = File(directory, "media.json")
+                val mediaJson = media.readText()
+                gson.fromJson(mediaJson, Media::class.java)
+            } catch (e: Exception) {
+                Logger.log("Error loading media.json: ${e.message}")
+                Logger.log(e)
+                Injekt.get<CrashlyticsInterface>().logException(e)
+                null
+            }
+        }
+
+        @Deprecated("external storage is deprecated, use SAF instead")
+        fun loadOfflineAnimeModelCompat(downloadedType: DownloadedType): OfflineAnimeModel {
+            val type = when (downloadedType.type) {
+                MediaType.MANGA -> "Manga"
+                MediaType.ANIME -> "Anime"
+                else -> "Novel"
+            }
+            val directory = File(
+                currContext()?.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS),
+                "Dantotsu/$type/${downloadedType.titleName}"
+            )
+            //load media.json and convert to media class with gson
+            try {
+                val mediaModel = loadMediaCompat(downloadedType)!!
+                val cover = File(directory, "cover.jpg")
+                val coverUri: Uri? = if (cover.exists()) {
+                    Uri.fromFile(cover)
+                } else null
+                val banner = File(directory, "banner.jpg")
+                val bannerUri: Uri? = if (banner.exists()) {
+                    Uri.fromFile(banner)
+                } else null
+                val title = mediaModel.mainName()
+                val score = ((if (mediaModel.userScore == 0) (mediaModel.meanScore
+                    ?: 0) else mediaModel.userScore) / 10.0).toString()
+                val isOngoing =
+                    mediaModel.status == currActivity()!!.getString(R.string.status_releasing)
+                val isUserScored = mediaModel.userScore != 0
+                val watchedEpisodes = (mediaModel.userProgress ?: "~").toString()
+                val totalEpisode =
+                    if (mediaModel.anime?.nextAiringEpisode != null) (mediaModel.anime.nextAiringEpisode.toString() + " | " + (mediaModel.anime.totalEpisodes
+                        ?: "~").toString()) else (mediaModel.anime?.totalEpisodes ?: "~").toString()
+                val chapters = " Chapters"
+                val totalEpisodesList =
+                    if (mediaModel.anime?.nextAiringEpisode != null) (mediaModel.anime.nextAiringEpisode.toString()) else (mediaModel.anime?.totalEpisodes
+                        ?: "~").toString()
+                return OfflineAnimeModel(
+                    title,
+                    score,
+                    totalEpisode,
+                    totalEpisodesList,
+                    watchedEpisodes,
+                    type,
+                    chapters,
+                    isOngoing,
+                    isUserScored,
+                    coverUri,
+                    bannerUri
+                )
+            } catch (e: Exception) {
+                Logger.log("Error loading media.json: ${e.message}")
+                Logger.log(e)
+                Injekt.get<CrashlyticsInterface>().logException(e)
+                return OfflineAnimeModel(
+                    "unknown",
+                    "0",
+                    "??",
+                    "??",
+                    "??",
+                    "movie",
+                    "hmm",
+                    isOngoing = false,
+                    isUserScored = false,
+                    null,
+                    null
+                )
+            }
+        }
+
+        @Deprecated("external storage is deprecated, use SAF instead")
+        fun loadOfflineMangaModelCompat(downloadedType: DownloadedType): OfflineMangaModel {
+            val type = when (downloadedType.type) {
+                MediaType.MANGA -> "Manga"
+                MediaType.ANIME -> "Anime"
+                else -> "Novel"
+            }
+            val directory = File(
+                currContext()?.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS),
+                "Dantotsu/$type/${downloadedType.titleName}"
+            )
+            //load media.json and convert to media class with gson
+            try {
+                val mediaModel = loadMediaCompat(downloadedType)!!
+                val cover = File(directory, "cover.jpg")
+                val coverUri: Uri? = if (cover.exists()) {
+                    Uri.fromFile(cover)
+                } else null
+                val banner = File(directory, "banner.jpg")
+                val bannerUri: Uri? = if (banner.exists()) {
+                    Uri.fromFile(banner)
+                } else null
+                val title = mediaModel.mainName()
+                val score = ((if (mediaModel.userScore == 0) (mediaModel.meanScore
+                    ?: 0) else mediaModel.userScore) / 10.0).toString()
+                val isOngoing =
+                    mediaModel.status == currActivity()!!.getString(R.string.status_releasing)
+                val isUserScored = mediaModel.userScore != 0
+                val readchapter = (mediaModel.userProgress ?: "~").toString()
+                val totalchapter = "${mediaModel.manga?.totalChapters ?: "??"}"
+                val chapters = " Chapters"
+                return OfflineMangaModel(
+                    title,
+                    score,
+                    totalchapter,
+                    readchapter,
+                    type,
+                    chapters,
+                    isOngoing,
+                    isUserScored,
+                    coverUri,
+                    bannerUri
+                )
+            } catch (e: Exception) {
+                Logger.log("Error loading media.json: ${e.message}")
+                Logger.log(e)
+                Injekt.get<CrashlyticsInterface>().logException(e)
+                return OfflineMangaModel(
+                    "unknown",
+                    "0",
+                    "??",
+                    "??",
+                    "movie",
+                    "hmm",
+                    isOngoing = false,
+                    isUserScored = false,
+                    null,
+                    null
+                )
+            }
+        }
+
+        @Deprecated("external storage is deprecated, use SAF instead")
+        suspend fun loadEpisodesCompat(
+            animeLink: String,
+            extra: Map<String, String>?,
+            sAnime: SAnime
+        ): List<Episode> {
+
+            val directory = File(
+                currContext()?.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS),
+                "${animeLocation}/$animeLink"
+            )
+            //get all of the folder names and add them to the list
+            val episodes = mutableListOf<Episode>()
+            if (directory.exists()) {
+                directory.listFiles()?.forEach {
+                    //put the title and episdode number in the extra data
+                    val extraData = mutableMapOf<String, String>()
+                    extraData["title"] = animeLink
+                    extraData["episode"] = it.name
+                    if (it.isDirectory) {
+                        val episode = Episode(
+                            it.name,
+                            "$animeLink - ${it.name}",
+                            it.name,
+                            null,
+                            null,
+                            extra = extraData,
+                            sEpisode = SEpisodeImpl()
+                        )
+                        episodes.add(episode)
+                    }
+                }
+                episodes.sortBy { MediaNameAdapter.findEpisodeNumber(it.number) }
+                return episodes
+            }
+            return emptyList()
+        }
+
+        @Deprecated("external storage is deprecated, use SAF instead")
+        suspend fun loadChaptersCompat(
+            mangaLink: String,
+            extra: Map<String, String>?,
+            sManga: SManga
+        ): List<MangaChapter> {
+            val directory = File(
+                currContext()?.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS),
+                "Dantotsu/Manga/$mangaLink"
+            )
+            //get all of the folder names and add them to the list
+            val chapters = mutableListOf<MangaChapter>()
+            if (directory.exists()) {
+                directory.listFiles()?.forEach {
+                    if (it.isDirectory) {
+                        val chapter = MangaChapter(
+                            it.name,
+                            "$mangaLink/${it.name}",
+                            it.name,
+                            null,
+                            null,
+                            SChapter.create()
+                        )
+                        chapters.add(chapter)
+                    }
+                }
+                chapters.sortBy { MediaNameAdapter.findChapterNumber(it.number) }
+                return chapters
+            }
+            return emptyList()
+        }
+
+        @Deprecated("external storage is deprecated, use SAF instead")
+        suspend fun loadImagesCompat(chapterLink: String, sChapter: SChapter): List<MangaImage> {
+            val directory = File(
+                currContext()?.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS),
+                "Dantotsu/Manga/$chapterLink"
+            )
+            val images = mutableListOf<MangaImage>()
+            val imageNumberRegex = Regex("""(\d+)\.jpg$""")
+            if (directory.exists()) {
+                directory.listFiles()?.forEach {
+                    if (it.isFile) {
+                        val image = MangaImage(it.absolutePath, false, null)
+                        images.add(image)
+                    }
+                }
+                images.sortBy { image ->
+                    val matchResult = imageNumberRegex.find(image.url.url)
+                    matchResult?.groups?.get(1)?.value?.toIntOrNull() ?: Int.MAX_VALUE
+                }
+                for (image in images) {
+                    Logger.log("imageNumber: ${image.url.url}")
+                }
+                return images
+            }
+            return emptyList()
+        }
+
+        @Deprecated("external storage is deprecated, use SAF instead")
+        fun loadSubtitleCompat(title: String, episode: String): List<Subtitle>? {
+            currContext()?.let {
+                File(
+                    it.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS),
+                    "$animeLocation/$title/$episode"
+                ).listFiles()?.forEach {
+                    if (it.name.contains("subtitle")) {
+                        return listOf(
+                            Subtitle(
+                                "Downloaded Subtitle",
+                                Uri.fromFile(it).toString(),
+                                determineSubtitletype(it.absolutePath)
+                            )
+                        )
+                    }
+                }
+            }
+            return null
+        }
+
+        private fun determineSubtitletype(url: String): SubtitleType {
+            return when {
+                url.lowercase(Locale.ROOT).endsWith("ass") -> SubtitleType.ASS
+                url.lowercase(Locale.ROOT).endsWith("vtt") -> SubtitleType.VTT
+                else -> SubtitleType.SRT
+            }
+        }
+
+        @Deprecated("external storage is deprecated, use SAF instead")
+        fun removeMediaCompat(context: Context, title: String, type: MediaType) {
+            val subDirectory = if (type == MediaType.MANGA) {
+                "Manga"
+            } else if (type == MediaType.ANIME) {
+                "Anime"
+            } else {
+                "Novel"
+            }
+            val directory = File(
+                context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS),
+                "Dantotsu/$subDirectory/$title"
+            )
+            if (directory.exists()) {
+                directory.deleteRecursively()
+            }
+        }
+
+        @Deprecated("external storage is deprecated, use SAF instead")
+        fun removeDownloadCompat(context: Context, downloadedType: DownloadedType) {
+            val directory = if (downloadedType.type == MediaType.MANGA) {
+                File(
+                    context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS),
+                    "Dantotsu/Manga/${downloadedType.titleName}/${downloadedType.chapterName}"
+                )
+            } else if (downloadedType.type == MediaType.ANIME) {
+                File(
+                    context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS),
+                    "Dantotsu/Anime/${downloadedType.titleName}/${downloadedType.chapterName}"
+                )
+            } else {
+                File(
+                    context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS),
+                    "Dantotsu/Novel/${downloadedType.titleName}/${downloadedType.chapterName}"
+                )
+            }
+
+            // Check if the directory exists and delete it recursively
+            if (directory.exists()) {
+                val deleted = directory.deleteRecursively()
+                if (deleted) {
+                    Toast.makeText(context, "Successfully deleted", Toast.LENGTH_SHORT).show()
+                } else {
+                    Toast.makeText(context, "Failed to delete directory", Toast.LENGTH_SHORT).show()
+                }
+            }
+        }
+
+        private val animeLocation = "Dantotsu/Anime"
+    }
+}

app/src/main/java/ani/dantotsu/download/DownloadsManager.kt

@@ -3,6 +3,8 @@ package ani.dantotsu.download
 import android.content.Context
 import android.net.Uri
 import androidx.documentfile.provider.DocumentFile
+import ani.dantotsu.download.DownloadCompat.Companion.removeDownloadCompat
+import ani.dantotsu.download.DownloadCompat.Companion.removeMediaCompat
 import ani.dantotsu.media.Media
 import ani.dantotsu.media.MediaType
 import ani.dantotsu.settings.saving.PrefManager
@@ -53,7 +55,12 @@ class DownloadsManager(private val context: Context) {
         saveDownloads()
     }
 
-    fun removeDownload(downloadedType: DownloadedType, toast: Boolean = true, onFinished: () -> Unit) {
+    fun removeDownload(
+        downloadedType: DownloadedType,
+        toast: Boolean = true,
+        onFinished: () -> Unit
+    ) {
+        removeDownloadCompat(context, downloadedType)
         downloadsList.remove(downloadedType)
         CoroutineScope(Dispatchers.IO).launch {
             removeDirectory(downloadedType, toast)
@@ -65,6 +72,7 @@ class DownloadsManager(private val context: Context) {
     }
 
     fun removeMedia(title: String, type: MediaType) {
+        removeMediaCompat(context, title, type)
         val baseDirectory = getBaseDirectory(context, type)
         val directory = baseDirectory?.findFolder(title)
         if (directory?.exists() == true) {
@@ -80,15 +88,15 @@ class DownloadsManager(private val context: Context) {
         }
         when (type) {
             MediaType.MANGA -> {
-                downloadsList.removeAll { it.title == title && it.type == MediaType.MANGA }
+                downloadsList.removeAll { it.titleName == title && it.type == MediaType.MANGA }
             }
 
             MediaType.ANIME -> {
-                downloadsList.removeAll { it.title == title && it.type == MediaType.ANIME }
+                downloadsList.removeAll { it.titleName == title && it.type == MediaType.ANIME }
             }
 
             MediaType.NOVEL -> {
-                downloadsList.removeAll { it.title == title && it.type == MediaType.NOVEL }
+                downloadsList.removeAll { it.titleName == title && it.type == MediaType.NOVEL }
             }
         }
         saveDownloads()
@@ -111,7 +119,7 @@ class DownloadsManager(private val context: Context) {
         if (directory?.exists() == true && directory.isDirectory) {
             val files = directory.listFiles()
             for (file in files) {
-                if (!downloadsSubLists.any { it.title == file.name }) {
+                if (!downloadsSubLists.any { it.titleName == file.name }) {
                     file.deleteRecursively(context, false)
                 }
             }
@@ -120,8 +128,8 @@ class DownloadsManager(private val context: Context) {
         val iterator = downloadsList.iterator()
         while (iterator.hasNext()) {
             val download = iterator.next()
-            val downloadDir = directory?.findFolder(download.title)
-            if ((downloadDir?.exists() == false && download.type == type) || download.title.isBlank()) {
+            val downloadDir = directory?.findFolder(download.titleName)
+            if ((downloadDir?.exists() == false && download.type == type) || download.titleName.isBlank()) {
                 iterator.remove()
             }
         }
@@ -207,16 +215,17 @@ class DownloadsManager(private val context: Context) {
 
     fun queryDownload(title: String, chapter: String, type: MediaType? = null): Boolean {
         return if (type == null) {
-            downloadsList.any { it.title == title && it.chapter == chapter }
+            downloadsList.any { it.titleName == title && it.chapterName == chapter }
         } else {
-            downloadsList.any { it.title == title && it.chapter == chapter && it.type == type }
+            downloadsList.any { it.titleName == title && it.chapterName == chapter && it.type == type }
         }
     }
 
     private fun removeDirectory(downloadedType: DownloadedType, toast: Boolean) {
         val baseDirectory = getBaseDirectory(context, downloadedType.type)
         val directory =
-            baseDirectory?.findFolder(downloadedType.title)?.findFolder(downloadedType.chapter)
+            baseDirectory?.findFolder(downloadedType.titleName)
+                ?.findFolder(downloadedType.chapterName)
         downloadsList.remove(downloadedType)
         // Check if the directory exists and delete it recursively
         if (directory?.exists() == true) {
@@ -360,15 +369,21 @@ class DownloadsManager(private val context: Context) {
 }
 
 private const val RESERVED_CHARS = "|\\?*<\":>+[]/'"
-private fun String?.findValidName(): String {
+fun String?.findValidName(): String {
     return this?.filterNot { RESERVED_CHARS.contains(it) } ?: ""
 }
 
 data class DownloadedType(
-    val pTitle: String, val pChapter: String, val type: MediaType
+    private val pTitle: String?,
+    private val pChapter: String?,
+    val type: MediaType,
+    @Deprecated("use pTitle instead")
+    private val title: String? = null,
+    @Deprecated("use pChapter instead")
+    private val chapter: String? = null
 ) : Serializable {
-    val title: String
-        get() = pTitle.findValidName()
-    val chapter: String
-        get() = pChapter.findValidName()
+    val titleName: String
+        get() = title?:pTitle.findValidName()
+    val chapterName: String
+        get() = chapter?:pChapter.findValidName()
 }

app/src/main/java/ani/dantotsu/download/anime/AnimeDownloaderService.kt

@@ -19,6 +19,7 @@ import androidx.documentfile.provider.DocumentFile
 import androidx.media3.common.util.UnstableApi
 import ani.dantotsu.FileUrl
 import ani.dantotsu.R
+import ani.dantotsu.addons.download.DownloadAddonManager
 import ani.dantotsu.connections.crashlytics.CrashlyticsInterface
 import ani.dantotsu.defaultHeaders
 import ani.dantotsu.download.DownloadedType
@@ -37,10 +38,6 @@ import ani.dantotsu.toast
 import ani.dantotsu.util.Logger
 import com.anggrayudi.storage.file.forceDelete
 import com.anggrayudi.storage.file.openOutputStream
-import com.arthenica.ffmpegkit.FFmpegKit
-import com.arthenica.ffmpegkit.FFmpegKitConfig
-import com.arthenica.ffmpegkit.FFprobeKit
-import com.arthenica.ffmpegkit.SessionState
 import com.google.gson.GsonBuilder
 import com.google.gson.InstanceCreator
 import eu.kanade.tachiyomi.animesource.model.SAnime
@@ -76,6 +73,7 @@ class AnimeDownloaderService : Service() {
     private val mutex = Mutex()
     private var isCurrentlyProcessing = false
     private var currentTasks: MutableList<AnimeDownloadTask> = mutableListOf()
+    private val ffExtension = Injekt.get<DownloadAddonManager>().extension?.extension
 
     override fun onBind(intent: Intent?): IBinder? {
         // This is only required for bound services.
@@ -84,6 +82,11 @@ class AnimeDownloaderService : Service() {
 
     override fun onCreate() {
         super.onCreate()
+        if (ffExtension == null) {
+            toast(getString(R.string.download_addon_not_found))
+            stopSelf()
+            return
+        }
         notificationManager = NotificationManagerCompat.from(this)
         builder =
             NotificationCompat.Builder(this, Notifications.CHANNEL_DOWNLOADER_PROGRESS).apply {
@@ -165,7 +168,7 @@ class AnimeDownloaderService : Service() {
                 .map { it.sessionId }.toMutableList()
         sessionIds.addAll(currentTasks.filter { it.getTaskName() == taskName }.map { it.sessionId })
         sessionIds.forEach {
-            FFmpegKit.cancel(it)
+            ffExtension!!.cancelDownload(it)
         }
         currentTasks.removeAll { it.getTaskName() == taskName }
         CoroutineScope(Dispatchers.Default).launch {
@@ -229,7 +232,7 @@ class AnimeDownloaderService : Service() {
 
                 var percent = 0
                 var totalLength = 0.0
-                val path = FFmpegKitConfig.getSafParameterForWrite(
+                val path = ffExtension!!.setDownloadPath(
                     this@AnimeDownloaderService,
                     outputFile.uri
                 )
@@ -241,50 +244,32 @@ class AnimeDownloaderService : Service() {
                     headersStringBuilder.append("\"").append("User-Agent: ")
                         .append(defaultHeaders["User-Agent"]).append("\"\'\r\n\'")
                 }
-                val probeRequest = "-headers $headersStringBuilder -i ${task.video.file.url} -show_entries format=duration -v quiet -of csv=\"p=0\""
-                FFprobeKit.executeAsync(
-                    probeRequest,
-                    {
-                        Logger.log("FFprobeKit: $it")
-                    }, {
-                        if (it.message.toDoubleOrNull() != null) {
-                            totalLength = it.message.toDouble()
-                        }
-                    })
+                val probeRequest =
+                    "-headers $headersStringBuilder -i ${task.video.file.url} -show_entries format=duration -v quiet -of csv=\"p=0\""
+                ffExtension.executeFFProbe(
+                    probeRequest
+                ) {
+                    if (it.toDoubleOrNull() != null) {
+                        totalLength = it.toDouble()
+                    }
+                }
 
                 val headers = headersStringBuilder.toString()
                 var request = "-headers $headers "
                 request += "-i ${task.video.file.url} -c copy -bsf:a aac_adtstoasc -tls_verify 0 $path -v trace"
                 Logger.log("Request: $request")
                 val ffTask =
-                    FFmpegKit.executeAsync(request,
-                        { session ->
-                            val state: SessionState = session.state
-                            val returnCode = session.returnCode
-                            // CALLED WHEN SESSION IS EXECUTED
-                            Logger.log(
-                                java.lang.String.format(
-                                    "FFmpeg process exited with state %s and rc %s.%s",
-                                    state,
-                                    returnCode,
-                                    session.failStackTrace
-                                )
-                            )
-
-                        }, {
-                            // CALLED WHEN SESSION PRINTS LOGS
-                            Logger.log(it.message)
-                        }) {
+                    ffExtension.executeFFMpeg(request) {
                         // CALLED WHEN SESSION GENERATES STATISTICS
-                        val timeInMilliseconds = it.time
+                        val timeInMilliseconds = it
                         if (timeInMilliseconds > 0 && totalLength > 0) {
-                            percent = ((it.time / 1000) / totalLength * 100).toInt()
+                            percent = ((it / 1000) / totalLength * 100).toInt()
                         }
                         Logger.log("Statistics: $it")
                     }
-                task.sessionId = ffTask.sessionId
+                task.sessionId = ffTask
                 currentTasks.find { it.getTaskName() == task.getTaskName() }?.sessionId =
-                    ffTask.sessionId
+                    ffTask
 
                 saveMediaInfo(task)
                 task.subtitle?.let {
@@ -300,8 +285,8 @@ class AnimeDownloaderService : Service() {
                 }
 
                 // periodically check if the download is complete
-                while (ffTask.state != SessionState.COMPLETED) {
-                    if (ffTask.state == SessionState.FAILED) {
+                while (ffExtension.getState(ffTask) != "COMPLETED") {
+                    if (ffExtension.getState(ffTask) == "FAILED") {
                         Logger.log("Download failed")
                         builder.setContentText(
                             "${
@@ -313,7 +298,7 @@ class AnimeDownloaderService : Service() {
                         )
                         notificationManager.notify(NOTIFICATION_ID, builder.build())
                         toast("${getTaskName(task.title, task.episode)} Download failed")
-                        Logger.log("Download failed: ${ffTask.failStackTrace}")
+                        Logger.log("Download failed: ${ffExtension.getStackTrace(ffTask)}")
                         downloadsManager.removeDownload(
                             DownloadedType(
                                 task.title,
@@ -348,8 +333,8 @@ class AnimeDownloaderService : Service() {
                     }
                     kotlinx.coroutines.delay(2000)
                 }
-                if (ffTask.state == SessionState.COMPLETED) {
-                    if (ffTask.returnCode.isValueError) {
+                if (ffExtension.getState(ffTask) == "COMPLETED") {
+                    if (ffExtension.hadError(ffTask)) {
                         Logger.log("Download failed")
                         builder.setContentText(
                             "${

app/src/main/java/ani/dantotsu/download/anime/OfflineAnimeFragment.kt

@@ -31,9 +31,12 @@ import ani.dantotsu.bottomBar
 import ani.dantotsu.connections.crashlytics.CrashlyticsInterface
 import ani.dantotsu.currActivity
 import ani.dantotsu.currContext
+import ani.dantotsu.download.DownloadCompat.Companion.loadMediaCompat
+import ani.dantotsu.download.DownloadCompat.Companion.loadOfflineAnimeModelCompat
 import ani.dantotsu.download.DownloadedType
 import ani.dantotsu.download.DownloadsManager
 import ani.dantotsu.download.DownloadsManager.Companion.compareName
+import ani.dantotsu.download.findValidName
 import ani.dantotsu.initActivity
 import ani.dantotsu.media.Media
 import ani.dantotsu.media.MediaDetailsActivity
@@ -175,7 +178,7 @@ class OfflineAnimeFragment : Fragment(), OfflineAnimeSearchListener {
             // Get the OfflineAnimeModel that was clicked
             val item = adapter.getItem(position) as OfflineAnimeModel
             val media =
-                downloadManager.animeDownloadedTypes.firstOrNull { it.title.compareName(item.title) }
+                downloadManager.animeDownloadedTypes.firstOrNull { it.titleName.compareName(item.title) }
             media?.let {
                 lifecycleScope.launch {
                     val mediaModel = getMedia(it)
@@ -287,10 +290,10 @@ class OfflineAnimeFragment : Fragment(), OfflineAnimeSearchListener {
         }
         downloadsJob = Job()
         CoroutineScope(Dispatchers.IO + downloadsJob).launch {
-            val animeTitles = downloadManager.animeDownloadedTypes.map { it.title }.distinct()
+            val animeTitles = downloadManager.animeDownloadedTypes.map { it.titleName.findValidName() }.distinct()
             val newAnimeDownloads = mutableListOf<OfflineAnimeModel>()
             for (title in animeTitles) {
-                val tDownloads = downloadManager.animeDownloadedTypes.filter { it.title == title }
+                val tDownloads = downloadManager.animeDownloadedTypes.filter { it.titleName == title }
                 val download = tDownloads.first()
                 val offlineAnimeModel = loadOfflineAnimeModel(download)
                 newAnimeDownloads += offlineAnimeModel
@@ -313,7 +316,7 @@ class OfflineAnimeFragment : Fragment(), OfflineAnimeSearchListener {
         return try {
             val directory = DownloadsManager.getSubDirectory(
                 context ?: currContext()!!, downloadedType.type,
-                false, downloadedType.title
+                false, downloadedType.titleName
             )
             val gson = GsonBuilder()
                 .registerTypeAdapter(SChapter::class.java, InstanceCreator<SChapter> {
@@ -327,7 +330,7 @@ class OfflineAnimeFragment : Fragment(), OfflineAnimeSearchListener {
                 })
                 .create()
             val media = directory?.findFile("media.json")
-                ?: return null
+                ?: return loadMediaCompat(downloadedType)
             val mediaJson =
                 media.openInputStream(context ?: currContext()!!)?.bufferedReader().use {
                     it?.readText()
@@ -352,7 +355,7 @@ class OfflineAnimeFragment : Fragment(), OfflineAnimeSearchListener {
         try {
             val directory = DownloadsManager.getSubDirectory(
                 context ?: currContext()!!, downloadedType.type,
-                false, downloadedType.title
+                false, downloadedType.titleName
             )
             val mediaModel = getMedia(downloadedType)!!
             val cover = directory?.findFile("cover.jpg")
@@ -363,6 +366,7 @@ class OfflineAnimeFragment : Fragment(), OfflineAnimeSearchListener {
             val bannerUri: Uri? = if (banner?.exists() == true) {
                 banner.uri
             } else null
+            if (coverUri == null && bannerUri == null) throw Exception("No cover or banner found, probably compat")
             val title = mediaModel.mainName()
             val score = ((if (mediaModel.userScore == 0) (mediaModel.meanScore
                 ?: 0) else mediaModel.userScore) / 10.0).toString()
@@ -391,22 +395,26 @@ class OfflineAnimeFragment : Fragment(), OfflineAnimeSearchListener {
                 bannerUri
             )
         } catch (e: Exception) {
-            Logger.log("Error loading media.json: ${e.message}")
-            Logger.log(e)
-            Injekt.get<CrashlyticsInterface>().logException(e)
-            return OfflineAnimeModel(
-                "unknown",
-                "0",
-                "??",
-                "??",
-                "??",
-                "movie",
-                "hmm",
-                isOngoing = false,
-                isUserScored = false,
-                null,
-                null
-            )
+            return try {
+                loadOfflineAnimeModelCompat(downloadedType)
+            } catch (e: Exception) {
+                Logger.log("Error loading media.json: ${e.message}")
+                Logger.log(e)
+                Injekt.get<CrashlyticsInterface>().logException(e)
+                OfflineAnimeModel(
+                    "unknown",
+                    "0",
+                    "??",
+                    "??",
+                    "??",
+                    "movie",
+                    "hmm",
+                    isOngoing = false,
+                    isUserScored = false,
+                    null,
+                    null
+                )
+            }
         }
     }
 }

app/src/main/java/ani/dantotsu/download/manga/OfflineMangaFragment.kt

@@ -28,10 +28,13 @@ import ani.dantotsu.bottomBar
 import ani.dantotsu.connections.crashlytics.CrashlyticsInterface
 import ani.dantotsu.currActivity
 import ani.dantotsu.currContext
+import ani.dantotsu.download.DownloadCompat
+import ani.dantotsu.download.DownloadCompat.Companion.loadOfflineMangaModelCompat
 import ani.dantotsu.download.DownloadedType
 import ani.dantotsu.download.DownloadsManager
 import ani.dantotsu.download.DownloadsManager.Companion.compareName
 import ani.dantotsu.download.DownloadsManager.Companion.getSubDirectory
+import ani.dantotsu.download.findValidName
 import ani.dantotsu.initActivity
 import ani.dantotsu.media.Media
 import ani.dantotsu.media.MediaDetailsActivity
@@ -169,8 +172,8 @@ class OfflineMangaFragment : Fragment(), OfflineMangaSearchListener {
             // Get the OfflineMangaModel that was clicked
             val item = adapter.getItem(position) as OfflineMangaModel
             val media =
-                downloadManager.mangaDownloadedTypes.firstOrNull { it.title.compareName(item.title) }
-                    ?: downloadManager.novelDownloadedTypes.firstOrNull { it.title.compareName(item.title) }
+                downloadManager.mangaDownloadedTypes.firstOrNull { it.titleName.compareName(item.title) }
+                    ?: downloadManager.novelDownloadedTypes.firstOrNull { it.titleName.compareName(item.title) }
             media?.let {
                 lifecycleScope.launch {
                     ContextCompat.startActivity(
@@ -190,7 +193,7 @@ class OfflineMangaFragment : Fragment(), OfflineMangaSearchListener {
             // Get the OfflineMangaModel that was clicked
             val item = adapter.getItem(position) as OfflineMangaModel
             val type: MediaType =
-                if (downloadManager.mangaDownloadedTypes.any { it.title == item.title }) {
+                if (downloadManager.mangaDownloadedTypes.any { it.titleName == item.title }) {
                     MediaType.MANGA
                 } else {
                     MediaType.NOVEL
@@ -278,19 +281,19 @@ class OfflineMangaFragment : Fragment(), OfflineMangaSearchListener {
         downloads = listOf()
         downloadsJob = Job()
         CoroutineScope(Dispatchers.IO + downloadsJob).launch {
-            val mangaTitles = downloadManager.mangaDownloadedTypes.map { it.title }.distinct()
+            val mangaTitles = downloadManager.mangaDownloadedTypes.map { it.titleName.findValidName() }.distinct()
             val newMangaDownloads = mutableListOf<OfflineMangaModel>()
             for (title in mangaTitles) {
-                val tDownloads = downloadManager.mangaDownloadedTypes.filter { it.title == title }
+                val tDownloads = downloadManager.mangaDownloadedTypes.filter { it.titleName == title }
                 val download = tDownloads.first()
                 val offlineMangaModel = loadOfflineMangaModel(download)
                 newMangaDownloads += offlineMangaModel
             }
             downloads = newMangaDownloads
-            val novelTitles = downloadManager.novelDownloadedTypes.map { it.title }.distinct()
+            val novelTitles = downloadManager.novelDownloadedTypes.map { it.titleName }.distinct()
             val newNovelDownloads = mutableListOf<OfflineMangaModel>()
             for (title in novelTitles) {
-                val tDownloads = downloadManager.novelDownloadedTypes.filter { it.title == title }
+                val tDownloads = downloadManager.novelDownloadedTypes.filter { it.titleName == title }
                 val download = tDownloads.first()
                 val offlineMangaModel = loadOfflineMangaModel(download)
                 newNovelDownloads += offlineMangaModel
@@ -315,7 +318,7 @@ class OfflineMangaFragment : Fragment(), OfflineMangaSearchListener {
         return try {
             val directory = getSubDirectory(
                 context ?: currContext()!!, downloadedType.type,
-                false, downloadedType.title
+                false, downloadedType.titleName
             )
             val gson = GsonBuilder()
                 .registerTypeAdapter(SChapter::class.java, InstanceCreator<SChapter> {
@@ -323,7 +326,7 @@ class OfflineMangaFragment : Fragment(), OfflineMangaSearchListener {
                 })
                 .create()
             val media = directory?.findFile("media.json")
-                ?: return null
+                ?: return DownloadCompat.loadMediaCompat(downloadedType)
             val mediaJson =
                 media.openInputStream(context ?: currContext()!!)?.bufferedReader().use {
                     it?.readText()
@@ -343,7 +346,7 @@ class OfflineMangaFragment : Fragment(), OfflineMangaSearchListener {
         try {
             val directory = getSubDirectory(
                 context ?: currContext()!!, downloadedType.type,
-                false, downloadedType.title
+                false, downloadedType.titleName
             )
             val mediaModel = getMedia(downloadedType)!!
             val cover = directory?.findFile("cover.jpg")
@@ -354,6 +357,7 @@ class OfflineMangaFragment : Fragment(), OfflineMangaSearchListener {
             val bannerUri: Uri? = if (banner?.exists() == true) {
                 banner.uri
             } else null
+            if (coverUri == null && bannerUri == null) throw Exception("No cover or banner found, probably compat")
             val title = mediaModel.mainName()
             val score = ((if (mediaModel.userScore == 0) (mediaModel.meanScore
                 ?: 0) else mediaModel.userScore) / 10.0).toString()
@@ -376,21 +380,25 @@ class OfflineMangaFragment : Fragment(), OfflineMangaSearchListener {
                 bannerUri
             )
         } catch (e: Exception) {
-            Logger.log("Error loading media.json: ${e.message}")
-            Logger.log(e)
-            Injekt.get<CrashlyticsInterface>().logException(e)
-            return OfflineMangaModel(
-                "unknown",
-                "0",
-                "??",
-                "??",
-                "movie",
-                "hmm",
-                isOngoing = false,
-                isUserScored = false,
-                null,
-                null
-            )
+            return try {
+                loadOfflineMangaModelCompat(downloadedType)
+            } catch (e: Exception) {
+                Logger.log("Error loading media.json: ${e.message}")
+                Logger.log(e)
+                Injekt.get<CrashlyticsInterface>().logException(e)
+                return OfflineMangaModel(
+                    "unknown",
+                    "0",
+                    "??",
+                    "??",
+                    "movie",
+                    "hmm",
+                    isOngoing = false,
+                    isUserScored = false,
+                    null,
+                    null
+                )
+            }
         }
     }
 }

app/src/main/java/ani/dantotsu/download/novel/NovelDownloaderService.kt

@@ -9,7 +9,6 @@ import android.content.IntentFilter
 import android.content.pm.PackageManager
 import android.content.pm.ServiceInfo
 import android.os.Build
-import android.os.Environment
 import android.os.IBinder
 import android.widget.Toast
 import androidx.core.app.ActivityCompat
@@ -50,8 +49,6 @@ import okio.sink
 import tachiyomi.core.util.lang.launchIO
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
-import java.io.File
-import java.io.FileOutputStream
 import java.io.IOException
 import java.net.HttpURLConnection
 import java.net.URL
@@ -270,7 +267,9 @@ class NovelDownloaderService : Service() {
                             task.coverUrl?.let {
                                 file.parentFile?.let { it1 -> downloadImage(it, it1, "cover.jpg") }
                             }
-                            val outputStream = this@NovelDownloaderService.contentResolver.openOutputStream(file.uri) ?: throw Exception("Could not open OutputStream")
+                            val outputStream =
+                                this@NovelDownloaderService.contentResolver.openOutputStream(file.uri)
+                                    ?: throw Exception("Could not open OutputStream")
 
                             val sink = outputStream.sink().buffer()
                             val responseBody = response.body
@@ -358,7 +357,7 @@ class NovelDownloaderService : Service() {
     private fun saveMediaInfo(task: DownloadTask) {
         launchIO {
             val directory =
-                DownloadsManager.getSubDirectory(
+                getSubDirectory(
                     this@NovelDownloaderService,
                     MediaType.NOVEL,
                     false,

app/src/main/java/ani/dantotsu/download/video/Helper.kt

@@ -7,14 +7,10 @@ import android.app.AlertDialog
 import android.content.Context
 import android.content.Intent
 import android.content.pm.PackageManager
-import android.net.Uri
 import android.os.Build
 import androidx.annotation.OptIn
 import androidx.core.app.ActivityCompat
 import androidx.core.content.ContextCompat
-import androidx.media3.common.C
-import androidx.media3.common.MediaItem
-import androidx.media3.common.MimeTypes
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.database.StandaloneDatabaseProvider
 import androidx.media3.datasource.DataSource
@@ -22,11 +18,8 @@ import androidx.media3.datasource.HttpDataSource
 import androidx.media3.datasource.cache.NoOpCacheEvictor
 import androidx.media3.datasource.cache.SimpleCache
 import androidx.media3.datasource.okhttp.OkHttpDataSource
-import androidx.media3.exoplayer.DefaultRenderersFactory
 import androidx.media3.exoplayer.offline.Download
-import androidx.media3.exoplayer.offline.DownloadHelper
 import androidx.media3.exoplayer.offline.DownloadManager
-import androidx.media3.exoplayer.offline.DownloadService
 import androidx.media3.exoplayer.scheduler.Requirements
 import ani.dantotsu.R
 import ani.dantotsu.defaultHeaders
@@ -34,21 +27,16 @@ import ani.dantotsu.download.DownloadedType
 import ani.dantotsu.download.DownloadsManager
 import ani.dantotsu.download.anime.AnimeDownloaderService
 import ani.dantotsu.download.anime.AnimeServiceDataSingleton
-import ani.dantotsu.logError
 import ani.dantotsu.media.Media
 import ani.dantotsu.media.MediaType
-import ani.dantotsu.okHttpClient
 import ani.dantotsu.parsers.Subtitle
-import ani.dantotsu.parsers.SubtitleType
 import ani.dantotsu.parsers.Video
-import ani.dantotsu.parsers.VideoType
 import ani.dantotsu.settings.saving.PrefManager
 import ani.dantotsu.util.Logger
 import eu.kanade.tachiyomi.network.NetworkHelper
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 import java.io.File
-import java.io.IOException
 import java.util.concurrent.Executors
 
 @SuppressLint("UnsafeOptInUsageError")
@@ -130,4 +118,92 @@ object Helper {
         }
         return true
     }
+
+    @Synchronized
+    @UnstableApi
+    @Deprecated("exoplayer download manager is no longer used")
+    fun downloadManager(context: Context): DownloadManager {
+        return download ?: let {
+            val database = Injekt.get<StandaloneDatabaseProvider>()
+            val downloadDirectory = File(getDownloadDirectory(context), DOWNLOAD_CONTENT_DIRECTORY)
+            val dataSourceFactory = DataSource.Factory {
+                //val dataSource: HttpDataSource = OkHttpDataSource.Factory(okHttpClient).createDataSource()
+                val networkHelper = Injekt.get<NetworkHelper>()
+                val okHttpClient = networkHelper.client
+                val dataSource: HttpDataSource =
+                    OkHttpDataSource.Factory(okHttpClient).createDataSource()
+                defaultHeaders.forEach {
+                    dataSource.setRequestProperty(it.key, it.value)
+                }
+                dataSource
+            }
+            val threadPoolSize = Runtime.getRuntime().availableProcessors()
+            val executorService = Executors.newFixedThreadPool(threadPoolSize)
+            val downloadManager = DownloadManager(
+                context,
+                database,
+                getSimpleCache(context),
+                dataSourceFactory,
+                executorService
+            ).apply {
+                requirements =
+                    Requirements(Requirements.NETWORK or Requirements.DEVICE_STORAGE_NOT_LOW)
+                maxParallelDownloads = 3
+            }
+            downloadManager.addListener(  //for testing
+                object : DownloadManager.Listener {
+                    override fun onDownloadChanged(
+                        downloadManager: DownloadManager,
+                        download: Download,
+                        finalException: Exception?
+                    ) {
+                        if (download.state == Download.STATE_COMPLETED) {
+                            Logger.log("Download Completed")
+                        } else if (download.state == Download.STATE_FAILED) {
+                            Logger.log("Download Failed")
+                        } else if (download.state == Download.STATE_STOPPED) {
+                            Logger.log("Download Stopped")
+                        } else if (download.state == Download.STATE_QUEUED) {
+                            Logger.log("Download Queued")
+                        } else if (download.state == Download.STATE_DOWNLOADING) {
+                            Logger.log("Download Downloading")
+                        }
+                    }
+                }
+            )
+
+            downloadManager
+        }
+    }
+    @Deprecated("exoplayer download manager is no longer used")
+    @OptIn(UnstableApi::class)
+    fun getSimpleCache(context: Context): SimpleCache {
+        return if (simpleCache == null) {
+            val downloadDirectory = File(getDownloadDirectory(context), DOWNLOAD_CONTENT_DIRECTORY)
+            val database = Injekt.get<StandaloneDatabaseProvider>()
+            simpleCache = SimpleCache(downloadDirectory, NoOpCacheEvictor(), database)
+            simpleCache!!
+        } else {
+            simpleCache!!
+        }
+    }
+    @Synchronized
+    @Deprecated("exoplayer download manager is no longer used")
+    private fun getDownloadDirectory(context: Context): File {
+        if (downloadDirectory == null) {
+            downloadDirectory = context.getExternalFilesDir(null)
+            if (downloadDirectory == null) {
+                downloadDirectory = context.filesDir
+            }
+        }
+        return downloadDirectory!!
+    }
+    @Deprecated("exoplayer download manager is no longer used")
+    private var download: DownloadManager? = null
+    @Deprecated("exoplayer download manager is no longer used")
+    private const val DOWNLOAD_CONTENT_DIRECTORY = "Anime_Downloads"
+    @Deprecated("exoplayer download manager is no longer used")
+    private var simpleCache: SimpleCache? = null
+    @Deprecated("exoplayer download manager is no longer used")
+    private var downloadDirectory: File? = null
 }

app/src/main/java/ani/dantotsu/home/AnimePageAdapter.kt

@@ -101,7 +101,7 @@ class AnimePageAdapter : RecyclerView.Adapter<AnimePageAdapter.AnimePageViewHold
             ContextCompat.startActivity(
                 view.context,
                 Intent(view.context, ProfileActivity::class.java)
-                    .putExtra("userId", Anilist.userid),null
+                    .putExtra("userId", Anilist.userid), null
             )
             false
         }
@@ -110,7 +110,8 @@ class AnimePageAdapter : RecyclerView.Adapter<AnimePageAdapter.AnimePageViewHold
             trendingBinding.searchBar.performClick()
         }
 
-        trendingBinding.notificationCount.visibility = if (Anilist.unreadNotificationCount > 0) View.VISIBLE else View.GONE
+        trendingBinding.notificationCount.visibility =
+            if (Anilist.unreadNotificationCount > 0) View.VISIBLE else View.GONE
         trendingBinding.notificationCount.text = Anilist.unreadNotificationCount.toString()
 
         listOf(
@@ -167,7 +168,8 @@ class AnimePageAdapter : RecyclerView.Adapter<AnimePageAdapter.AnimePageViewHold
         trendingBinding.trendingProgressBar.visibility = View.GONE
         trendingBinding.trendingViewPager.adapter = adaptor
         trendingBinding.trendingViewPager.offscreenPageLimit = 3
-        trendingBinding.trendingViewPager.getChildAt(0).overScrollMode = RecyclerView.OVER_SCROLL_NEVER
+        trendingBinding.trendingViewPager.getChildAt(0).overScrollMode =
+            RecyclerView.OVER_SCROLL_NEVER
         trendingBinding.trendingViewPager.setPageTransformer(MediaPageTransformer())
         trendHandler = Handler(Looper.getMainLooper())
         trendRun = Runnable {
@@ -195,7 +197,7 @@ class AnimePageAdapter : RecyclerView.Adapter<AnimePageAdapter.AnimePageViewHold
     }
 
     fun updateRecent(adaptor: MediaAdaptor) {
-        binding.apply{
+        binding.apply {
             init(
                 adaptor,
                 animeUpdatedRecyclerView,
@@ -210,8 +212,9 @@ class AnimePageAdapter : RecyclerView.Adapter<AnimePageAdapter.AnimePageViewHold
         }
 
     }
+
     fun updateMovies(adaptor: MediaAdaptor) {
-        binding.apply{
+        binding.apply {
             init(
                 adaptor,
                 animeMoviesRecyclerView,
@@ -222,7 +225,7 @@ class AnimePageAdapter : RecyclerView.Adapter<AnimePageAdapter.AnimePageViewHold
     }
 
     fun updateTopRated(adaptor: MediaAdaptor) {
-        binding.apply{
+        binding.apply {
             init(
                 adaptor,
                 animeTopRatedRecyclerView,
@@ -231,8 +234,9 @@ class AnimePageAdapter : RecyclerView.Adapter<AnimePageAdapter.AnimePageViewHold
             )
         }
     }
+
     fun updateMostFav(adaptor: MediaAdaptor) {
-        binding.apply{
+        binding.apply {
             init(
                 adaptor,
                 animeMostFavRecyclerView,
@@ -241,7 +245,8 @@ class AnimePageAdapter : RecyclerView.Adapter<AnimePageAdapter.AnimePageViewHold
             )
         }
     }
-    fun init(adaptor: MediaAdaptor,recyclerView: RecyclerView, progress: View, title: View){
+
+    fun init(adaptor: MediaAdaptor, recyclerView: RecyclerView, progress: View, title: View) {
         progress.visibility = View.GONE
         recyclerView.adapter = adaptor
         recyclerView.layoutManager =
@@ -256,6 +261,7 @@ class AnimePageAdapter : RecyclerView.Adapter<AnimePageAdapter.AnimePageViewHold
         recyclerView.layoutAnimation =
             LayoutAnimationController(setSlideIn(), 0.25f)
     }
+
     fun updateAvatar() {
         if (Anilist.avatar != null && ready.value == true) {
             trendingBinding.userAvatar.loadImage(Anilist.avatar)

app/src/main/java/ani/dantotsu/home/HomeFragment.kt

@@ -81,7 +81,10 @@ class HomeFragment : Fragment() {
                 binding.homeUserChaptersRead.text = Anilist.chapterRead.toString()
                 binding.homeUserAvatar.loadImage(Anilist.avatar)
                 val bannerAnimations: Boolean = PrefManager.getVal(PrefName.BannerAnimations)
-                blurImage(if (bannerAnimations) binding.homeUserBg else binding.homeUserBgNoKen, Anilist.bg)
+                blurImage(
+                    if (bannerAnimations) binding.homeUserBg else binding.homeUserBgNoKen,
+                    Anilist.bg
+                )
                 binding.homeUserDataProgressBar.visibility = View.GONE
                 binding.homeNotificationCount.isVisible = Anilist.unreadNotificationCount > 0
                 binding.homeNotificationCount.text = Anilist.unreadNotificationCount.toString()
@@ -128,7 +131,7 @@ class HomeFragment : Fragment() {
             it.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS)
             ContextCompat.startActivity(
                 requireContext(), Intent(requireContext(), ProfileActivity::class.java)
-                    .putExtra("userId", Anilist.userid),null
+                    .putExtra("userId", Anilist.userid), null
             )
             false
         }
@@ -376,6 +379,7 @@ class HomeFragment : Fragment() {
             }
         }
     }
+
     override fun onResume() {
         if (!model.loaded) Refresh.activity[1]!!.postValue(true)
         if (_binding != null) {

app/src/main/java/ani/dantotsu/home/MangaFragment.kt

@@ -172,7 +172,13 @@ class MangaFragment : Fragment() {
                 }
                 model.getPopularManhwa().observe(viewLifecycleOwner) {
                     if (it != null) {
-                        mangaPageAdapter.updateTrendingManhwa(MediaAdaptor(0, it, requireActivity()))
+                        mangaPageAdapter.updateTrendingManhwa(
+                            MediaAdaptor(
+                                0,
+                                it,
+                                requireActivity()
+                            )
+                        )
                     }
                 }
                 model.getTopRated().observe(viewLifecycleOwner) {

app/src/main/java/ani/dantotsu/home/MangaPageAdapter.kt

@@ -101,7 +101,7 @@ class MangaPageAdapter : RecyclerView.Adapter<MangaPageAdapter.MangaPageViewHold
             ContextCompat.startActivity(
                 view.context,
                 Intent(view.context, ProfileActivity::class.java)
-                    .putExtra("userId", Anilist.userid),null
+                    .putExtra("userId", Anilist.userid), null
             )
             false
         }
@@ -156,7 +156,8 @@ class MangaPageAdapter : RecyclerView.Adapter<MangaPageAdapter.MangaPageViewHold
         trendingBinding.trendingProgressBar.visibility = View.GONE
         trendingBinding.trendingViewPager.adapter = adaptor
         trendingBinding.trendingViewPager.offscreenPageLimit = 3
-        trendingBinding.trendingViewPager.getChildAt(0).overScrollMode = RecyclerView.OVER_SCROLL_NEVER
+        trendingBinding.trendingViewPager.getChildAt(0).overScrollMode =
+            RecyclerView.OVER_SCROLL_NEVER
         trendingBinding.trendingViewPager.setPageTransformer(MediaPageTransformer())
         trendHandler = Handler(Looper.getMainLooper())
         trendRun = Runnable {
@@ -191,6 +192,7 @@ class MangaPageAdapter : RecyclerView.Adapter<MangaPageAdapter.MangaPageViewHold
             )
         }
     }
+
     fun updateTrendingManhwa(adaptor: MediaAdaptor) {
         binding.apply {
             init(
@@ -201,6 +203,7 @@ class MangaPageAdapter : RecyclerView.Adapter<MangaPageAdapter.MangaPageViewHold
             )
         }
     }
+
     fun updateNovel(adaptor: MediaAdaptor) {
         binding.apply {
             init(
@@ -212,6 +215,7 @@ class MangaPageAdapter : RecyclerView.Adapter<MangaPageAdapter.MangaPageViewHold
         }
 
     }
+
     fun updateTopRated(adaptor: MediaAdaptor) {
         binding.apply {
             init(
@@ -222,6 +226,7 @@ class MangaPageAdapter : RecyclerView.Adapter<MangaPageAdapter.MangaPageViewHold
             )
         }
     }
+
     fun updateMostFav(adaptor: MediaAdaptor) {
         binding.apply {
             init(
@@ -234,7 +239,8 @@ class MangaPageAdapter : RecyclerView.Adapter<MangaPageAdapter.MangaPageViewHold
             mangaPopular.startAnimation(setSlideUp())
         }
     }
-    fun init(adaptor: MediaAdaptor,recyclerView: RecyclerView, progress: View, title: View){
+
+    fun init(adaptor: MediaAdaptor, recyclerView: RecyclerView, progress: View, title: View) {
         progress.visibility = View.GONE
         recyclerView.adapter = adaptor
         recyclerView.layoutManager =

app/src/main/java/ani/dantotsu/media/AuthorActivity.kt

@@ -95,8 +95,10 @@ class AuthorActivity : AppCompatActivity() {
 
                 binding.charactersRecycler.visibility = View.VISIBLE
                 binding.charactersText.visibility = View.VISIBLE
-                binding.charactersRecycler.adapter = CharacterAdapter(author!!.character ?: arrayListOf())
-                binding.charactersRecycler.layoutManager = LinearLayoutManager(this, LinearLayoutManager.HORIZONTAL, false)
+                binding.charactersRecycler.adapter =
+                    CharacterAdapter(author!!.character ?: arrayListOf())
+                binding.charactersRecycler.layoutManager =
+                    LinearLayoutManager(this, LinearLayoutManager.HORIZONTAL, false)
                 if (author!!.character.isNullOrEmpty()) {
                     binding.charactersRecycler.visibility = View.GONE
                     binding.charactersText.visibility = View.GONE
@@ -108,7 +110,7 @@ class AuthorActivity : AppCompatActivity() {
             if (it) {
                 scope.launch {
                     if (author != null)
-                        withContext(Dispatchers.IO) { model.loadAuthor(author!!)}
+                        withContext(Dispatchers.IO) { model.loadAuthor(author!!) }
                     live.postValue(false)
                 }
             }

app/src/main/java/ani/dantotsu/media/AuthorAdapter.kt

@@ -23,7 +23,7 @@ class AuthorAdapter(
         return AuthorViewHolder(binding)
     }
 
-    override fun onBindViewHolder(holder:AuthorViewHolder, position: Int) {
+    override fun onBindViewHolder(holder: AuthorViewHolder, position: Int) {
         val binding = holder.binding
         setAnimation(binding.root.context, holder.binding.root)
         val author = authorList[position]

app/src/main/java/ani/dantotsu/media/Character.kt

@@ -1,7 +1,6 @@
 package ani.dantotsu.media
 
 import ani.dantotsu.connections.anilist.api.FuzzyDate
-import ani.dantotsu.connections.anilist.api.Query
 import java.io.Serializable
 
 data class Character(

app/src/main/java/ani/dantotsu/media/CharacterDetailsActivity.kt

@@ -95,7 +95,8 @@ class CharacterDetailsActivity : AppCompatActivity(), AppBarLayout.OnOffsetChang
         }
         lifecycleScope.launch {
             withContext(Dispatchers.IO) {
-                character.isFav = Anilist.query.isUserFav(AnilistMutations.FavType.CHARACTER, character.id)
+                character.isFav =
+                    Anilist.query.isUserFav(AnilistMutations.FavType.CHARACTER, character.id)
             }
             withContext(Dispatchers.Main) {
                 binding.characterFav.setImageResource(

app/src/main/java/ani/dantotsu/media/CharacterDetailsAdapter.kt

@@ -29,10 +29,16 @@ class CharacterDetailsAdapter(private val character: Character, private val acti
                         "${currActivity()!!.getString(R.string.birthday)} ${character.dateOfBirth.toString()}" else "") +
                     (if (character.gender != "null")
                         currActivity()!!.getString(R.string.gender) + " " + when (character.gender) {
-                        currActivity()!!.getString(R.string.male) -> currActivity()!!.getString(R.string.male)
-                        currActivity()!!.getString(R.string.female) -> currActivity()!!.getString(R.string.female)
-                        else -> character.gender
-                    } else "") + "\n" + character.description
+                            currActivity()!!.getString(R.string.male) -> currActivity()!!.getString(
+                                R.string.male
+                            )
+
+                            currActivity()!!.getString(R.string.female) -> currActivity()!!.getString(
+                                R.string.female
+                            )
+
+                            else -> character.gender
+                        } else "") + "\n" + character.description
 
         binding.characterDesc.isTextSelectable
         val markWon = Markwon.builder(activity).usePlugin(SoftBreakAddsNewLinePlugin.create())

app/src/main/java/ani/dantotsu/media/Media.kt

@@ -100,7 +100,7 @@ data class Media(
         startDate = apiMedia.startDate,
         endDate = apiMedia.endDate,
         favourites = apiMedia.favourites,
-        timeUntilAiring = apiMedia.nextAiringEpisode?.timeUntilAiring?.let { it.toLong() * 1000},
+        timeUntilAiring = apiMedia.nextAiringEpisode?.timeUntilAiring?.let { it.toLong() * 1000 },
         anime = if (apiMedia.type == MediaType.ANIME) Anime(
             totalEpisodes = apiMedia.episodes,
             nextAiringEpisode = apiMedia.nextAiringEpisode?.episode?.minus(1)
@@ -115,7 +115,8 @@ data class Media(
         this.userScore = mediaList.score?.toInt() ?: 0
         this.userStatus = mediaList.status?.toString()
         this.userUpdatedAt = mediaList.updatedAt?.toLong()
-        this.genres = mediaList.media?.genres?.toMutableList() as? ArrayList<String>? ?: arrayListOf()
+        this.genres =
+            mediaList.media?.genres?.toMutableList() as? ArrayList<String>? ?: arrayListOf()
     }
 
     constructor(mediaEdge: MediaEdge) : this(mediaEdge.node!!) {

app/src/main/java/ani/dantotsu/media/MediaAdaptor.kt

@@ -149,14 +149,22 @@ class MediaAdaptor(
                         (if (media.userScore != 0) R.drawable.item_user_score else R.drawable.item_score)
                     )
                     if (media.anime != null) {
-                        val itemTotal =  " " + if ((media.anime.totalEpisodes ?: 0) != 1) currActivity()!!.getString(R.string.episode_plural) else currActivity()!!.getString(R.string.episode_singular)
+                        val itemTotal = " " + if ((media.anime.totalEpisodes
+                                ?: 0) != 1
+                        ) currActivity()!!.getString(R.string.episode_plural) else currActivity()!!.getString(
+                            R.string.episode_singular
+                        )
                         b.itemTotal.text = itemTotal
                         b.itemCompactTotal.text =
                             if (media.anime.nextAiringEpisode != null) (media.anime.nextAiringEpisode.toString() + " / " + (media.anime.totalEpisodes
                                 ?: "??").toString()) else (media.anime.totalEpisodes
                                 ?: "??").toString()
                     } else if (media.manga != null) {
-                        val itemTotal = " " + if ((media.manga.totalChapters ?: 0) != 1) currActivity()!!.getString(R.string.chapter_plural) else currActivity()!!.getString(R.string.chapter_singular)
+                        val itemTotal = " " + if ((media.manga.totalChapters
+                                ?: 0) != 1
+                        ) currActivity()!!.getString(R.string.chapter_plural) else currActivity()!!.getString(
+                            R.string.chapter_singular
+                        )
                         b.itemTotal.text = itemTotal
                         b.itemCompactTotal.text = "${media.manga.totalChapters ?: "??"}"
                     }
@@ -183,7 +191,10 @@ class MediaAdaptor(
                                 AccelerateDecelerateInterpolator()
                             )
                         )
-                    blurImage(if (bannerAnimations) b.itemCompactBanner else b.itemCompactBannerNoKen , media.banner ?: media.cover)
+                    blurImage(
+                        if (bannerAnimations) b.itemCompactBanner else b.itemCompactBannerNoKen,
+                        media.banner ?: media.cover
+                    )
                     b.itemCompactOngoing.isVisible =
                         media.status == currActivity()!!.getString(R.string.status_releasing)
                     b.itemCompactTitle.text = media.userPreferredName
@@ -232,7 +243,10 @@ class MediaAdaptor(
                                 AccelerateDecelerateInterpolator()
                             )
                         )
-                    blurImage(if (bannerAnimations) b.itemCompactBanner else b.itemCompactBannerNoKen , media.banner ?: media.cover)
+                    blurImage(
+                        if (bannerAnimations) b.itemCompactBanner else b.itemCompactBannerNoKen,
+                        media.banner ?: media.cover
+                    )
                     b.itemCompactOngoing.isVisible =
                         media.status == currActivity()!!.getString(R.string.status_releasing)
                     b.itemCompactTitle.text = media.userPreferredName

app/src/main/java/ani/dantotsu/media/MediaDetailsActivity.kt

@@ -109,7 +109,9 @@ class MediaDetailsActivity : AppCompatActivity(), AppBarLayout.OnOffsetChangedLi
         // Ui init
 
         initActivity(this)
-        binding.mediaViewPager.updateLayoutParams<ViewGroup.MarginLayoutParams> { bottomMargin = navBarHeight }
+        binding.mediaViewPager.updateLayoutParams<ViewGroup.MarginLayoutParams> {
+            bottomMargin = navBarHeight
+        }
         val oldMargin = binding.mediaViewPager.marginBottom
         AndroidBug5497Workaround.assistActivity(this) {
             if (it) {
@@ -125,9 +127,11 @@ class MediaDetailsActivity : AppCompatActivity(), AppBarLayout.OnOffsetChangedLi
             }
         }
         val navBarRightMargin = if (resources.configuration.orientation ==
-            Configuration.ORIENTATION_LANDSCAPE) navBarHeight else 0
+            Configuration.ORIENTATION_LANDSCAPE
+        ) navBarHeight else 0
         val navBarBottomMargin = if (resources.configuration.orientation ==
-            Configuration.ORIENTATION_LANDSCAPE) 0 else navBarHeight
+            Configuration.ORIENTATION_LANDSCAPE
+        ) 0 else navBarHeight
         navBar.updateLayoutParams<ViewGroup.MarginLayoutParams> {
             rightMargin = navBarRightMargin
             bottomMargin = navBarBottomMargin
@@ -345,7 +349,13 @@ class MediaDetailsActivity : AppCompatActivity(), AppBarLayout.OnOffsetChangedLi
         adult = media.isAdult
         if (media.anime != null) {
             viewPager.adapter =
-                ViewPagerAdapter(supportFragmentManager, lifecycle, SupportedMedia.ANIME, media, intent.getIntExtra("commentId", -1))
+                ViewPagerAdapter(
+                    supportFragmentManager,
+                    lifecycle,
+                    SupportedMedia.ANIME,
+                    media,
+                    intent.getIntExtra("commentId", -1)
+                )
         } else if (media.manga != null) {
             viewPager.adapter = ViewPagerAdapter(
                 supportFragmentManager,
@@ -368,7 +378,8 @@ class MediaDetailsActivity : AppCompatActivity(), AppBarLayout.OnOffsetChangedLi
         } else {
             navBar.createTab(R.drawable.ic_round_import_contacts_24, R.string.read, R.id.read)
         }
-        val commentTab = navBar.createTab(R.drawable.ic_round_comment_24, R.string.comments, R.id.comment)
+        val commentTab =
+            navBar.createTab(R.drawable.ic_round_comment_24, R.string.comments, R.id.comment)
         navBar.addTab(infoTab)
         navBar.addTab(watchTab)
         navBar.addTab(commentTab)
@@ -412,10 +423,12 @@ class MediaDetailsActivity : AppCompatActivity(), AppBarLayout.OnOffsetChangedLi
     override fun onConfigurationChanged(newConfig: Configuration) {
         super.onConfigurationChanged(newConfig)
         val rightMargin = if (resources.configuration.orientation ==
-            Configuration.ORIENTATION_LANDSCAPE) navBarHeight else 0
+            Configuration.ORIENTATION_LANDSCAPE
+        ) navBarHeight else 0
         val bottomMargin = if (resources.configuration.orientation ==
-            Configuration.ORIENTATION_LANDSCAPE) 0 else navBarHeight
-        val params : ViewGroup.MarginLayoutParams =
+            Configuration.ORIENTATION_LANDSCAPE
+        ) 0 else navBarHeight
+        val params: ViewGroup.MarginLayoutParams =
             navBar.layoutParams as ViewGroup.MarginLayoutParams
         params.updateMargins(right = rightMargin, bottom = bottomMargin)
     }
@@ -448,6 +461,7 @@ class MediaDetailsActivity : AppCompatActivity(), AppBarLayout.OnOffsetChangedLi
                 SupportedMedia.MANGA -> MangaReadFragment()
                 SupportedMedia.NOVEL -> NovelReadFragment()
             }
+
             2 -> {
                 val fragment = CommentsFragment()
                 val bundle = Bundle()

app/src/main/java/ani/dantotsu/media/MediaDetailsViewModel.kt

@@ -56,9 +56,11 @@ class MediaDetailsViewModel : ViewModel() {
                 media.anime != null -> {
                     AnimeSources.list.size - 1
                 }
+
                 media.format == "MANGA" || media.format == "ONE_SHOT" -> {
                     MangaSources.list.size - 1
                 }
+
                 else -> {
                     NovelSources.list.size - 1
                 }

app/src/main/java/ani/dantotsu/media/MediaInfoFragment.kt

@@ -145,7 +145,8 @@ class MediaInfoFragment : Fragment() {
                     }
                     binding.mediaInfoDurationContainer.visibility = View.VISIBLE
                     binding.mediaInfoSeasonContainer.visibility = View.VISIBLE
-                    val seasonInfo = "${(media.anime.season ?: "??")} ${(media.anime.seasonYear ?: "??")}"
+                    val seasonInfo =
+                        "${(media.anime.season ?: "??")} ${(media.anime.seasonYear ?: "??")}"
                     binding.mediaInfoSeason.text = seasonInfo
 
                     if (media.anime.mainStudio != null) {
@@ -182,9 +183,9 @@ class MediaInfoFragment : Fragment() {
                     }
                     binding.mediaInfoTotalTitle.setText(R.string.total_eps)
                     val infoTotal = if (media.anime.nextAiringEpisode != null)
-                            "${media.anime.nextAiringEpisode} | ${media.anime.totalEpisodes ?: "~"}"
+                        "${media.anime.nextAiringEpisode} | ${media.anime.totalEpisodes ?: "~"}"
                     else
-                            (media.anime.totalEpisodes ?: "~").toString()
+                        (media.anime.totalEpisodes ?: "~").toString()
                     binding.mediaInfoTotal.text = infoTotal
 
                 } else if (media.manga != null) {
@@ -213,7 +214,8 @@ class MediaInfoFragment : Fragment() {
                     (media.description ?: "null").replace("\\n", "<br>").replace("\\\"", "\""),
                     HtmlCompat.FROM_HTML_MODE_LEGACY
                 )
-                val infoDesc = tripleTab + if (desc.toString() != "null") desc else getString(R.string.no_description_available)
+                val infoDesc =
+                    tripleTab + if (desc.toString() != "null") desc else getString(R.string.no_description_available)
                 binding.mediaInfoDescription.text = infoDesc
 
                 binding.mediaInfoDescription.setOnClickListener {
@@ -570,7 +572,7 @@ class MediaInfoFragment : Fragment() {
                         parent.addView(root)
                     }
                 }
-                if(!media.users.isNullOrEmpty() && !offline){
+                if (!media.users.isNullOrEmpty() && !offline) {
                     ItemTitleRecyclerBinding.inflate(
                         LayoutInflater.from(context),
                         parent,

app/src/main/java/ani/dantotsu/media/MediaNameAdapter.kt

@@ -70,7 +70,7 @@ object MediaNameAdapter {
         return if (seasonMatcher.find()) {
             seasonMatcher.group(2)?.toInt()
         } else {
-            null
+            text.toIntOrNull()
         }
     }
 
@@ -93,7 +93,7 @@ object MediaNameAdapter {
                 }
             }
         } else {
-            null
+            text.toFloatOrNull()
         }
     }
 
@@ -139,7 +139,7 @@ object MediaNameAdapter {
             if (failedChapterNumberMatcher.find()) {
                 failedChapterNumberMatcher.group(1)?.toFloat()
             } else {
-                null
+                text.toFloatOrNull()
             }
         }
     }

app/src/main/java/ani/dantotsu/media/MediaSocialAdapter.kt

@@ -1,8 +1,6 @@
 package ani.dantotsu.media
 
 import android.annotation.SuppressLint
-import android.app.Activity
-import android.content.Context
 import android.content.Intent
 import android.view.LayoutInflater
 import android.view.View

app/src/main/java/ani/dantotsu/media/MediaType.kt

@@ -1,11 +1,15 @@
 package ani.dantotsu.media
 
-enum class MediaType {
+interface Type {
+    fun asText(): String
+}
+
+enum class MediaType : Type {
     ANIME,
     MANGA,
     NOVEL;
 
-    fun asText(): String {
+    override fun asText(): String {
         return when (this) {
             ANIME -> "Anime"
             MANGA -> "Manga"
@@ -14,12 +18,38 @@ enum class MediaType {
     }
 
     companion object {
-        fun fromText(string : String): MediaType {
+        fun fromText(string: String): MediaType? {
             return when (string) {
                 "Anime" -> ANIME
                 "Manga" -> MANGA
                 "Novel" -> NOVEL
-                else -> { ANIME }
+                else -> {
+                    null
+                }
+            }
+        }
+    }
+}
+
+enum class AddonType : Type {
+    TORRENT,
+    DOWNLOAD;
+
+    override fun asText(): String {
+        return when (this) {
+            TORRENT -> "Torrent"
+            DOWNLOAD -> "Download"
+        }
+    }
+
+    companion object {
+        fun fromText(string: String): AddonType? {
+            return when (string) {
+                "Torrent" -> TORRENT
+                "Download" -> DOWNLOAD
+                else -> {
+                    null
+                }
             }
         }
     }

app/src/main/java/ani/dantotsu/media/SearchActivity.kt

@@ -78,8 +78,10 @@ class SearchActivity : AppCompatActivity() {
                 source = intent.getStringExtra("source"),
                 countryOfOrigin = intent.getStringExtra("country"),
                 season = intent.getStringExtra("season"),
-                seasonYear = if (intent.getStringExtra("type") == "ANIME") intent.getStringExtra("seasonYear")?.toIntOrNull() else null,
-                startYear = if (intent.getStringExtra("type") == "MANGA") intent.getStringExtra("seasonYear")?.toIntOrNull() else null,
+                seasonYear = if (intent.getStringExtra("type") == "ANIME") intent.getStringExtra("seasonYear")
+                    ?.toIntOrNull() else null,
+                startYear = if (intent.getStringExtra("type") == "MANGA") intent.getStringExtra("seasonYear")
+                    ?.toIntOrNull() else null,
                 results = mutableListOf(),
                 hasNextPage = false
             )

app/src/main/java/ani/dantotsu/media/SearchAdapter.kt

@@ -13,7 +13,6 @@ import android.view.animation.AlphaAnimation
 import android.view.animation.Animation
 import android.view.inputmethod.EditorInfo
 import android.view.inputmethod.InputMethodManager
-import android.widget.ImageView
 import android.widget.PopupMenu
 import androidx.appcompat.app.AppCompatActivity
 import androidx.appcompat.content.res.AppCompatResources
@@ -60,6 +59,7 @@ class SearchAdapter(private val activity: SearchActivity, private val type: Stri
         }
         binding.filterTextView.setCompoundDrawablesWithIntrinsicBounds(filterDrawable, 0, 0, 0)
     }
+
     override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): SearchHeaderViewHolder {
         val binding =
             ItemSearchHeaderBinding.inflate(LayoutInflater.from(parent.context), parent, false)
@@ -129,36 +129,42 @@ class SearchAdapter(private val activity: SearchActivity, private val type: Stri
                         activity.search()
                         updateFilterTextViewDrawable()
                     }
+
                     R.id.sort_by_popular -> {
                         activity.result.sort = Anilist.sortBy[1]
                         activity.updateChips.invoke()
                         activity.search()
                         updateFilterTextViewDrawable()
                     }
+
                     R.id.sort_by_trending -> {
                         activity.result.sort = Anilist.sortBy[2]
                         activity.updateChips.invoke()
                         activity.search()
                         updateFilterTextViewDrawable()
                     }
+
                     R.id.sort_by_recent -> {
                         activity.result.sort = Anilist.sortBy[3]
                         activity.updateChips.invoke()
                         activity.search()
                         updateFilterTextViewDrawable()
                     }
+
                     R.id.sort_by_a_z -> {
                         activity.result.sort = Anilist.sortBy[4]
                         activity.updateChips.invoke()
                         activity.search()
                         updateFilterTextViewDrawable()
                     }
+
                     R.id.sort_by_z_a -> {
                         activity.result.sort = Anilist.sortBy[5]
                         activity.updateChips.invoke()
                         activity.search()
                         updateFilterTextViewDrawable()
                     }
+
                     R.id.sort_by_pure_pain -> {
                         activity.result.sort = Anilist.sortBy[6]
                         activity.updateChips.invoke()
@@ -299,14 +305,12 @@ class SearchAdapter(private val activity: SearchActivity, private val type: Stri
     private fun fadeInAnimation(): Animation {
         return AlphaAnimation(0f, 1f).apply {
             duration = 150
-            fillAfter = true
         }
     }
 
     private fun fadeOutAnimation(): Animation {
         return AlphaAnimation(1f, 0f).apply {
             duration = 150
-            fillAfter = true
         }
     }
 
@@ -325,7 +329,10 @@ class SearchAdapter(private val activity: SearchActivity, private val type: Stri
     }
 
 
-    class SearchChipAdapter(val activity: SearchActivity, private val searchAdapter: SearchAdapter) :
+    class SearchChipAdapter(
+        val activity: SearchActivity,
+        private val searchAdapter: SearchAdapter
+    ) :
         RecyclerView.Adapter<SearchChipAdapter.SearchChipViewHolder>() {
         private var chips = activity.result.toChipList()
 

app/src/main/java/ani/dantotsu/media/SearchFilterBottomDialog.kt

@@ -105,7 +105,8 @@ class SearchFilterBottomDialog : BottomSheetDialogFragment() {
         setSortByFilterImage()
 
         binding.resetSearchFilter.setOnClickListener {
-            val rotateAnimation = ObjectAnimator.ofFloat(binding.resetSearchFilter, "rotation", 180f, 540f)
+            val rotateAnimation =
+                ObjectAnimator.ofFloat(binding.resetSearchFilter, "rotation", 180f, 540f)
             rotateAnimation.duration = 500
             rotateAnimation.interpolator = AccelerateDecelerateInterpolator()
             rotateAnimation.start()
@@ -113,7 +114,8 @@ class SearchFilterBottomDialog : BottomSheetDialogFragment() {
         }
 
         binding.resetSearchFilter.setOnLongClickListener {
-            val rotateAnimation = ObjectAnimator.ofFloat(binding.resetSearchFilter, "rotation", 180f, 540f)
+            val rotateAnimation =
+                ObjectAnimator.ofFloat(binding.resetSearchFilter, "rotation", 180f, 540f)
             rotateAnimation.duration = 500
             rotateAnimation.interpolator = AccelerateDecelerateInterpolator()
             rotateAnimation.start()
@@ -125,8 +127,10 @@ class SearchFilterBottomDialog : BottomSheetDialogFragment() {
 
                 CoroutineScope(Dispatchers.Main).launch {
                     activity.result.apply {
-                        status = binding.searchStatus.text.toString().replace(" ", "_").ifBlank { null }
-                        source = binding.searchSource.text.toString().replace(" ", "_").ifBlank { null }
+                        status =
+                            binding.searchStatus.text.toString().replace(" ", "_").ifBlank { null }
+                        source =
+                            binding.searchSource.text.toString().replace(" ", "_").ifBlank { null }
                         format = binding.searchFormat.text.toString().ifBlank { null }
                         season = binding.searchSeason.text.toString().ifBlank { null }
                         startYear = binding.searchYear.text.toString().toIntOrNull()
@@ -206,21 +210,25 @@ class SearchFilterBottomDialog : BottomSheetDialogFragment() {
                         binding.countryFilter.setImageResource(R.drawable.ic_round_globe_search_googlefonts)
                         startBounceZoomAnimation(binding.countryFilter)
                     }
+
                     R.id.country_china -> {
                         activity.result.countryOfOrigin = "CN"
                         binding.countryFilter.setImageResource(R.drawable.ic_round_globe_china_googlefonts)
                         startBounceZoomAnimation(binding.countryFilter)
                     }
+
                     R.id.country_south_korea -> {
                         activity.result.countryOfOrigin = "KR"
                         binding.countryFilter.setImageResource(R.drawable.ic_round_globe_south_korea_googlefonts)
                         startBounceZoomAnimation(binding.countryFilter)
                     }
+
                     R.id.country_japan -> {
                         activity.result.countryOfOrigin = "JP"
                         binding.countryFilter.setImageResource(R.drawable.ic_round_globe_japan_googlefonts)
                         startBounceZoomAnimation(binding.countryFilter)
                     }
+
                     R.id.country_taiwan -> {
                         activity.result.countryOfOrigin = "TW"
                         binding.countryFilter.setImageResource(R.drawable.ic_round_globe_taiwan_googlefonts)
@@ -257,7 +265,8 @@ class SearchFilterBottomDialog : BottomSheetDialogFragment() {
         binding.searchFilterCancel.setOnClickListener {
             dismiss()
         }
-        val format = if (activity.result.type == "ANIME") Anilist.animeStatus else Anilist.mangaStatus
+        val format =
+            if (activity.result.type == "ANIME") Anilist.animeStatus else Anilist.mangaStatus
         binding.searchStatus.setText(activity.result.status?.replace("_", " "))
         binding.searchStatus.setAdapter(
             ArrayAdapter(

app/src/main/java/ani/dantotsu/media/SubtitleDownloader.kt

@@ -12,7 +12,6 @@ import kotlinx.coroutines.withContext
 import okhttp3.Request
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
-import java.io.File
 
 class SubtitleDownloader {
 
@@ -56,8 +55,8 @@ class SubtitleDownloader {
                     context,
                     downloadedType.type,
                     false,
-                    downloadedType.title,
-                    downloadedType.chapter
+                    downloadedType.titleName,
+                    downloadedType.chapterName
                 ) ?: throw Exception("Could not create directory")
                 val type = loadSubtitleType(url)
                 directory.findFile("subtitle.${type}")?.delete()

app/src/main/java/ani/dantotsu/media/anime/AnimeWatchAdapter.kt

@@ -330,6 +330,7 @@ class AnimeWatchAdapter(
                         0
                     )
                 }
+
                 val chipText = "${names[limit * (position)]} - ${names[last - 1]}"
                 chip.text = chipText
                 chip.setTextColor(
@@ -412,10 +413,12 @@ class AnimeWatchAdapter(
                     if (ep.filler) binding.itemEpisodeFillerView.visibility = View.VISIBLE
 
                     binding.animeSourceContinueText.text =
-                        currActivity()!!.getString(R.string.continue_episode, ep.number, if (ep.filler)
-                            currActivity()!!.getString(R.string.filler_tag)
-                        else
-                            "", cleanedTitle)
+                        currActivity()!!.getString(
+                            R.string.continue_episode, ep.number, if (ep.filler)
+                                currActivity()!!.getString(R.string.filler_tag)
+                            else
+                                "", cleanedTitle
+                        )
                     binding.animeSourceContinue.setOnClickListener {
                         fragment.onEpisodeClick(continueEp)
                     }
@@ -441,11 +444,14 @@ class AnimeWatchAdapter(
                 if (!sourceFound && PrefManager.getVal(PrefName.SearchSources) && autoSelect) {
                     if (binding.animeSource.adapter.count > media.selected!!.sourceIndex + 1) {
                         val nextIndex = media.selected!!.sourceIndex + 1
-                        binding.animeSource.setText(binding.animeSource.adapter
-                            .getItem(nextIndex).toString(), false)
+                        binding.animeSource.setText(
+                            binding.animeSource.adapter
+                                .getItem(nextIndex).toString(), false
+                        )
                         fragment.onSourceChange(nextIndex).apply {
                             binding.animeSourceTitle.text = showUserText
-                            showUserTextListener = { MainScope().launch { binding.animeSourceTitle.text = it } }
+                            showUserTextListener =
+                                { MainScope().launch { binding.animeSourceTitle.text = it } }
                             binding.animeSourceDubbed.isChecked = selectDub
                             binding.animeSourceDubbedCont.isVisible = isDubAvailableSeparately()
                             setLanguageList(0, nextIndex)

app/src/main/java/ani/dantotsu/media/anime/AnimeWatchFragment.kt

@@ -199,7 +199,8 @@ class AnimeWatchFragment : Fragment() {
                         ConcatAdapter(headerAdapter, episodeAdapter)
 
                     lifecycleScope.launch(Dispatchers.IO) {
-                        val offline = !isOnline(binding.root.context) || PrefManager.getVal(PrefName.OfflineMode)
+                        val offline =
+                            !isOnline(binding.root.context) || PrefManager.getVal(PrefName.OfflineMode)
                         if (offline) {
                             media.selected!!.sourceIndex = model.watchSources!!.list.lastIndex
                         } else {
@@ -552,8 +553,8 @@ class AnimeWatchFragment : Fragment() {
         episodeAdapter.updateType(style ?: PrefManager.getVal(PrefName.AnimeDefaultView))
         episodeAdapter.notifyItemRangeInserted(0, arr.size)
         for (download in downloadManager.animeDownloadedTypes) {
-            if (media.compareName(download.title)) {
-                episodeAdapter.stopDownload(download.chapter)
+            if (media.compareName(download.titleName)) {
+                episodeAdapter.stopDownload(download.chapterName)
             }
         }
     }

app/src/main/java/ani/dantotsu/media/anime/EpisodeAdapters.kt

@@ -17,9 +17,7 @@ import ani.dantotsu.currContext
 import ani.dantotsu.databinding.ItemEpisodeCompactBinding
 import ani.dantotsu.databinding.ItemEpisodeGridBinding
 import ani.dantotsu.databinding.ItemEpisodeListBinding
-import ani.dantotsu.download.DownloadsManager
 import ani.dantotsu.download.DownloadsManager.Companion.getDirSize
-import ani.dantotsu.download.anime.AnimeDownloaderService
 import ani.dantotsu.media.Media
 import ani.dantotsu.media.MediaNameAdapter
 import ani.dantotsu.media.MediaType

app/src/main/java/ani/dantotsu/media/anime/ExoplayerView.kt

@@ -111,6 +111,7 @@ import ani.dantotsu.connections.updateProgress
 import ani.dantotsu.databinding.ActivityExoplayerBinding
 import ani.dantotsu.defaultHeaders
 import ani.dantotsu.download.DownloadsManager.Companion.getSubDirectory
+import ani.dantotsu.download.video.Helper
 import ani.dantotsu.dp
 import ani.dantotsu.getCurrentBrightnessValue
 import ani.dantotsu.hideSystemBars
@@ -486,12 +487,14 @@ class ExoplayerView : AppCompatActivity(), Player.Listener, SessionAvailabilityL
                                     }
                                     rotation = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
                                 }
+
                                 in 225..315 -> {
                                     if (rotation != ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
                                         exoRotate.visibility = View.VISIBLE
                                     }
                                     rotation = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
                                 }
+
                                 in 315..360, in 0..45 -> {
                                     if (rotation != ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
                                         exoRotate.visibility = View.VISIBLE
@@ -1396,7 +1399,8 @@ class ExoplayerView : AppCompatActivity(), Player.Listener, SessionAvailabilityL
                 subClick()
             }
         }
-        val sub: MutableList<MediaItem.SubtitleConfiguration> = emptyList<MediaItem.SubtitleConfiguration>().toMutableList()
+        val sub: MutableList<MediaItem.SubtitleConfiguration> =
+            emptyList<MediaItem.SubtitleConfiguration>().toMutableList()
         ext.subtitles.forEach { subtitle ->
             val subtitleUrl = if (!hasExtSubtitles) video!!.file.url else subtitle.file.url
             //var localFile: String? = null
@@ -1478,26 +1482,38 @@ class ExoplayerView : AppCompatActivity(), Player.Listener, SessionAvailabilityL
         val downloadedMediaItem = if (ext.server.offline) {
             val titleName = ext.server.name.split("/").first()
             val episodeName = ext.server.name.split("/").last()
+            downloadId = PrefManager.getAnimeDownloadPreferences()
+                .getString("$titleName - $episodeName", null) ?:
+                    PrefManager.getAnimeDownloadPreferences()
+                        .getString(ext.server.name, null)
+            val exoItem = if (downloadId != null) {
+                Helper.downloadManager(this)
+                    .downloadIndex.getDownload(downloadId!!)?.request?.toMediaItem()
+            } else null
+            if (exoItem != null) {
+                exoItem
+            } else {
 
-            val directory = getSubDirectory(this, MediaType.ANIME, false, titleName, episodeName)
-            if (directory != null) {
-                val files = directory.listFiles()
-                println(files)
-                val docFile = directory.listFiles().firstOrNull {
-                    it.name?.endsWith(".mp4") == true || it.name?.endsWith(".mkv") == true
-                }
-                if (docFile != null) {
-                    val uri = docFile.uri
-                    MediaItem.Builder().setUri(uri).setMimeType(mimeType).build()
+                val directory =
+                    getSubDirectory(this, MediaType.ANIME, false, titleName, episodeName)
+                if (directory != null) {
+                    val files = directory.listFiles()
+                    println(files)
+                    val docFile = directory.listFiles().firstOrNull {
+                        it.name?.endsWith(".mp4") == true || it.name?.endsWith(".mkv") == true
+                    }
+                    if (docFile != null) {
+                        val uri = docFile.uri
+                        MediaItem.Builder().setUri(uri).setMimeType(mimeType).build()
+                    } else {
+                        snackString("File not found")
+                        null
+                    }
                 } else {
-                    snackString("File not found")
+                    snackString("Directory not found")
                     null
                 }
-            } else {
-                snackString("Directory not found")
-                null
             }
-
         } else null
 
         mediaItem = if (downloadedMediaItem == null) {
@@ -1570,7 +1586,8 @@ class ExoplayerView : AppCompatActivity(), Player.Listener, SessionAvailabilityL
                     }
                 }.show()
             dialog.window?.setDimAmount(0.8f)
-        } else buildExoplayer()
+        }
+        if (!this::exoPlayer.isInitialized) buildExoplayer()
 
         val isDisabled = (subtitle == null && hasExtSubtitles)
         exoPlayer.trackSelectionParameters = exoPlayer.trackSelectionParameters
@@ -1864,7 +1881,10 @@ class ExoplayerView : AppCompatActivity(), Player.Listener, SessionAvailabilityL
                     exoPlayer.seekTo((new.interval.endTime * 1000).toLong())
                     skippedTimeStamps.add(new)
                 }
-                if (PrefManager.getVal(PrefName.AutoSkipRecap) && new.skipType == "recap" && !skippedTimeStamps.contains(new)) {
+                if (PrefManager.getVal(PrefName.AutoSkipRecap) && new.skipType == "recap" && !skippedTimeStamps.contains(
+                        new
+                    )
+                ) {
                     exoPlayer.seekTo((new.interval.endTime * 1000).toLong())
                     skippedTimeStamps.add(new)
                 }
@@ -1909,12 +1929,15 @@ class ExoplayerView : AppCompatActivity(), Player.Listener, SessionAvailabilityL
         val audioTracks: ArrayList<Tracks.Group> = arrayListOf()
         val subTracks: ArrayList<Tracks.Group> = arrayListOf(dummyTrack)
         tracks.groups.forEach {
-            println("Track__: $it\nTrack__: ${it.length}\nTrack__: ${it.isSelected}\n" +
-                    "Track__: ${it.type}\nTrack__: ${it.mediaTrackGroup.id}")
+            println(
+                "Track__: $it\nTrack__: ${it.length}\nTrack__: ${it.isSelected}\n" +
+                        "Track__: ${it.type}\nTrack__: ${it.mediaTrackGroup.id}"
+            )
             when (it.type) {
                 TRACK_TYPE_AUDIO -> {
                     if (it.isSupported(true)) audioTracks.add(it)
                 }
+
                 TRACK_TYPE_TEXT -> {
                     if (!hasExtSubtitles) {
                         if (it.isSupported(true)) subTracks.add(it)
@@ -1950,7 +1973,8 @@ class ExoplayerView : AppCompatActivity(), Player.Listener, SessionAvailabilityL
                             onSetTrackGroupOverride(dummyTrack, TRACK_TYPE_TEXT)
                         }
                     }
-                    else -> { }
+
+                    else -> {}
                 }
             }
         }
@@ -1965,6 +1989,7 @@ class ExoplayerView : AppCompatActivity(), Player.Listener, SessionAvailabilityL
                 isPlayerPlaying = true
                 sourceClick()
             }
+
             else -> {
                 toast("Player Error ${error.errorCode} (${error.errorCodeName}) : ${error.message}")
                 Injekt.get<CrashlyticsInterface>().logException(error)

app/src/main/java/ani/dantotsu/media/anime/SelectorDialogFragment.kt

@@ -24,6 +24,8 @@ import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import ani.dantotsu.BottomSheetDialogFragment
 import ani.dantotsu.R
+import ani.dantotsu.addons.download.DownloadAddonManager
+import ani.dantotsu.addons.torrent.TorrentAddonManager
 import ani.dantotsu.connections.crashlytics.CrashlyticsInterface
 import ani.dantotsu.copyToClipboard
 import ani.dantotsu.currActivity
@@ -47,12 +49,16 @@ import ani.dantotsu.setSafeOnClickListener
 import ani.dantotsu.settings.saving.PrefManager
 import ani.dantotsu.settings.saving.PrefName
 import ani.dantotsu.snackString
+import ani.dantotsu.toast
 import ani.dantotsu.tryWith
 import ani.dantotsu.util.Logger
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withContext
+import tachiyomi.core.util.lang.launchIO
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 import java.text.DecimalFormat
@@ -230,11 +236,12 @@ class SelectorDialogFragment : BottomSheetDialogFragment() {
     }
 
     private val externalPlayerResult = registerForActivityResult(
-        ActivityResultContracts.StartActivityForResult()) { result: ActivityResult ->
+        ActivityResultContracts.StartActivityForResult()
+    ) { result: ActivityResult ->
         Logger.log(result.data.toString())
     }
 
-    private fun exportMagnetIntent(episode: Episode, video: Video) : Intent {
+    private fun exportMagnetIntent(episode: Episode, video: Video): Intent {
         val amnis = "com.amnis"
         return Intent(Intent.ACTION_VIEW).apply {
             component = ComponentName(amnis, "$amnis.gui.player.PlayerActivity")
@@ -252,32 +259,70 @@ class SelectorDialogFragment : BottomSheetDialogFragment() {
         }
     }
 
+    @OptIn(DelicateCoroutinesApi::class)
     @SuppressLint("UnsafeOptInUsageError")
     fun startExoplayer(media: Media) {
         prevEpisode = null
 
-        dismiss()
-
         episode?.let { ep ->
             val video = ep.extractors?.find {
                 it.server.name == ep.selectedExtractor
             }?.videos?.getOrNull(ep.selectedVideo)
             video?.file?.url?.let { url ->
-                if (url.startsWith("magnet:")) {
-                    try {
-                        externalPlayerResult.launch(exportMagnetIntent(ep, video))
-                    } catch (e: ActivityNotFoundException) {
-                        val amnis = "com.amnis"
-                        try {
-                            startActivity(Intent(
-                                Intent.ACTION_VIEW,
-                                Uri.parse("market://details?id=$amnis"))
+                if (url.startsWith("magnet:") || url.endsWith(".torrent")) {
+                    val torrentExtension = Injekt.get<TorrentAddonManager>()
+                    if (torrentExtension.isAvailable()) {
+                        val activity = currActivity() ?: requireActivity()
+                        launchIO {
+                            val extension = torrentExtension.extension!!.extension
+                            torrentExtension.torrentHash?.let {
+                                extension.removeTorrent(it)
+                            }
+                            val index = if (url.contains("index=")) {
+                                url.substringAfter("index=").toIntOrNull() ?: 0
+                            } else 0
+                            Logger.log("Sending: ${url}, ${video.quality}, $index")
+                            val currentTorrent = extension.addTorrent(
+                                url, video.quality.toString(), "", "", false
                             )
+                            torrentExtension.torrentHash = currentTorrent.hash
+                            video.file.url = extension.getLink(currentTorrent, index)
+                            Logger.log("Received: ${video.file.url}")
+                            if (launch == true) {
+                                Intent(activity, ExoplayerView::class.java).apply {
+                                    ExoplayerView.media = media
+                                    ExoplayerView.initialized = true
+                                    startActivity(this)
+                                }
+                            } else {
+                                model.setEpisode(
+                                    media.anime!!.episodes!![media.anime.selectedEpisode!!]!!,
+                                    "startExo no launch"
+                                )
+                            }
+                            dismiss()
+                        }
+                    } else {
+                        try {
+                            externalPlayerResult.launch(exportMagnetIntent(ep, video))
                         } catch (e: ActivityNotFoundException) {
-                            startActivity(Intent(
-                                Intent.ACTION_VIEW,
-                                Uri.parse("https://play.google.com/store/apps/details?id=$amnis")
-                            ))
+                            val amnis = "com.amnis"
+                            try {
+                                startActivity(
+                                    Intent(
+                                        Intent.ACTION_VIEW,
+                                        Uri.parse("market://details?id=$amnis")
+                                    )
+                                )
+                                dismiss()
+                            } catch (e: ActivityNotFoundException) {
+                                startActivity(
+                                    Intent(
+                                        Intent.ACTION_VIEW,
+                                        Uri.parse("https://play.google.com/store/apps/details?id=$amnis")
+                                    )
+                                )
+                            }
                         }
                     }
                     return
@@ -285,6 +330,7 @@ class SelectorDialogFragment : BottomSheetDialogFragment() {
             }
         }
 
+        dismiss()
         if (launch!! || model.watchSources!!.isDownloadedSource(media.selected!!.sourceIndex)) {
             stopAddingToList()
             val intent = Intent(activity, ExoplayerView::class.java)
@@ -403,7 +449,11 @@ class SelectorDialogFragment : BottomSheetDialogFragment() {
                                     SubtitleDownloader.downloadSubtitle(
                                         requireContext(),
                                         subtitleToDownload!!.file.url,
-                                        DownloadedType(media!!.mainName(), media!!.anime!!.episodes!![media!!.anime!!.selectedEpisode!!]!!.number, MediaType.ANIME)
+                                        DownloadedType(
+                                            media!!.mainName(),
+                                            media!!.anime!!.episodes!![media!!.anime!!.selectedEpisode!!]!!.number,
+                                            MediaType.ANIME
+                                        )
                                     )
                                 }
                             }
@@ -430,12 +480,45 @@ class SelectorDialogFragment : BottomSheetDialogFragment() {
                         media!!.userPreferredName
                     )
                 } else {
+                    val downloadAddonManager: DownloadAddonManager = Injekt.get()
+                    if (!downloadAddonManager.isAvailable()){
+                        toast("Download Extension not available")
+                        return@setSafeOnClickListener
+                    }
                     val episode = media!!.anime!!.episodes!![media!!.anime!!.selectedEpisode!!]!!
                     val selectedVideo =
                         if (extractor.videos.size > episode.selectedVideo) extractor.videos[episode.selectedVideo] else null
                     val subtitleNames = subtitles.map { it.language }
                     var subtitleToDownload: Subtitle? = null
-                    val activity = currActivity()?:requireActivity()
+                    val activity = currActivity() ?: requireActivity()
+                    selectedVideo?.file?.url?.let { url ->
+                        if (url.startsWith("magnet:") || url.endsWith(".torrent")) {
+                            val torrentExtension = Injekt.get<TorrentAddonManager>()
+                            if (!torrentExtension.isAvailable()) {
+                                toast("Torrent Extension not available")
+                                return@setSafeOnClickListener
+                            }
+                            runBlocking {
+                                withContext(Dispatchers.IO) {
+                                    val extension = torrentExtension.extension!!.extension
+                                    torrentExtension.torrentHash?.let {
+                                        extension.removeTorrent(it)
+                                    }
+                                    val index = if (url.contains("index=")) {
+                                        url.substringAfter("index=").toIntOrNull() ?: 0
+                                    } else 0
+                                    Logger.log("Sending: ${url}, ${selectedVideo.quality}, $index")
+                                    val currentTorrent = extension.addTorrent(
+                                        url, selectedVideo.quality.toString(), "", "", false
+                                    )
+                                    torrentExtension.torrentHash = currentTorrent.hash
+                                    selectedVideo.file.url =
+                                        extension.getLink(currentTorrent, index)
+                                    Logger.log("Received: ${selectedVideo.file.url}")
+                                }
+                            }
+                        }
+                    }
                     if (subtitles.isNotEmpty()) {
                         val alertDialog = AlertDialog.Builder(context, R.style.MyPopup)
                             .setTitle("Download Subtitle")
@@ -509,9 +592,13 @@ class SelectorDialogFragment : BottomSheetDialogFragment() {
             if (video.format == VideoType.CONTAINER) {
                 binding.urlSize.isVisible = video.size != null
                 // if video size is null or 0, show "Unknown Size" else show the size in MB
-                val sizeText = getString(R.string.mb_size, "${if (video.extraNote != null) " : " else ""}${
-                    if (video.size == 0.0) getString(R.string.size_unknown) else DecimalFormat("#.##").format(video.size ?: 0)
-                }")
+                val sizeText = getString(
+                    R.string.mb_size, "${if (video.extraNote != null) " : " else ""}${
+                        if (video.size == 0.0) getString(R.string.size_unknown) else DecimalFormat("#.##").format(
+                            video.size ?: 0
+                        )
+                    }"
+                )
                 binding.urlSize.text = sizeText
             }
             binding.urlNote.visibility = View.VISIBLE

app/src/main/java/ani/dantotsu/media/anime/SubtitleDialogFragment.kt

@@ -67,7 +67,11 @@ class SubtitleDialogFragment : BottomSheetDialogFragment() {
                 binding.subtitleTitle.setText(R.string.none)
                 model.getMedia().observe(viewLifecycleOwner) { media ->
                     val mediaID: Int = media.id
-                    val selSubs = PrefManager.getNullableCustomVal("subLang_${mediaID}", null, String::class.java)
+                    val selSubs = PrefManager.getNullableCustomVal(
+                        "subLang_${mediaID}",
+                        null,
+                        String::class.java
+                    )
                     if (episode.selectedSubtitle != null && selSubs != "None") {
                         binding.root.setCardBackgroundColor(TRANSPARENT)
                     }
@@ -107,7 +111,11 @@ class SubtitleDialogFragment : BottomSheetDialogFragment() {
                 model.getMedia().observe(viewLifecycleOwner) { media ->
                     val mediaID: Int = media.id
                     val selSubs: String? =
-                        PrefManager.getNullableCustomVal("subLang_${mediaID}", null, String::class.java)
+                        PrefManager.getNullableCustomVal(
+                            "subLang_${mediaID}",
+                            null,
+                            String::class.java
+                        )
                     if (episode.selectedSubtitle != position - 1 && selSubs != subtitles[position - 1].language) {
                         binding.root.setCardBackgroundColor(TRANSPARENT)
                     }

app/src/main/java/ani/dantotsu/media/anime/TrackGroupDialogFragment.kt

@@ -5,7 +5,6 @@ import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import androidx.annotation.OptIn
-import androidx.core.view.isVisible
 import androidx.media3.common.C.TRACK_TYPE_AUDIO
 import androidx.media3.common.C.TrackType
 import androidx.media3.common.Tracks
@@ -20,7 +19,7 @@ import java.util.Locale
 
 @OptIn(UnstableApi::class)
 class TrackGroupDialogFragment(
-    instance: ExoplayerView, trackGroups: ArrayList<Tracks.Group>, type : @TrackType Int
+    instance: ExoplayerView, trackGroups: ArrayList<Tracks.Group>, type: @TrackType Int
 ) : BottomSheetDialogFragment() {
     private var _binding: BottomSheetSubtitlesBinding? = null
     private val binding get() = _binding!!
@@ -70,21 +69,28 @@ class TrackGroupDialogFragment(
             trackGroups[position].let { trackGroup ->
                 when (val language = trackGroup.getTrackFormat(0).language?.lowercase()) {
                     null -> {
-                        binding.subtitleTitle.text = getString(R.string.unknown_track, "Track $position")
+                        binding.subtitleTitle.text =
+                            getString(R.string.unknown_track, "Track $position")
                     }
+
                     "none" -> {
                         binding.subtitleTitle.text = getString(R.string.disabled_track)
                     }
+
                     else -> {
                         val locale = if (language.contains("-")) {
                             val parts = language.split("-")
                             try {
                                 Locale(parts[0], parts[1])
-                            } catch (ignored: Exception) { null }
+                            } catch (ignored: Exception) {
+                                null
+                            }
                         } else {
                             try {
                                 Locale(language)
-                            } catch (ignored: Exception) { null }
+                            } catch (ignored: Exception) {
+                                null
+                            }
                         }
                         binding.subtitleTitle.text = locale?.let {
                             "[${it.language}] ${it.displayName}"

app/src/main/java/ani/dantotsu/media/comments/CommentItem.kt

@@ -60,7 +60,8 @@ class CommentItem(
     override fun bind(viewBinding: ItemCommentsBinding, position: Int) {
         binding = viewBinding
         setAnimation(binding.root.context, binding.root)
-        viewBinding.commentRepliesList.layoutManager = LinearLayoutManager(commentsFragment.activity)
+        viewBinding.commentRepliesList.layoutManager =
+            LinearLayoutManager(commentsFragment.activity)
         viewBinding.commentRepliesList.adapter = adapter
         val isUserComment = CommentsAPI.userId == comment.userId
         val levelColor = getAvatarColor(comment.totalVotes, backgroundColor)
@@ -112,16 +113,20 @@ class CommentItem(
 
         viewBinding.commentUserName.setOnClickListener {
             ContextCompat.startActivity(
-                commentsFragment.activity, Intent(commentsFragment.activity, ProfileActivity::class.java)
+                commentsFragment.activity,
+                Intent(commentsFragment.activity, ProfileActivity::class.java)
                     .putExtra("userId", comment.userId.toInt())
-                    .putExtra("userLVL","[${levelColor.second}]"), null
+                    .putExtra("userLVL", "[${levelColor.second}]"),
+                null
             )
         }
         viewBinding.commentUserAvatar.setOnClickListener {
             ContextCompat.startActivity(
-                commentsFragment.activity, Intent(commentsFragment.activity, ProfileActivity::class.java)
+                commentsFragment.activity,
+                Intent(commentsFragment.activity, ProfileActivity::class.java)
                     .putExtra("userId", comment.userId.toInt())
-                    .putExtra("userLVL","[${levelColor.second}]"), null
+                    .putExtra("userLVL", "[${levelColor.second}]"),
+                null
             )
         }
         viewBinding.commentText.setOnLongClickListener {
@@ -143,8 +148,10 @@ class CommentItem(
         viewBinding.commentInfo.setOnClickListener {
             val popup = PopupMenu(commentsFragment.requireContext(), viewBinding.commentInfo)
             popup.menuInflater.inflate(R.menu.profile_details_menu, popup.menu)
-            popup.menu.findItem(R.id.commentDelete)?.isVisible = isUserComment || CommentsAPI.isAdmin || CommentsAPI.isMod
-            popup.menu.findItem(R.id.commentBanUser)?.isVisible = (CommentsAPI.isAdmin || CommentsAPI.isMod) && !isUserComment
+            popup.menu.findItem(R.id.commentDelete)?.isVisible =
+                isUserComment || CommentsAPI.isAdmin || CommentsAPI.isMod
+            popup.menu.findItem(R.id.commentBanUser)?.isVisible =
+                (CommentsAPI.isAdmin || CommentsAPI.isMod) && !isUserComment
             popup.menu.findItem(R.id.commentReport)?.isVisible = !isUserComment
             popup.setOnMenuItemClickListener { item ->
                 when (item.itemId) {
@@ -273,12 +280,16 @@ class CommentItem(
     }
 
     fun replying(isReplying: Boolean) {
-        binding.commentReply.text = if (isReplying) commentsFragment.activity.getString(R.string.cancel) else "Reply"
+        binding.commentReply.text =
+            if (isReplying) commentsFragment.activity.getString(R.string.cancel) else "Reply"
         this.isReplying = isReplying
     }
 
     fun editing(isEditing: Boolean) {
-        binding.commentEdit.text = if (isEditing) commentsFragment.activity.getString(R.string.cancel) else commentsFragment.activity.getString(R.string.edit)
+        binding.commentEdit.text =
+            if (isEditing) commentsFragment.activity.getString(R.string.cancel) else commentsFragment.activity.getString(
+                R.string.edit
+            )
         this.isEditing = isEditing
     }
 
@@ -286,7 +297,7 @@ class CommentItem(
         subCommentIds.add(id)
     }
 
-    private fun removeSubCommentIds(){
+    private fun removeSubCommentIds() {
         subCommentIds.forEach { id ->
             @Suppress("UNCHECKED_CAST")
             val parentComments = parentSection.groups as? List<CommentItem> ?: emptyList()
@@ -306,11 +317,13 @@ class CommentItem(
                 viewBinding.commentUpVote.alpha = 1f
                 viewBinding.commentDownVote.setImageResource(R.drawable.ic_round_upvote_inactive_24)
             }
+
             -1 -> {
                 viewBinding.commentUpVote.setImageResource(R.drawable.ic_round_upvote_inactive_24)
                 viewBinding.commentDownVote.setImageResource(R.drawable.ic_round_upvote_active_24)
                 viewBinding.commentDownVote.alpha = 1f
             }
+
             else -> {
                 viewBinding.commentUpVote.setImageResource(R.drawable.ic_round_upvote_inactive_24)
                 viewBinding.commentDownVote.setImageResource(R.drawable.ic_round_upvote_inactive_24)
@@ -355,7 +368,8 @@ class CommentItem(
 
     private fun getAvatarColor(voteCount: Int, backgroundColor: Int): Pair<Int, Int> {
         val level = if (voteCount < 0) 0 else sqrt(abs(voteCount.toDouble()) / 0.8).toInt()
-        val colorString = if (level > usernameColors.size - 1) usernameColors[usernameColors.size - 1] else usernameColors[level]
+        val colorString =
+            if (level > usernameColors.size - 1) usernameColors[usernameColors.size - 1] else usernameColors[level]
         var color = Color.parseColor(colorString)
         val ratio = getContrastRatio(color, backgroundColor)
         if (ratio < 4.5) {
@@ -373,16 +387,17 @@ class CommentItem(
      * @param callback the callback to call when the user clicks yes
      */
     private fun dialogBuilder(title: String, message: String, callback: () -> Unit) {
-        val alertDialog = android.app.AlertDialog.Builder(commentsFragment.activity, R.style.MyPopup)
-            .setTitle(title)
-            .setMessage(message)
-            .setPositiveButton("Yes") { dialog, _ ->
-                callback()
-                dialog.dismiss()
-            }
-            .setNegativeButton("No") { dialog, _ ->
-                dialog.dismiss()
-            }
+        val alertDialog =
+            android.app.AlertDialog.Builder(commentsFragment.activity, R.style.MyPopup)
+                .setTitle(title)
+                .setMessage(message)
+                .setPositiveButton("Yes") { dialog, _ ->
+                    callback()
+                    dialog.dismiss()
+                }
+                .setNegativeButton("No") { dialog, _ ->
+                    dialog.dismiss()
+                }
         val dialog = alertDialog.show()
         dialog?.window?.setDimAmount(0.8f)
     }

app/src/main/java/ani/dantotsu/media/comments/CommentsFragment.kt

@@ -75,7 +75,10 @@ class CommentsFragment : Fragment() {
         super.onViewCreated(view, savedInstanceState)
         activity = requireActivity() as MediaDetailsActivity
 
-        binding.commentsListContainer.setBaseline(activity.navBar, activity.binding.commentInputLayout)
+        binding.commentsListContainer.setBaseline(
+            activity.navBar,
+            activity.binding.commentInputLayout
+        )
 
         //get the media id from the intent
         val mediaId = arguments?.getInt("mediaId") ?: -1
@@ -118,7 +121,6 @@ class CommentsFragment : Fragment() {
                 }
             }
         } else {
-            toast("Not logged in")
             activity.binding.commentMessageContainer.visibility = View.GONE
         }
 
@@ -301,7 +303,7 @@ class CommentsFragment : Fragment() {
 
             activity.binding.commentLabel.setOnClickListener {
                 //alert dialog to enter a number, with a cancel and ok button
-                val alertDialog = android.app.AlertDialog.Builder(activity, R.style.MyPopup)
+                val alertDialog = AlertDialog.Builder(activity, R.style.MyPopup)
                     .setTitle("Enter a chapter/episode number tag")
                     .setView(R.layout.dialog_edittext)
                     .setPositiveButton("OK") { dialog, _ ->
@@ -577,7 +579,7 @@ class CommentsFragment : Fragment() {
      * Called when the user tries to comment for the first time
      */
     private fun showCommentRulesDialog() {
-        val alertDialog = android.app.AlertDialog.Builder(activity, R.style.MyPopup)
+        val alertDialog = AlertDialog.Builder(activity, R.style.MyPopup)
             .setTitle("Commenting Rules")
             .setMessage(
                 "I WILL BAN YOU WITHOUT HESITATION\n" +

app/src/main/java/ani/dantotsu/media/manga/MangaChapterAdapter.kt

@@ -343,6 +343,7 @@ class MangaChapterAdapter(
     fun updateType(t: Int) {
         type = t
     }
+
     private fun formatDate(timestamp: Long?): String {
         timestamp ?: return "" // Return empty string if timestamp is null
 
@@ -366,6 +367,7 @@ class MangaChapterAdapter(
                     else -> "Just now"
                 }
             }
+
             1L -> "1 day ago"
             in 2..6 -> "$daysDifference days ago"
             else -> SimpleDateFormat("dd MMM yyyy", Locale.getDefault()).format(targetDate)

app/src/main/java/ani/dantotsu/media/manga/MangaReadAdapter.kt

@@ -229,7 +229,7 @@ class MangaReadAdapter(
                         refresh = true
                         val intent = Intent(fragment.requireContext(), CookieCatcher::class.java)
                             .putExtra("url", url)
-                        ContextCompat.startActivity(fragment.requireContext(), intent, null)
+                        startActivity(fragment.requireContext(), intent, null)
                     }
                 }
             }
@@ -258,8 +258,10 @@ class MangaReadAdapter(
             dialogBinding.animeScanlatorContainer.isVisible = options.count() > 1
             dialogBinding.scanlatorNo.text = "${options.count()}"
             dialogBinding.animeScanlatorTop.setOnClickListener {
-                val dialogView2 = LayoutInflater.from(currContext()).inflate(R.layout.custom_dialog_layout, null)
-                val checkboxContainer = dialogView2.findViewById<LinearLayout>(R.id.checkboxContainer)
+                val dialogView2 =
+                    LayoutInflater.from(currContext()).inflate(R.layout.custom_dialog_layout, null)
+                val checkboxContainer =
+                    dialogView2.findViewById<LinearLayout>(R.id.checkboxContainer)
                 val tickAllButton = dialogView2.findViewById<ImageButton>(R.id.toggleButton)
 
                 // Function to get the right image resource for the toggle button
@@ -441,7 +443,11 @@ class MangaReadAdapter(
             if (media.manga?.chapters != null) {
                 val chapters = media.manga.chapters!!.keys.toTypedArray()
                 val anilistEp = (media.userProgress ?: 0).plus(1)
-                val appEp = PrefManager.getNullableCustomVal("${media.id}_current_chp", null, String::class.java)
+                val appEp = PrefManager.getNullableCustomVal(
+                    "${media.id}_current_chp",
+                    null,
+                    String::class.java
+                )
                     ?.toIntOrNull() ?: 1
                 var continueEp = (if (anilistEp > appEp) anilistEp else appEp).toString()
                 val filteredChapters = chapters.filter { chapterKey ->
@@ -470,7 +476,11 @@ class MangaReadAdapter(
                     val ep = media.manga.chapters!![continueEp]!!
                     binding.itemEpisodeImage.loadImage(media.banner ?: media.cover)
                     binding.animeSourceContinueText.text =
-                        currActivity()!!.getString(R.string.continue_chapter, ep.number, if (!ep.title.isNullOrEmpty()) ep.title else "")
+                        currActivity()!!.getString(
+                            R.string.continue_chapter,
+                            ep.number,
+                            if (!ep.title.isNullOrEmpty()) ep.title else ""
+                        )
                     binding.animeSourceContinue.setOnClickListener {
                         fragment.onMangaChapterClick(continueEp)
                     }
@@ -491,11 +501,14 @@ class MangaReadAdapter(
                 if (!sourceFound && PrefManager.getVal(PrefName.SearchSources)) {
                     if (binding.animeSource.adapter.count > media.selected!!.sourceIndex + 1) {
                         val nextIndex = media.selected!!.sourceIndex + 1
-                        binding.animeSource.setText(binding.animeSource.adapter
-                            .getItem(nextIndex).toString(), false)
+                        binding.animeSource.setText(
+                            binding.animeSource.adapter
+                                .getItem(nextIndex).toString(), false
+                        )
                         fragment.onSourceChange(nextIndex).apply {
                             binding.animeSourceTitle.text = showUserText
-                            showUserTextListener = { MainScope().launch { binding.animeSourceTitle.text = it } }
+                            showUserTextListener =
+                                { MainScope().launch { binding.animeSourceTitle.text = it } }
                             setLanguageList(0, nextIndex)
                         }
                         subscribeButton(false)

app/src/main/java/ani/dantotsu/media/manga/MangaReadFragment.kt

@@ -42,8 +42,8 @@ import ani.dantotsu.isOnline
 import ani.dantotsu.media.Media
 import ani.dantotsu.media.MediaDetailsActivity
 import ani.dantotsu.media.MediaDetailsViewModel
-import ani.dantotsu.media.MediaType
 import ani.dantotsu.media.MediaNameAdapter
+import ani.dantotsu.media.MediaType
 import ani.dantotsu.media.manga.mangareader.ChapterLoaderDialog
 import ani.dantotsu.navBarHeight
 import ani.dantotsu.notifications.subscription.SubscriptionHelper
@@ -194,8 +194,8 @@ open class MangaReadFragment : Fragment(), ScanlatorSelectionListener {
                             )
 
                         for (download in downloadManager.mangaDownloadedTypes) {
-                            if (media.compareName(download.title)) {
-                                chapterAdapter.stopDownload(download.chapter)
+                            if (media.compareName(download.titleName)) {
+                                chapterAdapter.stopDownload(download.chapterName)
                             }
                         }
 
@@ -203,8 +203,10 @@ open class MangaReadFragment : Fragment(), ScanlatorSelectionListener {
                             ConcatAdapter(headerAdapter, chapterAdapter)
 
                         lifecycleScope.launch(Dispatchers.IO) {
-                            val offline = !isOnline(binding.root.context) || PrefManager.getVal(PrefName.OfflineMode)
-                            if (offline) media.selected!!.sourceIndex = model.mangaReadSources!!.list.lastIndex
+                            val offline =
+                                !isOnline(binding.root.context) || PrefManager.getVal(PrefName.OfflineMode)
+                            if (offline) media.selected!!.sourceIndex =
+                                model.mangaReadSources!!.list.lastIndex
                             model.loadMangaChapters(media, media.selected!!.sourceIndex)
                         }
                         loaded = true

app/src/main/java/ani/dantotsu/media/manga/mangareader/BaseImageAdapter.kt

@@ -42,7 +42,8 @@ abstract class BaseImageAdapter(
 
     override fun onAttachedToRecyclerView(recyclerView: RecyclerView) {
         images = if (settings.layout == CurrentReaderSettings.Layouts.PAGED
-            && settings.direction == CurrentReaderSettings.Directions.BOTTOM_TO_TOP) {
+            && settings.direction == CurrentReaderSettings.Directions.BOTTOM_TO_TOP
+        ) {
             chapterImages.reversed()
         } else {
             chapterImages

app/src/main/java/ani/dantotsu/media/manga/mangareader/MangaReaderActivity.kt

@@ -56,8 +56,8 @@ import ani.dantotsu.isOnline
 import ani.dantotsu.logError
 import ani.dantotsu.media.Media
 import ani.dantotsu.media.MediaDetailsViewModel
-import ani.dantotsu.media.MediaSingleton
 import ani.dantotsu.media.MediaNameAdapter
+import ani.dantotsu.media.MediaSingleton
 import ani.dantotsu.media.manga.MangaCache
 import ani.dantotsu.media.manga.MangaChapter
 import ani.dantotsu.others.ImageViewDialog
@@ -129,10 +129,12 @@ class MangaReaderActivity : AppCompatActivity() {
     var sliding = false
     var isAnimating = false
 
-    private val directionRLBT get() = defaultSettings.direction == RIGHT_TO_LEFT
-            || defaultSettings.direction == BOTTOM_TO_TOP
-    private val directionPagedBT get() = defaultSettings.layout == CurrentReaderSettings.Layouts.PAGED
-            && defaultSettings.direction == CurrentReaderSettings.Directions.BOTTOM_TO_TOP
+    private val directionRLBT
+        get() = defaultSettings.direction == RIGHT_TO_LEFT
+                || defaultSettings.direction == BOTTOM_TO_TOP
+    private val directionPagedBT
+        get() = defaultSettings.layout == CurrentReaderSettings.Layouts.PAGED
+                && defaultSettings.direction == CurrentReaderSettings.Directions.BOTTOM_TO_TOP
 
     override fun onAttachedToWindow() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P && !PrefManager.getVal<Boolean>(PrefName.ShowSystemBars)) {
@@ -229,7 +231,7 @@ class MangaReaderActivity : AppCompatActivity() {
                     binding.mangaReaderRecycler.scrollToPosition((value.toInt() - 1) / (dualPage { 2 }
                         ?: 1))
                 else
-                    if (defaultSettings.direction == CurrentReaderSettings.Directions.BOTTOM_TO_TOP ) {
+                    if (defaultSettings.direction == CurrentReaderSettings.Directions.BOTTOM_TO_TOP) {
                         binding.mangaReaderPager.currentItem =
                             (maxChapterPage.toInt() - value.toInt()) / (dualPage { 2 } ?: 1)
                     } else {
@@ -345,7 +347,11 @@ class MangaReaderActivity : AppCompatActivity() {
                 if (currentChapterIndex > 0) change(currentChapterIndex - 1)
                 else snackString(getString(R.string.first_chapter))
             } else {
-                if (chaptersArr.size > currentChapterIndex + 1) progress { change(currentChapterIndex + 1) }
+                if (chaptersArr.size > currentChapterIndex + 1) progress {
+                    change(
+                        currentChapterIndex + 1
+                    )
+                }
                 else snackString(getString(R.string.next_chapter_not_found))
             }
         }
@@ -355,7 +361,11 @@ class MangaReaderActivity : AppCompatActivity() {
         }
         binding.mangaReaderPreviousChapter.setOnClickListener {
             if (directionRLBT) {
-                if (chaptersArr.size > currentChapterIndex + 1) progress { change(currentChapterIndex + 1) }
+                if (chaptersArr.size > currentChapterIndex + 1) progress {
+                    change(
+                        currentChapterIndex + 1
+                    )
+                }
                 else snackString(getString(R.string.next_chapter_not_found))
             } else {
                 if (currentChapterIndex > 0) change(currentChapterIndex - 1)
@@ -372,11 +382,15 @@ class MangaReaderActivity : AppCompatActivity() {
                 currentChapterIndex = chaptersArr.indexOf(chap.number)
                 binding.mangaReaderChapterSelect.setSelection(currentChapterIndex)
                 if (directionRLBT) {
-                    binding.mangaReaderNextChap.text = chaptersTitleArr.getOrNull(currentChapterIndex - 1) ?: ""
-                    binding.mangaReaderPrevChap.text = chaptersTitleArr.getOrNull(currentChapterIndex + 1) ?: ""
+                    binding.mangaReaderNextChap.text =
+                        chaptersTitleArr.getOrNull(currentChapterIndex - 1) ?: ""
+                    binding.mangaReaderPrevChap.text =
+                        chaptersTitleArr.getOrNull(currentChapterIndex + 1) ?: ""
                 } else {
-                    binding.mangaReaderNextChap.text = chaptersTitleArr.getOrNull(currentChapterIndex + 1) ?: ""
-                    binding.mangaReaderPrevChap.text = chaptersTitleArr.getOrNull(currentChapterIndex - 1) ?: ""
+                    binding.mangaReaderNextChap.text =
+                        chaptersTitleArr.getOrNull(currentChapterIndex + 1) ?: ""
+                    binding.mangaReaderPrevChap.text =
+                        chaptersTitleArr.getOrNull(currentChapterIndex - 1) ?: ""
                 }
                 applySettings()
                 val context = this
@@ -389,10 +403,12 @@ class MangaReaderActivity : AppCompatActivity() {
                             "nothing" -> mutableListOf(
                                 RPC.Link(getString(R.string.view_manga), media.shareLink ?: ""),
                             )
+
                             "dantotsu" -> mutableListOf(
                                 RPC.Link(getString(R.string.view_manga), media.shareLink ?: ""),
                                 RPC.Link("Read on Dantotsu", getString(R.string.dantotsu))
                             )
+
                             "anilist" -> {
                                 val userId = PrefManager.getVal<String>(PrefName.AnilistUserId)
                                 val anilistLink = "https://anilist.co/user/$userId/"
@@ -401,6 +417,7 @@ class MangaReaderActivity : AppCompatActivity() {
                                     RPC.Link("View My AniList", anilistLink)
                                 )
                             }
+
                             else -> mutableListOf()
                         }
                         val presence = RPC.createPresence(
@@ -411,7 +428,12 @@ class MangaReaderActivity : AppCompatActivity() {
                                 details = chap.title?.takeIf { it.isNotEmpty() }
                                     ?: getString(R.string.chapter_num, chap.number),
                                 state = "${chap.number}/${media.manga?.totalChapters ?: "??"}",
-                                largeImage = media.cover?.let { cover -> RPC.Link(media.userPreferredName, cover) },
+                                largeImage = media.cover?.let { cover ->
+                                    RPC.Link(
+                                        media.userPreferredName,
+                                        cover
+                                    )
+                                },
                                 buttons = buttons
                             )
                         )
@@ -918,7 +940,12 @@ class MangaReaderActivity : AppCompatActivity() {
                     isAnimating = true
                     ObjectAnimator.ofFloat(binding.mangaReaderCont, "alpha", 1f, 0f)
                         .setDuration(controllerDuration).start()
-                    ObjectAnimator.ofFloat(binding.mangaReaderBottomLayout, "translationY", 0f, 128f)
+                    ObjectAnimator.ofFloat(
+                        binding.mangaReaderBottomLayout,
+                        "translationY",
+                        0f,
+                        128f
+                    )
                         .apply { interpolator = overshoot;duration = controllerDuration;start() }
                     ObjectAnimator.ofFloat(binding.mangaReaderTopLayout, "translationY", 0f, -128f)
                         .apply { interpolator = overshoot;duration = controllerDuration;start() }

app/src/main/java/ani/dantotsu/media/novel/NovelReadFragment.kt

@@ -5,7 +5,6 @@ import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
 import android.os.Bundle
-import android.os.Environment
 import android.os.Handler
 import android.os.Looper
 import android.os.Parcelable
@@ -13,7 +12,6 @@ import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import androidx.core.content.ContextCompat
-import androidx.core.content.FileProvider
 import androidx.core.view.updatePadding
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.activityViewModels
@@ -44,7 +42,6 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
-import java.io.File
 
 class NovelReadFragment : Fragment(),
     DownloadTriggerCallback,
@@ -116,8 +113,14 @@ class NovelReadFragment : Fragment(),
         ) {
             try {
                 val directory =
-                    DownloadsManager.getSubDirectory(context?:currContext()!!, MediaType.NOVEL, false, novel.name)
-                val file = directory?.findFile(novel.name)
+                    DownloadsManager.getSubDirectory(
+                        context ?: currContext()!!,
+                        MediaType.NOVEL,
+                        false,
+                        media.mainName(),
+                        novel.name
+                    )
+                val file = directory?.findFile("0.epub")
                 if (file?.exists() == false) return false
                 val fileUri = file?.uri ?: return false
                 val intent = Intent(context, NovelReaderActivity::class.java).apply {

app/src/main/java/ani/dantotsu/media/novel/NovelResponseAdapter.kt

@@ -8,6 +8,7 @@ import androidx.core.view.isVisible
 import androidx.recyclerview.widget.RecyclerView
 import ani.dantotsu.R
 import ani.dantotsu.databinding.ItemNovelResponseBinding
+import ani.dantotsu.loadImage
 import ani.dantotsu.parsers.ShowResponse
 import ani.dantotsu.setAnimation
 import ani.dantotsu.snackString
@@ -37,10 +38,7 @@ class NovelResponseAdapter(
         val binding = holder.binding
         val novel = list[position]
         setAnimation(fragment.requireContext(), holder.binding.root)
-
-        val cover = GlideUrl(novel.coverUrl.url) { novel.coverUrl.headers }
-        Glide.with(binding.itemEpisodeImage).load(cover).override(400, 0)
-            .into(binding.itemEpisodeImage)
+        binding.itemEpisodeImage.loadImage(novel.coverUrl, 400, 0)
 
         val typedValue = TypedValue()
         fragment.requireContext().theme?.resolveAttribute(
@@ -181,7 +179,7 @@ class NovelResponseAdapter(
         if (position != -1) {
             list[position].extra?.remove("0")
             list[position].extra?.set("0", "Downloading: $progress%")
-            Logger.log( "updateDownloadProgress: $progress, position: $position")
+            Logger.log("updateDownloadProgress: $progress, position: $position")
             notifyItemChanged(position)
         }
     }

app/src/main/java/ani/dantotsu/media/novel/novelreader/NovelReaderActivity.kt

@@ -292,7 +292,11 @@ class NovelReaderActivity : AppCompatActivity(), EbookReaderEventListener {
             applySettings()
         }
 
-        val cfi = PrefManager.getNullableCustomVal("${sanitizedBookId}_progress", null, String::class.java)
+        val cfi = PrefManager.getNullableCustomVal(
+            "${sanitizedBookId}_progress",
+            null,
+            String::class.java
+        )
 
         cfi?.let { binding.bookReader.goto(it) }
         binding.progress.visibility = View.GONE

app/src/main/java/ani/dantotsu/media/user/ListActivity.kt

@@ -70,8 +70,10 @@ class ListActivity : AppCompatActivity() {
         setContentView(binding.root)
 
         val anime = intent.getBooleanExtra("anime", true)
-        binding.listTitle.text = getString(R.string.user_list, intent.getStringExtra("username"),
-            if (anime) getString(R.string.anime) else getString(R.string.manga))
+        binding.listTitle.text = getString(
+            R.string.user_list, intent.getStringExtra("username"),
+            if (anime) getString(R.string.anime) else getString(R.string.manga)
+        )
         binding.listTabLayout.addOnTabSelectedListener(object : TabLayout.OnTabSelectedListener {
             override fun onTabSelected(tab: TabLayout.Tab?) {
                 this@ListActivity.selectedTabIdx = tab?.position ?: 0
@@ -158,7 +160,8 @@ class ListActivity : AppCompatActivity() {
         }
 
         binding.filter.setOnClickListener {
-            val genres = PrefManager.getVal<Set<String>>(PrefName.GenresList).toMutableSet().sorted()
+            val genres =
+                PrefManager.getVal<Set<String>>(PrefName.GenresList).toMutableSet().sorted()
             val popup = PopupMenu(this, it)
             popup.menu.add("All")
             genres.forEach { genre ->

app/src/main/java/ani/dantotsu/notifications/AlarmManagerScheduler.kt

@@ -5,9 +5,9 @@ import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
 import android.os.Build
+import ani.dantotsu.notifications.TaskScheduler.TaskType
 import ani.dantotsu.notifications.anilist.AnilistNotificationReceiver
 import ani.dantotsu.notifications.comment.CommentNotificationReceiver
-import ani.dantotsu.notifications.TaskScheduler.TaskType
 import ani.dantotsu.notifications.subscription.SubscriptionNotificationReceiver
 import ani.dantotsu.settings.saving.PrefManager
 import ani.dantotsu.settings.saving.PrefName

app/src/main/java/ani/dantotsu/notifications/BootCompletedReceiver.kt

@@ -5,9 +5,9 @@ import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import android.os.Build
+import ani.dantotsu.notifications.TaskScheduler.TaskType
 import ani.dantotsu.notifications.anilist.AnilistNotificationWorker
 import ani.dantotsu.notifications.comment.CommentNotificationWorker
-import ani.dantotsu.notifications.TaskScheduler.TaskType
 import ani.dantotsu.settings.saving.PrefManager
 import ani.dantotsu.settings.saving.PrefName
 import ani.dantotsu.util.Logger

app/src/main/java/ani/dantotsu/notifications/TaskScheduler.kt

@@ -21,11 +21,16 @@ interface TaskScheduler {
         for (taskType in TaskType.entries) {
             val interval = when (taskType) {
                 TaskType.COMMENT_NOTIFICATION -> CommentNotificationWorker.checkIntervals[PrefManager.getVal(
-                    PrefName.CommentNotificationInterval)]
+                    PrefName.CommentNotificationInterval
+                )]
+
                 TaskType.ANILIST_NOTIFICATION -> AnilistNotificationWorker.checkIntervals[PrefManager.getVal(
-                    PrefName.AnilistNotificationInterval)]
+                    PrefName.AnilistNotificationInterval
+                )]
+
                 TaskType.SUBSCRIPTION_NOTIFICATION -> SubscriptionNotificationWorker.checkIntervals[PrefManager.getVal(
-                    PrefName.SubscriptionNotificationInterval)]
+                    PrefName.SubscriptionNotificationInterval
+                )]
             }
             scheduleRepeatingTask(taskType, interval)
         }
@@ -62,6 +67,7 @@ interface TaskScheduler {
             }
         }
     }
+
     enum class TaskType {
         COMMENT_NOTIFICATION,
         ANILIST_NOTIFICATION,

app/src/main/java/ani/dantotsu/notifications/comment/MediaNameFetch.kt

@@ -66,6 +66,7 @@ class MediaNameFetch {
             val type = object : TypeToken<MediaResponse>() {}.type
             return gson.fromJson(response, type)
         }
+
         data class ReturnedData(val title: String, val coverImage: String, val color: String)
 
         data class MediaResponse(val data: Map<String, MediaItem>)

app/src/main/java/ani/dantotsu/notifications/subscription/SubscriptionHelper.kt

@@ -32,7 +32,7 @@ class SubscriptionHelper {
             return data
         }
 
-        private fun saveSelected( mediaId: Int, data: Selected) {
+        private fun saveSelected(mediaId: Int, data: Selected) {
             PrefManager.setCustomVal("${mediaId}-select", data)
         }
 

app/src/main/java/ani/dantotsu/others/AndroidBug5497Workaround.kt

@@ -5,7 +5,10 @@ import android.graphics.Rect
 import android.view.View
 import android.widget.FrameLayout
 
-class AndroidBug5497Workaround private constructor(activity: Activity, private val callback: (Boolean) -> Unit) {
+class AndroidBug5497Workaround private constructor(
+    activity: Activity,
+    private val callback: (Boolean) -> Unit
+) {
     private val mChildOfContent: View
     private var usableHeightPrevious = 0
     private val frameLayoutParams: FrameLayout.LayoutParams

app/src/main/java/ani/dantotsu/others/Download.kt

@@ -1,6 +1,5 @@
 package ani.dantotsu.others
 
-import android.app.DownloadManager
 import android.content.ComponentName
 import android.content.Context
 import android.content.Intent
@@ -8,7 +7,6 @@ import android.content.pm.PackageManager
 import android.net.Uri
 import android.os.Bundle
 import android.os.Environment
-import androidx.appcompat.app.AppCompatActivity
 import androidx.core.content.ContextCompat
 import ani.dantotsu.FileUrl
 import ani.dantotsu.R
@@ -19,9 +17,6 @@ import ani.dantotsu.parsers.Book
 import ani.dantotsu.settings.saving.PrefManager
 import ani.dantotsu.settings.saving.PrefName
 import ani.dantotsu.toast
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
 import java.io.File
 
 object Download {

app/src/main/java/ani/dantotsu/others/Kitsu.kt

@@ -2,10 +2,10 @@ package ani.dantotsu.others
 
 import ani.dantotsu.FileUrl
 import ani.dantotsu.client
-import ani.dantotsu.util.Logger
 import ani.dantotsu.media.Media
 import ani.dantotsu.media.anime.Episode
 import ani.dantotsu.tryWithSuspend
+import ani.dantotsu.util.Logger
 import com.google.gson.Gson
 import com.lagradost.nicehttp.NiceResponse
 import kotlinx.serialization.SerialName

app/src/main/java/ani/dantotsu/others/OutlineTextView.kt

@@ -56,9 +56,10 @@ class OutlineTextView : AppCompatTextView {
         setStrokeWidth(strokeWidth)
     }
 
-    private val Float.toPx get() = TypedValue.applyDimension(
-        TypedValue.COMPLEX_UNIT_DIP, this, Resources.getSystem().displayMetrics
-    )
+    private val Float.toPx
+        get() = TypedValue.applyDimension(
+            TypedValue.COMPLEX_UNIT_DIP, this, Resources.getSystem().displayMetrics
+        )
 
     private fun setStrokeWidth(width: Float) {
         strokeWidth = width.toPx

app/src/main/java/ani/dantotsu/others/Xpandable.kt

@@ -50,7 +50,7 @@ class Xpandable @JvmOverloads constructor(
             }
         }
         postDelayed({
-            listeners.forEach{
+            listeners.forEach {
                 it.onRetract()
             }
         }, 300)
@@ -66,7 +66,7 @@ class Xpandable @JvmOverloads constructor(
             }
         }
         postDelayed({
-            listeners.forEach{
+            listeners.forEach {
                 it.onExpand()
             }
         }, 300)

app/src/main/java/ani/dantotsu/others/webview/CookieCatcher.kt

@@ -24,7 +24,8 @@ class CookieCatcher : AppCompatActivity() {
 
         //get url from intent
         val url = intent.getStringExtra("url") ?: getString(R.string.cursed_yt)
-        val headers: Map<String, String> = intent.getSerializableExtraCompat("headers") as? Map<String, String> ?: emptyMap()
+        val headers: Map<String, String> =
+            intent.getSerializableExtraCompat("headers") as? Map<String, String> ?: emptyMap()
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
             val process = Application.getProcessName()

app/src/main/java/ani/dantotsu/parsers/AniyomiAdapter.kt

@@ -560,7 +560,7 @@ class VideoServerPassthrough(private val videoServer: VideoServer) : VideoExtrac
                 format = VideoType.CONTAINER
             }
         } catch (malformed: MalformedURLException) {
-            if (videoUrl.startsWith("magnet:"))
+            if (videoUrl.startsWith("magnet:") || videoUrl.endsWith(".torrent"))
                 format = VideoType.CONTAINER
             else
                 throw malformed

app/src/main/java/ani/dantotsu/parsers/OfflineAnimeParser.kt

@@ -2,11 +2,13 @@ package ani.dantotsu.parsers
 
 import android.app.Application
 import ani.dantotsu.currContext
+import ani.dantotsu.download.DownloadCompat.Companion.loadEpisodesCompat
+import ani.dantotsu.download.DownloadCompat.Companion.loadSubtitleCompat
 import ani.dantotsu.download.DownloadsManager
 import ani.dantotsu.download.DownloadsManager.Companion.getSubDirectory
 import ani.dantotsu.download.anime.AnimeDownloaderService.AnimeDownloadTask.Companion.getTaskName
-import ani.dantotsu.media.MediaType
 import ani.dantotsu.media.MediaNameAdapter
+import ani.dantotsu.media.MediaType
 import ani.dantotsu.tryWithSuspend
 import ani.dantotsu.util.Logger
 import eu.kanade.tachiyomi.animesource.model.SAnime
@@ -43,7 +45,7 @@ class OfflineAnimeParser : AnimeParser() {
                 if (it.isDirectory) {
                     val episode = Episode(
                         it.name!!,
-                        getTaskName(animeLink,it.name!!),
+                        getTaskName(animeLink, it.name!!),
                         it.name,
                         null,
                         null,
@@ -53,8 +55,11 @@ class OfflineAnimeParser : AnimeParser() {
                     episodes.add(episode)
                 }
             }
-            episodes.sortBy { MediaNameAdapter.findEpisodeNumber(it.number) }
-            return episodes
+            //episodes.sortBy { MediaNameAdapter.findEpisodeNumber(it.number) }
+            episodes.addAll(loadEpisodesCompat(animeLink, extra, sAnime))
+            //filter those with the same name
+            return episodes.distinctBy { it.number }
+                .sortedBy { MediaNameAdapter.findEpisodeNumber(it.number) }
         }
         return emptyList()
     }
@@ -75,14 +80,16 @@ class OfflineAnimeParser : AnimeParser() {
 
 
     override suspend fun search(query: String): List<ShowResponse> {
-        val titles = downloadManager.animeDownloadedTypes.map { it.title }.distinct()
-        val returnTitles: MutableList<String> = mutableListOf()
+        val titles = downloadManager.animeDownloadedTypes.map { it.titleName }.distinct()
+        val returnTitlesPair: MutableList<Pair<String, Int>> = mutableListOf()
         for (title in titles) {
             Logger.log("Comparing $title to $query")
-            if (FuzzySearch.ratio(title.lowercase(), query.lowercase()) > 80) {
-                returnTitles.add(title)
+            val score = FuzzySearch.ratio(title.lowercase(), query.lowercase())
+            if (score > 80) {
+                returnTitlesPair.add(Pair(title, score))
             }
         }
+        val returnTitles = returnTitlesPair.sortedByDescending { it.second }.map { it.first }
         val returnList: MutableList<ShowResponse> = mutableListOf()
         for (title in returnTitles) {
             returnList.add(ShowResponse(title, title, title))
@@ -148,6 +155,7 @@ class OfflineVideoExtractor(private val videoServer: VideoServer) : VideoExtract
                     )
                 }
             }
+            loadSubtitleCompat(title, episode)?.let { return it }
         }
         return null
     }