Cleanup BaseOAuthLoginActivity and TrackLoginActivity (#2748)

app/src/main/java/eu/kanade/tachiyomi/ui/setting/track/BaseOAuthLoginActivity.kt

@@ -14,7 +14,7 @@ abstract class BaseOAuthLoginActivity : BaseActivity() {
 
     internal val trackerManager: TrackerManager by injectLazy()
 
-    abstract fun handleResult(data: Uri?)
+    abstract fun handleResult(uri: Uri)
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
@@ -23,7 +23,12 @@ abstract class BaseOAuthLoginActivity : BaseActivity() {
             LoadingScreen()
         }
 
-        handleResult(intent.data)
+        val data = intent.data
+        if (data == null) {
+            returnToSettings()
+        } else {
+            handleResult(data)
+        }
     }
 
     internal fun returnToSettings() {

app/src/main/java/eu/kanade/tachiyomi/ui/setting/track/TrackLoginActivity.kt

@@ -2,69 +2,64 @@ package eu.kanade.tachiyomi.ui.setting.track
 
 import android.net.Uri
 import androidx.lifecycle.lifecycleScope
-import tachiyomi.core.common.util.lang.launchIO
+import kotlinx.coroutines.launch
 
 class TrackLoginActivity : BaseOAuthLoginActivity() {
 
-    override fun handleResult(data: Uri?) {
+    override fun handleResult(uri: Uri) {
-        when (data?.host) {
+        val data = when {
-            "anilist-auth" -> handleAnilist(data)
+            !uri.encodedQuery.isNullOrBlank() -> uri.encodedQuery
-            "bangumi-auth" -> handleBangumi(data)
+            !uri.encodedFragment.isNullOrBlank() -> uri.encodedFragment
-            "myanimelist-auth" -> handleMyAnimeList(data)
+            else -> null
-            "shikimori-auth" -> handleShikimori(data)
+        }
+            ?.split("&")
+            ?.filter { it.isNotBlank() }
+            ?.associate {
+                val parts = it.split("=", limit = 2).map<String, String>(Uri::decode)
+                parts[0] to parts.getOrNull(1)
+            }
+            .orEmpty()
+
+        lifecycleScope.launch {
+            when (uri.host) {
+                "anilist-auth" -> handleAniList(data["access_token"])
+                "bangumi-auth" -> handleBangumi(data["code"])
+                "myanimelist-auth" -> handleMyAnimeList(data["code"])
+                "shikimori-auth" -> handleShikimori(data["code"])
+            }
+            returnToSettings()
         }
     }
 
-    private fun handleAnilist(data: Uri) {
+    private suspend fun handleAniList(accessToken: String?) {
-        val regex = "(?:access_token=)(.*?)(?:&)".toRegex()
+        if (accessToken != null) {
-        val matchResult = regex.find(data.fragment.toString())
+            trackerManager.aniList.login(accessToken)
-        if (matchResult?.groups?.get(1) != null) {
-            lifecycleScope.launchIO {
-                trackerManager.aniList.login(matchResult.groups[1]!!.value)
-                returnToSettings()
-            }
         } else {
             trackerManager.aniList.logout()
-            returnToSettings()
         }
     }
 
-    private fun handleBangumi(data: Uri) {
+    private suspend fun handleBangumi(code: String?) {
-        val code = data.getQueryParameter("code")
         if (code != null) {
-            lifecycleScope.launchIO {
+            trackerManager.bangumi.login(code)
-                trackerManager.bangumi.login(code)
-                returnToSettings()
-            }
         } else {
             trackerManager.bangumi.logout()
-            returnToSettings()
         }
     }
 
-    private fun handleMyAnimeList(data: Uri) {
+    private suspend fun handleMyAnimeList(code: String?) {
-        val code = data.getQueryParameter("code")
         if (code != null) {
-            lifecycleScope.launchIO {
+            trackerManager.myAnimeList.login(code)
-                trackerManager.myAnimeList.login(code)
-                returnToSettings()
-            }
         } else {
             trackerManager.myAnimeList.logout()
-            returnToSettings()
         }
     }
 
-    private fun handleShikimori(data: Uri) {
+    private suspend fun handleShikimori(code: String?) {
-        val code = data.getQueryParameter("code")
         if (code != null) {
-            lifecycleScope.launchIO {
+            trackerManager.shikimori.login(code)
-                trackerManager.shikimori.login(code)
-                returnToSettings()
-            }
         } else {
             trackerManager.shikimori.logout()
-            returnToSettings()
         }
     }
 }