Fix crashes

(cherry picked from commit 1d32f53bdd)

app/build.gradle

@@ -21,8 +21,8 @@ android {
 		applicationId 'org.koitharu.kotatsu'
 		minSdk = 23
 		targetSdk = 36
-		versionCode = 1032
-		versionName = '9.4'
+		versionCode = 1033
+		versionName = '9.4.1'
 		generatedDensities = []
 		testInstrumentationRunner 'org.koitharu.kotatsu.HiltTestRunner'
 		ksp {

app/src/main/kotlin/org/koitharu/kotatsu/core/exceptions/EmptyMangaException.kt

@@ -0,0 +1,10 @@
+package org.koitharu.kotatsu.core.exceptions
+
+import org.koitharu.kotatsu.details.ui.pager.EmptyMangaReason
+import org.koitharu.kotatsu.parsers.model.Manga
+
+class EmptyMangaException(
+    val reason: EmptyMangaReason?,
+    val manga: Manga,
+    cause: Throwable?
+) : IllegalStateException(cause)

app/src/main/kotlin/org/koitharu/kotatsu/core/exceptions/resolve/ExceptionResolver.kt

@@ -8,13 +8,15 @@ import androidx.collection.MutableScatterMap
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentActivity
 import androidx.fragment.app.FragmentManager
-import dagger.assisted.Assisted
-import dagger.assisted.AssistedFactory
-import dagger.assisted.AssistedInject
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.lifecycleScope
+import kotlinx.coroutines.async
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.browser.BrowserActivity
 import org.koitharu.kotatsu.browser.cloudflare.CloudFlareActivity
 import org.koitharu.kotatsu.core.exceptions.CloudFlareProtectedException
+import org.koitharu.kotatsu.core.exceptions.EmptyMangaException
 import org.koitharu.kotatsu.core.exceptions.InteractiveActionRequiredException
 import org.koitharu.kotatsu.core.exceptions.ProxyConfigException
 import org.koitharu.kotatsu.core.exceptions.UnsupportedSourceException
@@ -24,6 +26,7 @@ import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.core.ui.dialog.buildAlertDialog
 import org.koitharu.kotatsu.core.util.ext.isHttpUrl
 import org.koitharu.kotatsu.core.util.ext.restartApplication
+import org.koitharu.kotatsu.details.ui.pager.EmptyMangaReason
 import org.koitharu.kotatsu.parsers.exception.AuthRequiredException
 import org.koitharu.kotatsu.parsers.exception.NotFoundException
 import org.koitharu.kotatsu.parsers.model.Manga
@@ -32,14 +35,15 @@ import org.koitharu.kotatsu.scrobbling.common.domain.ScrobblerAuthRequiredExcept
 import org.koitharu.kotatsu.scrobbling.common.ui.ScrobblerAuthHelper
 import org.koitharu.kotatsu.settings.sources.auth.SourceAuthActivity
 import java.security.cert.CertPathValidatorException
+import javax.inject.Inject
 import javax.inject.Provider
 import javax.net.ssl.SSLException
 import kotlin.coroutines.Continuation
 import kotlin.coroutines.resume
 import kotlin.coroutines.suspendCoroutine
 
-class ExceptionResolver @AssistedInject constructor(
-	@Assisted private val host: Host,
+class ExceptionResolver private constructor(
+    private val host: Host,
     private val settings: AppSettings,
     private val scrobblerAuthHelperProvider: Provider<ScrobblerAuthHelper>,
 ) {
@@ -56,10 +60,11 @@ class ExceptionResolver @AssistedInject constructor(
     }
 
     fun showErrorDetails(e: Throwable, url: String? = null) {
-		host.router()?.showErrorDialog(e, url)
+        host.router.showErrorDialog(e, url)
     }
 
-	suspend fun resolve(e: Throwable): Boolean = when (e) {
+    suspend fun resolve(e: Throwable): Boolean = host.lifecycleScope.async {
+        when (e) {
             is CloudFlareProtectedException -> resolveCF(e)
             is AuthRequiredException -> resolveAuthException(e.source)
             is SSLException,
@@ -71,7 +76,7 @@ class ExceptionResolver @AssistedInject constructor(
             is InteractiveActionRequiredException -> resolveBrowserAction(e)
 
             is ProxyConfigException -> {
-			host.router()?.openProxySettings()
+                host.router.openProxySettings()
                 false
             }
 
@@ -80,6 +85,16 @@ class ExceptionResolver @AssistedInject constructor(
                 false
             }
 
+            is EmptyMangaException -> {
+                when (e.reason) {
+                    EmptyMangaReason.NO_CHAPTERS -> openAlternatives(e.manga)
+                    EmptyMangaReason.LOADING_ERROR -> Unit
+                    EmptyMangaReason.RESTRICTED -> host.router.openBrowser(e.manga)
+                    else -> Unit
+                }
+                false
+            }
+
             is UnsupportedSourceException -> {
                 e.manga?.let { openAlternatives(it) }
                 false
@@ -99,6 +114,7 @@ class ExceptionResolver @AssistedInject constructor(
 
             else -> false
         }
+    }.await()
 
     private suspend fun resolveBrowserAction(
         e: InteractiveActionRequiredException
@@ -118,11 +134,11 @@ class ExceptionResolver @AssistedInject constructor(
     }
 
     private fun openInBrowser(url: String) {
-		host.router()?.openBrowser(url, null, null)
+        host.router.openBrowser(url, null, null)
     }
 
     private fun openAlternatives(manga: Manga) {
-		host.router()?.openAlternatives(manga)
+        host.router.openAlternatives(manga)
     }
 
     private fun handleActivityResult(tag: String, result: Boolean) {
@@ -130,7 +146,7 @@ class ExceptionResolver @AssistedInject constructor(
     }
 
     private fun showSslErrorDialog() {
-		val ctx = host.getContext() ?: return
+        val ctx = host.context ?: return
         if (settings.isSSLBypassEnabled) {
             Toast.makeText(ctx, R.string.operation_not_supported, Toast.LENGTH_SHORT).show()
             return
@@ -147,27 +163,65 @@ class ExceptionResolver @AssistedInject constructor(
         }.show()
     }
 
-	private inline fun Host.withContext(block: Context.() -> Unit) {
-		getContext()?.apply(block)
+    class Factory @Inject constructor(
+        private val settings: AppSettings,
+        private val scrobblerAuthHelperProvider: Provider<ScrobblerAuthHelper>,
+    ) {
+
+        fun create(fragment: Fragment) = ExceptionResolver(
+            host = Host.FragmentHost(fragment),
+            settings = settings,
+            scrobblerAuthHelperProvider = scrobblerAuthHelperProvider,
+        )
+
+        fun create(activity: FragmentActivity) = ExceptionResolver(
+            host = Host.ActivityHost(activity),
+            settings = settings,
+            scrobblerAuthHelperProvider = scrobblerAuthHelperProvider,
+        )
     }
 
-	private fun Host.router(): AppRouter? = when (this) {
-		is FragmentActivity -> router
-		is Fragment -> router
-		else -> null
+    private sealed interface Host : ActivityResultCaller, LifecycleOwner {
+
+        val context: Context?
+
+        val router: AppRouter
+
+        val fragmentManager: FragmentManager
+
+        inline fun withContext(block: Context.() -> Unit) {
+            context?.apply(block)
         }
 
-	interface Host : ActivityResultCaller {
+        class ActivityHost(val activity: FragmentActivity) : Host,
+            ActivityResultCaller by activity,
+            LifecycleOwner by activity {
 
-		fun getChildFragmentManager(): FragmentManager
+            override val context: Context
+                get() = activity
 
-		fun getContext(): Context?
+            override val router: AppRouter
+                get() = activity.router
+
+            override val fragmentManager: FragmentManager
+                get() = activity.supportFragmentManager
         }
 
-	@AssistedFactory
-	interface Factory {
+        class FragmentHost(val fragment: Fragment) : Host,
+            ActivityResultCaller by fragment {
 
-		fun create(host: Host): ExceptionResolver
+            override val context: Context?
+                get() = fragment.context
+
+            override val router: AppRouter
+                get() = fragment.router
+
+            override val fragmentManager: FragmentManager
+                get() = fragment.childFragmentManager
+
+            override val lifecycle: Lifecycle
+                get() = fragment.viewLifecycleOwner.lifecycle
+        }
     }
 
     companion object {
@@ -187,6 +241,12 @@ class ExceptionResolver @AssistedInject constructor(
 
             is InteractiveActionRequiredException -> R.string._continue
 
+            is EmptyMangaException -> when (e.reason) {
+                EmptyMangaReason.RESTRICTED -> if (e.manga.publicUrl.isHttpUrl()) R.string.open_in_browser else 0
+                EmptyMangaReason.NO_CHAPTERS -> R.string.alternatives
+                else -> 0
+            }
+
             else -> 0
         }
 

app/src/main/kotlin/org/koitharu/kotatsu/core/nav/AppRouter.kt

@@ -215,6 +215,12 @@ class AppRouter private constructor(
         startActivity(browserIntent(contextOrNull() ?: return, url, source, title))
     }
 
+    fun openBrowser(manga: Manga) = openBrowser(
+        url = manga.publicUrl,
+        source = manga.source,
+        title = manga.title,
+    )
+
     fun openColorFilterConfig(manga: Manga, page: MangaPage) {
         startActivity(
             Intent(contextOrNull(), ColorFilterConfigActivity::class.java)

app/src/main/kotlin/org/koitharu/kotatsu/core/prefs/AppSettings.kt

@@ -681,7 +681,7 @@ class AppSettings @Inject constructor(@ApplicationContext context: Context) {
 		const val KEY_REMOTE_SOURCES = "remote_sources"
 		const val KEY_LOCAL_STORAGE = "local_storage"
 		const val KEY_READER_DOUBLE_PAGES = "reader_double_pages"
-		const val KEY_READER_DOUBLE_PAGES_SENSITIVITY = "reader_double_pages_sensitivity"
+		const val KEY_READER_DOUBLE_PAGES_SENSITIVITY = "reader_double_pages_sensitivity_2"
 		const val KEY_READER_ZOOM_BUTTONS = "reader_zoom_buttons"
 		const val KEY_READER_CONTROL_LTR = "reader_taps_ltr"
 		const val KEY_READER_NAVIGATION_INVERTED = "reader_navigation_inverted"

app/src/main/kotlin/org/koitharu/kotatsu/core/ui/BaseActivity.kt

@@ -33,7 +33,6 @@ import androidx.appcompat.R as appcompatR
 
 abstract class BaseActivity<B : ViewBinding> :
 	AppCompatActivity(),
-	ExceptionResolver.Host,
 	OnApplyWindowInsetsListener,
 	ScreenshotPolicyHelper.ContentContainer {
 
@@ -87,10 +86,6 @@ abstract class BaseActivity<B : ViewBinding> :
 	@Deprecated("Use ViewBinding", level = DeprecationLevel.ERROR)
 	override fun setContentView(view: View?) = throw UnsupportedOperationException()
 
-	override fun getContext() = this
-
-	override fun getChildFragmentManager(): FragmentManager = supportFragmentManager
-
 	protected fun setContentView(binding: B) {
 		this.viewBinding = binding
 		super.setContentView(binding.root)

app/src/main/kotlin/org/koitharu/kotatsu/core/ui/BaseFragment.kt

@@ -15,8 +15,7 @@ import org.koitharu.kotatsu.core.ui.util.ActionModeDelegate
 
 abstract class BaseFragment<B : ViewBinding> :
 	OnApplyWindowInsetsListener,
-	Fragment(),
-	ExceptionResolver.Host {
+	Fragment() {
 
 	var viewBinding: B? = null
 		private set

app/src/main/kotlin/org/koitharu/kotatsu/core/ui/BasePreferenceFragment.kt

@@ -36,8 +36,7 @@ import com.google.android.material.R as materialR
 abstract class BasePreferenceFragment(@StringRes private val titleId: Int) :
 	PreferenceFragmentCompat(),
 	OnApplyWindowInsetsListener,
-	RecyclerViewOwner,
-	ExceptionResolver.Host {
+	RecyclerViewOwner {
 
 	protected lateinit var exceptionResolver: ExceptionResolver
 		private set

app/src/main/kotlin/org/koitharu/kotatsu/core/ui/sheet/BaseAdaptiveSheet.kt

@@ -32,8 +32,7 @@ import org.koitharu.kotatsu.core.ui.util.ActionModeDelegate
 import com.google.android.material.R as materialR
 
 abstract class BaseAdaptiveSheet<B : ViewBinding> : AppCompatDialogFragment(),
-	OnApplyWindowInsetsListener,
-	ExceptionResolver.Host {
+	OnApplyWindowInsetsListener {
 
 	private var waitingForDismissAllowingStateLoss = false
 	private var isFitToContentsDisabled = false

app/src/main/kotlin/org/koitharu/kotatsu/core/util/ext/Throwable.kt

@@ -22,6 +22,7 @@ import org.koitharu.kotatsu.core.exceptions.CaughtException
 import org.koitharu.kotatsu.core.exceptions.CloudFlareBlockedException
 import org.koitharu.kotatsu.core.exceptions.CloudFlareProtectedException
 import org.koitharu.kotatsu.core.exceptions.EmptyHistoryException
+import org.koitharu.kotatsu.core.exceptions.EmptyMangaException
 import org.koitharu.kotatsu.core.exceptions.IncompatiblePluginException
 import org.koitharu.kotatsu.core.exceptions.InteractiveActionRequiredException
 import org.koitharu.kotatsu.core.exceptions.NoDataReceivedException
@@ -103,6 +104,7 @@ private fun Throwable.getDisplayMessageOrNull(resources: Resources): String? = w
     is AccessDeniedException -> resources.getString(R.string.no_access_to_file)
     is NonFileUriException -> resources.getString(R.string.error_non_file_uri)
     is EmptyHistoryException -> resources.getString(R.string.history_is_empty)
+    is EmptyMangaException -> reason?.let { resources.getString(it.msgResId) } ?: cause?.getDisplayMessage(resources)
     is ProxyConfigException -> resources.getString(R.string.invalid_proxy_configuration)
     is SyncApiException,
     is ContentUnavailableException -> message
@@ -167,6 +169,8 @@ fun Throwable.getCauseUrl(): String? = when (this) {
     is CloudFlareProtectedException -> url
     is InteractiveActionRequiredException -> url
     is HttpStatusException -> url
+    is UnsupportedSourceException -> manga?.publicUrl?.takeIf { it.isHttpUrl() }
+    is EmptyMangaException -> manga.publicUrl.takeIf { it.isHttpUrl() }
     is HttpException -> (response.delegate as? Response)?.request?.url?.toString()
     else -> null
 }

app/src/main/kotlin/org/koitharu/kotatsu/details/data/MangaDetails.kt

@@ -7,6 +7,7 @@ import org.koitharu.kotatsu.core.ui.model.MangaOverride
 import org.koitharu.kotatsu.local.domain.model.LocalManga
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.parsers.model.MangaState
 import org.koitharu.kotatsu.parsers.util.ifNullOrEmpty
 import org.koitharu.kotatsu.parsers.util.nullIfEmpty
 import org.koitharu.kotatsu.reader.data.filterChapters
@@ -50,6 +51,9 @@ data class MangaDetails(
             .ifNullOrEmpty { localManga?.manga?.coverUrl }
             ?.nullIfEmpty()
 
+    val isRestricted: Boolean
+        get() = manga.state == MangaState.RESTRICTED
+
     private val mergedManga by lazy {
         if (localManga == null) {
             // fast path

app/src/main/kotlin/org/koitharu/kotatsu/details/ui/pager/ChaptersPagesSheet.kt

@@ -100,7 +100,7 @@ class ChaptersPagesSheet : BaseAdaptiveSheet<SheetChaptersPagesBinding>(),
 
 	override fun onStateChanged(sheet: View, newState: Int) {
         val binding = viewBinding ?: return
-        binding.layoutTouchBlock.isTouchEventsAllowed = newState != STATE_COLLAPSED
+        binding.layoutTouchBlock.isTouchEventsAllowed = dialog != null || newState != STATE_COLLAPSED
         if (newState == STATE_DRAGGING || newState == STATE_SETTLING) {
             return
         }

app/src/main/kotlin/org/koitharu/kotatsu/filter/ui/sheet/FilterSheetFragment.kt

@@ -133,9 +133,7 @@ class FilterSheetFragment : BaseAdaptiveSheet<SheetFilterBinding>(),
         layoutBody.updatePadding(top = layoutBody.paddingBottom)
         scrollView.scrollIndicators = 0
         buttonDone.isVisible = false
-        this.root.updateLayoutParams {
-            height = ViewGroup.LayoutParams.MATCH_PARENT
-        }
+        this.root.layoutParams?.height = ViewGroup.LayoutParams.MATCH_PARENT
         buttonSave.updateLayoutParams<LinearLayout.LayoutParams> {
             weight = 0f
             width = LinearLayout.LayoutParams.WRAP_CONTENT

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/ReaderViewModel.kt

@@ -29,6 +29,7 @@ import kotlinx.coroutines.plus
 import org.koitharu.kotatsu.R
 import org.koitharu.kotatsu.bookmarks.domain.Bookmark
 import org.koitharu.kotatsu.bookmarks.domain.BookmarksRepository
+import org.koitharu.kotatsu.core.exceptions.EmptyMangaException
 import org.koitharu.kotatsu.core.model.getPreferredBranch
 import org.koitharu.kotatsu.core.nav.MangaIntent
 import org.koitharu.kotatsu.core.nav.ReaderIntent
@@ -47,6 +48,7 @@ import org.koitharu.kotatsu.details.data.MangaDetails
 import org.koitharu.kotatsu.details.domain.DetailsInteractor
 import org.koitharu.kotatsu.details.domain.DetailsLoadUseCase
 import org.koitharu.kotatsu.details.ui.pager.ChaptersPagesViewModel
+import org.koitharu.kotatsu.details.ui.pager.EmptyMangaReason
 import org.koitharu.kotatsu.download.ui.worker.DownloadWorker
 import org.koitharu.kotatsu.history.data.HistoryRepository
 import org.koitharu.kotatsu.history.domain.HistoryUpdateUseCase
@@ -405,9 +407,11 @@ class ReaderViewModel @Inject constructor(
     private fun loadImpl() {
         loadingJob = launchLoadingJob(Dispatchers.Default + EventExceptionHandler(onLoadingError)) {
             var exception: Exception? = null
+            var loadedDetails: MangaDetails? = null
             try {
                 detailsLoadUseCase(intent, force = false)
                     .collect { details ->
+                        loadedDetails = details
                         if (mangaDetails.value == null) {
                             mangaDetails.value = details
                         }
@@ -452,9 +456,28 @@ class ReaderViewModel @Inject constructor(
                 exception = e.mergeWith(exception)
             }
             if (readingState.value == null) {
-				onLoadingError.call(
-					exception ?: IllegalStateException("Unable to load manga. This should never happen. Please report"),
+                val loadedManga = loadedDetails // for smart cast
+                if (loadedManga != null) {
+                    mangaDetails.value = loadedManga.filterChapters(selectedBranch.value)
+                }
+                val loadingError = when {
+                    exception != null -> exception
+                    loadedManga == null || !loadedManga.isLoaded -> null
+                    loadedManga.isRestricted -> EmptyMangaException(
+                        EmptyMangaReason.RESTRICTED,
+                        loadedManga.toManga(),
+                        null,
                     )
+
+                    loadedManga.allChapters.isEmpty() -> EmptyMangaException(
+                        EmptyMangaReason.NO_CHAPTERS,
+                        loadedManga.toManga(),
+                        null,
+                    )
+
+                    else -> null
+                } ?: IllegalStateException("Unable to load manga. This should never happen. Please report")
+                onLoadingError.call(loadingError)
             } else exception?.let { e ->
                 // manga has been loaded but error occurred
                 errorEvent.call(e)

app/src/main/kotlin/org/koitharu/kotatsu/reader/ui/pager/BaseReaderFragment.kt

@@ -25,11 +25,26 @@ abstract class BaseReaderFragment<B : ViewBinding> : BaseFragment<B>(), ZoomCont
 		readerAdapter = onCreateAdapter()
 
 		viewModel.content.observe(viewLifecycleOwner) {
-			if (it.state == null && it.pages.isNotEmpty() && readerAdapter?.hasItems != true) {
-				onPagesChanged(it.pages, viewModel.getCurrentState())
-			} else {
-				onPagesChanged(it.pages, it.state)
+			// Determine which state to use for restoring position:
+			// - content.state: explicitly set state (e.g., after mode switch or chapter change)
+			// - getCurrentState(): current reading position saved in SavedStateHandle
+			val currentState = viewModel.getCurrentState()
+			val pendingState = when {
+				// If content.state is null and we have pages, use getCurrentState
+				it.state == null
+					&& it.pages.isNotEmpty()
+					&& readerAdapter?.hasItems != true -> currentState
+
+				// use currentState only if it matches the current pages (to avoid the error message)
+				readerAdapter?.hasItems != true
+					&& it.state != currentState
+					&& currentState != null
+					&& it.pages.any { page -> page.chapterId == currentState.chapterId } -> currentState
+
+				// Otherwise, use content.state (normal flow, mode switch, chapter change)
+				else -> it.state
 			}
+			onPagesChanged(it.pages, pendingState)
 		}
 	}