Prepare for release 1.11.6-RC2

Update Compose snapshot
https://issuetracker.google.com/343750859
2024-06-06 22:07:23 +08:00 · 2024-06-06 21:54:22 +08:00 · 2024-06-06 13:52:43 +00:00 · 2024-06-06 00:09:30 +00:00 · 2024-06-04 15:13:09 +08:00 · 2024-06-03 01:53:41 +00:00
206 changed files with 6446 additions and 3742 deletions
@@ -21,7 +21,7 @@ jobs:
          java-version: 21

      - name: Install Rust Toolchain
-        run: rustup update && rustup target add armv7-linux-androideabi aarch64-linux-android i686-linux-android x86_64-linux-android && rustup component add rustfmt clippy
+        run: rustup update && rustup target add armv7-linux-androideabi aarch64-linux-android x86_64-linux-android && rustup component add rustfmt clippy

      - name: Rust Cache
        uses: Swatinem/rust-cache@v2
@@ -42,6 +42,9 @@ jobs:
        with:
          cache-read-only: true

+      - name: Install NDK
+        run: echo "y" | ${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin/sdkmanager --install "ndk;27.0.11718014"
+
      - name: Spotless Check
        run: ./gradlew spotlessCheck

@@ -57,8 +60,11 @@ jobs:
          distribution: temurin
          java-version: 21

+      - name: Install NDK
+        run: echo "y" | ${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin/sdkmanager --install "ndk;27.0.11718014"
+
      - name: Install Rust Toolchain
-        run: rustup update && rustup target add armv7-linux-androideabi aarch64-linux-android i686-linux-android x86_64-linux-android && rustup component add rustfmt clippy
+        run: rustup update && rustup target add armv7-linux-androideabi aarch64-linux-android x86_64-linux-android && rustup component add rustfmt clippy

      - name: Rust Cache
        uses: Swatinem/rust-cache@v2
@@ -101,12 +107,6 @@ jobs:
          name: default-armeabi-v7a-${{ github.sha }}
          path: app/build/outputs/apk/default/release/app-default-armeabi-v7a-release.apk

-      - name: Upload x86
-        uses: actions/upload-artifact@v4
-        with:
-          name: default-x86-${{ github.sha }}
-          path: app/build/outputs/apk/default/release/app-default-x86-release.apk
-
      - name: Upload mapping
        uses: actions/upload-artifact@v4
        with:
@@ -131,8 +131,11 @@ jobs:
          distribution: temurin
          java-version: 21

+      - name: Install NDK
+        run: echo "y" | ${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin/sdkmanager --install "ndk;27.0.11718014"
+
      - name: Install Rust Toolchain
-        run: rustup update && rustup target add armv7-linux-androideabi aarch64-linux-android i686-linux-android x86_64-linux-android && rustup component add rustfmt clippy
+        run: rustup update && rustup target add armv7-linux-androideabi aarch64-linux-android x86_64-linux-android && rustup component add rustfmt clippy

      - name: Rust Cache
        uses: Swatinem/rust-cache@v2
@@ -175,12 +178,6 @@ jobs:
          name: marshmallow-armeabi-v7a-${{ github.sha }}
          path: app/build/outputs/apk/marshmallow/release/app-marshmallow-armeabi-v7a-release.apk

-      - name: Upload x86
-        uses: actions/upload-artifact@v4
-        with:
-          name: marshmallow-x86-${{ github.sha }}
-          path: app/build/outputs/apk/marshmallow/release/app-marshmallow-x86-release.apk
-
      - name: Upload mapping
        uses: actions/upload-artifact@v4
        with:
@@ -18,8 +18,11 @@ jobs:
          distribution: temurin
          java-version: 21

+      - name: Install NDK
+        run: echo "y" | ${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin/sdkmanager --install "ndk;27.0.11718014"
+
      - name: Install Rust Toolchain
-        run: rustup update && rustup target add armv7-linux-androideabi aarch64-linux-android i686-linux-android x86_64-linux-android
+        run: rustup update && rustup target add armv7-linux-androideabi aarch64-linux-android x86_64-linux-android

      - name: Rust Cache
        uses: Swatinem/rust-cache@v2
@@ -43,7 +46,6 @@ jobs:
          mv app/build/outputs/apk/default/release/app-default-universal-release.apk EhViewer-${{ github.ref_name }}-default-universal.apk
          mv app/build/outputs/apk/default/release/app-default-arm64-v8a-release.apk EhViewer-${{ github.ref_name }}-default-arm64-v8a.apk
          mv app/build/outputs/apk/default/release/app-default-x86_64-release.apk EhViewer-${{ github.ref_name }}-default-x86_64.apk
-          mv app/build/outputs/apk/default/release/app-default-x86-release.apk EhViewer-${{ github.ref_name }}-default-x86.apk
          mv app/build/outputs/apk/default/release/app-default-armeabi-v7a-release.apk EhViewer-${{ github.ref_name }}-default-armeabi-v7a.apk
          mv app/build/outputs/mapping/defaultRelease/mapping.txt EhViewer-${{ github.ref_name }}-default-mapping.txt
          mv app/build/outputs/native-debug-symbols/defaultRelease/native-debug-symbols.zip EhViewer-${{ github.ref_name }}-default-native-debug-symbols.zip
@@ -51,7 +53,6 @@ jobs:
          mv app/build/outputs/apk/marshmallow/release/app-marshmallow-universal-release.apk EhViewer-${{ github.ref_name }}-marshmallow-universal.apk
          mv app/build/outputs/apk/marshmallow/release/app-marshmallow-arm64-v8a-release.apk EhViewer-${{ github.ref_name }}-marshmallow-arm64-v8a.apk
          mv app/build/outputs/apk/marshmallow/release/app-marshmallow-x86_64-release.apk EhViewer-${{ github.ref_name }}-marshmallow-x86_64.apk
-          mv app/build/outputs/apk/marshmallow/release/app-marshmallow-x86-release.apk EhViewer-${{ github.ref_name }}-marshmallow-x86.apk
          mv app/build/outputs/apk/marshmallow/release/app-marshmallow-armeabi-v7a-release.apk EhViewer-${{ github.ref_name }}-marshmallow-armeabi-v7a.apk
          mv app/build/outputs/mapping/marshmallowRelease/mapping.txt EhViewer-${{ github.ref_name }}-marshmallow-mapping.txt
          mv app/build/outputs/native-debug-symbols/marshmallowRelease/native-debug-symbols.zip EhViewer-${{ github.ref_name }}-marshmallow-native-debug-symbols.zip
@@ -64,7 +65,6 @@ jobs:
            EhViewer-${{ github.ref_name }}-default-universal.apk
            EhViewer-${{ github.ref_name }}-default-arm64-v8a.apk
            EhViewer-${{ github.ref_name }}-default-x86_64.apk
-            EhViewer-${{ github.ref_name }}-default-x86.apk
            EhViewer-${{ github.ref_name }}-default-armeabi-v7a.apk
            EhViewer-${{ github.ref_name }}-default-mapping.txt
            EhViewer-${{ github.ref_name }}-default-native-debug-symbols.zip
@@ -72,7 +72,6 @@ jobs:
            EhViewer-${{ github.ref_name }}-marshmallow-universal.apk
            EhViewer-${{ github.ref_name }}-marshmallow-arm64-v8a.apk
            EhViewer-${{ github.ref_name }}-marshmallow-x86_64.apk
-            EhViewer-${{ github.ref_name }}-marshmallow-x86.apk
            EhViewer-${{ github.ref_name }}-marshmallow-armeabi-v7a.apk
            EhViewer-${{ github.ref_name }}-marshmallow-mapping.txt
            EhViewer-${{ github.ref_name }}-marshmallow-native-debug-symbols.zip
@@ -0,0 +1,29 @@
+name: 'Update Chrome Version'
+
+on:
+  schedule:
+    - cron: '0 0 1 * *'
+  workflow_dispatch:
+
+jobs:
+  action:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Update Chrome Version
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          cd chrome-for-testing
+          curl -OLf https://googlechromelabs.github.io/chrome-for-testing/LATEST_RELEASE_STABLE
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git config push.autoSetupRemote true
+          git switch -c chore/chrome
+          if git commit -am "Update Chrome version for default User-Agent"; then
+            git push
+            gh pr create -f
+            gh pr merge chore/chrome --auto -dr
+          fi
@@ -1,5 +1,111 @@
 # 变更日志

+## [1.11.6-RC2] - 2024-06-06
+
+### 改进
+
+* 下载图片时执行完整性校验以防止文件损坏/被篡改
+
+
+## [1.11.6-RC1] - 2024-06-02
+
+### 改进
+
+* 下载列表默认显示全部下载项目
+* 替换搜索文本中的换行符为空格 [#1258](https://github.com/FooIbar/EhViewer/issues/1258)
+
+### Bug 修复
+
+* 评价画廊时未使用输入的评分
+* 搜索时意外选择 Non-H 类别 [#1246](https://github.com/FooIbar/EhViewer/issues/1246)
+* 侧边栏与导航抽屉重叠 [#1262](https://github.com/FooIbar/EhViewer/issues/1262)
+* 快速搜索/下载标签排序失效 [#1267](https://github.com/FooIbar/EhViewer/issues/1267)
+* 加载压缩包/种子列表出错时 UI 冻结
+* 低版本 Android 上某些 UI 被遮挡
+
+
+## [1.11.5] - 2024-05-19
+
+### 重大变更
+
+* 不再支持 32 位 x86
+
+### 新功能
+
+* 支持按作者对下载分组
+* 由于 E 站不再强制要求人机验证，重新支持账号密码登录
+
+### 改进
+
+* 在登录时加载收藏名称 [#1077](https://github.com/FooIbar/EhViewer/issues/1077)
+* 优化归档和种子界面 UI
+* 禁止在 cookie 界面截图以防止泄露
+* 在缩略图模式下显示画廊页数
+* 记住最低评分和页数搜索参数
+* 更新 User-Agent 以缓解 IP 封禁 [#1182](https://github.com/FooIbar/EhViewer/issues/1182)
+* 账号密码登录支持自动填充
+* 更新中文（台灣）翻译
+
+### Bug 修复
+
+* 非触摸模式下无法退出搜索界面 [#1060](https://github.com/FooIbar/EhViewer/issues/1060)
+* 某些设备上无法安装更新 [#1067](https://github.com/FooIbar/EhViewer/issues/1067)
+* 某些设备上崩溃/卡顿 [#996](https://github.com/FooIbar/EhViewer/issues/996) [#1023](https://github.com/FooIbar/EhViewer/issues/1023)
+* 搜索记录中存在重复条目时崩溃 [#1130](https://github.com/FooIbar/EhViewer/issues/1130)
+* 条漫模式下缩小后点按区域偏移 [#127](https://github.com/FooIbar/EhViewer/issues/127)
+* 多窗口模式下点按区域偏移
+* 点击下载通知时未清除状态
+* 保存未完成加载的图片时崩溃 [#1154](https://github.com/FooIbar/EhViewer/issues/1154)
+* 历史记录界面无法在项目上滑动打开抽屉 [#464](https://github.com/FooIbar/EhViewer/issues/464)
+* 导入数据失败时显示导入成功 [#1174](https://github.com/FooIbar/EhViewer/issues/1174)
+* 某些条件下收藏界面崩溃 [#1190](https://github.com/FooIbar/EhViewer/issues/1190)
+* 反转点按区域功能失效 [#1217](https://github.com/FooIbar/EhViewer/issues/1217)
+
+### 已知问题
+
+* 某些设备上从后台返回时某些 UI 消失，可通过关闭列表项目动画部分缓解 [#1184](https://github.com/FooIbar/EhViewer/issues/1184)
+
+
+## [1.11.4] - 2024-04-21
+
+### 新功能
+
+* 更新前自动备份数据
+
+### 改进
+
+* 在 设置-高级 中加入了禁用列表项目动画的选项，该功能在部分设备上导致崩溃/卡顿 [#996](https://github.com/FooIbar/EhViewer/issues/996) [#1023](https://github.com/FooIbar/EhViewer/issues/1023)
+* 下载列表多选模式下避免误触 [#1016](https://github.com/FooIbar/EhViewer/issues/1016)
+* 杂项 UI 优化
+
+### Bug 修复
+
+* 重命名下载标签后删除该标签时崩溃 [#1008](https://github.com/FooIbar/EhViewer/issues/1008)
+* 搜索栏中某些输入法长按退格无法连续删除 [#606](https://github.com/FooIbar/EhViewer/issues/606)
+* 评论/屏蔽/搜索建议/下载标签/快速搜索列表卡顿 [#1041](https://github.com/FooIbar/EhViewer/issues/1041)
+
+
+## [1.11.3] - 2024-04-06
+
+### 改进
+
+* 优化预加载逻辑和图片加载顺序
+* 优化画廊详情和评论页面 UI
+
+### Bug 修复
+
+* 某些模式下搜索结果不显示画廊语言 [#923](https://github.com/FooIbar/EhViewer/issues/923)
+* 某些情况下在搜索结果中直接阅读画廊后崩溃 [#927](https://github.com/FooIbar/EhViewer/issues/927)
+* 更新至最新版本后仍提示有新版本 [#927](https://github.com/FooIbar/EhViewer/issues/927)
+* 从旧版本升级时包含不兼容数据导致崩溃/无法导出数据 [#940](https://github.com/FooIbar/EhViewer/issues/940) [#974](https://github.com/FooIbar/EhViewer/issues/974)
+* Android 10 以下的设备打开 设置-隐私 时崩溃 [#953](https://github.com/FooIbar/EhViewer/issues/953)
+* 下载标签无法拖动
+* 刷新 和 刷新（原图） 无法在已下载的图片上使用
+* 临时 IP 封禁错误显示为解析失败
+* 某些情况下下载时闪退 [#980](https://github.com/FooIbar/EhViewer/issues/980)
+* 某些设备上下载列表中的缩略图无法显示 [#977](https://github.com/FooIbar/EhViewer/issues/977)
+
+
 ## [1.11.2] - 2024-03-17

 ### 重大变更
@@ -85,13 +85,13 @@ and [Dynamic Color](https://m3.material.io/styles/color/dynamic-color/overview)
 Here is the libraries

 - [Arrow](https://arrow-kt.io/)
- [AOSP & AndroidX](http://source.android.com/)
+- [AOSP & AndroidX](https://source.android.com/)
 - [Kotlin & KotlinX](https://kotlinlang.org/)
 - [Material Icons](https://github.com/google/material-design-icons)
 - [Ktor](https://ktor.io/)
 - [Coil](https://coil-kt.github.io/coil/)
 - [Compose Destinations](https://composedestinations.rafaelcosta.xyz/)
- [libarchive](http://www.libarchive.org/)
+- [libarchive](https://www.libarchive.org/)
 - [jsoup](https://jsoup.org/)

 Specially thanks [Tachiyomi](https://tachiyomi.org/) for its reader implementation!
@@ -1,8 +1,5 @@
 import com.mikepenz.aboutlibraries.plugin.DuplicateMode.MERGE
 import com.mikepenz.aboutlibraries.plugin.DuplicateRule.GROUP
-import java.time.Instant
-import java.time.ZoneOffset
-import java.time.format.DateTimeFormatter

 val isRelease: Boolean
    get() = gradle.startParameter.taskNames.any { it.contains("Release") }
@@ -10,6 +7,7 @@ val isRelease: Boolean
 plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.android)
+    alias(libs.plugins.kotlin.compose)
    alias(libs.plugins.kotlin.parcelize)
    alias(libs.plugins.kotlin.serialization)
    alias(libs.plugins.ksp)
@@ -18,16 +16,19 @@ plugins {
    alias(libs.plugins.composeCompilerReportGenerator)
 }

+val supportedAbis = arrayOf("arm64-v8a", "x86_64", "armeabi-v7a")
+
 android {
    compileSdk = 34
-    ndkVersion = "26.2.11394342"
+    ndkVersion = "27.0.11718014-beta1"
+    androidResources.generateLocaleConfig = true

    splits {
        abi {
            isEnable = true
            reset()
            if (isRelease) {
-                include("arm64-v8a", "x86_64", "armeabi-v7a", "x86")
+                include(*supportedAbis)
                isUniversalApk = true
            } else {
                include("arm64-v8a", "x86_64")
@@ -48,22 +49,25 @@ android {
        commandLine = "git rev-parse --short=7 HEAD".split(' ')
    }.standardOutput.asText.get().trim()

-    val buildTime by lazy {
-        val formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm").withZone(ZoneOffset.UTC)
-        formatter.format(Instant.now())
-    }
+    val commitTime = providers.exec {
+        commandLine = "git log -1 --format=%ct".split(' ')
+    }.standardOutput.asText.get().trim()

    val repoName = providers.exec {
        commandLine = "git remote get-url origin".split(' ')
    }.standardOutput.asText.get().trim().removePrefix("https://github.com/").removePrefix("git@github.com:")
        .removeSuffix(".git")

+    val chromeVersion = rootProject.layout.projectDirectory.file("chrome-for-testing/LATEST_RELEASE_STABLE").asFile
+        .readText().substringBefore('.')
+
    defaultConfig {
        applicationId = "moe.tarsin.ehviewer"
        minSdk = 26
        targetSdk = 34
-        versionCode = 180053
-        versionName = "1.11.2"
+        versionCode = 180056
+        versionName = "1.11.6"
+        versionNameSuffix = "-RC2"
        resourceConfigurations.addAll(
            listOf(
                "zh",
@@ -80,12 +84,22 @@ android {
                "nb-rNO",
            ),
        )
-        buildConfigField("String", "RAW_VERSION_NAME", "\"$versionName$versionNameSuffix\"")
+        buildConfigField("String", "RAW_VERSION_NAME", "\"$versionName${versionNameSuffix.orEmpty()}\"")
        buildConfigField("String", "COMMIT_SHA", "\"$commitSha\"")
+        buildConfigField("long", "COMMIT_TIME", commitTime)
        buildConfigField("String", "REPO_NAME", "\"$repoName\"")
+        buildConfigField("String", "CHROME_VERSION", "\"$chromeVersion\"")
        ndk {
+            if (isRelease) {
+                abiFilters.addAll(supportedAbis)
+            }
            debugSymbolLevel = "FULL"
        }
+        externalNativeBuild {
+            cmake {
+                arguments += "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+            }
+        }
    }

    flavorDimensions += "api"
@@ -109,49 +123,15 @@ android {
        isCoreLibraryDesugaringEnabled = true
    }

-    kotlinOptions {
-        freeCompilerArgs = listOf(
-            // https://kotlinlang.org/docs/compiler-reference.html#progressive
-            "-progressive",
-            "-Xjvm-default=all",
-            "-Xlambdas=indy",
-            "-Xcontext-receivers",
-
-            "-opt-in=coil3.annotation.ExperimentalCoilApi",
-            "-opt-in=androidx.compose.foundation.layout.ExperimentalLayoutApi",
-            "-opt-in=androidx.compose.material3.ExperimentalMaterial3Api",
-            "-opt-in=androidx.compose.material3.windowsizeclass.ExperimentalMaterial3WindowSizeClassApi",
-            "-opt-in=androidx.compose.ui.ExperimentalComposeUiApi",
-            "-opt-in=androidx.compose.foundation.ExperimentalFoundationApi",
-            "-opt-in=androidx.compose.animation.ExperimentalAnimationApi",
-            "-opt-in=androidx.paging.ExperimentalPagingApi",
-            "-opt-in=kotlin.contracts.ExperimentalContracts",
-            "-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
-            "-opt-in=kotlinx.coroutines.FlowPreview",
-            "-opt-in=kotlinx.serialization.ExperimentalSerializationApi",
-            "-opt-in=splitties.experimental.ExperimentalSplittiesApi",
-            "-opt-in=splitties.preferences.DataStorePreferencesPreview",
-
-            "-P", "plugin:androidx.compose.compiler.plugins.kotlin:experimentalStrongSkipping=true",
-            "-P", "plugin:androidx.compose.compiler.plugins.kotlin:nonSkippingGroupOptimization=true",
-        )
-    }
-
    lint {
        disable += setOf("MissingTranslation", "MissingQuantity")
-        fatal += setOf("NewApi", "InlineApi")
+        fatal += setOf("NewApi", "InlinedApi")
    }

    packaging {
        dex {
            useLegacyPackaging = false
        }
-        resources {
-            excludes += "/META-INF/**"
-            excludes += "/kotlin/**"
-            excludes += "**.txt"
-            excludes += "**.bin"
-        }
    }

    dependenciesInfo.includeInApk = false
@@ -162,11 +142,12 @@ android {
            isShrinkResources = true
            proguardFiles("proguard-rules.pro")
            signingConfig = signConfig
-            buildConfigField("String", "BUILD_TIME", "\"$buildTime\"")
        }
        debug {
            applicationIdSuffix = ".debug"
-            buildConfigField("String", "BUILD_TIME", "\"\"")
+            lint {
+                abortOnError = false
+            }
        }
    }

@@ -176,13 +157,25 @@ android {
        viewBinding = true
    }

-    composeOptions {
-        kotlinCompilerExtensionVersion = libs.versions.compose.compiler.get()
-    }
-
    namespace = "com.hippo.ehviewer"
 }

+composeCompiler {
+    enableNonSkippingGroupOptimization = true
+    enableStrongSkippingMode = true
+}
+
+androidComponents {
+    onVariants(selector().withBuildType("release")) {
+        it.packaging.resources.excludes.addAll(
+            "/META-INF/**",
+            "/kotlin/**",
+            "**.txt",
+            "**.bin",
+        )
+    }
+}
+
 dependencies {
    // https://developer.android.com/jetpack/androidx/releases/activity
    implementation(libs.androidx.activity.compose)
@@ -201,13 +194,13 @@ dependencies {
    implementation(libs.androidx.core.splashscreen)

    implementation(libs.androidx.constraintlayout.compose)
+    implementation(libs.androidx.datastore)
+    implementation(libs.androidx.graphics.path)
+
    // https://developer.android.com/jetpack/androidx/releases/lifecycle
    implementation(libs.androidx.lifecycle.process)
    implementation(libs.androidx.lifecycle.compose)

-    // https://developer.android.com/jetpack/androidx/releases/navigation
-    implementation(libs.androidx.navigation.compose)
-
    // https://developer.android.com/jetpack/androidx/releases/paging
    implementation(libs.androidx.paging.compose)

@@ -263,20 +256,36 @@ dependencies {
    implementation(libs.compose.ui.tooling.preview)
 }

-configurations.all {
-    resolutionStrategy {
-        // Workaround for https://issuetracker.google.com/329489167
-        force("androidx.compose.foundation:foundation-android:1.7.0-alpha03")
-    }
-}
-
 kotlin {
    jvmToolchain(21)
+    compilerOptions {
+        freeCompilerArgs = listOf(
+            // https://kotlinlang.org/docs/compiler-reference.html#progressive
+            "-progressive",
+            "-Xjvm-default=all",
+            "-Xcontext-receivers",
+
+            "-opt-in=coil3.annotation.ExperimentalCoilApi",
+            "-opt-in=androidx.compose.foundation.layout.ExperimentalLayoutApi",
+            "-opt-in=androidx.compose.material3.ExperimentalMaterial3Api",
+            "-opt-in=androidx.compose.material3.adaptive.ExperimentalMaterial3AdaptiveApi",
+            "-opt-in=androidx.compose.ui.ExperimentalComposeUiApi",
+            "-opt-in=androidx.compose.foundation.ExperimentalFoundationApi",
+            "-opt-in=androidx.compose.animation.ExperimentalAnimationApi",
+            "-opt-in=androidx.paging.ExperimentalPagingApi",
+            "-opt-in=kotlin.contracts.ExperimentalContracts",
+            "-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
+            "-opt-in=kotlinx.coroutines.FlowPreview",
+            "-opt-in=kotlinx.serialization.ExperimentalSerializationApi",
+            "-opt-in=splitties.experimental.ExperimentalSplittiesApi",
+            "-opt-in=splitties.preferences.DataStorePreferencesPreview",
+        )
+    }
 }

 ksp {
    arg("room.schemaLocation", "$projectDir/schemas")
-    arg("room.generateKotlin", "true")
+    arg("compose-destinations.codeGenPackageName", "com.hippo.ehviewer.ui")
 }

 aboutLibraries {
@@ -16,6 +16,10 @@

 -dontwarn org.conscrypt.Conscrypt

+# https://issuetracker.google.com/222232895
+-dontwarn androidx.window.extensions.**
+-dontwarn androidx.window.sidecar.Sidecar*
+
 -keepattributes LineNumberTable

 -allowaccessmodification
@@ -0,0 +1,564 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 23,
+    "identityHash": "7d1cfc4e9a9d506a73eb0520ae414d25",
+    "entities": [
+      {
+        "tableName": "GALLERIES",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`GID` INTEGER NOT NULL, `TOKEN` TEXT NOT NULL, `TITLE` TEXT, `TITLE_JPN` TEXT, `THUMB` TEXT, `CATEGORY` INTEGER NOT NULL, `POSTED` TEXT, `UPLOADER` TEXT, `RATING` REAL NOT NULL, `SIMPLE_TAGS` TEXT, `PAGES` INTEGER NOT NULL DEFAULT 0, `SIMPLE_LANGUAGE` TEXT, `FAVORITE_SLOT` INTEGER NOT NULL, PRIMARY KEY(`GID`))",
+        "fields": [
+          {
+            "fieldPath": "gid",
+            "columnName": "GID",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "token",
+            "columnName": "TOKEN",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "title",
+            "columnName": "TITLE",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "titleJpn",
+            "columnName": "TITLE_JPN",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "thumbKey",
+            "columnName": "THUMB",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "category",
+            "columnName": "CATEGORY",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "posted",
+            "columnName": "POSTED",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "uploader",
+            "columnName": "UPLOADER",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "rating",
+            "columnName": "RATING",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "simpleTags",
+            "columnName": "SIMPLE_TAGS",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "pages",
+            "columnName": "PAGES",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "0"
+          },
+          {
+            "fieldPath": "simpleLanguage",
+            "columnName": "SIMPLE_LANGUAGE",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "favoriteSlot",
+            "columnName": "FAVORITE_SLOT",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "GID"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "DOWNLOAD_LABELS",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`LABEL` TEXT NOT NULL, `POSITION` INTEGER NOT NULL, `_id` INTEGER, PRIMARY KEY(`_id`))",
+        "fields": [
+          {
+            "fieldPath": "label",
+            "columnName": "LABEL",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "position",
+            "columnName": "POSITION",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "id",
+            "columnName": "_id",
+            "affinity": "INTEGER",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "_id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_DOWNLOAD_LABELS_LABEL",
+            "unique": true,
+            "columnNames": [
+              "LABEL"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_DOWNLOAD_LABELS_LABEL` ON `${TABLE_NAME}` (`LABEL`)"
+          }
+        ],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "DOWNLOADS",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`GID` INTEGER NOT NULL, `STATE` INTEGER NOT NULL, `LEGACY` INTEGER NOT NULL, `TIME` INTEGER NOT NULL, `LABEL` TEXT, PRIMARY KEY(`GID`), FOREIGN KEY(`GID`) REFERENCES `GALLERIES`(`GID`) ON UPDATE NO ACTION ON DELETE NO ACTION , FOREIGN KEY(`LABEL`) REFERENCES `DOWNLOAD_LABELS`(`LABEL`) ON UPDATE CASCADE ON DELETE SET NULL )",
+        "fields": [
+          {
+            "fieldPath": "gid",
+            "columnName": "GID",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "state",
+            "columnName": "STATE",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "legacy",
+            "columnName": "LEGACY",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "time",
+            "columnName": "TIME",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "label",
+            "columnName": "LABEL",
+            "affinity": "TEXT",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "GID"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_DOWNLOADS_LABEL",
+            "unique": false,
+            "columnNames": [
+              "LABEL"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_DOWNLOADS_LABEL` ON `${TABLE_NAME}` (`LABEL`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "GALLERIES",
+            "onDelete": "NO ACTION",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "GID"
+            ],
+            "referencedColumns": [
+              "GID"
+            ]
+          },
+          {
+            "table": "DOWNLOAD_LABELS",
+            "onDelete": "SET NULL",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "LABEL"
+            ],
+            "referencedColumns": [
+              "LABEL"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "DOWNLOAD_DIRNAME",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`GID` INTEGER NOT NULL, `DIRNAME` TEXT NOT NULL, PRIMARY KEY(`GID`))",
+        "fields": [
+          {
+            "fieldPath": "gid",
+            "columnName": "GID",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "dirname",
+            "columnName": "DIRNAME",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "GID"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "DOWNLOAD_ARTISTS",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`GID` INTEGER NOT NULL, `ARTIST` TEXT NOT NULL, PRIMARY KEY(`GID`, `ARTIST`), FOREIGN KEY(`GID`) REFERENCES `DOWNLOADS`(`GID`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "gid",
+            "columnName": "GID",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "artist",
+            "columnName": "ARTIST",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "GID",
+            "ARTIST"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": [
+          {
+            "table": "DOWNLOADS",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "GID"
+            ],
+            "referencedColumns": [
+              "GID"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "FILTER",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`MODE` INTEGER NOT NULL, `TEXT` TEXT NOT NULL, `ENABLE` INTEGER NOT NULL, `_id` INTEGER, PRIMARY KEY(`_id`))",
+        "fields": [
+          {
+            "fieldPath": "mode",
+            "columnName": "MODE",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "text",
+            "columnName": "TEXT",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "enable",
+            "columnName": "ENABLE",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "id",
+            "columnName": "_id",
+            "affinity": "INTEGER",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "_id"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "HISTORY",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`GID` INTEGER NOT NULL, `TIME` INTEGER NOT NULL, PRIMARY KEY(`GID`), FOREIGN KEY(`GID`) REFERENCES `GALLERIES`(`GID`) ON UPDATE NO ACTION ON DELETE NO ACTION )",
+        "fields": [
+          {
+            "fieldPath": "gid",
+            "columnName": "GID",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "time",
+            "columnName": "TIME",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "GID"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": [
+          {
+            "table": "GALLERIES",
+            "onDelete": "NO ACTION",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "GID"
+            ],
+            "referencedColumns": [
+              "GID"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "LOCAL_FAVORITES",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`GID` INTEGER NOT NULL, `TIME` INTEGER NOT NULL, PRIMARY KEY(`GID`), FOREIGN KEY(`GID`) REFERENCES `GALLERIES`(`GID`) ON UPDATE NO ACTION ON DELETE NO ACTION )",
+        "fields": [
+          {
+            "fieldPath": "gid",
+            "columnName": "GID",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "time",
+            "columnName": "TIME",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "GID"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": [
+          {
+            "table": "GALLERIES",
+            "onDelete": "NO ACTION",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "GID"
+            ],
+            "referencedColumns": [
+              "GID"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "PROGRESS",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`GID` INTEGER NOT NULL, `PAGE` INTEGER NOT NULL, PRIMARY KEY(`GID`), FOREIGN KEY(`GID`) REFERENCES `GALLERIES`(`GID`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "gid",
+            "columnName": "GID",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "page",
+            "columnName": "PAGE",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "GID"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": [
+          {
+            "table": "GALLERIES",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "GID"
+            ],
+            "referencedColumns": [
+              "GID"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "QUICK_SEARCH",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`_id` INTEGER, `NAME` TEXT NOT NULL, `MODE` INTEGER NOT NULL, `CATEGORY` INTEGER NOT NULL, `KEYWORD` TEXT, `ADVANCE_SEARCH` INTEGER NOT NULL, `MIN_RATING` INTEGER NOT NULL, `PAGE_FROM` INTEGER NOT NULL, `PAGE_TO` INTEGER NOT NULL, `POSITION` INTEGER NOT NULL, PRIMARY KEY(`_id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "_id",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "NAME",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "mode",
+            "columnName": "MODE",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "category",
+            "columnName": "CATEGORY",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "keyword",
+            "columnName": "KEYWORD",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "advanceSearch",
+            "columnName": "ADVANCE_SEARCH",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "minRating",
+            "columnName": "MIN_RATING",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "pageFrom",
+            "columnName": "PAGE_FROM",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "pageTo",
+            "columnName": "PAGE_TO",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "position",
+            "columnName": "POSITION",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "_id"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      },
+      {
+        "ftsVersion": "FTS4",
+        "ftsOptions": {
+          "tokenizer": "simple",
+          "tokenizerArgs": [],
+          "contentTable": "GALLERIES",
+          "languageIdColumnName": "",
+          "matchInfo": "FTS4",
+          "notIndexedColumns": [],
+          "prefixSizes": [],
+          "preferredOrder": "ASC"
+        },
+        "contentSyncTriggers": [
+          "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_GALLERIES_FTS_BEFORE_UPDATE BEFORE UPDATE ON `GALLERIES` BEGIN DELETE FROM `GALLERIES_FTS` WHERE `docid`=OLD.`rowid`; END",
+          "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_GALLERIES_FTS_BEFORE_DELETE BEFORE DELETE ON `GALLERIES` BEGIN DELETE FROM `GALLERIES_FTS` WHERE `docid`=OLD.`rowid`; END",
+          "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_GALLERIES_FTS_AFTER_UPDATE AFTER UPDATE ON `GALLERIES` BEGIN INSERT INTO `GALLERIES_FTS`(`docid`, `TITLE`, `TITLE_JPN`, `SIMPLE_TAGS`) VALUES (NEW.`rowid`, NEW.`TITLE`, NEW.`TITLE_JPN`, NEW.`SIMPLE_TAGS`); END",
+          "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_GALLERIES_FTS_AFTER_INSERT AFTER INSERT ON `GALLERIES` BEGIN INSERT INTO `GALLERIES_FTS`(`docid`, `TITLE`, `TITLE_JPN`, `SIMPLE_TAGS`) VALUES (NEW.`rowid`, NEW.`TITLE`, NEW.`TITLE_JPN`, NEW.`SIMPLE_TAGS`); END"
+        ],
+        "tableName": "GALLERIES_FTS",
+        "createSql": "CREATE VIRTUAL TABLE IF NOT EXISTS `${TABLE_NAME}` USING FTS4(`TITLE` TEXT NOT NULL, `TITLE_JPN` TEXT NOT NULL, `SIMPLE_TAGS` TEXT, content=`GALLERIES`)",
+        "fields": [
+          {
+            "fieldPath": "title",
+            "columnName": "TITLE",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "titleJpn",
+            "columnName": "TITLE_JPN",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "simpleTags",
+            "columnName": "SIMPLE_TAGS",
+            "affinity": "TEXT",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": []
+        },
+        "indices": [],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '7d1cfc4e9a9d506a73eb0520ae414d25')"
+    ]
+  }
+}
@@ -29,7 +29,6 @@
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:largeHeap="@bool/large_heap"
-        android:localeConfig="@xml/locale_config"
        android:networkSecurityConfig="@xml/network_security_config"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
@@ -101,23 +100,24 @@
                <data android:scheme="content" />
                <data android:host="*" />
                <data android:mimeType="application/octet-stream" />
-                <data android:mimeType="application/7z" />
-                <data android:mimeType="application/rar" />
                <data android:mimeType="application/zip" />
                <data android:mimeType="application/x-7z-compressed" />
-                <data android:mimeType="application/x-rar-compressed" />
-                <data android:mimeType="application/x-zip-compressed" />
                <data android:mimeType="application/x-tar" />
                <data android:mimeType="application/x-xz" />
                <data android:mimeType="application/gzip" />
+                <data android:mimeType="application/vnd.rar" />
+                <data android:mimeType="application/vnd.comicbook+zip" />
+                <data android:mimeType="application/vnd.comicbook-rar" />
+
+                <!-- unofficial -->
+                <data android:mimeType="application/7z" />
+                <data android:mimeType="application/rar" />
                <data android:mimeType="application/x-cbz" />
                <data android:mimeType="application/x-cbr" />
                <data android:mimeType="application/x-cbt" />
                <data android:mimeType="application/x-cb7" />
-
-                <!-- untested -->
-                <data android:mimeType="application/vnd.comicbook+zip" />
-                <data android:mimeType="application/vnd.comicbook-rar" />
+                <data android:mimeType="application/x-zip-compressed" />
+                <data android:mimeType="application/x-rar-compressed" />
                <data android:mimeType="application/x-compressed-tar" />
                <data android:mimeType="application/x-bzip-compressed-tar" />
                <data android:mimeType="application/x-lzma-compressed-tar" />
@@ -0,0 +1,52 @@
+From d1db03ebd9989d10a5a905b792b712c6487a0057 Mon Sep 17 00:00:00 2001
+From: FooIbar <118464521+FooIbar@users.noreply.github.com>
+Date: Sat, 24 Feb 2024 12:03:15 +0000
+Subject: [PATCH] Don't build other binaries
+
+---
+ CMakeLists.txt | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index a346dd02..52b5d0d8 100644
+--- a/CMakeLists.txt
+++ b/CMakeLists.txt
+@@ -1567,7 +1567,7 @@ endif()
+ # xzdec and lzmadec
+ #############################################################################
+ 
+-if(HAVE_DECODERS AND (NOT MSVC OR MSVC_VERSION GREATER_EQUAL 1900))
+if(0)
+     foreach(XZDEC xzdec lzmadec)
+         add_executable("${XZDEC}"
+             src/common/sysdefs.h
+@@ -1624,7 +1624,7 @@ endif()
+ # lzmainfo
+ #############################################################################
+ 
+-if(HAVE_DECODERS AND (NOT MSVC OR MSVC_VERSION GREATER_EQUAL 1900))
+if(0)
+     add_executable(lzmainfo
+         src/common/sysdefs.h
+         src/common/tuklib_common.h
+@@ -1680,7 +1680,7 @@ endif()
+ # xz
+ #############################################################################
+ 
+-if(NOT MSVC OR MSVC_VERSION GREATER_EQUAL 1900)
+if(0)
+     add_executable(xz
+         src/common/mythread.h
+         src/common/sysdefs.h
+@@ -1914,7 +1914,7 @@ endif()
+ # Scripts
+ #############################################################################
+ 
+-if(UNIX)
+if(0)
+     # NOTE: This isn't as sophisticated as in the Autotools build which
+     # uses posix-shell.m4 but hopefully this doesn't need to be either.
+     # CMake likely won't be used on as many (old) obscure systems as the
+-- 
+2.34.1
+
@@ -0,0 +1,29 @@
+From 2fa97f75b64c05da506968fa9a1711716f2d45a0 Mon Sep 17 00:00:00 2001
+From: FooIbar <118464521+FooIbar@users.noreply.github.com>
+Date: Tue, 26 Sep 2023 00:08:03 +0800
+Subject: [PATCH 1/2] Hide symbols
+
+---
+ CMakeLists.txt | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index ec97e4c7..4d859341 100644
+--- a/CMakeLists.txt
+++ b/CMakeLists.txt
+@@ -2129,10 +2129,10 @@ SET(OLD_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
+ SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -fvisibility=hidden -Werror")
+ CHECK_C_SOURCE_COMPILES("void __attribute__((visibility(\"default\"))) foo(void);
+ int main() { return 0; }" HAVE_VISIBILITY_ATTR)
+-IF (HAVE_VISIBILITY_ATTR)
+IF (0)
+   SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
+   ADD_DEFINITIONS(-D__LIBARCHIVE_ENABLE_VISIBILITY)
+-ENDIF(HAVE_VISIBILITY_ATTR)
+ENDIF(0)
+ SET(CMAKE_REQUIRED_FLAGS "${OLD_CMAKE_REQUIRED_FLAGS}")
+ 
+ # Generate "config.h" from "build/cmake/config.h.in"
+-- 
+2.34.1
+
@@ -0,0 +1,25 @@
+From 2dcc8be937499022c37678eb6bf4bd026b6fcbb0 Mon Sep 17 00:00:00 2001
+From: FooIbar <118464521+FooIbar@users.noreply.github.com>
+Date: Tue, 26 Sep 2023 00:09:25 +0800
+Subject: [PATCH 2/2] Insert link libs
+
+---
+ CMakeLists.txt | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 4d859341..1cd1cd47 100644
+--- a/CMakeLists.txt
+++ b/CMakeLists.txt
+@@ -438,7 +438,7 @@ IF(DEFINED __GNUWIN32PATH AND EXISTS "${__GNUWIN32PATH}")
+   # #  endif
+ ENDIF(DEFINED __GNUWIN32PATH AND EXISTS "${__GNUWIN32PATH}")
+ 
+-SET(ADDITIONAL_LIBS "")
+SET(ADDITIONAL_LIBS ${LIBARCHIVE_CUSTOM_LIBS})
+ #
+ # Find ZLIB
+ #
+-- 
+2.34.1
+
@@ -20,8 +20,9 @@ option(BUILD_TESTING OFF)

 FetchContent_Declare(
        liblzma
-        GIT_REPOSITORY https://github.com/FooIbar/xz.git
-        GIT_TAG v5.6.1
+        GIT_REPOSITORY https://github.com/tukaani-project/xz.git
+        GIT_TAG v5.6.2
+        PATCH_COMMAND git apply ${CMAKE_CURRENT_LIST_DIR}/0001-Don-t-build-other-binaries.patch || cd .
 )

 FetchContent_MakeAvailable(liblzma)
@@ -68,8 +69,9 @@ SET(LIBARCHIVE_CUSTOM_LIBS "nettle" "liblzma")

 FetchContent_Declare(
        libarchive
-        GIT_REPOSITORY https://github.com/FooIbar/libarchive.git
-        GIT_TAG v3.7.2
+        GIT_REPOSITORY https://github.com/libarchive/libarchive.git
+        GIT_TAG v3.7.4
+        PATCH_COMMAND git apply ${CMAKE_CURRENT_LIST_DIR}/0001-Hide-symbols.patch ${CMAKE_CURRENT_LIST_DIR}/0002-Insert-link-libs.patch || cd .
 )

 FetchContent_MakeAvailable(libarchive)
@@ -78,11 +80,12 @@ include_directories(${libarchive_SOURCE_DIR}/libarchive)
 FetchContent_Declare(
        Corrosion
        GIT_REPOSITORY https://github.com/corrosion-rs/corrosion.git
-        GIT_TAG 0a3bdf452995803c334d79dc9a2affbfad51b720
+        GIT_TAG v0.5
 )

 FetchContent_MakeAvailable(Corrosion)
 corrosion_import_crate(MANIFEST_PATH ../rust/Cargo.toml)
+corrosion_add_target_local_rustflags(ehviewer_rust "-Clink-args=-Wl,-z,max-page-size=16384")

 # Build and link our app's native lib
 add_library(${PROJECT_NAME} SHARED archive.c border.c gifutils.c natsort/strnatcmp.c)
@@ -54,8 +54,9 @@ static archive_ctx **ctx_pool;

 static void *mempool = NULL;
 static size_t *mempoolofs = NULL;
+static int page_size = 0;

-#define PAGE_ALIGN(x) ((x + ~PAGE_MASK) & PAGE_MASK)
+#define PAGE_ALIGN(x) ((x + page_size - 1) & ~(page_size - 1))

 #define MEMPOOL_ADDR_BY_SORTED_IDX(x) (mempool + (index ? mempoolofs[index - 1] : 0))
 #define MEMPOOL_SIZE (mempoolofs[entryCount - 1])
@@ -127,8 +128,6 @@ static long archive_map_entries_index(archive_ctx *ctx, bool sort) {
            count++;
        }
    }
-    if (!count)
-        LOGE("%s", archive_error_string(ctx->arc));
    if (sort)
        qsort(entries, entryCount, sizeof(entry), compare_entries);
    return count;
@@ -171,8 +170,6 @@ static long archive_list_all_entries(archive_ctx *ctx) {
    while (archive_read_next_header(ctx->arc, &ctx->entry) == ARCHIVE_OK)
        if (archive_entry_is_playable(ctx->entry))
            count++;
-    if (!count)
-        LOGE("%s", archive_error_string(ctx->arc));
    return count;
 }

@@ -286,6 +283,7 @@ JNIEXPORT jint JNICALL
 Java_com_hippo_ehviewer_jni_ArchiveKt_openArchive(JNIEnv *env, jclass thiz, jint fd, jlong size, jboolean sort_entries) {
    EH_UNUSED(env);
    EH_UNUSED(thiz);
+    page_size = getpagesize();
    archive_ctx *ctx = NULL;
    archiveAddr = mmap(0, size, PROT_READ, MAP_PRIVATE, fd, 0);
    if (archiveAddr == MAP_FAILED) {
@@ -306,6 +304,11 @@ Java_com_hippo_ehviewer_jni_ArchiveKt_openArchive(JNIEnv *env, jclass thiz, jint
    } else {
        entryCount = archive_list_all_entries(ctx);
        LOGI("%s%zu%s", "Found ", entryCount, " image entries in archive");
+        if (!entryCount) {
+            LOGE("%s%s", "Archive open failed:", archive_error_string(ctx->arc));
+            archive_release_ctx(ctx);
+            return 0;
+        }

        // We must read through the file|vm then we can know whether it is encrypted
        int encryptRet = archive_read_has_encrypted_entries(ctx->arc);
@@ -0,0 +1,278 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.foundation.gestures
+
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.gestures.HorizontalDragEvent.DragDelta
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.input.pointer.PointerInputChange
+import androidx.compose.ui.input.pointer.positionChange
+import androidx.compose.ui.layout.Measurable
+import androidx.compose.ui.layout.MeasureResult
+import androidx.compose.ui.layout.MeasureScope
+import androidx.compose.ui.node.LayoutModifierNode
+import androidx.compose.ui.node.ModifierNodeElement
+import androidx.compose.ui.node.requireLayoutDirection
+import androidx.compose.ui.platform.InspectorInfo
+import androidx.compose.ui.platform.debugInspectorInfo
+import androidx.compose.ui.unit.Constraints
+import androidx.compose.ui.unit.IntSize
+import androidx.compose.ui.unit.LayoutDirection
+import androidx.compose.ui.unit.Velocity
+import kotlin.math.absoluteValue
+import kotlin.math.roundToInt
+import kotlinx.coroutines.launch
+
+@ExperimentalFoundationApi
+fun <T> Modifier.anchoredHorizontalDraggable(
+    state: AnchoredDraggableState<T>,
+    enableDragFromStartToEnd: Boolean = true,
+    enableDragFromEndToStart: Boolean = true,
+    enabled: Boolean = true,
+    startDragImmediately: Boolean = state.isAnimationRunning,
+): Modifier = this then AnchoredHorizontalDraggableElement(
+    state = state,
+    canDrag = { (x, y) ->
+        if (x > 0) {
+            enableDragFromStartToEnd
+        } else {
+            enableDragFromEndToStart
+        } && x.absoluteValue > y.absoluteValue * 2f
+    },
+    enabled = enabled,
+    startDragImmediately = startDragImmediately,
+)
+
+@OptIn(ExperimentalFoundationApi::class)
+private class AnchoredHorizontalDraggableElement<T>(
+    private val state: AnchoredDraggableState<T>,
+    private val canDrag: (Offset) -> Boolean,
+    private val enabled: Boolean,
+    private val startDragImmediately: Boolean,
+) : ModifierNodeElement<AnchoredHorizontalDraggableNode<T>>() {
+    override fun create() = AnchoredHorizontalDraggableNode(
+        state,
+        canDrag,
+        enabled,
+        startDragImmediately,
+    )
+
+    override fun update(node: AnchoredHorizontalDraggableNode<T>) {
+        node.update(
+            state,
+            canDrag,
+            enabled,
+            startDragImmediately,
+        )
+    }
+
+    override fun hashCode(): Int {
+        var result = state.hashCode()
+        result = 31 * result + canDrag.hashCode()
+        result = 31 * result + enabled.hashCode()
+        result = 31 * result + startDragImmediately.hashCode()
+        return result
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+
+        if (other !is AnchoredHorizontalDraggableElement<*>) return false
+
+        if (state != other.state) return false
+        if (canDrag != other.canDrag) return false
+        if (enabled != other.enabled) return false
+        if (startDragImmediately != other.startDragImmediately) return false
+
+        return true
+    }
+
+    override fun InspectorInfo.inspectableProperties() {
+        name = "anchoredDraggable"
+        properties["state"] = state
+        properties["canDrag"] = canDrag
+        properties["enabled"] = enabled
+        properties["startDragImmediately"] = startDragImmediately
+    }
+}
+
+@OptIn(ExperimentalFoundationApi::class)
+private class AnchoredHorizontalDraggableNode<T>(
+    private var state: AnchoredDraggableState<T>,
+    private var canDrag: (Offset) -> Boolean,
+    enabled: Boolean,
+    private var startDragImmediately: Boolean,
+) : HorizontalDragGestureNode(
+    enabled = enabled,
+) {
+
+    private val isReverseDirection: Boolean
+        get() = requireLayoutDirection() == LayoutDirection.Rtl
+
+    override fun canDrag(change: PointerInputChange): Boolean {
+        return canDrag(change.positionChange().reverseIfNeeded())
+    }
+
+    override suspend fun drag(forEachDelta: suspend ((dragDelta: DragDelta) -> Unit) -> Unit) {
+        state.anchoredDrag {
+            forEachDelta { dragDelta ->
+                dragTo(state.newOffsetForDelta(dragDelta.delta.reverseIfNeeded().x))
+            }
+        }
+    }
+
+    override fun onDragStarted(startedPosition: Offset) { }
+
+    override fun onDragStopped(velocity: Velocity) {
+        if (!isAttached) return
+        coroutineScope.launch {
+            state.settle(velocity.reverseIfNeeded().x)
+        }
+    }
+
+    override fun startDragImmediately(): Boolean = startDragImmediately
+
+    fun update(
+        state: AnchoredDraggableState<T>,
+        canDrag: (Offset) -> Boolean,
+        enabled: Boolean,
+        startDragImmediately: Boolean,
+    ) {
+        var resetPointerInputHandling = false
+
+        if (this.state != state) {
+            this.state = state
+            resetPointerInputHandling = true
+        }
+
+        this.canDrag = canDrag
+        this.startDragImmediately = startDragImmediately
+
+        update(
+            enabled = enabled,
+            shouldResetPointerInputHandling = resetPointerInputHandling,
+        )
+    }
+
+    private fun Velocity.reverseIfNeeded() = if (isReverseDirection) this * -1f else this * 1f
+    private fun Offset.reverseIfNeeded() = if (isReverseDirection) this * -1f else this * 1f
+}
+
+internal fun <T> AnchoredDraggableState<T>.newOffsetForDelta(delta: Float) =
+    ((if (offset.isNaN()) 0f else offset) + delta)
+        .coerceIn(anchors.minAnchor(), anchors.maxAnchor())
+
+/**
+ * This Modifier allows configuring an [AnchoredDraggableState]'s anchors based on this layout
+ * node's size and offsetting it.
+ * It considers lookahead and reports the appropriate size and measurement for the appropriate
+ * phase.
+ *
+ * @param state The state the anchors should be attached to
+ * @param orientation The orientation the component should be offset in
+ * @param anchors Lambda to calculate the anchors based on this layout's size and the incoming
+ * constraints. These can be useful to avoid subcomposition.
+ */
+internal fun <T> Modifier.draggableAnchors(
+    state: AnchoredDraggableState<T>,
+    orientation: Orientation,
+    anchors: (size: IntSize, constraints: Constraints) -> Pair<DraggableAnchors<T>, T>,
+) = this then DraggableAnchorsElement(state, anchors, orientation)
+
+private class DraggableAnchorsElement<T>(
+    private val state: AnchoredDraggableState<T>,
+    private val anchors: (size: IntSize, constraints: Constraints) -> Pair<DraggableAnchors<T>, T>,
+    private val orientation: Orientation,
+) : ModifierNodeElement<DraggableAnchorsNode<T>>() {
+
+    override fun create() = DraggableAnchorsNode(state, anchors, orientation)
+
+    override fun update(node: DraggableAnchorsNode<T>) {
+        node.state = state
+        node.anchors = anchors
+        node.orientation = orientation
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+
+        if (other !is DraggableAnchorsElement<*>) return false
+
+        if (state != other.state) return false
+        if (anchors !== other.anchors) return false
+        if (orientation != other.orientation) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = state.hashCode()
+        result = 31 * result + anchors.hashCode()
+        result = 31 * result + orientation.hashCode()
+        return result
+    }
+
+    override fun InspectorInfo.inspectableProperties() {
+        debugInspectorInfo {
+            properties["state"] = state
+            properties["anchors"] = anchors
+            properties["orientation"] = orientation
+        }
+    }
+}
+
+private class DraggableAnchorsNode<T>(
+    var state: AnchoredDraggableState<T>,
+    var anchors: (size: IntSize, constraints: Constraints) -> Pair<DraggableAnchors<T>, T>,
+    var orientation: Orientation,
+) : Modifier.Node(), LayoutModifierNode {
+    private var didLookahead: Boolean = false
+
+    override fun onDetach() {
+        didLookahead = false
+    }
+
+    override fun MeasureScope.measure(
+        measurable: Measurable,
+        constraints: Constraints,
+    ): MeasureResult {
+        val placeable = measurable.measure(constraints)
+        // If we are in a lookahead pass, we only want to update the anchors here and not in
+        // post-lookahead. If there is no lookahead happening (!isLookingAhead && !didLookahead),
+        // update the anchors in the main pass.
+        if (!isLookingAhead || !didLookahead) {
+            val size = IntSize(placeable.width, placeable.height)
+            val newAnchorResult = anchors(size, constraints)
+            state.updateAnchors(newAnchorResult.first, newAnchorResult.second)
+        }
+        didLookahead = isLookingAhead || didLookahead
+        return layout(placeable.width, placeable.height) {
+            // In a lookahead pass, we use the position of the current target as this is where any
+            // ongoing animations would move. If the component is in a settled state, lookahead
+            // and post-lookahead will converge.
+            val offset = if (isLookingAhead) {
+                state.anchors.positionOf(state.targetValue)
+            } else {
+                state.requireOffset()
+            }
+            val xOffset = if (orientation == Orientation.Horizontal) offset else 0f
+            val yOffset = if (orientation == Orientation.Vertical) offset else 0f
+            placeable.placeRelative(xOffset.roundToInt(), yOffset.roundToInt())
+        }
+    }
+}
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.foundation.gestures
+
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.input.pointer.PointerEventPass
+import androidx.compose.ui.input.pointer.PointerInputChange
+import androidx.compose.ui.input.pointer.PointerInputScope
+import androidx.compose.ui.input.pointer.positionChange
+import androidx.compose.ui.platform.ViewConfiguration
+import kotlin.coroutines.cancellation.CancellationException
+
+/**
+ * A Gesture detector that waits for pointer down and touch slop in the horizontal direction and
+ * then calls [onDrag] for each drag event.
+ * It follows the touch slop detection of [awaitHorizontalTouchSlopOrCancellation] but will consume
+ * the position change automatically once the touch slop has been crossed, the amount of drag over
+ * the touch slop is reported as the first drag event [onDrag] after the slop is crossed.
+ * If [shouldAwaitTouchSlop] returns true the touch slop recognition phase will be ignored
+ * and the drag gesture will be recognized immediately.The first [onDrag] in this case will report
+ * an [Offset.Zero].
+ *
+ * [onDragStart] is called when the touch slop has been passed and includes an [Offset] representing
+ * the last known pointer position relative to the containing element as well as  the initial
+ * down event that triggered this gesture detection cycle. The [Offset] can be outside
+ * the actual bounds of the element itself meaning the numbers can be negative or larger than the
+ * element bounds if the touch target is smaller than the
+ * [ViewConfiguration.minimumTouchTargetSize].
+ *
+ * [onDragEnd] is called after all pointers are up with the event change of the up event
+ * and [onDragCancel] is called if another gesture has consumed pointer input,
+ * canceling this gesture.
+ *
+ * @param onDragStart A lambda to be called when the drag gesture starts, it contains information
+ * about the last known [PointerInputChange] relative to the containing element and the post slop
+ * delta.
+ * @param onDragEnd A lambda to be called when the gesture ends. It contains information about the
+ * up [PointerInputChange] that finished the gesture.
+ * @param onDragCancel A lambda to be called when the gesture is cancelled either by an error or
+ * when it was consumed.
+ * @param shouldAwaitTouchSlop Indicates if touch slop detection should be skipped.
+ * @param onDrag A lambda to be called for each delta event in the gesture. It contains information
+ * about the [PointerInputChange] and the movement offset.
+ */
+internal suspend fun PointerInputScope.detectHorizontalDragGestures(
+    canDrag: (PointerInputChange) -> Boolean,
+    onDragStart: (change: PointerInputChange, initialDelta: Offset) -> Unit,
+    onDragEnd: () -> Unit,
+    onDragCancel: () -> Unit,
+    shouldAwaitTouchSlop: () -> Boolean,
+    onDrag: (change: PointerInputChange, dragAmount: Offset) -> Unit,
+) {
+    awaitEachGesture {
+        val initialDown =
+            awaitFirstDown(requireUnconsumed = false, pass = PointerEventPass.Initial)
+        val awaitTouchSlop = shouldAwaitTouchSlop()
+
+        if (!awaitTouchSlop) {
+            initialDown.consume()
+        }
+        val down = awaitFirstDown(requireUnconsumed = false)
+        var drag: PointerInputChange?
+        var overSlop = Offset.Zero
+
+        if (awaitTouchSlop) {
+            do {
+                drag = awaitHorizontalTouchSlopOrCancellation(
+                    down.id,
+                ) { change, over ->
+                    if (canDrag.invoke(change)) {
+                        change.consume()
+                        overSlop = Offset(over, 0f)
+                    } else {
+                        throw CancellationException()
+                    }
+                }
+            } while (drag != null && !drag.isConsumed)
+        } else {
+            drag = initialDown
+        }
+
+        if (drag != null) {
+            onDragStart.invoke(drag, overSlop)
+            onDrag(drag, overSlop)
+            val dragEnd = horizontalDrag(
+                pointerId = drag.id,
+                onDrag = {
+                    onDrag(it, it.positionChange())
+                    it.consume()
+                },
+            )
+            if (dragEnd) {
+                onDragEnd()
+            } else {
+                onDragCancel()
+            }
+        }
+    }
+}
@@ -0,0 +1,228 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.foundation.gestures
+
+import androidx.compose.foundation.gestures.HorizontalDragEvent.DragCancelled
+import androidx.compose.foundation.gestures.HorizontalDragEvent.DragDelta
+import androidx.compose.foundation.gestures.HorizontalDragEvent.DragStarted
+import androidx.compose.foundation.gestures.HorizontalDragEvent.DragStopped
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.input.pointer.PointerEvent
+import androidx.compose.ui.input.pointer.PointerEventPass
+import androidx.compose.ui.input.pointer.PointerInputChange
+import androidx.compose.ui.input.pointer.SuspendingPointerInputModifierNode
+import androidx.compose.ui.input.pointer.util.VelocityTracker
+import androidx.compose.ui.input.pointer.util.addPointerInputChange
+import androidx.compose.ui.node.CompositionLocalConsumerModifierNode
+import androidx.compose.ui.node.DelegatingNode
+import androidx.compose.ui.node.PointerInputModifierNode
+import androidx.compose.ui.node.currentValueOf
+import androidx.compose.ui.platform.LocalViewConfiguration
+import androidx.compose.ui.unit.IntSize
+import androidx.compose.ui.unit.Velocity
+import kotlin.coroutines.cancellation.CancellationException
+import kotlin.math.sign
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+
+/**
+ * A node that performs drag gesture recognition and event propagation.
+ */
+internal abstract class HorizontalDragGestureNode(
+    enabled: Boolean,
+) : DelegatingNode(), PointerInputModifierNode, CompositionLocalConsumerModifierNode {
+
+    protected var enabled = enabled
+        private set
+
+    private var channel: Channel<HorizontalDragEvent>? = null
+    private var isListeningForEvents = false
+
+    abstract fun canDrag(change: PointerInputChange): Boolean
+
+    /**
+     * Responsible for the dragging behavior between the start and the end of the drag. It
+     * continually invokes `forEachDelta` to process incoming events. In return, `forEachDelta`
+     * calls `dragBy` method to process each individual delta.
+     */
+    abstract suspend fun drag(forEachDelta: suspend ((dragDelta: DragDelta) -> Unit) -> Unit)
+
+    /**
+     * Passes the action needed when a drag starts. This gives the ability to pass the desired
+     * behavior from other nodes implementing AbstractDraggableNode
+     */
+    abstract fun onDragStarted(startedPosition: Offset)
+
+    /**
+     * Passes the action needed when a drag stops. This gives the ability to pass the desired
+     * behavior from other nodes implementing AbstractDraggableNode
+     */
+    abstract fun onDragStopped(velocity: Velocity)
+
+    /**
+     * If touch slop recognition should be skipped. If this is true, this node will start
+     * recognizing drag events immediately without waiting for touch slop.
+     */
+    abstract fun startDragImmediately(): Boolean
+
+    private fun startListeningForEvents() {
+        isListeningForEvents = true
+
+        /**
+         * To preserve the original behavior we had (before the Modifier.Node migration) we need to
+         * scope the DragStopped and DragCancel methods to the node's coroutine scope instead of using
+         * the one provided by the pointer input modifier, this is to ensure that even when the pointer
+         * input scope is reset we will continue any coroutine scope scope that we started from these
+         * methods while the pointer input scope was active.
+         */
+        coroutineScope.launch {
+            while (isActive) {
+                var event = channel?.receive()
+                if (event !is DragStarted) continue
+                onDragStarted(event.startPoint)
+                try {
+                    drag { processDelta ->
+                        while (event !is DragStopped && event !is DragCancelled) {
+                            (event as? DragDelta)?.let(processDelta)
+                            event = channel?.receive()
+                        }
+                    }
+                    if (event is DragStopped) {
+                        onDragStopped((event as DragStopped).velocity)
+                    } else if (event is DragCancelled) {
+                        onDragStopped(Velocity.Zero)
+                    }
+                } catch (c: CancellationException) {
+                    onDragStopped(Velocity.Zero)
+                }
+            }
+        }
+    }
+
+    private var pointerInputNode: SuspendingPointerInputModifierNode? = null
+
+    override fun onDetach() {
+        isListeningForEvents = false
+    }
+
+    override fun onPointerEvent(
+        pointerEvent: PointerEvent,
+        pass: PointerEventPass,
+        bounds: IntSize,
+    ) {
+        if (enabled && pointerInputNode == null) {
+            pointerInputNode = delegate(initializePointerInputNode())
+        }
+        pointerInputNode?.onPointerEvent(pointerEvent, pass, bounds)
+    }
+
+    private fun initializePointerInputNode(): SuspendingPointerInputModifierNode {
+        return SuspendingPointerInputModifierNode {
+            // re-create tracker when pointer input block restarts. This lazily creates the tracker
+            // only when it is need.
+            val velocityTracker = VelocityTracker()
+            val onDragStart: (change: PointerInputChange, initialDelta: Offset) -> Unit =
+                { startEvent, initialDelta ->
+                    if (!isListeningForEvents) {
+                        if (channel == null) {
+                            channel = Channel(capacity = Channel.UNLIMITED)
+                        }
+                        startListeningForEvents()
+                    }
+                    val xSign = sign(startEvent.position.x)
+                    val ySign = sign(startEvent.position.y)
+                    val adjustedStart = startEvent.position -
+                        Offset(initialDelta.x * xSign, initialDelta.y * ySign)
+
+                    channel?.trySend(DragStarted(adjustedStart))
+                }
+
+            val onDragEnd: () -> Unit = {
+                val maximumVelocity = currentValueOf(LocalViewConfiguration)
+                    .maximumFlingVelocity
+                val velocity = velocityTracker.calculateVelocity(
+                    Velocity(maximumVelocity, maximumVelocity),
+                )
+                velocityTracker.resetTracking()
+                channel?.trySend(DragStopped(velocity))
+            }
+
+            val onDragCancel: () -> Unit = {
+                channel?.trySend(DragCancelled)
+            }
+
+            val shouldAwaitTouchSlop: () -> Boolean = {
+                !startDragImmediately()
+            }
+
+            val onDrag: (change: PointerInputChange, dragAmount: Offset) -> Unit =
+                { change, delta ->
+                    velocityTracker.addPointerInputChange(change)
+                    channel?.trySend(DragDelta(delta))
+                }
+
+            coroutineScope {
+                try {
+                    detectHorizontalDragGestures(
+                        canDrag = ::canDrag,
+                        onDragStart = onDragStart,
+                        onDragEnd = onDragEnd,
+                        onDragCancel = onDragCancel,
+                        shouldAwaitTouchSlop = shouldAwaitTouchSlop,
+                        onDrag = onDrag,
+                    )
+                } catch (cancellation: CancellationException) {
+                    channel?.trySend(DragCancelled)
+                    if (!isActive) throw cancellation
+                }
+            }
+        }
+    }
+
+    override fun onCancelPointerInput() {
+        pointerInputNode?.onCancelPointerInput()
+    }
+
+    fun update(
+        enabled: Boolean = this.enabled,
+        shouldResetPointerInputHandling: Boolean = false,
+    ) {
+        var resetPointerInputHandling = shouldResetPointerInputHandling
+
+        if (this.enabled != enabled) {
+            this.enabled = enabled
+            if (!enabled) {
+                pointerInputNode?.let { undelegate(it) }
+                pointerInputNode = null
+            }
+            resetPointerInputHandling = true
+        }
+
+        if (resetPointerInputHandling) {
+            pointerInputNode?.resetPointerInputHandler()
+        }
+    }
+}
+
+internal sealed class HorizontalDragEvent {
+    class DragStarted(val startPoint: Offset) : HorizontalDragEvent()
+    class DragStopped(val velocity: Velocity) : HorizontalDragEvent()
+    object DragCancelled : HorizontalDragEvent()
+    class DragDelta(val delta: Offset) : HorizontalDragEvent()
+}
@@ -0,0 +1,106 @@
+@file:Suppress("ktlint:standard:property-naming")
+
+package androidx.compose.material3
+
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.collectIsFocusedAsState
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.sizeIn
+import androidx.compose.foundation.text.BasicTextField
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.foundation.text.input.TextFieldLineLimits
+import androidx.compose.foundation.text.input.TextFieldState
+import androidx.compose.material3.SearchBarDefaults.InputFieldHeight
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.focus.onFocusChanged
+import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.graphics.takeOrElse
+import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.input.VisualTransformation
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.delay
+
+@Composable
+fun SearchBarInputField(
+    state: TextFieldState,
+    onSearch: () -> Unit,
+    expanded: Boolean,
+    onExpandedChange: (Boolean) -> Unit,
+    modifier: Modifier = Modifier,
+    enabled: Boolean = true,
+    label: @Composable (() -> Unit)? = null,
+    placeholder: @Composable (() -> Unit)? = null,
+    leadingIcon: @Composable (() -> Unit)? = null,
+    trailingIcon: @Composable (() -> Unit)? = null,
+    colors: TextFieldColors = SearchBarDefaults.inputFieldColors(),
+    interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
+) {
+    val focusRequester = remember { FocusRequester() }
+    val focusManager = LocalFocusManager.current
+    val focused by interactionSource.collectIsFocusedAsState()
+    val textColor = LocalTextStyle.current.color.takeOrElse {
+        if (focused) colors.focusedTextColor else colors.unfocusedTextColor
+    }
+
+    BasicTextField(
+        state = state,
+        modifier = modifier.sizeIn(
+            minWidth = SearchBarMinWidth,
+            maxWidth = SearchBarMaxWidth,
+            minHeight = InputFieldHeight,
+        ).focusRequester(focusRequester).onFocusChanged {
+            if (it.isFocused) onExpandedChange(true)
+        }.fillMaxWidth(),
+        enabled = enabled,
+        lineLimits = TextFieldLineLimits.SingleLine,
+        textStyle = LocalTextStyle.current.merge(TextStyle(color = textColor)),
+        cursorBrush = SolidColor(colors.cursorColor),
+        keyboardOptions = KeyboardOptions(imeAction = ImeAction.Search),
+        onKeyboardAction = { onSearch() },
+        interactionSource = interactionSource,
+        decorator = @Composable { innerTextField ->
+            TextFieldDefaults.DecorationBox(
+                value = state.text.toString(),
+                innerTextField = innerTextField,
+                enabled = enabled,
+                singleLine = true,
+                visualTransformation = VisualTransformation.None,
+                interactionSource = interactionSource,
+                label = label,
+                placeholder = placeholder,
+                leadingIcon = leadingIcon?.let { leading -> { Box(Modifier.offset(x = SearchBarIconOffsetX)) { leading() } } },
+                trailingIcon = trailingIcon?.let { trailing -> { Box(Modifier.offset(x = -SearchBarIconOffsetX)) { trailing() } } },
+                shape = SearchBarDefaults.inputFieldShape,
+                colors = colors,
+                contentPadding = TextFieldDefaults.contentPaddingWithoutLabel(),
+                container = {},
+            )
+        },
+    )
+
+    val shouldClearFocus = !expanded && focused
+    LaunchedEffect(expanded) {
+        if (shouldClearFocus) {
+            // Not strictly needed according to the motion spec, but since the animation
+            // already has a delay, this works around b/261632544.
+            delay(AnimationDelayMillis.toLong())
+            focusManager.clearFocus()
+        }
+    }
+}
+
+val SearchBarIconOffsetX = 4.dp
+val SearchBarMinWidth = 360.dp
+val SearchBarMaxWidth = 720.dp
+val SearchBarHorizontalPadding = 16.dp
+const val AnimationDelayMillis = 100
@@ -1,591 +0,0 @@
-/*
- * Copyright 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-@file:Suppress("ktlint:standard:property-naming")
-
-package androidx.compose.material3
-
-import androidx.activity.BackEventCompat
-import androidx.activity.compose.PredictiveBackHandler
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.AnimationVector1D
-import androidx.compose.animation.core.CubicBezierEasing
-import androidx.compose.animation.core.EaseOut
-import androidx.compose.animation.core.FiniteAnimationSpec
-import androidx.compose.animation.core.tween
-import androidx.compose.foundation.MutatorMutex
-import androidx.compose.foundation.interaction.Interaction
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.interaction.collectIsFocusedAsState
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.ColumnScope
-import androidx.compose.foundation.layout.MutableWindowInsets
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.WindowInsets
-import androidx.compose.foundation.layout.asPaddingValues
-import androidx.compose.foundation.layout.consumeWindowInsets
-import androidx.compose.foundation.layout.exclude
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.offset
-import androidx.compose.foundation.layout.onConsumedWindowInsetsChanged
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.GenericShape
-import androidx.compose.foundation.text.BasicTextField2
-import androidx.compose.foundation.text.KeyboardActions
-import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.foundation.text.input.TextFieldLineLimits
-import androidx.compose.foundation.text.input.TextFieldState
-import androidx.compose.material3.SearchBarDefaults.InputFieldHeight
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.MutableFloatState
-import androidx.compose.runtime.MutableState
-import androidx.compose.runtime.Stable
-import androidx.compose.runtime.State
-import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableFloatStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.structuralEqualityPolicy
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.focus.onFocusChanged
-import androidx.compose.ui.geometry.CornerRadius
-import androidx.compose.ui.geometry.RoundRect
-import androidx.compose.ui.geometry.toRect
-import androidx.compose.ui.graphics.Shape
-import androidx.compose.ui.graphics.SolidColor
-import androidx.compose.ui.graphics.graphicsLayer
-import androidx.compose.ui.graphics.takeOrElse
-import androidx.compose.ui.layout.layout
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.platform.LocalFocusManager
-import androidx.compose.ui.semantics.onClick
-import androidx.compose.ui.semantics.semantics
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.input.ImeAction
-import androidx.compose.ui.text.input.VisualTransformation
-import androidx.compose.ui.unit.Constraints
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.LayoutDirection
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.lerp
-import androidx.compose.ui.unit.offset
-import androidx.compose.ui.util.lerp
-import androidx.compose.ui.zIndex
-import kotlin.coroutines.cancellation.CancellationException
-import kotlin.math.abs
-import kotlin.math.max
-import kotlin.math.min
-import kotlin.math.roundToInt
-import kotlin.math.sign
-import kotlinx.coroutines.delay
-
-/**
- * <a href="https://m3.material.io/components/search/overview" class="external" target="_blank">Material Design search</a>.
- *
- * A search bar represents a floating search field that allows users to enter a keyword or phrase
- * and get relevant information. It can be used as a way to navigate through an app via search
- * queries.
- *
- * An active search bar expands into a search "view" and can be used to display dynamic suggestions.
- *
- * ![Search bar image](https://developer.android.com/images/reference/androidx/compose/material3/search-bar.png)
- *
- * A [SearchBar] expands to occupy the entirety of its allowed size when active. For full-screen
- * behavior as specified by Material guidelines, parent layouts of the [SearchBar] must not pass
- * any [Constraints] that limit its size, and the host activity should set
- * `WindowCompat.setDecorFitsSystemWindows(window, false)`.
- *
- * If this expansion behavior is undesirable, for example on large tablet screens, [DockedSearchBar]
- * can be used instead.
- *
- * @param state the query text to be shown in the search bar's input field
- * @param onSearch the callback to be invoked when the input service triggers the [ImeAction.Search]
- * action.
- * @param active whether this search bar is active
- * @param onActiveChange the callback to be invoked when this search bar's active state is changed
- * @param modifier the [Modifier] to be applied to this search bar
- * @param enabled controls the enabled state of this search bar. When `false`, this component will
- * not respond to user input, and it will appear visually disabled and disabled to accessibility
- * services.
- * @param placeholder the placeholder to be displayed when the search bar's query is empty.
- * @param leadingIcon the leading icon to be displayed at the beginning of the search bar container
- * @param trailingIcon the trailing icon to be displayed at the end of the search bar container
- * @param shape the shape of this search bar when it is not [active]. When [active], the shape will
- * always be [SearchBarDefaults.fullScreenShape].
- * @param colors [SearchBarColors] that will be used to resolve the colors used for this search bar
- * in different states. See [SearchBarDefaults.colors].
- * @param tonalElevation when [SearchBarColors.containerColor] is [ColorScheme.surface], a
- * translucent primary color overlay is applied on top of the container. A higher tonal elevation
- * value will result in a darker color in light theme and lighter color in dark theme. See also:
- * [Surface].
- * @param shadowElevation the elevation for the shadow below the search bar
- * @param windowInsets the window insets that the search bar will respect
- * @param interactionSource an optional hoisted [MutableInteractionSource] for observing and
- * emitting [Interaction]s for this search bar. You can use this to change the search bar's
- * appearance or preview the search bar in different states. Note that if `null` is provided,
- * interactions will still happen internally.
- * @param content the content of this search bar that will be displayed below the input field
- */
-@ExperimentalMaterial3Api
-@Composable
-fun SearchBar(
-    state: TextFieldState,
-    onSearch: () -> Unit,
-    active: Boolean,
-    onActiveChange: (Boolean) -> Unit,
-    modifier: Modifier = Modifier,
-    enabled: Boolean = true,
-    title: @Composable (() -> Unit)? = null,
-    placeholder: @Composable (() -> Unit)? = null,
-    leadingIcon: @Composable (() -> Unit)? = null,
-    trailingIcon: @Composable (() -> Unit)? = null,
-    shape: Shape = SearchBarDefaults.inputFieldShape,
-    colors: SearchBarColors = SearchBarDefaults.colors(),
-    tonalElevation: Dp = SearchBarDefaults.TonalElevation,
-    shadowElevation: Dp = SearchBarDefaults.ShadowElevation,
-    windowInsets: WindowInsets = SearchBarDefaults.windowInsets,
-    interactionSource: MutableInteractionSource? = null,
-    content: @Composable ColumnScope.() -> Unit,
-) {
-    val animationProgress = remember { Animatable(initialValue = if (active) 1f else 0f) }
-    val finalBackProgress = remember { mutableFloatStateOf(Float.NaN) }
-    val firstBackEvent = remember { mutableStateOf<BackEventCompat?>(null) }
-    val currentBackEvent = remember { mutableStateOf<BackEventCompat?>(null) }
-
-    LaunchedEffect(active) {
-        val animationInProgress = animationProgress.value > 0 && animationProgress.value < 1
-        val animationSpec =
-            if (animationInProgress) {
-                AnimationPredictiveBackExitFloatSpec
-            } else if (active) {
-                AnimationEnterFloatSpec
-            } else {
-                AnimationExitFloatSpec
-            }
-        val targetValue = if (active) 1f else 0f
-        if (animationProgress.value != targetValue) {
-            animationProgress.animateTo(targetValue, animationSpec)
-        }
-        if (!active) {
-            finalBackProgress.floatValue = Float.NaN
-            firstBackEvent.value = null
-            currentBackEvent.value = null
-        }
-    }
-
-    val mutatorMutex = remember { MutatorMutex() }
-    PredictiveBackHandler(enabled = active) { progress ->
-        mutatorMutex.mutate {
-            try {
-                finalBackProgress.floatValue = Float.NaN
-                progress.collect { backEvent ->
-                    if (firstBackEvent.value == null) {
-                        firstBackEvent.value = backEvent
-                    }
-                    currentBackEvent.value = backEvent
-                    val interpolatedProgress = EaseOut.transform(backEvent.progress)
-                    animationProgress.snapTo(targetValue = 1 - interpolatedProgress)
-                }
-                finalBackProgress.floatValue = animationProgress.value
-                onActiveChange(false)
-            } catch (e: CancellationException) {
-                animationProgress.animateTo(
-                    targetValue = 1f,
-                    animationSpec = AnimationPredictiveBackExitFloatSpec,
-                )
-                finalBackProgress.floatValue = Float.NaN
-                firstBackEvent.value = null
-                currentBackEvent.value = null
-            }
-        }
-    }
-
-    SearchBarInternal(
-        animationProgress = animationProgress,
-        finalBackProgress = finalBackProgress,
-        firstBackEvent = firstBackEvent,
-        currentBackEvent = currentBackEvent,
-        state = state,
-        onSearch = onSearch,
-        active = active,
-        onActiveChange = onActiveChange,
-        modifier = modifier,
-        enabled = enabled,
-        title = title,
-        placeholder = placeholder,
-        leadingIcon = leadingIcon,
-        trailingIcon = trailingIcon,
-        shape = shape,
-        colors = colors,
-        tonalElevation = tonalElevation,
-        shadowElevation = shadowElevation,
-        windowInsets = windowInsets,
-        interactionSource = interactionSource,
-        content = content,
-    )
-}
-
-@ExperimentalMaterial3Api
-@Composable
-internal fun SearchBarInternal(
-    animationProgress: Animatable<Float, AnimationVector1D>,
-    finalBackProgress: MutableFloatState,
-    firstBackEvent: MutableState<BackEventCompat?>,
-    currentBackEvent: MutableState<BackEventCompat?>,
-    state: TextFieldState,
-    onSearch: () -> Unit,
-    active: Boolean,
-    onActiveChange: (Boolean) -> Unit,
-    modifier: Modifier = Modifier,
-    enabled: Boolean = true,
-    title: @Composable (() -> Unit)? = null,
-    placeholder: @Composable (() -> Unit)? = null,
-    leadingIcon: @Composable (() -> Unit)? = null,
-    trailingIcon: @Composable (() -> Unit)? = null,
-    shape: Shape = SearchBarDefaults.inputFieldShape,
-    colors: SearchBarColors = SearchBarDefaults.colors(),
-    tonalElevation: Dp = SearchBarDefaults.TonalElevation,
-    shadowElevation: Dp = SearchBarDefaults.ShadowElevation,
-    windowInsets: WindowInsets = SearchBarDefaults.windowInsets,
-    interactionSource: MutableInteractionSource? = null,
-    content: @Composable ColumnScope.() -> Unit,
-) {
-    @Suppress("NAME_SHADOWING")
-    val interactionSource = interactionSource ?: remember { MutableInteractionSource() }
-    val focusManager = LocalFocusManager.current
-    val density = LocalDensity.current
-
-    val defaultInputFieldShape = SearchBarDefaults.inputFieldShape
-    val defaultFullScreenShape = SearchBarDefaults.fullScreenShape
-    val useFullScreenShape by remember {
-        derivedStateOf(structuralEqualityPolicy()) { animationProgress.value == 1f }
-    }
-    val animatedShape = remember(useFullScreenShape, shape) {
-        when {
-            shape == defaultInputFieldShape ->
-                // The shape can only be animated if it's the default spec value
-                GenericShape { size, _ ->
-                    val radius = with(density) {
-                        (SearchBarCornerRadius * (1 - animationProgress.value)).toPx()
-                    }
-                    addRoundRect(RoundRect(size.toRect(), CornerRadius(radius)))
-                }
-            useFullScreenShape -> defaultFullScreenShape
-            else -> shape
-        }
-    }
-
-    // The main animation complexity is allowing the component to smoothly expand while keeping the
-    // input field at the same relative location on screen. `Modifier.windowInsetsPadding` does not
-    // support animation and thus is not suitable. Instead, we convert the insets to a padding
-    // applied to the Surface, which gradually becomes padding applied to the input field as the
-    // animation proceeds.
-    val unconsumedInsets = remember { MutableWindowInsets() }
-    val topPadding = remember(density) {
-        derivedStateOf {
-            SearchBarVerticalPadding +
-                unconsumedInsets.asPaddingValues(density).calculateTopPadding()
-        }
-    }
-
-    Surface(
-        shape = animatedShape,
-        color = colors.containerColor,
-        contentColor = contentColorFor(colors.containerColor),
-        tonalElevation = tonalElevation,
-        shadowElevation = shadowElevation,
-        modifier = modifier
-            .padding(horizontal = lerp(SearchBarHorizontalPadding, 0.dp, animationProgress.value))
-            .zIndex(1f)
-            .onConsumedWindowInsetsChanged { consumedInsets ->
-                unconsumedInsets.insets = windowInsets.exclude(consumedInsets)
-            }
-            .consumeWindowInsets(unconsumedInsets)
-            .layout { measurable, constraints ->
-                val animatedTopPadding =
-                    lerp(topPadding.value, 0.dp, animationProgress.value).roundToPx()
-
-                val defaultStartWidth = max(constraints.minWidth, SearchBarMinWidth.roundToPx())
-                    .coerceAtMost(min(constraints.maxWidth, SearchBarMaxWidth.roundToPx()))
-                val defaultStartHeight = max(constraints.minHeight, InputFieldHeight.roundToPx())
-                    .coerceAtMost(constraints.maxHeight)
-                val predictiveBackStartWidth =
-                    (constraints.maxWidth * SearchBarPredictiveBackMinScale).roundToInt()
-                val predictiveBackStartHeight =
-                    (constraints.maxHeight * SearchBarPredictiveBackMinScale).roundToInt()
-                val predictiveBackMultiplier = calculatePredictiveBackMultiplier(
-                    currentBackEvent.value,
-                    animationProgress.value,
-                    finalBackProgress.floatValue,
-                )
-                val startWidth =
-                    lerp(defaultStartWidth, predictiveBackStartWidth, predictiveBackMultiplier)
-                val startHeight =
-                    lerp(defaultStartHeight, predictiveBackStartHeight, predictiveBackMultiplier)
-
-                val endWidth = constraints.maxWidth
-                val endHeight = constraints.maxHeight
-
-                val width = lerp(startWidth, endWidth, animationProgress.value)
-                val height =
-                    lerp(startHeight, endHeight, animationProgress.value) + animatedTopPadding
-
-                val minOffsetMargin = SearchBarPredictiveBackMinMargin.roundToPx()
-                val predictiveBackOffsetX = calculatePredictiveBackOffsetX(
-                    constraints,
-                    minOffsetMargin,
-                    currentBackEvent.value,
-                    animationProgress.value,
-                    predictiveBackMultiplier,
-                )
-                val predictiveBackOffsetY = calculatePredictiveBackOffsetY(
-                    constraints,
-                    minOffsetMargin,
-                    currentBackEvent.value,
-                    firstBackEvent.value,
-                    height,
-                    SearchBarPredictiveBackMaxOffsetY.roundToPx(),
-                    predictiveBackMultiplier,
-                )
-
-                val placeable = measurable.measure(
-                    Constraints
-                        .fixed(width, height)
-                        .offset(
-                            vertical = -animatedTopPadding,
-                        ),
-                )
-                layout(width, height) {
-                    placeable.placeRelative(
-                        predictiveBackOffsetX,
-                        animatedTopPadding + predictiveBackOffsetY,
-                    )
-                }
-            },
-    ) {
-        Column {
-            val animatedInputFieldPadding = remember {
-                AnimatedPaddingValues2(animationProgress.asState(), topPadding)
-            }
-            SearchBarInputField(
-                state = state,
-                onSearch = onSearch,
-                onActiveChange = onActiveChange,
-                modifier = Modifier.padding(paddingValues = animatedInputFieldPadding),
-                enabled = enabled,
-                label = title.takeUnless { active || animationProgress.value > 0 || state.text.isNotEmpty() },
-                placeholder = placeholder,
-                leadingIcon = leadingIcon,
-                trailingIcon = trailingIcon,
-                colors = colors.inputFieldColors,
-                interactionSource = interactionSource,
-            )
-
-            val showResults by remember {
-                derivedStateOf(structuralEqualityPolicy()) { animationProgress.value > 0 }
-            }
-            if (showResults) {
-                Column(Modifier.graphicsLayer { alpha = animationProgress.value }) {
-                    HorizontalDivider(color = colors.dividerColor)
-                    content()
-                }
-            }
-        }
-    }
-
-    val isFocused = interactionSource.collectIsFocusedAsState().value
-    val shouldClearFocus = !active && isFocused
-    LaunchedEffect(active) {
-        if (shouldClearFocus) {
-            // Not strictly needed according to the motion spec, but since the animation already has
-            // a delay, this works around b/261632544.
-            delay(AnimationDelayMillis.toLong())
-            focusManager.clearFocus()
-        }
-    }
-}
-
-private fun calculatePredictiveBackMultiplier(
-    currentBackEvent: BackEventCompat?,
-    progress: Float,
-    finalBackProgress: Float,
-) = when {
-    currentBackEvent == null -> 0f // Not in predictive back at all.
-    finalBackProgress.isNaN() -> 1f // User is currently swiping predictive back.
-    finalBackProgress <= 0 -> 0f // Safety check for divide by zero.
-    else -> progress / finalBackProgress // User has released predictive back swipe.
-}
-
-private fun calculatePredictiveBackOffsetX(
-    constraints: Constraints,
-    minMargin: Int,
-    currentBackEvent: BackEventCompat?,
-    progress: Float,
-    predictiveBackMultiplier: Float,
-): Int {
-    if (currentBackEvent == null || predictiveBackMultiplier == 0f) {
-        return 0
-    }
-    val directionMultiplier = if (currentBackEvent.swipeEdge == BackEventCompat.EDGE_LEFT) 1 else -1
-    val maxOffsetX =
-        (constraints.maxWidth * SearchBarPredictiveBackMaxOffsetXRatio) - minMargin
-    val interpolatedOffsetX = maxOffsetX * (1 - progress)
-    return (interpolatedOffsetX * predictiveBackMultiplier * directionMultiplier).roundToInt()
-}
-
-private fun calculatePredictiveBackOffsetY(
-    constraints: Constraints,
-    minMargin: Int,
-    currentBackEvent: BackEventCompat?,
-    firstBackEvent: BackEventCompat?,
-    height: Int,
-    maxOffsetY: Int,
-    predictiveBackMultiplier: Float,
-): Int {
-    if (firstBackEvent == null || currentBackEvent == null || predictiveBackMultiplier == 0f) {
-        return 0
-    }
-    val availableVerticalSpace = max(0, (constraints.maxHeight - height) / 2 - minMargin)
-    val adjustedMaxOffsetY = min(availableVerticalSpace, maxOffsetY)
-    val yDelta = currentBackEvent.touchY - firstBackEvent.touchY
-    val yProgress = abs(yDelta) / constraints.maxHeight
-    val directionMultiplier = sign(yDelta)
-    val interpolatedOffsetY = lerp(0, adjustedMaxOffsetY, yProgress)
-    return (interpolatedOffsetY * predictiveBackMultiplier * directionMultiplier).roundToInt()
-}
-
-@Composable
-private fun SearchBarInputField(
-    state: TextFieldState,
-    onSearch: () -> Unit,
-    onActiveChange: (Boolean) -> Unit,
-    modifier: Modifier = Modifier,
-    enabled: Boolean = true,
-    label: @Composable (() -> Unit)? = null,
-    placeholder: @Composable (() -> Unit)? = null,
-    leadingIcon: @Composable (() -> Unit)? = null,
-    trailingIcon: @Composable (() -> Unit)? = null,
-    colors: TextFieldColors = SearchBarDefaults.inputFieldColors(),
-    interactionSource: MutableInteractionSource? = null,
-) {
-    @Suppress("NAME_SHADOWING")
-    val interactionSource = interactionSource ?: remember { MutableInteractionSource() }
-    val focusRequester = remember { FocusRequester() }
-    val focused by interactionSource.collectIsFocusedAsState()
-    val textColor = LocalTextStyle.current.color.takeOrElse {
-        if (focused) colors.focusedTextColor else colors.unfocusedTextColor
-    }
-
-    BasicTextField2(
-        state = state,
-        modifier = modifier
-            .height(InputFieldHeight)
-            .fillMaxWidth()
-            .focusRequester(focusRequester)
-            .onFocusChanged { if (it.isFocused) onActiveChange(true) }
-            .semantics {
-                onClick {
-                    focusRequester.requestFocus()
-                    true
-                }
-            },
-        enabled = enabled,
-        lineLimits = TextFieldLineLimits.SingleLine,
-        textStyle = LocalTextStyle.current.merge(TextStyle(color = textColor)),
-        cursorBrush = SolidColor(colors.cursorColor),
-        keyboardOptions = KeyboardOptions(imeAction = ImeAction.Search),
-        keyboardActions = KeyboardActions(onSearch = { onSearch() }),
-        interactionSource = interactionSource,
-        decorator = @Composable { innerTextField ->
-            TextFieldDefaults.DecorationBox(
-                value = state.text.toString(),
-                innerTextField = innerTextField,
-                enabled = enabled,
-                singleLine = true,
-                visualTransformation = VisualTransformation.None,
-                interactionSource = interactionSource,
-                label = label,
-                placeholder = placeholder,
-                leadingIcon = leadingIcon?.let { leading ->
-                    {
-                        Box(Modifier.offset(x = SearchBarIconOffsetX)) { leading() }
-                    }
-                },
-                trailingIcon = trailingIcon?.let { trailing ->
-                    {
-                        Box(Modifier.offset(x = -SearchBarIconOffsetX)) { trailing() }
-                    }
-                },
-                shape = SearchBarDefaults.inputFieldShape,
-                colors = colors,
-                contentPadding = TextFieldDefaults.contentPaddingWithoutLabel(),
-                container = {},
-            )
-        },
-    )
-}
-
-@Stable
-private class AnimatedPaddingValues2(
-    val animationProgress: State<Float>,
-    val topPadding: State<Dp>,
-) : PaddingValues {
-    override fun calculateTopPadding(): Dp = topPadding.value * animationProgress.value
-    override fun calculateBottomPadding(): Dp = SearchBarVerticalPadding * animationProgress.value
-
-    override fun calculateLeftPadding(layoutDirection: LayoutDirection): Dp = 0.dp
-    override fun calculateRightPadding(layoutDirection: LayoutDirection): Dp = 0.dp
-}
-
-// Measurement specs
-private val SearchBarCornerRadius: Dp = InputFieldHeight / 2
-internal val SearchBarMinWidth: Dp = 360.dp
-private val SearchBarMaxWidth: Dp = 720.dp
-internal val SearchBarVerticalPadding: Dp = 8.dp
-internal val SearchBarHorizontalPadding: Dp = 16.dp
-
-// Search bar has 16dp padding between icons and start/end, while by default text field has 12dp.
-private val SearchBarIconOffsetX: Dp = 4.dp
-private const val SearchBarPredictiveBackMinScale: Float = 9f / 10f
-private val SearchBarPredictiveBackMinMargin: Dp = 8.dp
-private const val SearchBarPredictiveBackMaxOffsetXRatio: Float = 1f / 20f
-private val SearchBarPredictiveBackMaxOffsetY: Dp = 24.dp
-
-// Animation specs
-private const val AnimationEnterDurationMillis: Int = 600
-private const val AnimationExitDurationMillis: Int = 350
-private const val AnimationDelayMillis: Int = 100
-private val AnimationEnterEasing = CubicBezierEasing(0.05f, 0.7f, 0.1f, 1.0f)
-private val AnimationExitEasing = CubicBezierEasing(0.0f, 1.0f, 0.0f, 1.0f)
-private val AnimationEnterFloatSpec: FiniteAnimationSpec<Float> = tween(
-    durationMillis = AnimationEnterDurationMillis,
-    delayMillis = AnimationDelayMillis,
-    easing = AnimationEnterEasing,
-)
-private val AnimationExitFloatSpec: FiniteAnimationSpec<Float> = tween(
-    durationMillis = AnimationExitDurationMillis,
-    delayMillis = AnimationDelayMillis,
-    easing = AnimationExitEasing,
-)
-private val AnimationPredictiveBackExitFloatSpec: FiniteAnimationSpec<Float> = tween(
-    durationMillis = AnimationExitDurationMillis,
-    easing = AnimationExitEasing,
-)
@@ -10,11 +10,8 @@ import androidx.compose.foundation.Canvas
 import androidx.compose.foundation.background
 import androidx.compose.foundation.gestures.AnchoredDraggableState
 import androidx.compose.foundation.gestures.DraggableAnchors
-import androidx.compose.foundation.gestures.awaitEachGesture
-import androidx.compose.foundation.gestures.awaitFirstDown
-import androidx.compose.foundation.gestures.awaitHorizontalTouchSlopOrCancellation
+import androidx.compose.foundation.gestures.anchoredHorizontalDraggable
 import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.foundation.gestures.horizontalDrag
 import androidx.compose.foundation.gestures.snapTo
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
@@ -42,17 +39,12 @@ import androidx.compose.ui.graphics.RectangleShape
 import androidx.compose.ui.graphics.TileMode
 import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.input.pointer.positionChange
-import androidx.compose.ui.input.pointer.util.VelocityTracker
-import androidx.compose.ui.input.pointer.util.addPointerInputChange
 import androidx.compose.ui.layout.layout
-import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.layout.onSizeChanged
 import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.platform.LocalLayoutDirection
 import androidx.compose.ui.unit.Constraints
 import androidx.compose.ui.unit.Density
 import androidx.compose.ui.unit.IntOffset
-import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.util.lerp
 import com.hippo.ehviewer.ui.tools.animateFloatMergeOneWayPredictiveBackAsState
@@ -63,7 +55,6 @@ import kotlinx.coroutines.launch
 private val AnimationSpec = TweenSpec<Float>(durationMillis = 256)
 private const val DrawerPositionalThreshold = 0.5f
 private val DrawerVelocityThreshold = 400.dp
-private val ContainerWidth = 360.0.dp

@Suppress("NotCloseable")
@Stable
@@ -236,7 +227,7 @@ class DrawerState2(
 * @param confirmStateChange Optional callback invoked to confirm or veto a pending state change.
 */
@Composable
-fun rememberDrawerState(
+fun rememberDrawerState2(
    initialValue: DrawerValue,
    confirmStateChange: (DrawerValue) -> Boolean = { true },
 ): DrawerState2 {
@@ -246,69 +237,40 @@ fun rememberDrawerState(
 }

@Composable
-fun ModalNavigationDrawer(
+fun ModalSideDrawer(
    drawerContent: @Composable () -> Unit,
    modifier: Modifier = Modifier,
-    drawerState: DrawerState2 = rememberDrawerState(DrawerValue.Closed),
+    drawerState: DrawerState2 = rememberDrawerState2(DrawerValue.Closed),
    gesturesEnabled: Boolean = true,
    scrimColor: Color = DrawerDefaults.scrimColor,
    content: @Composable () -> Unit,
 ) {
    val scope = rememberCoroutineScope()
    val density = LocalDensity.current
-    var minValue by remember { mutableFloatStateOf(-with(density) { ContainerWidth.toPx() }) }
-    val maxValue = 0f
+    var maxValue by remember { mutableFloatStateOf(with(density) { DrawerDefaults.MaximumDrawerWidth.toPx() }) }
+    val minValue = 0f

    SideEffect {
        drawerState.density = density
        drawerState.anchoredDraggableState.updateAnchors(
            DraggableAnchors {
-                DrawerValue.Closed at minValue
-                DrawerValue.Open at maxValue
+                DrawerValue.Closed at maxValue
+                DrawerValue.Open at minValue
            },
        )
    }

-    val isRtl = LocalLayoutDirection.current == LayoutDirection.Rtl
-    val velocityTracker = remember { VelocityTracker() }
-    val dragModifier = if (gesturesEnabled) {
-        Modifier.pointerInput(isRtl) {
-            val multiplier = if (isRtl) -1 else 1
-            awaitEachGesture {
-                fun canConsume(slop: Float) = (slop > 0 && drawerState.isClosed) || (slop < 0 && drawerState.isOpen)
-                val down = awaitFirstDown(requireUnconsumed = false)
-                var ignore = false
-                val drag = awaitHorizontalTouchSlopOrCancellation(down.id) { change, over ->
-                    val overSlop = over * multiplier
-                    val canConsume = canConsume(overSlop)
-                    if (canConsume && !ignore) {
-                        velocityTracker.addPointerInputChange(change)
-                        change.consume()
-                        drawerState.anchoredDraggableState.dispatchRawDelta(overSlop)
-                    } else {
-                        ignore = true
-                    }
-                }
-                if (drag != null) {
-                    horizontalDrag(drag.id) {
-                        velocityTracker.addPointerInputChange(it)
-                        drawerState.anchoredDraggableState.dispatchRawDelta(it.positionChange().x * multiplier)
-                    }
-                    val velocity = velocityTracker.calculateVelocity()
-                    velocityTracker.resetTracking()
-                    scope.launch {
-                        drawerState.anchoredDraggableState.settle(velocity.x * multiplier)
-                    }
-                }
-            }
-        }
-    } else {
-        Modifier
-    }
-    Box(modifier.fillMaxSize().then(dragModifier)) {
+    Box(
+        modifier.fillMaxSize().anchoredHorizontalDraggable(
+            state = drawerState.anchoredDraggableState,
+            enableDragFromStartToEnd = drawerState.isOpen,
+            enableDragFromEndToStart = drawerState.isClosed,
+            enabled = gesturesEnabled,
+        ),
+    ) {
        val radius by remember {
            snapshotFlow {
-                val step = calculateFraction(minValue, maxValue, drawerState.currentOffset)
+                val step = calculateFraction(maxValue, minValue, drawerState.currentOffset)
                lerp(0, 10, step).dp
            }
        }.collectAsState(0.dp)
@@ -330,145 +292,7 @@ fun ModalNavigationDrawer(
                }
            },
            fraction = {
-                calculateFraction(minValue, maxValue, drawerState.requireOffset())
-            },
-            color = scrimColor,
-        )
-        val predictiveState by animateFloatMergeOneWayPredictiveBackAsState(drawerState.isOpen) {
-            drawerState.close()
-        }
-        val absoluteElevation = LocalAbsoluteTonalElevation.current + DrawerDefaults.ModalDrawerElevation
-        val predictiveModifier = if (drawerState.isOpen) {
-            if (predictiveState > 0) {
-                Modifier.layout { measurable, constraints ->
-                    val placeable = measurable.measure(constraints)
-                    val multiplierX = lerp(1f, 1.05f, predictiveState)
-                    val multiplierY = lerp(1f, 0.95f, predictiveState)
-                    val scaledWidth = (multiplierX * placeable.width).roundToInt()
-                    val scaledHeight = (multiplierY * placeable.height).roundToInt()
-                    val reMeasured = measurable.measure(Constraints.fixed(scaledWidth, scaledHeight))
-                    layout(scaledWidth, scaledHeight) {
-                        reMeasured.placeRelative(scaledWidth - placeable.width, 0)
-                    }
-                }.background(
-                    color = MaterialTheme.colorScheme.surfaceColorAtElevation(absoluteElevation),
-                    shape = DrawerDefaults.shape,
-                )
-            } else {
-                Modifier.graphicsLayer {
-                    val scale = lerp(1f, 0.95f, -predictiveState)
-                    scaleX = scale
-                    scaleY = scale
-                }.offset {
-                    IntOffset(lerp(0f, minValue * 0.05f, -predictiveState).roundToInt(), 0)
-                }
-            }
-        } else {
-            Modifier.onGloballyPositioned {
-                val w = it.size.width
-                if (w != 0) {
-                    minValue = -it.size.width.toFloat()
-                }
-            }
-        }
-        Box(
-            modifier = Modifier.offset {
-                IntOffset(drawerState.requireOffset().roundToInt(), 0)
-            } then predictiveModifier.align(Alignment.CenterStart),
-            contentAlignment = Alignment.CenterEnd,
-        ) {
-            drawerContent()
-        }
-    }
-}
-
-@Composable
-fun SideDrawer(
-    drawerContent: @Composable () -> Unit,
-    modifier: Modifier = Modifier,
-    drawerState: DrawerState2 = rememberDrawerState(DrawerValue.Closed),
-    gesturesEnabled: Boolean = true,
-    scrimColor: Color = DrawerDefaults.scrimColor,
-    content: @Composable () -> Unit,
-) {
-    val scope = rememberCoroutineScope()
-    val density = LocalDensity.current
-    var minValue by remember { mutableFloatStateOf(with(density) { ContainerWidth.toPx() }) }
-    val maxValue = 0f
-
-    SideEffect {
-        drawerState.density = density
-        drawerState.anchoredDraggableState.updateAnchors(
-            DraggableAnchors {
-                DrawerValue.Closed at minValue
-                DrawerValue.Open at maxValue
-            },
-        )
-    }
-
-    val isRtl = LocalLayoutDirection.current == LayoutDirection.Rtl
-    val velocityTracker = remember { VelocityTracker() }
-    val dragModifier = if (gesturesEnabled) {
-        Modifier.pointerInput(isRtl) {
-            val multiplier = if (isRtl) -1 else 1
-            awaitEachGesture {
-                fun canConsume(slop: Float) = (slop > 0 && drawerState.isOpen) || (slop < 0 && drawerState.isClosed)
-                val down = awaitFirstDown(requireUnconsumed = false)
-                var ignore = false
-                val drag = awaitHorizontalTouchSlopOrCancellation(down.id) { change, over ->
-                    val overSlop = over * multiplier
-                    val canConsume = canConsume(overSlop)
-                    if (canConsume && !ignore) {
-                        velocityTracker.addPointerInputChange(change)
-                        change.consume()
-                        drawerState.anchoredDraggableState.dispatchRawDelta(overSlop)
-                    } else {
-                        ignore = true
-                    }
-                }
-                if (drag != null) {
-                    horizontalDrag(drag.id) {
-                        velocityTracker.addPointerInputChange(it)
-                        drag.consume()
-                        drawerState.anchoredDraggableState.dispatchRawDelta(it.positionChange().x * multiplier)
-                    }
-                    val velocity = velocityTracker.calculateVelocity()
-                    velocityTracker.resetTracking()
-                    scope.launch {
-                        drawerState.anchoredDraggableState.settle(velocity.x * multiplier)
-                    }
-                }
-            }
-        }
-    } else {
-        Modifier
-    }
-    Box(modifier.fillMaxSize().then(dragModifier)) {
-        val radius by remember {
-            snapshotFlow {
-                val step = calculateFraction(minValue, maxValue, drawerState.currentOffset)
-                lerp(0, 10, step).dp
-            }
-        }.collectAsState(0.dp)
-        val blurModifier = Modifier.graphicsLayer {
-            if (radius != 0.dp) {
-                renderEffect = BlurEffect(radius.toPx(), radius.toPx(), TileMode.Clamp)
-                shape = RectangleShape
-                clip = true
-            }
-        }
-        Box(modifier = blurModifier) {
-            content()
-        }
-        Scrim(
-            open = drawerState.isOpen,
-            onClose = {
-                if (gesturesEnabled && drawerState.confirmStateChange(DrawerValue.Closed)) {
-                    scope.launch { drawerState.close() }
-                }
-            },
-            fraction = {
-                calculateFraction(minValue, maxValue, drawerState.requireOffset())
+                calculateFraction(maxValue, minValue, drawerState.requireOffset())
            },
            color = scrimColor,
        )
@@ -486,7 +310,7 @@ fun SideDrawer(
                    val scaledHeight = (multiplierY * placeable.height).roundToInt()
                    val reMeasured = measurable.measure(Constraints.fixed(scaledWidth, scaledHeight))
                    layout(scaledWidth, scaledHeight) {
-                        reMeasured.placeRelative(-(scaledWidth - placeable.width), 0)
+                        reMeasured.placeRelative(placeable.width - scaledWidth, 0)
                    }
                }.background(
                    color = MaterialTheme.colorScheme.surfaceColorAtElevation(absoluteElevation),
@@ -498,14 +322,20 @@ fun SideDrawer(
                    scaleX = scale
                    scaleY = scale
                }.offset {
-                    IntOffset(lerp(0f, minValue * 0.05f, predictiveState).roundToInt(), 0)
+                    IntOffset(lerp(0f, maxValue * 0.05f, predictiveState).roundToInt(), 0)
                }
            }
        } else {
-            Modifier.onGloballyPositioned {
-                val w = it.size.width
-                if (w != 0) {
-                    minValue = it.size.width.toFloat()
+            Modifier.onSizeChanged {
+                val width = it.width
+                if (width != 0) {
+                    maxValue = width.toFloat()
+                    drawerState.anchoredDraggableState.updateAnchors(
+                        DraggableAnchors {
+                            DrawerValue.Closed at maxValue
+                            DrawerValue.Open at minValue
+                        },
+                    )
                }
            }
        }
@@ -0,0 +1,255 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.material3.fork
+
+import androidx.annotation.FloatRange
+import androidx.compose.animation.core.SpringSpec
+import androidx.compose.animation.core.exponentialDecay
+import androidx.compose.foundation.gestures.AnchoredDraggableState
+import androidx.compose.foundation.gestures.DraggableAnchors
+import androidx.compose.foundation.gestures.Orientation
+import androidx.compose.foundation.gestures.anchoredHorizontalDraggable
+import androidx.compose.foundation.gestures.animateTo
+import androidx.compose.foundation.gestures.draggableAnchors
+import androidx.compose.foundation.gestures.snapTo
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.RowScope
+import androidx.compose.material3.SwipeToDismissBoxDefaults
+import androidx.compose.material3.SwipeToDismissBoxValue
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.Saver
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.Density
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.CancellationException
+
+private val SnapAnimationSpec = SpringSpec<Float>()
+
+// TODO: Update to M3 spec once it's available
+private val DecayAnimationSpec = exponentialDecay<Float>()
+
+/**
+ * State of the [SwipeToDismissBox] composable.
+ *
+ * @param initialValue The initial value of the state.
+ * @param density The density that this state can use to convert values to and from dp.
+ * @param confirmValueChange Optional callback invoked to confirm or veto a pending state change.
+ * @param positionalThreshold The positional threshold to be used when calculating the target state
+ * while a swipe is in progress and when settling after the swipe ends. This is the distance from
+ * the start of a transition. It will be, depending on the direction of the interaction, added or
+ * subtracted from/to the origin offset. It should always be a positive value.
+ */
+class SwipeToDismissBoxState(
+    initialValue: SwipeToDismissBoxValue,
+    internal val density: Density,
+    confirmValueChange: (SwipeToDismissBoxValue) -> Boolean = { true },
+    positionalThreshold: (totalDistance: Float) -> Float,
+) {
+    internal val anchoredDraggableState =
+        AnchoredDraggableState(
+            initialValue = initialValue,
+            snapAnimationSpec = SnapAnimationSpec,
+            decayAnimationSpec = DecayAnimationSpec,
+            confirmValueChange = confirmValueChange,
+            positionalThreshold = positionalThreshold,
+            velocityThreshold = { with(density) { DismissVelocityThreshold.toPx() } },
+        )
+
+    internal val offset: Float get() = anchoredDraggableState.offset
+
+    /**
+     * Require the current offset.
+     *
+     * @throws IllegalStateException If the offset has not been initialized yet
+     */
+    fun requireOffset(): Float = anchoredDraggableState.requireOffset()
+
+    /**
+     * The current state value of the [SwipeToDismissBoxState].
+     */
+    val currentValue: SwipeToDismissBoxValue get() = anchoredDraggableState.currentValue
+
+    /**
+     * The target state. This is the closest state to the current offset (taking into account
+     * positional thresholds). If no interactions like animations or drags are in progress, this
+     * will be the current state.
+     */
+    val targetValue: SwipeToDismissBoxValue get() = anchoredDraggableState.targetValue
+
+    /**
+     * The fraction of the progress going from currentValue to targetValue, within [0f..1f] bounds.
+     */
+    @get:FloatRange(from = 0.0, to = 1.0)
+    val progress: Float get() = anchoredDraggableState.progress(anchoredDraggableState.settledValue, anchoredDraggableState.targetValue)
+
+    /**
+     * The direction (if any) in which the composable has been or is being dismissed.
+     *
+     * Use this to change the background of the [SwipeToDismissBox] if you want different actions
+     * on each side.
+     */
+    val dismissDirection: SwipeToDismissBoxValue
+        get() = when {
+            offset == 0f || offset.isNaN() -> SwipeToDismissBoxValue.Settled
+            offset > 0f -> SwipeToDismissBoxValue.StartToEnd
+            else -> SwipeToDismissBoxValue.EndToStart
+        }
+
+    /**
+     * Set the state without any animation and suspend until it's set
+     *
+     * @param targetValue The new target value
+     */
+    suspend fun snapTo(targetValue: SwipeToDismissBoxValue) {
+        anchoredDraggableState.snapTo(targetValue)
+    }
+
+    /**
+     * Reset the component to the default position with animation and suspend until it if fully
+     * reset or animation has been cancelled. This method will throw [CancellationException] if
+     * the animation is interrupted
+     *
+     * @return the reason the reset animation ended
+     */
+    suspend fun reset() = anchoredDraggableState.animateTo(
+        targetValue = SwipeToDismissBoxValue.Settled,
+    )
+
+    /**
+     * Dismiss the component in the given [direction], with an animation and suspend. This method
+     * will throw [CancellationException] if the animation is interrupted
+     *
+     * @param direction The dismiss direction.
+     */
+    suspend fun dismiss(direction: SwipeToDismissBoxValue) {
+        anchoredDraggableState.animateTo(targetValue = direction)
+    }
+
+    companion object {
+
+        /**
+         * The default [Saver] implementation for [SwipeToDismissBoxState].
+         */
+        fun Saver(
+            confirmValueChange: (SwipeToDismissBoxValue) -> Boolean,
+            positionalThreshold: (totalDistance: Float) -> Float,
+            density: Density,
+        ) = Saver<SwipeToDismissBoxState, SwipeToDismissBoxValue>(
+            save = { it.currentValue },
+            restore = {
+                SwipeToDismissBoxState(
+                    it,
+                    density,
+                    confirmValueChange,
+                    positionalThreshold,
+                )
+            },
+        )
+    }
+}
+
+/**
+ * Create and [remember] a [SwipeToDismissBoxState].
+ *
+ * @param initialValue The initial value of the state.
+ * @param confirmValueChange Optional callback invoked to confirm or veto a pending state change.
+ * @param positionalThreshold The positional threshold to be used when calculating the target state
+ * while a swipe is in progress and when settling after the swipe ends. This is the distance from
+ * the start of a transition. It will be, depending on the direction of the interaction, added or
+ * subtracted from/to the origin offset. It should always be a positive value.
+ */
+@Composable
+fun rememberSwipeToDismissBoxState(
+    initialValue: SwipeToDismissBoxValue = SwipeToDismissBoxValue.Settled,
+    confirmValueChange: (SwipeToDismissBoxValue) -> Boolean = { true },
+    positionalThreshold: (totalDistance: Float) -> Float =
+        SwipeToDismissBoxDefaults.positionalThreshold,
+): SwipeToDismissBoxState {
+    val density = LocalDensity.current
+    return rememberSaveable(
+        saver = SwipeToDismissBoxState.Saver(
+            confirmValueChange = confirmValueChange,
+            density = density,
+            positionalThreshold = positionalThreshold,
+        ),
+    ) {
+        SwipeToDismissBoxState(initialValue, density, confirmValueChange, positionalThreshold)
+    }
+}
+
+/**
+ * A composable that can be dismissed by swiping left or right.
+ *
+ * @param state The state of this component.
+ * @param backgroundContent A composable that is stacked behind the [content] and is exposed when
+ * the content is swiped. You can/should use the [state] to have different backgrounds on each side.
+ * @param modifier Optional [Modifier] for this component.
+ * @param enableDismissFromStartToEnd Whether SwipeToDismissBox can be dismissed from start to end.
+ * @param enableDismissFromEndToStart Whether SwipeToDismissBox can be dismissed from end to start.
+ * @param gesturesEnabled Whether swipe-to-dismiss can be interacted by gestures.
+ * @param content The content that can be dismissed.
+ */
+@Composable
+fun SwipeToDismissBox(
+    state: SwipeToDismissBoxState,
+    backgroundContent: @Composable RowScope.() -> Unit,
+    modifier: Modifier = Modifier,
+    enableDismissFromStartToEnd: Boolean = true,
+    enableDismissFromEndToStart: Boolean = true,
+    gesturesEnabled: Boolean = true,
+    content: @Composable RowScope.() -> Unit,
+) {
+    Box(
+        modifier
+            .anchoredHorizontalDraggable(
+                state = state.anchoredDraggableState,
+                enableDragFromStartToEnd = enableDismissFromStartToEnd,
+                enableDragFromEndToStart = enableDismissFromEndToStart,
+                enabled = gesturesEnabled && state.currentValue == SwipeToDismissBoxValue.Settled,
+            ),
+        propagateMinConstraints = true,
+    ) {
+        Row(
+            content = backgroundContent,
+            modifier = Modifier.matchParentSize(),
+        )
+        Row(
+            content = content,
+            modifier = Modifier.draggableAnchors(
+                state.anchoredDraggableState,
+                Orientation.Horizontal,
+            ) { size, _ ->
+                val width = size.width.toFloat()
+                return@draggableAnchors DraggableAnchors {
+                    SwipeToDismissBoxValue.Settled at 0f
+                    if (enableDismissFromStartToEnd) {
+                        SwipeToDismissBoxValue.StartToEnd at width
+                    }
+                    if (enableDismissFromEndToStart) {
+                        SwipeToDismissBoxValue.EndToStart at -width
+                    }
+                } to state.targetValue
+            },
+        )
+    }
+}
+
+private val DismissVelocityThreshold = 125.dp
@@ -56,7 +56,8 @@ open class SubsamplingScaleImageView @JvmOverloads constructor(
    private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)

    // Current quickscale state
-    private val quickScaleThreshold: Float
+    private val quickScaleThreshold =
+        TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 20F, context.resources.displayMetrics)

    // Long click handler
    private var longClickJob: Job? = null
@@ -85,9 +86,6 @@ open class SubsamplingScaleImageView @JvmOverloads constructor(
    @ScaleType
    private var minimumScaleType = SCALE_TYPE_CENTER_INSIDE

-    // Whether to crop borders.
-    private var cropBorders = false
-
    // Gesture detection settings
    private var panEnabled = true

@@ -186,15 +184,6 @@ open class SubsamplingScaleImageView @JvmOverloads constructor(
    var isReady = false
        private set

-    /**
-     * Call to find whether the main image (base layer tiles where relevant) have been loaded. Before
-     * this event the view is blank unless a preview was provided.
-     *
-     * @return true if the main image (not the preview) has been loaded and is ready to display.
-     */
-    var isImageLoaded = false
-        private set
-
    // Event listener
    private var onImageEventListener: OnImageEventListener? = null

@@ -218,11 +207,7 @@ open class SubsamplingScaleImageView @JvmOverloads constructor(
    private val mtrx = Matrix()

    init {
-        setMinimumDpi(160)
-        setDoubleTapZoomDpi(160)
        setGestureDetector(context)
-        quickScaleThreshold =
-            TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 20F, context.resources.displayMetrics)
    }

    /**
@@ -270,7 +255,6 @@ open class SubsamplingScaleImageView @JvmOverloads constructor(
            sHeight = 0
            srcRect.setEmpty()
            isReady = false
-            isImageLoaded = false
            bitmap = null
            bitmapIsCached = false
        }
@@ -768,19 +752,13 @@ open class SubsamplingScaleImageView @JvmOverloads constructor(
        }
    }

-    /**
-     * Checks whether the base layer of tiles or full size bitmap is ready.
-     */
-    private val isBaseLayerReady: Boolean
-        get() = bitmap != null
-
    /**
     * Check whether view and image dimensions are known and either a preview, full size image or
     * base layer tiles are loaded. First time, send ready event to listener. The next draw will
     * display an image.
     */
    private fun checkReady(): Boolean {
-        val ready = width > 0 && height > 0 && sWidth > 0 && sHeight > 0 && (bitmap != null || isBaseLayerReady)
+        val ready = width > 0 && height > 0 && sWidth > 0 && sHeight > 0 && bitmap != null
        if (!isReady && ready) {
            preDraw()
            isReady = true
@@ -789,19 +767,6 @@ open class SubsamplingScaleImageView @JvmOverloads constructor(
        return ready
    }

-    /**
-     * Check whether either the full size bitmap or base layer tiles are loaded. First time, send image
-     * loaded event to listener.
-     */
-    private fun checkImageLoaded(): Boolean {
-        val imageLoaded = isBaseLayerReady
-        if (!isImageLoaded && imageLoaded) {
-            preDraw()
-            isImageLoaded = true
-        }
-        return imageLoaded
-    }
-
    /**
     * Sets scale and translate ready for the next draw.
     */
@@ -832,13 +797,14 @@ open class SubsamplingScaleImageView @JvmOverloads constructor(
     * is set so one dimension fills the view and the image is centered on the other dimension. Used to calculate what the target of an
     * animation should be.
     *
-     * @param _center Whether the image should be centered in the dimension it's too small to fill. While animating this can be false to avoid changes in direction as bounds are reached.
+     * @param maybeCenter Whether the image should be centered in the dimension it's too small to fill. While animating this can be false to avoid changes in direction as bounds are reached.
     * @param sat    The scale we want and the translation we're aiming for. The values are adjusted to be valid.
     */
-    private fun fitToBounds(_center: Boolean, sat: ScaleAndTranslate) {
-        var center = _center
-        if (panLimit == PAN_LIMIT_OUTSIDE && isReady) {
-            center = false
+    private fun fitToBounds(maybeCenter: Boolean, sat: ScaleAndTranslate) {
+        val center = if (panLimit == PAN_LIMIT_OUTSIDE && isReady) {
+            false
+        } else {
+            maybeCenter
        }
        val vTranslate = sat.vTranslate
        val scale = limitedScale(sat.scale)
@@ -920,21 +886,9 @@ open class SubsamplingScaleImageView @JvmOverloads constructor(
        this.bitmap = bitmap
        sWidth = srcRect.width()
        sHeight = srcRect.height()
-        val ready = checkReady()
-        val imageLoaded = checkImageLoaded()
-        if (ready || imageLoaded) {
-            invalidate()
-            requestLayout()
-        }
-    }
-
-    /**
-     * Set border crop of non-filled (white or black) content.
-     *
-     * @param cropBorders Whether to crop image borders.
-     */
-    fun setCropBorders(cropBorders: Boolean) {
-        this.cropBorders = cropBorders
+        checkReady()
+        invalidate()
+        requestLayout()
    }

    /**
@@ -987,7 +941,7 @@ open class SubsamplingScaleImageView @JvmOverloads constructor(
     * @param sTarget target object for result. The same instance is also returned.
     * @return a coordinate representing the corresponding source coordinate. This is the same instance passed to the sTarget param.
     */
-    fun viewToSourceCoord(vx: Float, vy: Float, sTarget: PointF = PointF()): PointF? {
+    private fun viewToSourceCoord(vx: Float, vy: Float, sTarget: PointF = PointF()): PointF? {
        if (vTranslate == null) {
            return null
        }
@@ -1027,7 +981,7 @@ open class SubsamplingScaleImageView @JvmOverloads constructor(
     * @param vTarget target object for result. The same instance is also returned.
     * @return view coordinates. This is the same instance passed to the vTarget param.
     */
-    fun sourceToViewCoord(sx: Float, sy: Float, vTarget: PointF = PointF()): PointF? {
+    private fun sourceToViewCoord(sx: Float, sy: Float, vTarget: PointF = PointF()): PointF? {
        if (vTranslate == null) {
            return null
        }
@@ -1336,8 +1290,7 @@ open class SubsamplingScaleImageView @JvmOverloads constructor(
    }

    /**
-     * Add a listener allowing notification of load and error events. Extend [DefaultOnImageEventListener]
-     * to simplify implementation.
+     * Add a listener allowing notification of load and error events.
     *
     * @param onImageEventListener an [OnImageEventListener] instance.
     */
@@ -1391,7 +1344,7 @@ open class SubsamplingScaleImageView @JvmOverloads constructor(
    /**
     * An event listener, allowing subclasses and activities to be notified of significant events.
     */
-    interface OnImageEventListener {
+    fun interface OnImageEventListener {
        /**
         * Called when the dimensions of the image and view are known, and either a preview image,
         * the full size image, or base layer tiles are loaded. This indicates the scale and translate
@@ -1399,16 +1352,6 @@ open class SubsamplingScaleImageView @JvmOverloads constructor(
         * graphic, or inform a subclass that it is safe to draw overlays.
         */
        fun onReady()
-
-        /**
-         * Indicates an error initiliasing the decoder when using a tiling, or when loading the full
-         * size bitmap when tiling is disabled. This method cannot be relied upon; certain encoding
-         * types of supported image formats can result in corrupt or blank images being loaded and
-         * displayed with no detectable error.
-         *
-         * @param e The exception thrown. This error is also logged by the view.
-         */
-        fun onImageLoadError(e: Exception)
    }

    /**
@@ -1467,14 +1410,6 @@ open class SubsamplingScaleImageView @JvmOverloads constructor(

    private data class ScaleAndTranslate(var scale: Float, val vTranslate: PointF)

-    /**
-     * Default implementation of [OnImageEventListener] for extension. This does nothing in any method.
-     */
-    open class DefaultOnImageEventListener : OnImageEventListener {
-        override fun onReady() {}
-        override fun onImageLoadError(e: Exception) {}
-    }
-
    /**
     * Builder class used to set additional options for a scale animation. Create an instance using [.animateScale],
     * then set your options and call [.start].
@@ -1723,7 +1658,5 @@ open class SubsamplingScaleImageView @JvmOverloads constructor(
         * State change originated from a double tap zoom anim.
         */
        const val ORIGIN_DOUBLE_TAP_ZOOM = 4
-
-        private val TAG = SubsamplingScaleImageView::class.java.simpleName
    }
 }
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.accompanist.systemuicontroller
+
+import android.app.Activity
+import android.content.Context
+import android.content.ContextWrapper
+import android.view.View
+import android.view.Window
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.window.DialogWindowProvider
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
+
+/**
+ * A class which provides easy-to-use utilities for updating the System UI bar
+ * colors within Jetpack Compose.
+ */
+@Stable
+interface SystemUiController {
+
+    /**
+     * Control for the behavior of the system bars. This value should be one of the
+     * [WindowInsetsControllerCompat] behavior constants:
+     * [WindowInsetsControllerCompat.BEHAVIOR_SHOW_BARS_BY_TOUCH] (Deprecated),
+     * [WindowInsetsControllerCompat.BEHAVIOR_DEFAULT] and
+     * [WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE].
+     */
+    var systemBarsBehavior: Int
+
+    /**
+     * Property which holds the status bar visibility. If set to true, show the status bar,
+     * otherwise hide the status bar.
+     */
+    var isStatusBarVisible: Boolean
+
+    /**
+     * Property which holds the navigation bar visibility. If set to true, show the navigation bar,
+     * otherwise hide the navigation bar.
+     */
+    var isNavigationBarVisible: Boolean
+
+    /**
+     * Property which holds the status & navigation bar visibility. If set to true, show both bars,
+     * otherwise hide both bars.
+     */
+    var isSystemBarsVisible: Boolean
+        get() = isNavigationBarVisible && isStatusBarVisible
+        set(value) {
+            isStatusBarVisible = value
+            isNavigationBarVisible = value
+        }
+}
+
+/**
+ * Remembers a [SystemUiController] for the given [window].
+ *
+ * If no [window] is provided, an attempt to find the correct [Window] is made.
+ *
+ * First, if the [LocalView]'s parent is a [DialogWindowProvider], then that dialog's [Window] will
+ * be used.
+ *
+ * Second, we attempt to find [Window] for the [Activity] containing the [LocalView].
+ *
+ * If none of these are found (such as may happen in a preview), then the functionality of the
+ * returned [SystemUiController] will be degraded, but won't throw an exception.
+ */
+@Composable
+fun rememberSystemUiController(
+    window: Window? = findWindow(),
+): SystemUiController {
+    val view = LocalView.current
+    return remember(view, window) { AndroidSystemUiController(view, window) }
+}
+
+@Composable
+private fun findWindow(): Window? =
+    (LocalView.current.parent as? DialogWindowProvider)?.window
+        ?: LocalView.current.context.findWindow()
+
+private tailrec fun Context.findWindow(): Window? =
+    when (this) {
+        is Activity -> window
+        is ContextWrapper -> baseContext.findWindow()
+        else -> null
+    }
+
+/**
+ * A helper class for setting the navigation and status bar colors for a [View], gracefully
+ * degrading behavior based upon API level.
+ *
+ * Typically you would use [rememberSystemUiController] to remember an instance of this.
+ */
+internal class AndroidSystemUiController(
+    private val view: View,
+    window: Window?,
+) : SystemUiController {
+    private val windowInsetsController = window?.let {
+        WindowCompat.getInsetsController(it, view)
+    }
+
+    override var systemBarsBehavior: Int
+        get() = windowInsetsController?.systemBarsBehavior ?: 0
+        set(value) {
+            windowInsetsController?.systemBarsBehavior = value
+        }
+
+    override var isStatusBarVisible: Boolean
+        get() {
+            return ViewCompat.getRootWindowInsets(view)
+                ?.isVisible(WindowInsetsCompat.Type.statusBars()) == true
+        }
+        set(value) {
+            if (value) {
+                windowInsetsController?.show(WindowInsetsCompat.Type.statusBars())
+            } else {
+                windowInsetsController?.hide(WindowInsetsCompat.Type.statusBars())
+            }
+        }
+
+    override var isNavigationBarVisible: Boolean
+        get() {
+            return ViewCompat.getRootWindowInsets(view)
+                ?.isVisible(WindowInsetsCompat.Type.navigationBars()) == true
+        }
+        set(value) {
+            if (value) {
+                windowInsetsController?.show(WindowInsetsCompat.Type.navigationBars())
+            } else {
+                windowInsetsController?.hide(WindowInsetsCompat.Type.navigationBars())
+            }
+        }
+}
@@ -25,11 +25,14 @@ import androidx.collection.LruCache
 import androidx.compose.runtime.snapshots.Snapshot
 import androidx.lifecycle.ProcessLifecycleOwner
 import androidx.lifecycle.coroutineScope
+import coil3.EventListener
 import coil3.SingletonImageLoader
 import coil3.asCoilImage
 import coil3.gif.AnimatedImageDecoder
 import coil3.gif.GifDecoder
 import coil3.network.ktor.KtorNetworkFetcherFactory
+import coil3.request.ErrorResult
+import coil3.request.ImageRequest
 import coil3.request.crossfade
 import coil3.serviceLoaderEnabled
 import coil3.util.DebugLogger
@@ -43,12 +46,14 @@ import com.hippo.ehviewer.coil.MergeInterceptor
 import com.hippo.ehviewer.dailycheck.checkDawn
 import com.hippo.ehviewer.dao.SearchDatabase
 import com.hippo.ehviewer.download.DownloadManager
+import com.hippo.ehviewer.download.DownloadsFilterMode
 import com.hippo.ehviewer.ktbuilder.diskCache
 import com.hippo.ehviewer.ktbuilder.imageLoader
 import com.hippo.ehviewer.ktor.CronetEngine
 import com.hippo.ehviewer.legacy.cleanObsoleteCache
 import com.hippo.ehviewer.ui.keepNoMediaFileStatus
 import com.hippo.ehviewer.ui.lockObserver
+import com.hippo.ehviewer.ui.tools.dataStateFlow
 import com.hippo.ehviewer.util.AppConfig
 import com.hippo.ehviewer.util.Crash
 import com.hippo.ehviewer.util.FavouriteStatusRouter
@@ -64,6 +69,7 @@ import kotlinx.coroutines.launch
 import logcat.AndroidLogcatLogger
 import logcat.LogPriority
 import logcat.LogcatLogger
+import logcat.asLog
 import okio.Path.Companion.toOkioPath
 import splitties.arch.room.roomDb
 import splitties.init.appCtx
@@ -99,13 +105,13 @@ class EhApplication : Application(), SingletonImageLoader.Factory {
        super.onCreate()
        System.loadLibrary("ehviewer")
        lifecycleScope.launchIO {
+            launch { EhTagDatabase }
+            launch { EhDB }
+            dataStateFlow.value
            launch {
-                EhTagDatabase
-            }
-            launch {
-                EhDB
-            }
-            launch {
+                if (DownloadManager.labelList.isNotEmpty() && Settings.downloadFilterMode.key !in Settings.prefs) {
+                    Settings.downloadFilterMode.value = DownloadsFilterMode.CUSTOM.flag
+                }
                DownloadManager.readMetadataFromLocal()
            }
            launch {
@@ -174,7 +180,17 @@ class EhApplication : Application(), SingletonImageLoader.Factory {
        crossfade(300)
        val drawable = AppCompatResources.getDrawable(appCtx, R.drawable.image_failed)
        if (drawable != null) error(drawable.asCoilImage(true))
-        if (BuildConfig.DEBUG) logger(DebugLogger())
+        if (BuildConfig.DEBUG) {
+            logger(DebugLogger())
+        } else {
+            eventListener(object : EventListener() {
+                override fun onError(request: ImageRequest, result: ErrorResult) {
+                    logcat("ImageLoader", LogPriority.ERROR) {
+                        "🚨 Failed - ${request.data}\n${result.throwable.asLog()}"
+                    }
+                }
+            })
+        }
    }

    companion object {
@@ -187,7 +203,7 @@ class EhApplication : Application(), SingletonImageLoader.Factory {
        }

        val noRedirectKtorClient by lazy {
-            HttpClient(ktorClient.engine) {
+            HttpClient(CronetEngine) {
                followRedirects = false
                install(HttpCookies) {
                    storage = EhCookieStore
@@ -20,6 +20,7 @@ import android.net.Uri
 import arrow.fx.coroutines.release
 import arrow.fx.coroutines.resource
 import com.hippo.ehviewer.client.data.BaseGalleryInfo
+import com.hippo.ehviewer.dao.DownloadArtist
 import com.hippo.ehviewer.dao.DownloadDirname
 import com.hippo.ehviewer.dao.DownloadInfo
 import com.hippo.ehviewer.dao.DownloadLabel
@@ -29,14 +30,19 @@ import com.hippo.ehviewer.dao.HistoryInfo
 import com.hippo.ehviewer.dao.LocalFavoriteInfo
 import com.hippo.ehviewer.dao.ProgressInfo
 import com.hippo.ehviewer.dao.QuickSearch
+import com.hippo.ehviewer.dao.Schema17to18
 import com.hippo.ehviewer.download.DownloadManager
 import com.hippo.ehviewer.util.sendTo
+import com.hippo.unifile.UniFile
 import com.hippo.unifile.asUniFile
 import kotlinx.coroutines.flow.Flow
 import splitties.arch.room.roomDb

 object EhDB {
-    private val db = roomDb<EhDatabase>("eh.db")
+    private const val DB_NAME = "eh.db"
+    private val db = roomDb<EhDatabase>(DB_NAME) {
+        addMigrations(Schema17to18())
+    }

    private suspend fun putGalleryInfo(galleryInfo: BaseGalleryInfo) {
        db.galleryDao().upsert(galleryInfo)
@@ -108,8 +114,11 @@ object EhDB {
        dao.insertOrIgnore(downloadDirnameList)
    }

-    val downloadsCount
-        get() = db.downloadsDao().count()
+    val downloadsCountByLabel
+        get() = db.downloadsDao().countByLabel()
+
+    val downloadsCountByArtist
+        get() = db.downloadsDao().countByArtist()

    suspend fun getAllDownloadLabelList() = db.downloadLabelDao().list()

@@ -137,6 +146,14 @@ object EhDB {
        dao.fill(raw.position)
    }

+    suspend fun putDownloadArtist(gid: Long, artists: List<DownloadArtist>) {
+        if (artists.isNotEmpty()) {
+            val dao = db.downloadArtistDao()
+            dao.deleteByGid(gid)
+            dao.insert(artists)
+        }
+    }
+
    suspend fun removeLocalFavorites(galleryInfo: BaseGalleryInfo) {
        db.localFavoritesDao().deleteByKey(galleryInfo.gid)
        deleteGalleryInfo(galleryInfo)
@@ -256,82 +273,57 @@ object EhDB {
        db.filterDao().update(filter)
    }

-    suspend fun exportDB(context: Context, uri: Uri) {
-        val ehExportName = "eh.export.db"
-        resource {
-            context.deleteDatabase(ehExportName)
-            roomDb<EhDatabase>(ehExportName)
-        } release {
-            it.close()
-            context.deleteDatabase(ehExportName)
-        } use { newDb ->
-            db.galleryDao().list().let { newDb.galleryDao().insertOrIgnore(it) }
-            db.progressDao().list().let { newDb.progressDao().insertOrIgnore(it) }
-            db.downloadLabelDao().list().let { newDb.downloadLabelDao().insert(it) }
-            db.downloadDirnameDao().list().let { newDb.downloadDirnameDao().insertOrIgnore(it) }
-            db.downloadsDao().list().let { newDb.downloadsDao().insert(it) }
-            db.historyDao().list().let { newDb.historyDao().insertOrIgnore(it) }
-            db.quickSearchDao().list().let { newDb.quickSearchDao().insert(it) }
-            db.localFavoritesDao().list().let { newDb.localFavoritesDao().insertOrIgnore(it) }
-            db.filterDao().list().let { newDb.filterDao().insert(it) }
-            newDb.close()
-            val dbFile = context.getDatabasePath(ehExportName)
-            dbFile.asUniFile() sendTo uri.asUniFile()
-        }
+    fun exportDB(context: Context, file: UniFile) {
+        db.query("PRAGMA wal_checkpoint(FULL)", null).use { it.moveToNext() }
+        val dbFile = context.getDatabasePath(DB_NAME)
+        dbFile.asUniFile() sendTo file
    }

    suspend fun importDB(context: Context, uri: Uri) {
        val tempDBName = "tmp.db"
        resource {
            context.deleteDatabase(tempDBName)
-            roomDb<EhDatabase>(tempDBName) { createFromInputStream { context.contentResolver.openInputStream(uri) } }
+            roomDb<EhDatabase>(tempDBName) {
+                createFromInputStream { context.contentResolver.openInputStream(uri) }
+                addMigrations(Schema17to18())
+            }
        } release {
            it.close()
            context.deleteDatabase(tempDBName)
        } use { oldDB ->
-            runCatching {
-                db.galleryDao().insertOrIgnore(oldDB.galleryDao().list())
+            db.galleryDao().insertOrIgnore(oldDB.galleryDao().list())
+
+            db.progressDao().insertOrIgnore(oldDB.progressDao().list())
+
+            val downloadLabelList = oldDB.downloadLabelDao().list()
+            DownloadManager.addDownloadLabel(downloadLabelList)
+
+            oldDB.downloadDirnameDao().list().let {
+                importDownloadDirname(it)
            }
-            runCatching {
-                db.progressDao().insertOrIgnore(oldDB.progressDao().list())
+
+            val downloadInfoList = oldDB.downloadsDao().joinList().asReversed()
+            DownloadManager.addDownload(downloadInfoList)
+
+            val historyInfoList = oldDB.historyDao().list()
+            importHistoryInfo(historyInfoList)
+
+            val quickSearchList = oldDB.quickSearchDao().list()
+            val currentQuickSearchList = db.quickSearchDao().list()
+            val offset = currentQuickSearchList.size
+            val importList = quickSearchList.filter { newQS ->
+                currentQuickSearchList.none { it.name == newQS.name }
+            }.onEachIndexed { index, q -> q.position = index + offset }
+            importQuickSearch(importList)
+
+            oldDB.localFavoritesDao().list().let {
+                importLocalFavorites(it)
            }
-            runCatching {
-                val downloadLabelList = oldDB.downloadLabelDao().list()
-                DownloadManager.addDownloadLabel(downloadLabelList)
-            }
-            runCatching {
-                oldDB.downloadDirnameDao().list().let {
-                    importDownloadDirname(it)
-                }
-            }
-            runCatching {
-                val downloadInfoList = oldDB.downloadsDao().joinList().asReversed()
-                DownloadManager.addDownload(downloadInfoList)
-            }
-            runCatching {
-                val historyInfoList = oldDB.historyDao().list()
-                importHistoryInfo(historyInfoList)
-            }
-            runCatching {
-                val quickSearchList = oldDB.quickSearchDao().list()
-                val currentQuickSearchList = db.quickSearchDao().list()
-                val offset = currentQuickSearchList.size
-                val importList = quickSearchList.filter { newQS ->
-                    currentQuickSearchList.none { it.name == newQS.name }
-                }.onEachIndexed { index, q -> q.position = index + offset }
-                importQuickSearch(importList)
-            }
-            runCatching {
-                oldDB.localFavoritesDao().list().let {
-                    importLocalFavorites(it)
-                }
-            }
-            runCatching {
-                val filterList = oldDB.filterDao().list()
-                val currentFilterList = db.filterDao().list()
-                filterList.forEach {
-                    if (it !in currentFilterList) addFilter(it)
-                }
+
+            val filterList = oldDB.filterDao().list()
+            val currentFilterList = db.filterDao().list()
+            filterList.forEach {
+                if (it !in currentFilterList) addFilter(it)
            }
        }
    }
@@ -10,9 +10,11 @@ import androidx.compose.runtime.State
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.remember
 import com.hippo.ehviewer.client.CHROME_USER_AGENT
-import com.hippo.ehviewer.client.EhUtils
+import com.hippo.ehviewer.client.EhCookieStore
 import com.hippo.ehviewer.client.data.FavListUrlBuilder
+import com.hippo.ehviewer.download.DownloadsFilterMode
 import com.hippo.ehviewer.download.SortMode
+import com.hippo.ehviewer.util.AppConfig
 import eu.kanade.tachiyomi.ui.reader.setting.OrientationType
 import eu.kanade.tachiyomi.ui.reader.setting.ReadingModeType
 import java.util.Locale
@@ -110,13 +112,17 @@ object Settings : DataStorePreferences(null) {
    val listThumbSize = intPref("list_tile_size", 40)
    val languageFilter = intPref("language_filter", -1)
    val downloadSortMode = intPref("download_sort_mode", SortMode.Default.flag)
+    val downloadFilterMode = intPref("download_filter_mode", DownloadsFilterMode.Default.flag)
+    val hasSignedIn = boolPref("has_signed_in", EhCookieStore.hasSignedIn())
    val meteredNetworkWarning = boolPref("cellular_network_warning", false)
    val blackDarkTheme = boolPref("black_dark_theme", false)
    val gridView = boolPref("grid_view", false)
    val showGalleryPages = boolPref("show_gallery_pages", true)
    val qSSaveProgress = boolPref("qs_save_progress", true)
    val security = boolPref("require_unlock", false)
-    val recentDownloadLabel = stringOrNullPref("recent_download_label", null)
+    val animateItems = boolPref("animate_items", true)
+    val displayName = stringOrNullPref("display_name", null)
+    val recentDownloadLabel = stringOrNullPref("recent_download_label", "")

    var downloadScheme by stringOrNullPref("image_scheme", null)
    var downloadAuthority by stringOrNullPref("image_authority", null)
@@ -142,7 +148,8 @@ object Settings : DataStorePreferences(null) {
    var showTagTranslations by boolPref(KEY_SHOW_TAG_TRANSLATIONS, false).observed { updateWhenTagTranslationChanges() }
    var appLinkVerifyTip by boolPref("app_link_verify_tip", false)
    var enabledSecurity by boolPref("enable_secure", false)
-    var useCIUpdateChannel by boolPref("ci_update_channel", false)
+    var backupBeforeUpdate by boolPref("backup_before_update", true)
+    var useCIUpdateChannel by boolPref("ci_update_channel", AppConfig.isSnapshot)
    var mediaScan by boolPref("media_scan", false).observed { updateWhenKeepMediaStatusChanges() }
    var hasDefaultDownloadLabel by boolPref("has_default_download_label", false)
    var saveParseErrorBody by boolPref("save_parse_error_body", true)
@@ -158,21 +165,13 @@ object Settings : DataStorePreferences(null) {
    var defaultFavSlot by intPref("default_favorite_slot", -2)
    var securityDelay by intPref("require_unlock_delay", 0)
    var clipboardTextHashCode by intPref("clipboard_text_hash_code", 0)
-    var searchCategory by intPref("search_pref", EhUtils.ALL_CATEGORY)
    var requestNewsTime by intPref("request_news_time", 0).observed { updateWhenRequestNewsChanges() }
    var updateIntervalDays by intPref("update_interval_days", 7)
    var lastDawnDays by intPref("last_dawn_days", 0)
    var recentToplist by stringPref("recent_toplist", "11")
    var userAgent by stringPref("user_agent", CHROME_USER_AGENT)
    var defaultDownloadLabel by stringOrNullPref("default_download_label", null)
-    var displayName by stringOrNullPref("display_name", null)
-    var avatar by stringOrNullPref("avatar", null)
-    var language by stringPref("app_language", "system").observed { updateWhenLocaleChanges() }
-    var lastUpdateTime by longPref("last_update_time", 0)
-    var favDialogTheta by floatPref("fav_select_dialog_delta", 0F)
-
-    // TODO: Remove this after swipe gestures are correctly handled in compose
-    var touchSlopFactor by intPref("touch_slop", 3)
+    var lastUpdateTime by longPref("last_update_time", BuildConfig.COMMIT_TIME)

    // Tachiyomi Reader
    var newReader by boolPref("new_compose_reader", false)
@@ -201,7 +200,8 @@ object Settings : DataStorePreferences(null) {
    val invertedColors = boolPref("pref_inverted_colors", false)
    val readerWebtoonNav = intPref("reader_navigation_mode_webtoon", 0)
    val readerPagerNav = intPref("reader_navigation_mode_pager", 0)
-    val readerWebtoonNavInverted = intPref("reader_tapping_inverted_webtoon", 0)
+    val readerPagerNavInverted = intPref("reader_tapping_inverted_2", 0)
+    val readerWebtoonNavInverted = intPref("reader_tapping_inverted_webtoon_2", 0)
    val webtoonSidePadding = intPref("webtoon_side_padding", 0)
    val navigateToPan = boolPref("navigate_pan", true)
    val imageScaleType = intPref("pref_image_scale_type_key", 1)
@@ -2,8 +2,6 @@ package com.hippo.ehviewer

 import android.app.UiModeManager
 import androidx.appcompat.app.AppCompatDelegate
-import androidx.core.os.LocaleListCompat
-import com.hippo.ehviewer.client.EhCookieStore
 import com.hippo.ehviewer.client.EhEngine
 import com.hippo.ehviewer.client.EhTagDatabase
 import com.hippo.ehviewer.dailycheck.updateDailyCheckWork
@@ -27,15 +25,6 @@ fun <T, R : Settings.Delegate<T>> R.observed(func: (Unit) -> Unit) = apply { col
 fun <T, R : Settings.Delegate<T>> R.emitTo(flow: MutableSharedFlow<Unit>) = apply { collectScope.launch { flowGetter().collect { flow.emit(Unit) } } }
 fun <T, R : PrefDelegate<T>> R.emitTo(flow: MutableSharedFlow<Unit>) = apply { collectScope.launch { changesFlow().collect { flow.emit(Unit) } } }

-fun updateWhenLocaleChanges() {
-    val newValue = Settings.language
-    if ("system" == newValue) {
-        AppCompatDelegate.setApplicationLocales(LocaleListCompat.getEmptyLocaleList())
-    } else {
-        AppCompatDelegate.setApplicationLocales(LocaleListCompat.forLanguageTags(newValue))
-    }
-}
-
 fun updateWhenKeepMediaStatusChanges() {
    collectScope.launchIO {
        runCatching {
@@ -64,7 +53,7 @@ fun updateWhenRequestNewsChanges() {
 }

 fun updateWhenGallerySiteChanges() {
-    if (!Settings.needSignIn && EhCookieStore.hasSignedIn()) {
+    if (Settings.hasSignedIn.value) {
        collectScope.launchIO {
            runCatching {
                EhEngine.getUConfig()
@@ -12,7 +12,7 @@ import io.ktor.http.renderSetCookieHeader

 object EhCookieStore : CookiesStorage {
    private val manager = CookieManager.getInstance()
-    fun signOut() = manager.removeAllCookies(null)
+    fun removeAllCookies() = manager.removeAllCookies(null)
    fun contains(url: String, name: String) = load(Url(url)).fastAny { it.name == name }

    fun hasSignedIn(): Boolean {
@@ -17,6 +17,7 @@ package com.hippo.ehviewer.client

 import arrow.core.Either
 import arrow.core.left
+import arrow.core.partially2
 import arrow.core.right
 import arrow.fx.coroutines.parMap
 import arrow.fx.coroutines.parZip
@@ -44,8 +45,10 @@ import com.hippo.ehviewer.client.parser.GalleryTokenApiParser
 import com.hippo.ehviewer.client.parser.HomeParser
 import com.hippo.ehviewer.client.parser.ProfileParser
 import com.hippo.ehviewer.client.parser.RateGalleryResult
+import com.hippo.ehviewer.client.parser.SignInParser
 import com.hippo.ehviewer.client.parser.TorrentParser
 import com.hippo.ehviewer.client.parser.TorrentResult
+import com.hippo.ehviewer.client.parser.UserConfigParser
 import com.hippo.ehviewer.client.parser.VoteCommentResult
 import com.hippo.ehviewer.client.parser.VoteTagParser
 import com.hippo.ehviewer.dailycheck.showEventNotification
@@ -60,9 +63,9 @@ import io.ktor.client.statement.bodyAsChannel
 import io.ktor.utils.io.pool.DirectByteBufferPool
 import io.ktor.utils.io.pool.useInstance
 import java.io.File
-import java.io.RandomAccessFile
 import java.nio.ByteBuffer
 import kotlin.math.ceil
+import kotlin.system.measureTimeMillis
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.delay
 import kotlinx.serialization.SerializationException
@@ -71,6 +74,8 @@ import kotlinx.serialization.json.addJsonArray
 import kotlinx.serialization.json.put
 import moe.tarsin.coroutines.removeAllSuspend
 import moe.tarsin.coroutines.runSuspendCatching
+import okio.buffer
+import okio.sink
 import org.jsoup.Jsoup
 import splitties.init.appCtx

@@ -79,16 +84,14 @@ private const val MAX_REQUEST_SIZE = 25
 private const val MAX_SEQUENTIAL_REQUESTS = 5
 private const val REQUEST_INTERVAL = 5000L

-private const val U_CONFIG_TEXT = "Selected Profile"
-
 fun Either<String, ByteBuffer>.saveParseError(e: Throwable) {
    val dir = AppConfig.externalParseErrorDir ?: return
-    val file = File(dir, ReadableTime.getFilenamableTime(System.currentTimeMillis()) + ".txt")
-    RandomAccessFile(file, "rw").use { randomAccessFile ->
-        with(randomAccessFile) {
-            writeUTF(e.message + "\n")
-            onLeft { writeUTF(it) }
-            onRight { channel.write(it) }
+    val file = File(dir, ReadableTime.getFilenamableTime() + ".txt")
+    file.sink().buffer().use { sink ->
+        with(sink) {
+            writeUtf8(e.message + "\n")
+            onLeft { writeUtf8(it) }
+            onRight { write(it) }
        }
    }
 }
@@ -100,7 +103,7 @@ fun rethrowExactly(code: Int, body: Either<String, ByteBuffer>, e: Throwable): N
    // Check sad panda (without panda)
    val empty = body.fold(
        { it.isEmpty() },
-        { it.limit() == 0 },
+        { !it.hasRemaining() },
    )
    if (empty) {
        if (EhUtils.isExHentai) {
@@ -143,7 +146,7 @@ fun rethrowExactly(code: Int, body: Either<String, ByteBuffer>, e: Throwable): N

 val httpContentPool = DirectByteBufferPool(8, 0x80000)

-suspend inline fun <T> HttpStatement.fetchUsingAsText(crossinline block: suspend String.() -> T) = execute { response ->
+suspend inline fun <T> HttpStatement.fetchUsingAsText(crossinline block: suspend String.() -> T) = executeSafely { response ->
    val body = response.bodyAsUtf8Text()
    runSuspendCatching {
        block(body)
@@ -152,20 +155,21 @@ suspend inline fun <T> HttpStatement.fetchUsingAsText(crossinline block: suspend
    }.getOrThrow()
 }

-suspend inline fun <T> HttpStatement.fetchUsingAsByteBuffer(crossinline block: suspend ByteBuffer.() -> T) = execute { response ->
+suspend inline fun <T> HttpStatement.fetchUsingAsByteBuffer(crossinline block: suspend ByteBuffer.() -> T) = executeSafely { response ->
    httpContentPool.useInstance { buffer ->
        with(response.bodyAsChannel()) { while (!isClosedForRead) readAvailable(buffer) }
        buffer.flip()
        runSuspendCatching {
            block(buffer)
        }.onFailure {
+            buffer.rewind()
            rethrowExactly(response.status.value, buffer.right(), it)
        }.getOrThrow()
    }
 }

 object EhEngine {
-    suspend fun getOriginalImageUrl(url: String, referer: String?) = noRedirectEhRequest(url, referer).execute { response ->
+    suspend fun getOriginalImageUrl(url: String, referer: String?) = noRedirectEhRequest(url, referer).executeSafely { response ->
        val location = response.headers["Location"] ?: throw InsufficientFundsException()
        location.takeIf { "bounce_login" !in it } ?: throw NotLoggedInException()
    }
@@ -175,16 +179,20 @@ object EhEngine {
        return ehRequest(url, referer).fetchUsingAsByteBuffer(TorrentParser::parse)
    }

-    suspend fun getArchiveList(url: String, gid: Long, token: String) = ehRequest(url, EhUrl.getGalleryDetailUrl(gid, token))
-        .fetchUsingAsText(ArchiveParser::parse)
-        .apply { funds = funds ?: ehRequest(EhUrl.URL_FUNDS).fetchUsingAsText(HomeParser::parseFunds) }
+    suspend fun getArchiveList(url: String, gid: Long, token: String): ArchiveParser.Result {
+        val funds = if (EhUtils.isExHentai) getFunds() else null
+        return ehRequest(url, EhUrl.getGalleryDetailUrl(gid, token))
+            .fetchUsingAsText(ArchiveParser::parse.partially2(funds))
+    }

    suspend fun getImageLimits() = parZip(
        { ehRequest(EhUrl.URL_HOME).fetchUsingAsByteBuffer(HomeParser::parse) },
-        { ehRequest(EhUrl.URL_FUNDS).fetchUsingAsText(HomeParser::parseFunds) },
+        { getFunds() },
        { limits, funds -> HomeParser.Result(limits, funds) },
    )

+    private suspend fun getFunds() = ehRequest(EhUrl.URL_FUNDS).fetchUsingAsText(HomeParser::parseFunds)
+
    suspend fun getNews(parse: Boolean) = ehRequest(EhUrl.URL_NEWS, EhUrl.REFERER_E)
        .fetchUsingAsText { if (parse) EventPaneParser.parse(this) else null }

@@ -195,12 +203,12 @@ object EhEngine {

    suspend fun getUConfig(url: String = EhUrl.uConfigUrl) {
        runSuspendCatching {
-            ehRequest(url).fetchUsingAsText { check(U_CONFIG_TEXT in this) { "Unable to load config from $url!" } }
+            ehRequest(url).fetchUsingAsByteBuffer(UserConfigParser::parse)
        }.onFailure { throwable ->
            // It may get redirected when accessing ex for the first time
            if (url == EhUrl.URL_UCONFIG_EX) {
                logcat(throwable)
-                ehRequest(url).fetchUsingAsText { check(U_CONFIG_TEXT in this) { "Unable to load config from $url!" } }
+                ehRequest(url).fetchUsingAsByteBuffer(UserConfigParser::parse)
            } else {
                throw throwable
            }
@@ -232,6 +240,22 @@ object EhEngine {
    suspend fun getFavorites(url: String) = ehRequest(url, EhUrl.referer).fetchUsingAsByteBuffer(FavoritesParser::parse)
        .apply { galleryInfoList.fillInfo(url) }

+    suspend fun signIn(username: String, password: String): String {
+        val referer = "https://forums.e-hentai.org/index.php?act=Login&CODE=00"
+        val url = EhUrl.API_SIGN_IN
+        val origin = "https://forums.e-hentai.org"
+        return ehRequest(url, referer, origin) {
+            formBody {
+                append("referer", referer)
+                append("b", "")
+                append("bt", "")
+                append("UserName", username)
+                append("PassWord", password)
+                append("CookieDate", "1")
+            }
+        }.fetchUsingAsText(SignInParser::parse)
+    }
+
    suspend fun commentGallery(url: String, comment: String, id: Long = -1) = ehRequest(url, url, EhUrl.origin) {
        formBody {
            if (id == -1L) {
@@ -241,7 +265,7 @@ object EhEngine {
                append("edit_comment", id.toString())
            }
        }
-    }.execute { response ->
+    }.executeSafely { response ->
        // Ktor does not handle POST redirect, we need to do it manually
        // https://youtrack.jetbrains.com/issue/KTOR-478
        val location = response.headers["Location"] ?: url
@@ -270,7 +294,7 @@ object EhEngine {
                append("apply", "Apply Changes")
                append("update", "1")
            }
-        }.execute { }
+        }.executeSafely { }
    }

    suspend fun downloadArchive(gid: Long, token: String, or: String, res: String, isHAtH: Boolean): String? {
@@ -429,13 +453,13 @@ object EhEngine {
    }

    suspend fun addFavorites(galleryList: List<Pair<Long, String>>, dstCat: Int) {
-        galleryList.chunked(MAX_SEQUENTIAL_REQUESTS).forEachIndexed { index, chunk ->
-            if (index != 0) {
-                delay(REQUEST_INTERVAL)
-            }
-            chunk.parMap { (gid, token) ->
+        galleryList.forEach { (gid, token) ->
+            // https://github.com/FooIbar/EhViewer/issues/1190
+            // Workaround for duplicate items when sorting by favorited time
+            val timeTaken = measureTimeMillis {
                modifyFavorites(gid, token, dstCat)
            }
+            delay(1000 - timeTaken)
        }
    }
 }
@@ -15,6 +15,7 @@
 */
 package com.hippo.ehviewer.client

+import com.hippo.ehviewer.BuildConfig
 import com.hippo.ehviewer.EhApplication.Companion.ktorClient
 import com.hippo.ehviewer.EhApplication.Companion.noRedirectKtorClient
 import com.hippo.ehviewer.Settings
@@ -25,6 +26,7 @@ import io.ktor.client.request.forms.FormDataContent
 import io.ktor.client.request.header
 import io.ktor.client.request.prepareRequest
 import io.ktor.client.request.setBody
+import io.ktor.client.statement.HttpResponse
 import io.ktor.client.statement.HttpStatement
 import io.ktor.http.ContentType
 import io.ktor.http.HttpHeaders
@@ -32,6 +34,7 @@ import io.ktor.http.HttpMethod
 import io.ktor.http.ParametersBuilder
 import io.ktor.http.content.TextContent
 import io.ktor.http.userAgent
+import kotlinx.coroutines.cancel
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonArrayBuilder
 import kotlinx.serialization.json.JsonObjectBuilder
@@ -42,13 +45,13 @@ import okio.BufferedSource

 inline fun JsonObjectBuilder.array(name: String, builder: JsonArrayBuilder.() -> Unit) = put(name, buildJsonArray(builder))

-suspend inline fun <reified T> HttpStatement.executeAndParseAs() = execute { it.bodyAsUtf8Text().parseAs<T>() }
+suspend inline fun <reified T> HttpStatement.executeAndParseAs() = executeSafely { it.bodyAsUtf8Text().parseAs<T>() }
 inline fun <reified T> BufferedSource.parseAs(): T = json.decodeFromBufferedSource(this)
 inline fun <reified T> String.parseAs(): T = json.decodeFromString(this)

 val json = Json { ignoreUnknownKeys = true }

-const val CHROME_USER_AGENT = "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Mobile Safari/537.36"
+const val CHROME_USER_AGENT = "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${BuildConfig.CHROME_VERSION}.0.0.0 Mobile Safari/537.36"
 const val CHROME_ACCEPT = "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9"
 const val CHROME_ACCEPT_LANGUAGE = "en-US,en;q=0.5"

@@ -82,6 +85,16 @@ suspend inline fun noRedirectEhRequest(
    apply(builder)
 }.also { logcat("EhRequest") { url } }

+suspend inline fun <T> HttpStatement.executeSafely(
+    crossinline block: suspend (response: HttpResponse) -> T,
+) = execute { resp ->
+    try {
+        block(resp)
+    } finally {
+        resp.coroutineContext.cancel()
+    }
+}
+
 inline fun HttpRequestBuilder.formBody(builder: ParametersBuilder.() -> Unit) {
    method = HttpMethod.Post
    val parameters = ParametersBuilder().apply(builder).build()
@@ -152,7 +152,7 @@ object EhTagDatabase : CoroutineScope {

    private suspend fun save(client: HttpClient, url: String, file: File) {
        runCatching {
-            client.prepareGet(url).execute {
+            client.prepareGet(url).executeSafely {
                if (it.status.isSuccess()) {
                    it.bodyAsChannel().copyTo(file)
                } else {
@@ -36,6 +36,7 @@ object EhUrl {
    const val API_E = "https://api.e-hentai.org/api.php"
    const val URL_UCONFIG_E = HOST_E + "uconfig.php"
    const val URL_MY_TAGS_E = HOST_E + "mytags"
+    const val API_SIGN_IN = "https://forums.e-hentai.org/index.php?act=Login&CODE=01"
    const val URL_POPULAR_E = "https://e-hentai.org/popular"
    const val URL_POPULAR_EX = "https://exhentai.org/popular"
    const val URL_IMAGE_SEARCH_E = "https://upload.e-hentai.org/image_lookup.php"
@@ -152,9 +152,9 @@ object EhUtils {
    val categoryTextColor = Color(0xffe6e0e9)

    fun signOut() {
-        EhCookieStore.signOut()
-        Settings.avatar = null
-        Settings.displayName = null
+        EhCookieStore.removeAllCookies()
+        Settings.displayName.value = null
+        Settings.hasSignedIn.value = false
        Settings.gallerySite = EhUrl.SITE_E
        Settings.needSignIn = true
    }
@@ -122,7 +122,7 @@ interface GalleryInfo {

        private fun generateSLangFromTitle(title: String): String? {
            for (i in S_LANGS.indices) {
-                if (S_LANG_PATTERNS[i].matches(title)) {
+                if (S_LANG_PATTERNS[i].containsMatchIn(title)) {
                    return S_LANGS[i]
                }
            }
@@ -262,6 +262,7 @@ data class ListUrlBuilder(
    fun build(): String {
        return when (mode) {
            MODE_NORMAL, MODE_SUBSCRIPTION -> ehUrl(EhUrl.WATCHED_PATH.takeIf { mode == MODE_SUBSCRIPTION }) {
+                val category = if (!Settings.hasSignedIn.value && category <= 0) EhUtils.NON_H else category
                if (category > 0) {
                    addQueryParameter("f_cats", (category.inv() and EhUtils.ALL_CATEGORY).toString())
                }
@@ -34,7 +34,7 @@ object ArchiveParser {
    private const val ERROR_INSUFFICIENT_FUNDS =
        "You do not have enough funds to download this archive."

-    fun parse(body: String): Result {
+    fun parse(body: String, maybeFunds: Funds?): Result {
        val m = PATTERN_HATH_FORM.find(body)!!
        val paramOr = m.groupValues[1]
        val archiveList = ArrayList<Archive>()
@@ -59,14 +59,12 @@ object ArchiveParser {
            val item = Archive(res, name, size, cost, true)
            archiveList.add(item)
        }
-        val result = Result(paramOr, archiveList, null)
-        PATTERN_CURRENT_FUNDS.find(body)?.groupValues?.run {
+        val funds = maybeFunds ?: PATTERN_CURRENT_FUNDS.find(body)!!.groupValues.run {
            val fundsGP = ParserUtils.parseInt(get(1), 0)
            val fundsC = ParserUtils.parseInt(get(2), 0)
-            val funds = HomeParser.Funds(fundsGP, fundsC)
-            result.funds = funds
+            Funds("%,d".format(fundsGP), "%,d".format(fundsC))
        }
-        return result
+        return Result(paramOr, archiveList, funds)
    }

    fun parseArchiveUrl(body: String): String? {
@@ -80,13 +78,13 @@ object ArchiveParser {
        // TODO: Check more errors
    }

-    class Archive(
-        val res: String,
-        val name: String,
-        val size: String,
-        val cost: String,
-        val isHAtH: Boolean,
-    )
-
-    class Result(val paramOr: String, val archiveList: List<Archive>, var funds: HomeParser.Funds?)
+    data class Result(val paramOr: String, val archiveList: List<Archive>, val funds: Funds)
 }
+
+class Archive(
+    val res: String,
+    val name: String,
+    val size: String,
+    val cost: String,
+    val isHAtH: Boolean,
+)
@@ -25,18 +25,18 @@ object HomeParser {
        PATTERN_FUNDS.find(body)?.groupValues?.run {
            val fundsC = ParserUtils.parseInt(get(1), 0)
            val fundsGP = ParserUtils.parseInt(get(2), 0) * 1000
-            return Funds(fundsGP, fundsC)
+            return Funds("%,d+".format(fundsGP), "%,d".format(fundsC))
        }
        throw ParseException("Parse funds error")
    }

-    @Parcelize
-    data class Funds(val fundsGP: Int, val fundsC: Int) : Parcelable
-
    @Parcelize
    data class Result(val limits: Limits, val funds: Funds) : Parcelable
 }

+@Parcelize
+data class Funds(val gp: String, val credit: String) : Parcelable
+
@Parcelize
@Serializable
 data class Limits(val current: Int, val maximum: Int, val resetCost: Int) : Parcelable
@@ -15,6 +15,7 @@
 */
 package com.hippo.ehviewer.client.parser

+import com.hippo.ehviewer.util.toEpochMillis
 import com.hippo.ehviewer.util.toIntOrDefault
 import com.hippo.ehviewer.util.toLocalDateTime
 import com.hippo.ehviewer.util.toLongOrDefault
@@ -36,11 +37,14 @@ object ParserUtils {
        minute()
    }

-    @Synchronized
    fun formatDate(time: Long): String {
        return formatter.format(time.toLocalDateTime())
    }

+    fun parseDate(str: String): Long {
+        return formatter.parse(str).toEpochMillis()
+    }
+
    fun trim(str: String?): String {
        return str?.unescapeXml()?.trim() ?: ""
    }
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2016 Hippo Seven
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hippo.ehviewer.client.parser
+
+import com.hippo.ehviewer.client.exception.EhException
+import com.hippo.ehviewer.client.exception.ParseException
+
+object SignInParser {
+    private val NAME_PATTERN = Regex("<p>You are now logged in as: (.+?)<")
+    private val ERROR_PATTERN = Regex(
+        "<h4>The error returned was:</h4>\\s*<p>(.+?)</p>" +
+            "|<span class=\"postcolor\">(.+?)</span>",
+    )
+
+    fun parse(body: String): String {
+        return NAME_PATTERN.find(body)?.let {
+            it.groupValues[1]
+        } ?: ERROR_PATTERN.find(body)?.let {
+            throw EhException(it.groupValues[1].ifEmpty { it.groupValues[2] })
+        } ?: throw ParseException("Can't parse sign in")
+    }
+}
@@ -14,16 +14,18 @@ object TorrentParser {

@Serializable
 data class Torrent(
+    val outdated: Boolean,
    val posted: String,
    val size: String,
    val seeds: Int,
    val peers: Int,
    val downloads: Int,
+    val uploader: String,
    val url: String,
    val name: String,
 )

-fun Torrent.format() = "[$posted] $name [$size] [↑$seeds ↓$peers ✓$downloads]"
+fun Torrent.format() = "↑$seeds ↓$peers ✓$downloads"

 typealias TorrentResult = List<Torrent>

@@ -0,0 +1,16 @@
+package com.hippo.ehviewer.client.parser
+
+import com.hippo.ehviewer.Settings
+import com.hippo.ehviewer.client.exception.ParseException
+import java.nio.ByteBuffer
+
+object UserConfigParser {
+    private external fun parseFavCat(body: ByteBuffer, size: Int = body.limit()): Int
+
+    fun parse(body: ByteBuffer) = runCatching {
+        val favCat = unmarshalParsingAs<Array<String>>(body, ::parseFavCat)
+        Settings.favCat = favCat
+    }.onFailure {
+        throw ParseException("Can't parse user config", it)
+    }
+}
@@ -17,7 +17,7 @@ import com.hippo.ehviewer.image.detectBorder
 import com.hippo.ehviewer.util.isAtLeastO

 private const val CROP_THRESHOLD = 0.75f
-private const val WEBTOON_THRESHOLD = 3
+private const val RATIO_THRESHOLD = 2

 private val maybeCropBorderKey = Extras.Key(default = false)

@@ -48,7 +48,12 @@ object CropBorderInterceptor : Interceptor {
                val image = result.image
                if (image is BitmapImage) {
                    val bitmap = image.bitmap
-                    val rect = if (image.height / image.width < WEBTOON_THRESHOLD) {
+                    val ratio = if (image.height > image.width) {
+                        image.height / image.width
+                    } else {
+                        image.width / image.height
+                    }
+                    val rect = if (ratio < RATIO_THRESHOLD) {
                        val array = detectBorder(bitmap)
                        val minWidth = image.width * CROP_THRESHOLD
                        val minHeight = image.height * CROP_THRESHOLD
@@ -1,7 +1,6 @@
 package com.hippo.ehviewer.coil

 import coil3.intercept.Interceptor
-import coil3.request.ErrorResult
 import coil3.request.ImageResult
 import coil3.request.SuccessResult
 import com.hippo.ehviewer.EhApplication.Companion.imageCache
@@ -30,24 +29,24 @@ object DownloadThumbInterceptor : Interceptor {
                }
                if (withIOContext { thumb.isFile }) {
                    val new = chain.request.newBuilder().data(thumb.uri.toString()).build()
-                    when (val result = chain.withRequest(new).proceed()) {
-                        is SuccessResult -> return result
-                        is ErrorResult -> withIOContext { thumb.delete() }
-                    }
+                    val result = chain.withRequest(new).proceed()
+                    if (result is SuccessResult) return result
                }
                val new = chain.request.newBuilder().data(url).build()
-                return chain.withRequest(new).proceed().also {
-                    if (it is SuccessResult) {
-                        withIOContext {
-                            if (thumb.ensureFile()) {
-                                val key = requireNotNull(chain.request.memoryCacheKey)
-                                imageCache.read(key) {
-                                    data.asUniFile() sendTo thumb
-                                }
+                val result = chain.withRequest(new).proceed()
+                if (result is SuccessResult) {
+                    withIOContext {
+                        // Accessing the recreated file immediately after deleting it throws
+                        // FileNotFoundException, so we just overwrite the existing file.
+                        if (thumb.ensureFile()) {
+                            val key = requireNotNull(chain.request.memoryCacheKey)
+                            imageCache.read(key) {
+                                data.asUniFile() sendTo thumb
                            }
                        }
                    }
                }
+                return result
            }
        }
        return chain.proceed()
@@ -21,7 +21,6 @@ import androidx.work.WorkManager
 import androidx.work.WorkerParameters
 import com.hippo.ehviewer.R
 import com.hippo.ehviewer.Settings
-import com.hippo.ehviewer.client.EhCookieStore
 import com.hippo.ehviewer.client.EhEngine
 import eu.kanade.tachiyomi.util.lang.withIOContext
 import eu.kanade.tachiyomi.util.system.logcat
@@ -83,7 +82,7 @@ val today
    get() = (Clock.System.now().epochSeconds / 86400).toInt()

 suspend fun checkDawn() = runCatching {
-    if (EhCookieStore.hasSignedIn() && Settings.lastDawnDays != today) {
+    if (Settings.hasSignedIn.value && Settings.lastDawnDays != today) {
        EhEngine.getNews(true)?.let {
            Settings.lastDawnDays = today
            showEventNotification(it)
@@ -8,11 +8,11 @@ import com.hippo.ehviewer.client.data.BaseGalleryInfo

@Database(
    entities = [
-        BaseGalleryInfo::class, DownloadLabel::class, DownloadEntity::class, DownloadDirname::class,
+        BaseGalleryInfo::class, DownloadLabel::class, DownloadEntity::class, DownloadDirname::class, DownloadArtist::class,
        Filter::class, HistoryInfo::class, LocalFavoriteInfo::class, ProgressInfo::class, QuickSearch::class,
        GalleryEntityFts::class,
    ],
-    version = 22,
+    version = 23,
    exportSchema = true,
    autoMigrations = [
        AutoMigration(from = 4, to = 5, spec = Schema4to5::class),
@@ -28,16 +28,17 @@ import com.hippo.ehviewer.client.data.BaseGalleryInfo
        AutoMigration(from = 14, to = 15),
        AutoMigration(from = 15, to = 16),
        AutoMigration(from = 16, to = 17),
-        AutoMigration(from = 17, to = 18),
        AutoMigration(from = 18, to = 19, spec = Schema18to19::class),
        AutoMigration(from = 19, to = 20),
        AutoMigration(from = 20, to = 21, spec = Schema20to21::class),
        AutoMigration(from = 21, to = 22, spec = Schema21to22::class),
+        AutoMigration(from = 22, to = 23),
    ],
 )
@TypeConverters(FilterModeConverter::class)
 abstract class EhDatabase : RoomDatabase() {
    abstract fun galleryDao(): GalleryDao
+    abstract fun downloadArtistDao(): DownloadArtistDao
    abstract fun downloadDirnameDao(): DownloadDirnameDao
    abstract fun downloadLabelDao(): DownloadLabelDao
    abstract fun downloadsDao(): DownloadsDao
@@ -5,6 +5,7 @@ import androidx.room.DeleteTable
 import androidx.room.RenameColumn
 import androidx.room.RenameTable
 import androidx.room.migration.AutoMigrationSpec
+import androidx.room.migration.Migration
 import androidx.sqlite.db.SupportSQLiteDatabase
 import com.hippo.ehviewer.client.data.GalleryInfo.Companion.NOT_FAVORITED

@@ -103,6 +104,15 @@ class Schema12to13 : AutoMigrationSpec {
@DeleteColumn(tableName = "DOWNLOADS", columnName = "SIMPLE_LANGUAGE")
 class Schema13to14 : AutoMigrationSpec

+class Schema17to18 : Migration(17, 18) {
+    override fun migrate(db: SupportSQLiteDatabase) {
+        db.execSQL("CREATE TABLE IF NOT EXISTS `_new_GALLERIES` (`GID` INTEGER NOT NULL, `TOKEN` TEXT NOT NULL, `TITLE` TEXT, `TITLE_JPN` TEXT, `THUMB` TEXT, `CATEGORY` INTEGER NOT NULL, `POSTED` TEXT, `UPLOADER` TEXT, `RATING` REAL NOT NULL, `SIMPLE_LANGUAGE` TEXT, `FAVORITE_SLOT` INTEGER NOT NULL, PRIMARY KEY(`GID`))")
+        db.execSQL("INSERT INTO `_new_GALLERIES` (`GID`,`TOKEN`,`TITLE`,`TITLE_JPN`,`THUMB`,`CATEGORY`,`POSTED`,`UPLOADER`,`RATING`,`SIMPLE_LANGUAGE`,`FAVORITE_SLOT`) SELECT `GID`,`TOKEN`,`TITLE`,`TITLE_JPN`,`THUMB`,`CATEGORY`,`POSTED`,`UPLOADER`,`RATING`,`SIMPLE_LANGUAGE`,`FAVORITE_SLOT` FROM `GALLERIES` WHERE `TOKEN` IS NOT NULL")
+        db.execSQL("DROP TABLE `GALLERIES`")
+        db.execSQL("ALTER TABLE `_new_GALLERIES` RENAME TO `GALLERIES`")
+    }
+}
+
@RenameColumn(tableName = "DOWNLOADS", fromColumnName = "POSITION", toColumnName = "TIME")
 class Schema18to19 : AutoMigrationSpec

@@ -0,0 +1,24 @@
+package com.hippo.ehviewer.dao
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.ForeignKey
+
+@Entity(
+    tableName = "DOWNLOAD_ARTISTS",
+    primaryKeys = ["GID", "ARTIST"],
+    foreignKeys = [
+        ForeignKey(DownloadEntity::class, ["GID"], ["GID"], onDelete = ForeignKey.CASCADE),
+    ],
+)
+data class DownloadArtist(
+    @ColumnInfo(name = "GID")
+    val gid: Long,
+
+    @ColumnInfo(name = "ARTIST")
+    val artist: String,
+) {
+    companion object {
+        fun from(gid: Long, artists: Iterable<String>) = artists.map { DownloadArtist(gid, it) }
+    }
+}
@@ -0,0 +1,14 @@
+package com.hippo.ehviewer.dao
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.Query
+
+@Dao
+interface DownloadArtistDao {
+    @Insert
+    suspend fun insert(downloadArtists: List<DownloadArtist>)
+
+    @Query("DELETE FROM DOWNLOAD_ARTISTS WHERE GID = :gid")
+    suspend fun deleteByGid(gid: Long)
+}
@@ -67,9 +67,13 @@ data class DownloadInfo(
    @ColumnInfo(name = "DIRNAME")
    val dirname: String?,

+    @Relation(parentColumn = "GID", entityColumn = "GID")
+    var artistInfoList: List<DownloadArtist> = emptyList(),
+
    @Embedded
    val downloadInfo: DownloadEntity = DownloadEntity(galleryInfo.gid),
 ) : GalleryInfo by galleryInfo, AbstractDownloadInfo by downloadInfo {
+
    companion object {
        const val STATE_INVALID = -1
        const val STATE_NONE = 0
@@ -79,3 +83,6 @@ data class DownloadInfo(
        const val STATE_FAILED = 4
    }
 }
+
+val DownloadInfo.artists: List<String>
+    get() = artistInfoList.map { it.artist }
@@ -14,7 +14,11 @@ import kotlinx.coroutines.flow.Flow
 interface DownloadsDao {
    @Suppress("ktlint:standard:annotation")
    @Query("SELECT LABEL, COUNT(*) AS COUNT FROM DOWNLOADS LEFT JOIN DOWNLOAD_LABELS USING(LABEL) GROUP BY LABEL")
-    fun count(): Flow<Map<@MapColumn("LABEL") String?, @MapColumn("COUNT") Int>>
+    fun countByLabel(): Flow<Map<@MapColumn("LABEL") String?, @MapColumn("COUNT") Int>>
+
+    @Suppress("ktlint:standard:annotation")
+    @Query("SELECT ARTIST, COUNT(*) AS COUNT FROM DOWNLOADS LEFT JOIN DOWNLOAD_ARTISTS USING(GID) GROUP BY ARTIST ORDER BY COUNT DESC, ARTIST")
+    fun countByArtist(): Flow<Map<@MapColumn("ARTIST") String?, @MapColumn("COUNT") Int>>

    @Query("SELECT * FROM DOWNLOADS ORDER BY TIME")
    suspend fun list(): List<DownloadEntity>
@@ -12,11 +12,11 @@ interface SearchDao {
    @Query("DELETE FROM suggestions WHERE `query` = :query")
    suspend fun deleteQuery(query: String)

-    @Query("SELECT * FROM suggestions WHERE `query` LIKE :prefix || '%' ORDER BY date DESC LIMIT :limit")
-    suspend fun rawSuggestions(prefix: String, limit: Int): Array<Search>
+    @Query("SELECT DISTINCT `query` FROM suggestions WHERE `query` LIKE :prefix || '%' ORDER BY date DESC LIMIT :limit")
+    suspend fun rawSuggestions(prefix: String, limit: Int): List<String>

-    @Query("SELECT * FROM suggestions ORDER BY date DESC LIMIT :limit")
-    suspend fun list(limit: Int): Array<Search>
+    @Query("SELECT DISTINCT `query` FROM suggestions ORDER BY date DESC LIMIT :limit")
+    suspend fun list(limit: Int): List<String>

    @Insert
    suspend fun insert(search: Search)
@@ -30,6 +30,7 @@ import com.hippo.ehviewer.EhDB
 import com.hippo.ehviewer.Settings
 import com.hippo.ehviewer.client.data.BaseGalleryInfo
 import com.hippo.ehviewer.client.data.GalleryInfo
+import com.hippo.ehviewer.dao.DownloadArtist
 import com.hippo.ehviewer.dao.DownloadInfo
 import com.hippo.ehviewer.dao.DownloadLabel
 import com.hippo.ehviewer.image.Image
@@ -174,7 +175,6 @@ object DownloadManager : OnSpiderListener, CoroutineScope {
            info = DownloadInfo(galleryInfo, galleryInfo.putToDownloadDir())
            info.label = label
            info.state = DownloadInfo.STATE_WAIT
-
            // Add to all download list and map
            allInfoList.insertWith(info, comparator())
            mAllInfoMap[galleryInfo.gid] = info
@@ -266,6 +266,7 @@ object DownloadManager : OnSpiderListener, CoroutineScope {

            // Save to
            EhDB.putDownloadInfo(info)
+            EhDB.putDownloadArtist(info.gid, info.artistInfoList)
        }
    }

@@ -530,26 +531,63 @@ object DownloadManager : OnSpiderListener, CoroutineScope {
    }

    suspend fun readMetadataFromLocal() {
-        val list = allInfoList.filter { it.pages == 0 || it.simpleTags == null }.parMapNotNull(concurrency = 5) { info ->
+        val list = allInfoList.mapNotNull {
+            val updateGallery = it.pages == 0 || it.simpleTags == null
+            val updateArtist = it.artistInfoList.isEmpty()
+            if (updateGallery || updateArtist) {
+                Triple(it, updateGallery, updateArtist)
+            } else {
+                null
+            }
+        }.parMapNotNull(concurrency = 5) { (info, updateGallery, updateArtist) ->
            info.downloadDir?.run {
                val comicInfo = findFile(COMIC_INFO_FILE)?.let { readComicInfo(it) }
                if (comicInfo != null) {
-                    info.pages = comicInfo.pageCount
-                    info.simpleTags = comicInfo.toSimpleTags()
-                    info.galleryInfo
+                    val galleryInfo = if (updateGallery) {
+                        info.pages = comicInfo.pageCount
+                        info.simpleTags = comicInfo.toSimpleTags()
+                        info.galleryInfo
+                    } else {
+                        null
+                    }
+
+                    val artistList = if (updateArtist && comicInfo.penciller != null) {
+                        info.artistInfoList = DownloadArtist.from(info.gid, comicInfo.penciller)
+                        info.gid to info.artistInfoList
+                    } else {
+                        null
+                    }
+
+                    if (galleryInfo != null || artistList != null) {
+                        galleryInfo to artistList
+                    } else {
+                        null
+                    }
                } else if (info.pages == 0) {
-                    findFile(SPIDER_INFO_FILENAME)?.let {
+                    val galleryInfo = findFile(SPIDER_INFO_FILENAME)?.let {
                        readCompatFromUniFile(it)?.run {
                            info.pages = pages
                            info.galleryInfo
                        }
                    }
+
+                    galleryInfo?.let { it to null }
                } else {
                    null
                }
            }
        }
-        EhDB.updateGalleryInfo(list)
+
+        val galleryInfoList = mutableListOf<BaseGalleryInfo>()
+        list.forEach { (info, artists) ->
+            info?.let {
+                galleryInfoList.add(it)
+            }
+            artists?.let { (gid, updateList) ->
+                EhDB.putDownloadArtist(gid, updateList)
+            }
+        }
+        if (galleryInfoList.isNotEmpty()) EhDB.updateGalleryInfo(galleryInfoList)
    }

    val isIdle: Boolean
@@ -797,5 +835,5 @@ var downloadLocation: UniFile
    }

 val DownloadInfo.downloadDir get() = dirname?.let { downloadLocation / it }
-val DownloadInfo.archiveFile get() = downloadDir?.findFile("$gid.cbz")
+val DownloadInfo.archiveFile get() = downloadDir?.run { findFile("$gid.cbz") ?: findFile("$gid.zip") }
 val GalleryInfo.tempDownloadDir get() = AppConfig.getTempDir("$gid")
@@ -34,7 +34,6 @@ import com.hippo.ehviewer.client.EhUtils
 import com.hippo.ehviewer.client.data.BaseGalleryInfo
 import com.hippo.ehviewer.dao.DownloadInfo
 import com.hippo.ehviewer.ui.MainActivity
-import com.hippo.ehviewer.ui.screen.DownloadsFragment
 import com.hippo.ehviewer.util.FileUtils
 import com.hippo.ehviewer.util.ReadableTime
 import com.hippo.ehviewer.util.SimpleHandler
@@ -148,9 +147,9 @@ class DownloadService : Service(), DownloadManager.DownloadListener, CoroutineSc

            ACTION_CLEAR -> {
                clear()
+                checkStopSelf()
            }
        }
-        checkStopSelf()
    }

    override fun onBind(intent: Intent) = error("No bindService")
@@ -187,7 +186,7 @@ class DownloadService : Service(), DownloadManager.DownloadListener, CoroutineSc
        clearIntent.action = ACTION_CLEAR
        val piClear = PendingIntent.getService(this, 0, clearIntent, PendingIntent.FLAG_IMMUTABLE)
        val bundle = Bundle()
-        bundle.putString(DownloadsFragment.KEY_ACTION, DownloadsFragment.ACTION_CLEAR_DOWNLOAD_SERVICE)
+        bundle.putString(KEY_ACTION, ACTION_CLEAR_DOWNLOAD_SERVICE)
        val activityIntent = Intent(this, MainActivity::class.java)
        activityIntent.action = ACTION_START_DOWNLOADSCENE
        activityIntent.putExtra(ACTION_START_DOWNLOADSCENE_ARGS, bundle)
@@ -243,7 +242,7 @@ class DownloadService : Service(), DownloadManager.DownloadListener, CoroutineSc
        }
        ensureDownloadingBuilder()
        val bundle = Bundle()
-        bundle.putLong(DownloadsFragment.KEY_GID, info.gid)
+        bundle.putLong(KEY_GID, info.gid)
        val activityIntent = Intent(this, MainActivity::class.java)
        activityIntent.action = ACTION_START_DOWNLOADSCENE
        activityIntent.putExtra(ACTION_START_DOWNLOADSCENE_ARGS, bundle)
@@ -540,6 +539,8 @@ class DownloadService : Service(), DownloadManager.DownloadListener, CoroutineSc
        const val KEY_LABEL = "label"
        const val KEY_GID = "gid"
        const val KEY_GID_LIST = "gid_list"
+        const val KEY_ACTION = "action"
+        const val ACTION_CLEAR_DOWNLOAD_SERVICE = "clear_download_service"
        private const val ID_DOWNLOADING = 1
        private const val ID_DOWNLOADED = 2
        private const val ID_509 = 3
@@ -0,0 +1,26 @@
+package com.hippo.ehviewer.download
+
+import com.hippo.ehviewer.dao.DownloadInfo
+import com.hippo.ehviewer.dao.artists
+
+enum class DownloadsFilterMode(
+    val flag: Int,
+    val take: (info: DownloadInfo, label: String?) -> Boolean,
+) {
+    CUSTOM(flag = 0, take = { info, label ->
+        label == "" || info.label == label
+    }),
+    ARTIST(flag = 1, take = { info, label ->
+        if (null == label) {
+            info.artistInfoList.isEmpty()
+        } else {
+            label == "" || info.artists.contains(label)
+        }
+    }),
+    ;
+
+    companion object {
+        val Default = ARTIST
+        fun from(flag: Int) = DownloadsFilterMode.entries[flag]
+    }
+}
@@ -55,7 +55,7 @@ class ArchivePageLoader(
    private val hostJob = launch(start = CoroutineStart.LAZY) {
        logcat(DEBUG_TAG) { "Open archive ${file.uri.displayPath}" }
        pfd = file.openFileDescriptor("r")
-        size = openArchive(pfd.fd, pfd.statSize, gid == 0L)
+        size = openArchive(pfd.fd, pfd.statSize, gid == 0L || file.name!!.endsWith(".zip"))
        if (size == 0) {
            return@launch
        }
@@ -22,7 +22,6 @@ import com.hippo.ehviewer.spider.SpiderQueen
 import com.hippo.ehviewer.spider.SpiderQueen.Companion.obtainSpiderQueen
 import com.hippo.ehviewer.spider.SpiderQueen.Companion.releaseSpiderQueen
 import com.hippo.ehviewer.spider.SpiderQueen.OnSpiderListener
-import com.hippo.ehviewer.util.FileUtils
 import com.hippo.unifile.UniFile

 class EhPageLoader(private val mGalleryInfo: GalleryInfo, startPage: Int) :
@@ -43,11 +42,11 @@ class EhPageLoader(private val mGalleryInfo: GalleryInfo, startPage: Int) :
    }

    override val title by lazy {
-        FileUtils.sanitizeFilename(EhUtils.getSuitableTitle(mGalleryInfo))
+        EhUtils.getSuitableTitle(mGalleryInfo)
    }

-    override fun getImageExtension(index: Int): String {
-        return mSpiderQueen.getExtension(index)!!
+    override fun getImageExtension(index: Int): String? {
+        return mSpiderQueen.getExtension(index)
    }

    override fun save(index: Int, file: UniFile): Boolean {
@@ -17,6 +17,7 @@ package com.hippo.ehviewer.gallery

 import androidx.annotation.CallSuper
 import com.hippo.ehviewer.EhDB
+import com.hippo.ehviewer.util.FileUtils
 import com.hippo.unifile.UniFile
 import eu.kanade.tachiyomi.ui.reader.loader.PageLoader
 import kotlinx.coroutines.CoroutineScope
@@ -59,16 +60,15 @@ abstract class PageLoader2(private val gid: Long, var startPage: Int) : PageLoad

    protected abstract val title: String

-    protected abstract fun getImageExtension(index: Int): String
+    protected abstract fun getImageExtension(index: Int): String?

-    fun getImageFilename(index: Int): String {
-        return "$title - ${index + 1}.${getImageExtension(index)}"
+    fun getImageFilename(index: Int): String? = getImageExtension(index)?.let {
+        FileUtils.sanitizeFilename("$title - ${index + 1}.${it.lowercase()}")
    }

    abstract fun save(index: Int, file: UniFile): Boolean

-    fun saveToDir(index: Int, dir: UniFile): UniFile? {
-        val filename = getImageFilename(index)
-        return (dir / filename).takeIf { save(index, it) }
+    fun saveToDir(index: Int, dir: UniFile): UniFile? = getImageFilename(index)?.let { filename ->
+        (dir / filename).takeIf { save(index, it) }
    }
 }
@@ -30,8 +30,8 @@ import coil3.imageLoader
 import coil3.request.CachePolicy
 import coil3.request.ErrorResult
 import coil3.request.SuccessResult
+import coil3.size.Dimension
 import coil3.size.Precision
-import coil3.size.Scale
 import com.hippo.ehviewer.Settings
 import com.hippo.ehviewer.coil.BitmapImageWithRect
 import com.hippo.ehviewer.coil.maybeCropBorder
@@ -73,15 +73,13 @@ class Image private constructor(image: CoilImage, private val src: AutoCloseable
    }

    companion object {
-        private val targetWidth = appCtx.resources.displayMetrics.widthPixels * 2
-        private val targetHeight = appCtx.resources.displayMetrics.heightPixels * 2
+        private val targetWidth = appCtx.resources.displayMetrics.widthPixels * 3

        private suspend fun Either<ByteBufferSource, UniFileSource>.decodeCoil(): CoilImage {
            val req = appCtx.imageRequest {
                onLeft { data(it.source) }
                onRight { data(it.source.uri) }
-                size(targetWidth, targetHeight)
-                scale(Scale.FILL)
+                size(Dimension(targetWidth), Dimension.Undefined)
                precision(Precision.INEXACT)
                maybeCropBorder(Settings.cropBorder.value)
                memoryCachePolicy(CachePolicy.DISABLED)
@@ -94,7 +92,7 @@ class Image private constructor(image: CoilImage, private val src: AutoCloseable

        suspend fun decode(src: ImageSource): Image? {
            return runCatching {
-                when (src) {
+                val image = when (src) {
                    is UniFileSource -> {
                        if (isAtLeastP && !isAtLeastU) {
                            src.source.openFileDescriptor("rw").use {
@@ -112,20 +110,19 @@ class Image private constructor(image: CoilImage, private val src: AutoCloseable
                                }
                            }
                        }
-                        val image = src.right().decodeCoil()
-                        if (image is BitmapImage) src.close()
-                        Image(image, src)
+                        src.right().decodeCoil()
                    }

                    is ByteBufferSource -> {
                        if (isAtLeastP && !isAtLeastU) {
                            rewriteGifSource(src.source)
                        }
-                        val image = src.left().decodeCoil()
-                        if (image is BitmapImage) src.close()
-                        Image(image, src)
+                        src.left().decodeCoil()
                    }
                }
+                Image(image, src).apply {
+                    if (innerImage is BitmapImage) src.close()
+                }
            }.onFailure {
                src.close()
                logcat(it)
@@ -24,8 +24,6 @@ import java.nio.ByteBuffer
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
-import kotlinx.coroutines.DelicateCoroutinesApi
-import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.consumeEach
 import kotlinx.coroutines.job
@@ -42,7 +40,6 @@ object CronetEngine : HttpClientEngineBase("Cronet") {
    @InternalAPI
    override suspend fun execute(data: HttpRequestData) = executeHttpRequest(callContext(), data)

-    @OptIn(DelicateCoroutinesApi::class)
    private suspend fun executeHttpRequest(
        callContext: CoroutineContext,
        data: HttpRequestData,
@@ -50,7 +47,7 @@ object CronetEngine : HttpClientEngineBase("Cronet") {
        val requestTime = GMTDate()

        val callback = object : UrlRequest.Callback() {
-            lateinit var chunkChan: Channel<ByteBuffer>
+            val chunkChan = Channel<ByteBuffer>()
            override fun onRedirectReceived(request: UrlRequest, info: UrlResponseInfo, newLocationUrl: String) {
                continuation.resume(
                    info.toHttpResponseData(
@@ -65,9 +62,8 @@ object CronetEngine : HttpClientEngineBase("Cronet") {
                    info.toHttpResponseData(
                        requestTime = requestTime,
                        callContext = callContext,
-                        responseBody = GlobalScope.writer(callContext) {
+                        responseBody = writer(callContext.job) {
                            pool.useInstance {
-                                chunkChan = Channel()
                                request.read(it)
                                chunkChan.consumeEach { buffer ->
                                    buffer.flip()
@@ -76,7 +76,7 @@ fun GalleryInfo.getComicInfo(): ComicInfo {
    }
    return ComicInfo(
        series = title,
-        alternateSeries = titleJpn.takeUnless { it.isNullOrBlank() },
+        alternateSeries = titleJpn?.ifBlank { null },
        writer = groups.ifEmpty { null },
        penciller = artists.ifEmpty { null },
        genre = otherTags.ifEmpty { null },
@@ -99,7 +99,6 @@ fun ComicInfo.toSimpleTags() = listOfNotNull(

 fun ComicInfo.write(file: UniFile) {
    file.openOutputStream().use {
-        it.channel.truncate(0)
        OutputStreamWriter(it, Charsets.UTF_8).use { writer ->
            xmlStreaming.newGenericWriter(writer).use { xmlWriter ->
                xml.encodeToWriter(xmlWriter, ComicInfo.serializer(), this)
@@ -28,9 +28,12 @@ import com.hippo.ehviewer.client.EhUtils.getSuitableTitle
 import com.hippo.ehviewer.client.data.GalleryDetail
 import com.hippo.ehviewer.client.data.GalleryInfo
 import com.hippo.ehviewer.client.ehRequest
+import com.hippo.ehviewer.client.executeSafely
 import com.hippo.ehviewer.client.getImageKey
 import com.hippo.ehviewer.coil.read
 import com.hippo.ehviewer.coil.suspendEdit
+import com.hippo.ehviewer.dao.DownloadArtist
+import com.hippo.ehviewer.download.DownloadManager
 import com.hippo.ehviewer.download.downloadLocation
 import com.hippo.ehviewer.download.tempDownloadDir
 import com.hippo.ehviewer.image.UniFileSource
@@ -40,7 +43,7 @@ import com.hippo.ehviewer.util.sendTo
 import com.hippo.unifile.UniFile
 import com.hippo.unifile.asUniFile
 import com.hippo.unifile.openOutputStream
-import eu.kanade.tachiyomi.util.lang.withNonCancellableContext
+import com.hippo.unifile.sha1
 import eu.kanade.tachiyomi.util.system.logcat
 import io.ktor.client.plugins.onDownload
 import io.ktor.client.statement.HttpResponse
@@ -157,7 +160,7 @@ class SpiderDen(val info: GalleryInfo) {
            notifyProgress(total!!, done, (done - prev).toInt())
            prev = done
        }
-    }.execute {
+    }.executeSafely {
        if (it.status.isSuccess()) {
            saveFromHttpResponse(index, it)
        } else {
@@ -191,9 +194,11 @@ class SpiderDen(val info: GalleryInfo) {
        val extension = MimeTypeMap.getFileExtensionFromUrl(url).ifEmpty { "jpg" }
        return saveResponseMeta(index, extension) { outFile ->
            outFile.openOutputStream().use {
-                val chan = it.channel.apply { truncate(0) }
-                response.bodyAsChannel().copyTo(chan)
+                response.bodyAsChannel().copyTo(it.channel)
            }
+            val expected = FileHashRegex.find(url)?.run { groupValues[0] }
+            val actual = outFile.sha1()
+            check(expected == actual) { "File hash mismatch: expected $expected, but got $actual\nURL: $url" }
        }
    }

@@ -274,7 +279,7 @@ class SpiderDen(val info: GalleryInfo) {
        val archived = saveAsCbz && dir?.findFile(archiveName) != null
        if (archived) {
            dir.listFiles().parMap(concurrency = 10) {
-                if (it.name?.matches(filenamePattern) == true) {
+                if (it.name?.matches(FileNameRegex) == true) {
                    it.delete()
                }
            }
@@ -321,11 +326,15 @@ class SpiderDen(val info: GalleryInfo) {
            createFile(COMIC_INFO_FILE)?.also {
                runCatching {
                    if (info !is GalleryDetail && fetchMetadata) {
-                        withNonCancellableContext {
-                            EhEngine.fillGalleryListByApi(listOf(info))
+                        EhEngine.fillGalleryListByApi(listOf(info))
+                    }
+                    info.getComicInfo().apply {
+                        write(it)
+                        DownloadManager.getDownloadInfo(gid)?.let { downloadInfo ->
+                            downloadInfo.artistInfoList = DownloadArtist.from(gid, penciller.orEmpty())
+                            EhDB.putDownloadArtist(gid, downloadInfo.artistInfoList)
                        }
                    }
-                    info.getComicInfo().write(it)
                }.onFailure {
                    logcat(it)
                }
@@ -334,7 +343,8 @@ class SpiderDen(val info: GalleryInfo) {
    }
 }

-private val filenamePattern = Regex("^\\d{8}\\.\\w{3,4}")
+private val FileNameRegex = Regex("^\\d{8}\\.\\w{3,4}")
+private val FileHashRegex = Regex("[0-9a-f]{40}")

 fun perFilename(index: Int, extension: String = ""): String {
    return "%08d.%s".format(index + 1, extension)
@@ -244,12 +244,15 @@ class SpiderQueen private constructor(val galleryInfo: GalleryInfo) : CoroutineS
            if (archiveJob.isActive) {
                archiveJob.join()
            }
-            runCatching {
-                if (!mSpiderDen.postArchive()) {
+            if (!mSpiderDen.postArchive()) {
+                if (mWorkerScope.isDownloadMode) {
+                    mSpiderDen.writeComicInfo()
+                }
+                runCatching {
                    writeSpiderInfoToLocal()
+                }.onFailure {
+                    logcat(it)
                }
-            }.onFailure {
-                logcat(it)
            }
            queenScope.cancel()
        }
@@ -483,13 +486,7 @@ class SpiderQueen private constructor(val galleryInfo: GalleryInfo) : CoroutineS
            val gid = galleryInfo.gid
            return (sQueenMap[gid] ?: SpiderQueen(galleryInfo).also { sQueenMap[gid] = it }).apply {
                setMode(mode)
-                launch {
-                    // Will create download dir if not exists
-                    updateMode()
-                    if (mode == MODE_DOWNLOAD) {
-                        mSpiderDen.writeComicInfo()
-                    }
-                }
+                launch { updateMode() }
            }
        }

@@ -516,7 +513,8 @@ class SpiderQueen private constructor(val galleryInfo: GalleryInfo) : CoroutineS
        private val downloadTimeout = Settings.downloadTimeout.seconds
        private val delayLock = Mutex()
        private var lastRequestTime = TimeSource.Monotonic.markNow()
-        private var isDownloadMode = false
+        var isDownloadMode = false
+            private set

        fun cancelDecode(index: Int) {
            decoder.cancel(index)
@@ -547,13 +545,20 @@ class SpiderQueen private constructor(val galleryInfo: GalleryInfo) : CoroutineS

        private fun doLaunchDownloadJob(index: Int, force: Boolean, orgImg: Boolean = false) {
            val state = mPageStateArray[index]
-            if (!force && state == STATE_FINISHED) return
+            if (!force) {
+                if (state == STATE_FINISHED) return
+                if (index in mSpiderDen) return updatePageState(index, STATE_FINISHED)
+            }
            val currentJob = mFetcherJobMap[index]
            val skipHath = force && !orgImg && currentJob?.isActive == true
            if (force) currentJob?.cancel(CancellationException(FORCE_RETRY))
            if (currentJob?.isActive != true) {
                mFetcherJobMap[index] = launch {
                    runCatching {
+                        delayLock.withLock {
+                            delay(mDownloadDelay - lastRequestTime.elapsedNow())
+                            lastRequestTime = TimeSource.Monotonic.markNow()
+                        }
                        mSemaphore.withPermit {
                            doInJob(index, force, orgImg, skipHath)
                        }
@@ -591,19 +596,14 @@ class SpiderQueen private constructor(val galleryInfo: GalleryInfo) : CoroutineS
                    ?: getPTokenFromMultiPageViewer(index)
            }
            updatePageState(index, STATE_DOWNLOADING)
-            if (!force && index in mSpiderDen) {
-                return updatePageState(index, STATE_FINISHED)
-            }
-            if (force) {
-                pTokenLock.withLock {
-                    val pToken = mSpiderInfo.pTokenMap[index]
-                    if (pToken == TOKEN_FAILED) mSpiderInfo.pTokenMap.remove(index)
-                }
-            }
            val previousPToken: String?
            val pToken: String
-
            pTokenLock.withLock {
+                if (force) {
+                    if (mSpiderInfo.pTokenMap[index] == TOKEN_FAILED) {
+                        mSpiderInfo.pTokenMap.remove(index)
+                    }
+                }
                pToken = getPToken(index)
                    ?: return updatePageState(index, STATE_FAILED, PTOKEN_FAILED_MESSAGE).also {
                        mSpiderInfo.pTokenMap[index] = TOKEN_FAILED
@@ -611,11 +611,6 @@ class SpiderQueen private constructor(val galleryInfo: GalleryInfo) : CoroutineS
                previousPToken = getPToken(index - 1)
            }

-            delayLock.withLock {
-                delay(mDownloadDelay - lastRequestTime.elapsedNow())
-                lastRequestTime = TimeSource.Monotonic.markNow()
-            }
-
            var skipHathKey: String? = null
            var originImageUrl: String? = null
            var error: String? = null
@@ -651,15 +646,15 @@ class SpiderQueen private constructor(val galleryInfo: GalleryInfo) : CoroutineS
                                pToken,
                                localShowKey,
                                previousPToken,
-                            ).let {
-                                check509(it.imageUrl)
-                                imageUrl = it.imageUrl
-                                skipHathKey = it.skipHathKey
-                                originImageUrl = it.originImageUrl
-                            }
-                        }.onFailure {
+                            )
+                        }.getOrElse {
                            forceHtml = true
                            return@repeat
+                        }.let {
+                            check509(it.imageUrl)
+                            imageUrl = it.imageUrl
+                            skipHathKey = it.skipHathKey
+                            originImageUrl = it.originImageUrl
                        }
                    }

@@ -738,31 +733,37 @@ class SpiderQueen private constructor(val galleryInfo: GalleryInfo) : CoroutineS
                    val currentJob = mDecodeJobMap[index]
                    if (currentJob?.isActive != true) {
                        mDecodeJobMap[index] = launch {
-                            doInJob(index)
+                            runCatching {
+                                mSemaphore.withPermit {
+                                    mFetcherJobMap[index]?.join()
+                                    if (mPageStateArray[index] == STATE_FINISHED) {
+                                        doInJob(index)
+                                    }
+                                }
+                            }.onFailure {
+                                if (mPageStateArray[index] == STATE_FINISHED) {
+                                    notifyGetImageFailure(index, DECODE_ERROR)
+                                }
+                                if (it is CancellationException) {
+                                    throw it
+                                }
+                            }
                        }
                    }
                }
            }

            private suspend fun doInJob(index: Int) {
-                mFetcherJobMap[index]?.takeIf { it.isActive }?.join()
+                val src = mSpiderDen.getImageSource(index) ?: return
+                val image = Image.decode(src)
+                checkNotNull(image)
                runCatching {
-                    val src = mSpiderDen.getImageSource(index) ?: return
-                    val image = mSemaphore.withPermit { Image.decode(src) }
-                    checkNotNull(image)
-                    runCatching {
-                        currentCoroutineContext().ensureActive()
-                    }.onFailure {
-                        image.recycle()
-                        throw it
-                    }
-                    notifyGetImageSuccess(index, image)
+                    currentCoroutineContext().ensureActive()
                }.onFailure {
-                    notifyGetImageFailure(index, DECODE_ERROR)
-                    if (it is CancellationException) {
-                        throw it
-                    }
+                    image.recycle()
+                    throw it
                }
+                notifyGetImageSuccess(index, image)
            }
        }
    }
@@ -40,7 +40,6 @@ import androidx.core.content.ContextCompat
 import com.hippo.ehviewer.EhDB
 import com.hippo.ehviewer.R
 import com.hippo.ehviewer.Settings
-import com.hippo.ehviewer.client.EhCookieStore
 import com.hippo.ehviewer.client.EhEngine
 import com.hippo.ehviewer.client.EhUtils
 import com.hippo.ehviewer.client.data.BaseGalleryInfo
@@ -161,7 +160,7 @@ suspend fun DialogState.startDownload(
                add(it.label)
            }
        }
-        val (selected, checked) = showSelectItemWithCheckBox(
+        val (selected, checked) = awaitSelectItemWithCheckBox(
            items,
            title = R.string.download,
            checkBoxText = R.string.remember_download_label,
@@ -190,7 +189,7 @@ suspend fun DialogState.startDownload(

 suspend fun DialogState.modifyFavorites(galleryInfo: BaseGalleryInfo): Boolean {
    val localFavorited = EhDB.containLocalFavorites(galleryInfo.gid)
-    if (EhCookieStore.hasSignedIn()) {
+    if (Settings.hasSignedIn.value) {
        val isFavorited = galleryInfo.favoriteSlot != NOT_FAVORITED
        val defaultFavSlot = Settings.defaultFavSlot
        if (defaultFavSlot == -2) {
@@ -206,7 +205,7 @@ suspend fun DialogState.modifyFavorites(galleryInfo: BaseGalleryInfo): Boolean {
                add(localFav)
                addAll(cloudFav)
            }
-            val (slot, note) = showSelectItemWithIconAndTextField(
+            val (slot, note) = awaitSelectItemWithIconAndTextField(
                items,
                title = R.string.add_favorites_dialog_title,
                hint = R.string.favorite_note,
@@ -311,10 +310,14 @@ suspend fun doGalleryInfoAction(info: BaseGalleryInfo) {
            add(Icons.AutoMirrored.Default.DriveFileMove to R.string.download_move_dialog_title)
        }
    }
-    val selected = showSelectItemWithIcon(items, EhUtils.getSuitableTitle(info))
+    val selected = awaitSelectItemWithIcon(items, EhUtils.getSuitableTitle(info))
    with(findActivity<MainActivity>()) {
        when (selected) {
-            0 -> navToReader(info)
+            0 -> {
+                EhDB.putHistoryInfo(info)
+                navToReader(info)
+            }
+
            1 -> withUIContext {
                if (downloaded) {
                    confirmRemoveDownload(info)
@@ -406,7 +409,7 @@ suspend fun DialogState.showMoveDownloadLabel(info: GalleryInfo) {
            add(it.label)
        }
    }
-    val selected = showSelectItem(labels, R.string.download_move_dialog_title)
+    val selected = awaitSelectItem(labels, R.string.download_move_dialog_title)
    val downloadInfo = DownloadManager.getDownloadInfo(info.gid) ?: return
    val label = if (selected == 0) null else labels[selected]
    DownloadManager.changeLabel(listOf(downloadInfo), label)
@@ -420,19 +423,19 @@ suspend fun DialogState.showMoveDownloadLabelList(list: Collection<DownloadInfo>
            add(it.label)
        }
    }
-    val selected = showSelectItem(labels, R.string.download_move_dialog_title)
+    val selected = awaitSelectItem(labels, R.string.download_move_dialog_title)
    val label = if (selected == 0) null else labels[selected]
    DownloadManager.changeLabel(list, label)
    return label
 }

-suspend fun DialogState.showDatePicker(): String? {
+suspend fun DialogState.awaitSelectDate(): String? {
    val initial = LocalDate(2007, 3, 21)
    val yesterday = Clock.System.todayIn(TimeZone.UTC).minus(1, DateTimeUnit.DAY)
    val initialMillis = initial.toEpochMillis()
    val yesterdayMillis = yesterday.toEpochMillis()
    val dateRange = initialMillis..yesterdayMillis
-    val dateMillis = showDatePicker(
+    val dateMillis = awaitSelectDate(
        title = R.string.go_to,
        yearRange = initial.year..yesterday.year,
        selectableDates = object : SelectableDates {
@@ -16,16 +16,26 @@
 package com.hippo.ehviewer.ui

 import android.os.Bundle
+import android.view.View
 import androidx.activity.enableEdgeToEdge
 import androidx.appcompat.app.AppCompatActivity
 import androidx.navigation.ActivityNavigator
 import com.hippo.ehviewer.Settings
+import com.hippo.ehviewer.util.isAtLeastR
 import eu.kanade.tachiyomi.util.view.setSecureScreen

 abstract class EhActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
+        // https://issuetracker.google.com/204791558
+        // Fix system bars insets still exist in fullscreen mode on API < 30
+        @Suppress("DEPRECATION")
+        if (!isAtLeastR) {
+            with(window.decorView) {
+                systemUiVisibility = systemUiVisibility and View.SYSTEM_UI_FLAG_LAYOUT_STABLE.inv()
+            }
+        }
    }

    override fun onResume() {
@@ -49,47 +49,59 @@ import androidx.compose.material.icons.filled.History
 import androidx.compose.material.icons.filled.Home
 import androidx.compose.material.icons.filled.Settings
 import androidx.compose.material.icons.filled.Whatshot
+import androidx.compose.material3.DrawerDefaults
+import androidx.compose.material3.DrawerState
 import androidx.compose.material3.DrawerState2
 import androidx.compose.material3.DrawerValue
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.ModalDrawerSheet
 import androidx.compose.material3.ModalNavigationDrawer
+import androidx.compose.material3.ModalSideDrawer
 import androidx.compose.material3.NavigationDrawerItem
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.ShapeDefaults
-import androidx.compose.material3.SideDrawer
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.SnackbarResult
 import androidx.compose.material3.Text
+import androidx.compose.material3.adaptive.currentWindowAdaptiveInfo
 import androidx.compose.material3.rememberDrawerState
-import androidx.compose.material3.windowsizeclass.calculateWindowSizeClass
+import androidx.compose.material3.rememberDrawerState2
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.State
+import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.compositionLocalOf
 import androidx.compose.runtime.currentCompositeKeyHash
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
 import androidx.compose.runtime.mutableStateListOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.setValue
+import androidx.compose.runtime.snapshotFlow
 import androidx.compose.runtime.snapshots.SnapshotStateList
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.BlurEffect
+import androidx.compose.ui.graphics.RectangleShape
+import androidx.compose.ui.graphics.TileMode
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.layout.onSizeChanged
 import androidx.compose.ui.platform.LocalConfiguration
 import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.platform.LocalViewConfiguration
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.util.lerp
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.lifecycle.compose.LifecycleResumeEffect
 import androidx.navigation.compose.rememberNavController
@@ -117,15 +129,14 @@ import com.hippo.ehviewer.ui.destinations.WhatshotScreenDestination
 import com.hippo.ehviewer.ui.screen.asDst
 import com.hippo.ehviewer.ui.screen.asDstWith
 import com.hippo.ehviewer.ui.screen.navWithUrl
-import com.hippo.ehviewer.ui.screen.navigate
 import com.hippo.ehviewer.ui.settings.showNewVersion
 import com.hippo.ehviewer.ui.tools.DialogState
 import com.hippo.ehviewer.ui.tools.LabeledCheckbox
 import com.hippo.ehviewer.ui.tools.LocalDialogState
-import com.hippo.ehviewer.ui.tools.LocalTouchSlopProvider
 import com.hippo.ehviewer.ui.tools.LocalWindowSizeClass
 import com.hippo.ehviewer.updater.AppUpdater
 import com.hippo.ehviewer.util.addTextToClipboard
+import com.hippo.ehviewer.util.calculateFraction
 import com.hippo.ehviewer.util.displayString
 import com.hippo.ehviewer.util.getParcelableExtraCompat
 import com.hippo.ehviewer.util.getUrlFromClipboard
@@ -134,8 +145,9 @@ import com.hippo.ehviewer.util.isAtLeastS
 import com.hippo.unifile.asUniFile
 import com.hippo.unifile.sha1
 import com.ramcosta.composedestinations.DestinationsNavHost
-import com.ramcosta.composedestinations.rememberNavHostEngine
+import com.ramcosta.composedestinations.spec.DirectionDestinationSpec
 import com.ramcosta.composedestinations.utils.currentDestinationAsState
+import com.ramcosta.composedestinations.utils.rememberDestinationsNavigator
 import eu.kanade.tachiyomi.util.lang.withIOContext
 import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.channels.Channel
@@ -148,7 +160,7 @@ import moe.tarsin.coroutines.runSuspendCatching
 import splitties.systemservices.clipboardManager
 import splitties.systemservices.connectivityManager

-private val navItems = arrayOf(
+private val navItems = arrayOf<Triple<DirectionDestinationSpec, Int, ImageVector>>(
    Triple(HomePageScreenDestination, R.string.homepage, Icons.Default.Home),
    Triple(SubscriptionScreenDestination, R.string.subscription, EhIcons.Default.Subscriptions),
    Triple(WhatshotScreenDestination, R.string.whats_hot, Icons.Default.Whatshot),
@@ -203,10 +215,11 @@ class MainActivity : EhActivity() {
            val configuration = LocalConfiguration.current
            val dialogState = LocalDialogState.current
            val navDrawerState = rememberDrawerState(DrawerValue.Closed)
-            val sideSheetState = rememberDrawerState(DrawerValue.Closed)
+            val sideSheetState = rememberDrawerState2(DrawerValue.Closed)
            val snackbarState = remember { SnackbarHostState() }
            val scope = rememberCoroutineScope()
            val navController = rememberNavController()
+            val navigator = navController.rememberDestinationsNavigator()
            fun closeDrawer(callback: () -> Unit = {}) = scope.launch {
                navDrawerState.close()
                callback()
@@ -225,7 +238,7 @@ class MainActivity : EhActivity() {
                            style = MaterialTheme.typography.titleMedium,
                        )
                    }
-                    navController.navigate(DownloadScreenDestination)
+                    navigator.navigate(DownloadScreenDestination)
                }
            }

@@ -249,7 +262,7 @@ class MainActivity : EhActivity() {
                    when (intent.action) {
                        Intent.ACTION_VIEW -> {
                            val url = intent.data?.toString()
-                            if (url != null && !navController.navWithUrl(url)) {
+                            if (url != null && !navigator.navWithUrl(url)) {
                                val new = dialogState.awaitInputText(initial = url, title = cannotParse)
                                addTextToClipboard(new)
                            }
@@ -258,26 +271,28 @@ class MainActivity : EhActivity() {
                            val type = intent.type
                            if ("text/plain" == type) {
                                val keyword = intent.getStringExtra(Intent.EXTRA_TEXT)
-                                if (keyword != null && !navController.navWithUrl(keyword)) {
-                                    navController.navigate(ListUrlBuilder(mKeyword = keyword).asDst())
+                                if (keyword != null && !navigator.navWithUrl(keyword)) {
+                                    navigator.navigate(ListUrlBuilder(mKeyword = keyword).asDst())
                                }
                            } else if (type != null && type.startsWith("image/")) {
                                val uri = intent.getParcelableExtraCompat<Uri>(Intent.EXTRA_STREAM)
                                if (null != uri) {
-                                    withIOContext { uri.asUniFile().sha1() }?.let {
-                                        navController.navigate(
-                                            ListUrlBuilder(
-                                                mode = ListUrlBuilder.MODE_IMAGE_SEARCH,
-                                                hash = it,
-                                            ).asDst(),
-                                        )
-                                    }
+                                    val hash = withIOContext { uri.asUniFile().sha1() }
+                                    navigator.navigate(
+                                        ListUrlBuilder(
+                                            mode = ListUrlBuilder.MODE_IMAGE_SEARCH,
+                                            hash = hash,
+                                        ).asDst(),
+                                    )
                                }
                            }
                        }
                        DownloadService.ACTION_START_DOWNLOADSCENE -> {
-                            val args = intent.getBundleExtra(DownloadService.ACTION_START_DOWNLOADSCENE_ARGS)
-                            navController.navigate(DownloadsScreenDestination)
+                            val args = intent.getBundleExtra(DownloadService.ACTION_START_DOWNLOADSCENE_ARGS)!!
+                            if (args.getString(DownloadService.KEY_ACTION) == DownloadService.ACTION_CLEAR_DOWNLOAD_SERVICE) {
+                                DownloadService.clear()
+                            }
+                            navigator.navigate(DownloadsScreenDestination)
                        }
                    }
                }
@@ -308,7 +323,7 @@ class MainActivity : EhActivity() {
            }
            val snackMessage = stringResource(R.string.clipboard_gallery_url_snack_message)
            val snackAction = stringResource(R.string.clipboard_gallery_url_snack_action)
-            LifecycleResumeEffect {
+            LifecycleResumeEffect(scope) {
                val job = scope.launch {
                    delay(300)
                    val text = clipboardManager.getUrlFromClipboard(applicationContext)
@@ -317,11 +332,11 @@ class MainActivity : EhActivity() {
                        val result1 = GalleryDetailUrlParser.parse(text, false)
                        var launch: (() -> Unit)? = null
                        if (result1 != null) {
-                            launch = { navController.navigate(result1.gid asDstWith result1.token) }
+                            launch = { navigator.navigate(result1.gid asDstWith result1.token) }
                        }
                        val result2 = GalleryPageUrlParser.parse(text, false)
                        if (result2 != null) {
-                            launch = { navController.navigate(ProgressScreenDestination(result2.gid, result2.pToken, result2.page)) }
+                            launch = { navigator.navigate(ProgressScreenDestination(result2.gid, result2.pToken, result2.page)) }
                        }
                        launch?.let {
                            val ret = snackbarState.showSnackbar(snackMessage, snackAction, true)
@@ -333,17 +348,18 @@ class MainActivity : EhActivity() {
                onPauseOrDispose { job.cancel() }
            }
            val currentDestination by navController.currentDestinationAsState()
-            val lockDrawerHandle = remember { mutableStateListOf<Int>() }
+            val drawerHandle = remember { mutableStateListOf<Int>() }
            var snackbarFabPadding by remember { mutableStateOf(0.dp) }
-            val drawerLocked = lockDrawerHandle.isNotEmpty()
-            val viewConfiguration = LocalViewConfiguration.current
+            val drawerEnabled = drawerHandle.isNotEmpty()
            val density = LocalDensity.current
+            val adaptiveInfo = currentWindowAdaptiveInfo()
            CompositionLocalProvider(
                LocalNavDrawerState provides navDrawerState,
                LocalSideSheetState provides sideSheetState,
-                LocalDrawerLockHandle provides lockDrawerHandle,
+                LocalDrawerHandle provides drawerHandle,
                LocalSnackBarHostState provides snackbarState,
                LocalSnackBarFabPadding provides animateDpAsState(snackbarFabPadding, label = "SnackbarFabPadding"),
+                LocalWindowSizeClass provides adaptiveInfo.windowSizeClass,
            ) {
                Scaffold(
                    snackbarHost = {
@@ -357,81 +373,85 @@ class MainActivity : EhActivity() {
                        )
                    },
                ) {
-                    LocalTouchSlopProvider(Settings.touchSlopFactor.toFloat()) {
-                        ModalNavigationDrawer(
-                            drawerContent = {
-                                ModalDrawerSheet(
-                                    modifier = Modifier.widthIn(max = (configuration.screenWidthDp - 56).dp),
-                                    windowInsets = WindowInsets.systemBars.only(WindowInsetsSides.Start),
+                    var minOffset by remember {
+                        mutableFloatStateOf(-with(density) { DrawerDefaults.MaximumDrawerWidth.toPx() })
+                    }
+                    ModalNavigationDrawer(
+                        drawerContent = {
+                            ModalDrawerSheet(
+                                drawerState = navDrawerState,
+                                modifier = Modifier.widthIn(max = (configuration.screenWidthDp - 56).dp)
+                                    .onSizeChanged { minOffset = -it.width.toFloat() },
+                                windowInsets = WindowInsets.systemBars.only(WindowInsetsSides.Start),
+                            ) {
+                                val scrollState = rememberScrollState()
+                                Column(
+                                    modifier = Modifier.verticalScroll(scrollState)
+                                        .windowInsetsPadding(WindowInsets.systemBars.only(WindowInsetsSides.Bottom)),
                                ) {
-                                    val scrollState = rememberScrollState()
-                                    Column(
-                                        modifier = Modifier.verticalScroll(scrollState)
-                                            .windowInsetsPadding(WindowInsets.systemBars.only(WindowInsetsSides.Bottom)),
-                                    ) {
-                                        Image(
-                                            painter = painterResource(id = R.drawable.sadpanda_low_poly),
-                                            contentDescription = null,
-                                            modifier = Modifier.fillMaxWidth().padding(bottom = 8.dp),
-                                            contentScale = ContentScale.FillWidth,
+                                    Image(
+                                        painter = painterResource(id = R.drawable.sadpanda_low_poly),
+                                        contentDescription = null,
+                                        modifier = Modifier.fillMaxWidth().padding(bottom = 8.dp),
+                                        contentScale = ContentScale.FillWidth,
+                                    )
+                                    navItems.forEach { (direction, stringId, icon) ->
+                                        NavigationDrawerItem(
+                                            label = {
+                                                Text(text = stringResource(id = stringId))
+                                            },
+                                            selected = currentDestination === direction,
+                                            onClick = {
+                                                navigator.navigate(direction)
+                                                closeDrawer()
+                                            },
+                                            modifier = Modifier.padding(horizontal = 12.dp),
+                                            icon = {
+                                                Icon(imageVector = icon, contentDescription = null)
+                                            },
                                        )
-                                        navItems.forEach { (direction, stringId, icon) ->
-                                            NavigationDrawerItem(
-                                                label = {
-                                                    Text(text = stringResource(id = stringId))
-                                                },
-                                                selected = currentDestination === direction,
-                                                onClick = {
-                                                    navController.navigate(direction.route)
-                                                    closeDrawer()
-                                                },
-                                                modifier = Modifier.padding(horizontal = 12.dp),
-                                                icon = {
-                                                    Icon(imageVector = icon, contentDescription = null)
-                                                },
-                                            )
-                                        }
+                                    }
+                                }
+                            }
+                        },
+                        drawerState = navDrawerState,
+                        gesturesEnabled = drawerEnabled && sideSheetState.isClosed || navDrawerState.isOpen,
+                    ) {
+                        val sheet = sideSheet.firstOrNull()
+                        val radius by remember {
+                            snapshotFlow {
+                                val step = calculateFraction(minOffset, 0f, navDrawerState.currentOffset)
+                                with(density) { lerp(0, 10, step).dp.toPx() }
+                            }
+                        }.collectAsState(0f)
+                        ModalSideDrawer(
+                            drawerContent = {
+                                if (sheet != null) {
+                                    ModalDrawerSheet(
+                                        modifier = Modifier.widthIn(max = (configuration.screenWidthDp - 112).dp),
+                                        drawerShape = ShapeDefaults.Large.copy(topEnd = CornerSize(0), bottomEnd = CornerSize(0)),
+                                        windowInsets = WindowInsets.systemBars.only(WindowInsetsSides.Top + WindowInsetsSides.End),
+                                    ) {
+                                        sheet(sideSheetState)
                                    }
                                }
                            },
-                            drawerState = navDrawerState,
-                            gesturesEnabled = !drawerLocked || navDrawerState.isOpen,
-                        ) {
-                            val sheet = sideSheet.firstOrNull()
-                            SideDrawer(
-                                drawerContent = {
-                                    if (sheet != null) {
-                                        ModalDrawerSheet(
-                                            modifier = Modifier.widthIn(max = (configuration.screenWidthDp - 112).dp),
-                                            drawerShape = ShapeDefaults.Large.copy(topEnd = CornerSize(0), bottomEnd = CornerSize(0)),
-                                            windowInsets = WindowInsets.systemBars.only(WindowInsetsSides.Top + WindowInsetsSides.End),
-                                        ) {
-                                            CompositionLocalProvider(LocalViewConfiguration provides viewConfiguration) {
-                                                sheet(sideSheetState)
-                                            }
-                                        }
-                                    }
-                                },
-                                drawerState = sideSheetState,
-                                gesturesEnabled = sheet != null && !drawerLocked,
-                            ) {
-                                val windowSizeClass = calculateWindowSizeClass(this)
-                                CompositionLocalProvider(
-                                    LocalViewConfiguration provides viewConfiguration,
-                                    LocalWindowSizeClass provides windowSizeClass,
-                                ) {
-                                    DestinationsNavHost(
-                                        navGraph = NavGraphs.root,
-                                        startRoute = if (Settings.needSignIn) {
-                                            SignInScreenDestination
-                                        } else {
-                                            StartDestination
-                                        },
-                                        engine = rememberNavHostEngine(rootDefaultAnimations = rememberEhNavAnim()),
-                                        navController = navController,
-                                    )
+                            modifier = Modifier.graphicsLayer {
+                                if (radius != 0f) {
+                                    renderEffect = BlurEffect(radius, radius, TileMode.Clamp)
+                                    shape = RectangleShape
+                                    clip = true
                                }
-                            }
+                            },
+                            drawerState = sideSheetState,
+                            gesturesEnabled = sheet != null && drawerEnabled,
+                        ) {
+                            DestinationsNavHost(
+                                navGraph = NavGraphs.root,
+                                startRoute = if (Settings.needSignIn) SignInScreenDestination else StartDestination,
+                                defaultTransitions = rememberEhNavAnim(),
+                                navController = navController,
+                            )
                        }
                    }
                }
@@ -508,18 +528,17 @@ class MainActivity : EhActivity() {
    }
 }

-val LocalNavDrawerState = compositionLocalOf<DrawerState2> { error("CompositionLocal LocalNavDrawerState not present!") }
+val LocalNavDrawerState = compositionLocalOf<DrawerState> { error("CompositionLocal LocalNavDrawerState not present!") }
 val LocalSideSheetState = compositionLocalOf<DrawerState2> { error("CompositionLocal LocalSideSheetState not present!") }
-val LocalDrawerLockHandle = compositionLocalOf<SnapshotStateList<Int>> { error("CompositionLocal LocalDrawerLockHandle not present!") }
+val LocalDrawerHandle = compositionLocalOf<SnapshotStateList<Int>> { error("CompositionLocal LocalDrawerHandle not present!") }
 val LocalSnackBarHostState = compositionLocalOf<SnackbarHostState> { error("CompositionLocal LocalSnackBarHostState not present!") }
 val LocalSnackBarFabPadding = compositionLocalOf<State<Dp>> { error("CompositionLocal LocalSnackBarFabPadding not present!") }

@Composable
-fun LockDrawer(value: Boolean) {
-    val updated by rememberUpdatedState(value)
-    if (updated) {
+fun DrawerHandle(enabled: Boolean) {
+    if (enabled) {
        val current = currentCompositeKeyHash
-        val handle = LocalDrawerLockHandle.current
+        val handle = LocalDrawerHandle.current
        DisposableEffect(current) {
            handle.add(current)
            onDispose {
@@ -2,17 +2,21 @@ package com.hippo.ehviewer.ui

 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
+import androidx.compose.animation.AnimatedContentTransitionScope
+import androidx.compose.animation.EnterTransition
+import androidx.compose.animation.ExitTransition
 import androidx.compose.material3.LocalContentColor
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.remember
 import androidx.compose.ui.platform.ComposeView
+import androidx.navigation.NavBackStackEntry
 import com.hippo.ehviewer.ui.theme.EhTheme
 import com.hippo.ehviewer.ui.tools.DialogState
 import com.hippo.ehviewer.ui.tools.LocalDialogState
 import com.hippo.ehviewer.ui.tools.ProvideVectorPainterCache
-import com.ramcosta.composedestinations.animations.defaults.RootNavGraphDefaultAnimations
+import com.ramcosta.composedestinations.animations.NavHostAnimatedDestinationStyle
 import soup.compose.material.motion.animation.materialSharedAxisXIn
 import soup.compose.material.motion.animation.materialSharedAxisXOut
 import soup.compose.material.motion.animation.rememberSlideDistance
@@ -46,14 +50,14 @@ inline fun ComponentActivity.setMD3Content(crossinline content: @Composable () -
 }

@Composable
-fun rememberEhNavAnim(): RootNavGraphDefaultAnimations {
+fun rememberEhNavAnim(): NavHostAnimatedDestinationStyle {
    val slideDistance = rememberSlideDistance()
-    return remember {
-        RootNavGraphDefaultAnimations(
-            enterTransition = { materialSharedAxisXIn(true, slideDistance) },
-            exitTransition = { materialSharedAxisXOut(true, slideDistance) },
-            popEnterTransition = { materialSharedAxisXIn(false, slideDistance) },
-            popExitTransition = { materialSharedAxisXOut(false, slideDistance) },
-        )
+    return remember(slideDistance) {
+        object : NavHostAnimatedDestinationStyle() {
+            override val enterTransition: AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition = { materialSharedAxisXIn(true, slideDistance) }
+            override val exitTransition: AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition = { materialSharedAxisXOut(true, slideDistance) }
+            override val popEnterTransition: AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition = { materialSharedAxisXIn(false, slideDistance) }
+            override val popExitTransition: AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition = { materialSharedAxisXOut(false, slideDistance) }
+        }
    }
 }
@@ -12,8 +12,7 @@ suspend fun postLogin() = coroutineScope {
    launch {
        runCatching {
            EhEngine.getProfile().run {
-                Settings.displayName = displayName
-                Settings.avatar = avatar
+                Settings.displayName.value = displayName
            }
        }.onFailure {
            logcat(it)
@@ -41,5 +40,6 @@ suspend fun postLogin() = coroutineScope {
    }.onFailure {
        Settings.gallerySite = EhUrl.SITE_E
    }
+    Settings.hasSignedIn.value = true
    Settings.needSignIn = false
 }
@@ -14,49 +14,176 @@ import androidx.compose.foundation.layout.systemBarsPadding
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.layout.widthIn
 import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Info
+import androidx.compose.material.icons.filled.Visibility
+import androidx.compose.material.icons.filled.VisibilityOff
 import androidx.compose.material3.Button
+import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.FilledTonalButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
-import androidx.compose.material3.windowsizeclass.WindowWidthSizeClass
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.autofill.AutofillType
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.res.dimensionResource
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.SpanStyle
 import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.text.input.PasswordVisualTransformation
+import androidx.compose.ui.text.input.VisualTransformation
 import androidx.compose.ui.text.style.TextDecoration
 import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.unit.dp
+import androidx.window.core.layout.WindowWidthSizeClass
 import com.hippo.ehviewer.R
 import com.hippo.ehviewer.Settings
+import com.hippo.ehviewer.client.EhEngine
 import com.hippo.ehviewer.client.EhUrl
-import com.hippo.ehviewer.ui.LockDrawer
+import com.hippo.ehviewer.client.EhUtils
 import com.hippo.ehviewer.ui.StartDestination
 import com.hippo.ehviewer.ui.destinations.WebViewSignInScreenDestination
 import com.hippo.ehviewer.ui.openBrowser
 import com.hippo.ehviewer.ui.screen.popNavigate
+import com.hippo.ehviewer.ui.tools.LocalDialogState
 import com.hippo.ehviewer.ui.tools.LocalWindowSizeClass
+import com.hippo.ehviewer.ui.tools.autofill
+import com.hippo.ehviewer.util.displayString
 import com.ramcosta.composedestinations.annotation.Destination
-import com.ramcosta.composedestinations.annotation.RootNavGraph
+import com.ramcosta.composedestinations.annotation.RootGraph
 import com.ramcosta.composedestinations.navigation.DestinationsNavigator
+import eu.kanade.tachiyomi.util.lang.launchIO
+import eu.kanade.tachiyomi.util.lang.withNonCancellableContext
+import eu.kanade.tachiyomi.util.lang.withUIContext
+import kotlinx.coroutines.Job

-@RootNavGraph(start = true)
-@Destination
+@Destination<RootGraph>(start = true)
@Composable
 fun SignInScreen(navigator: DestinationsNavigator) {
-    LockDrawer(true)
    val windowSizeClass = LocalWindowSizeClass.current
+    val coroutineScope = rememberCoroutineScope()
+    val focusManager = LocalFocusManager.current
+    var isProgressIndicatorVisible by rememberSaveable { mutableStateOf(false) }
+    var showUsernameError by rememberSaveable { mutableStateOf(false) }
+    var showPasswordError by rememberSaveable { mutableStateOf(false) }
+    var username by rememberSaveable { mutableStateOf("") }
+    var password by rememberSaveable { mutableStateOf("") }
+    var passwordHidden by rememberSaveable { mutableStateOf(true) }
    val context = LocalContext.current
+    var signInJob by remember { mutableStateOf<Job?>(null) }
+    val dialogState = LocalDialogState.current
+
+    fun signIn() {
+        if (signInJob?.isActive == true) return
+        if (username.isEmpty()) {
+            showUsernameError = true
+            return
+        } else {
+            showUsernameError = false
+        }
+        if (password.isEmpty()) {
+            showPasswordError = true
+            return
+        } else {
+            showPasswordError = false
+        }
+        focusManager.clearFocus()
+        isProgressIndicatorVisible = true
+
+        EhUtils.signOut()
+        signInJob = coroutineScope.launchIO {
+            runCatching {
+                EhEngine.signIn(username, password)
+            }.onFailure {
+                withUIContext {
+                    focusManager.clearFocus()
+                    dialogState.awaitPermissionOrCancel(
+                        confirmText = R.string.get_it,
+                        title = R.string.sign_in_failed,
+                        showCancelButton = false,
+                        text = {
+                            Text(
+                                """
+                                ${it.displayString()}
+                                ${stringResource(R.string.sign_in_failed_tip, stringResource(R.string.sign_in_via_webview))}
+                                """.trimIndent(),
+                            )
+                        },
+                    )
+                    isProgressIndicatorVisible = false
+                }
+            }.onSuccess {
+                withNonCancellableContext { postLogin() }
+                withUIContext { navigator.popNavigate(StartDestination) }
+            }
+        }
+    }
+
+    @Composable
+    fun UsernameAndPasswordTextField() {
+        OutlinedTextField(
+            value = username,
+            onValueChange = { username = it },
+            modifier = Modifier.width(dimensionResource(id = R.dimen.single_max_width)).autofill(
+                autofillTypes = listOf(AutofillType.Username),
+                onFill = { username = it },
+            ),
+            label = { Text(stringResource(R.string.username)) },
+            supportingText = { if (showUsernameError) Text(stringResource(R.string.error_username_cannot_empty)) },
+            trailingIcon = { if (showUsernameError) Icon(imageVector = Icons.Filled.Info, contentDescription = null) },
+            keyboardOptions = KeyboardOptions(imeAction = ImeAction.Next),
+            singleLine = true,
+            isError = showUsernameError,
+        )
+        OutlinedTextField(
+            value = password,
+            onValueChange = { password = it },
+            modifier = Modifier.width(dimensionResource(id = R.dimen.single_max_width)).autofill(
+                autofillTypes = listOf(AutofillType.Password),
+                onFill = { password = it },
+            ),
+            label = { Text(stringResource(R.string.password)) },
+            visualTransformation = if (passwordHidden) PasswordVisualTransformation() else VisualTransformation.None,
+            supportingText = { if (showPasswordError) Text(stringResource(R.string.error_password_cannot_empty)) },
+            keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Password),
+            keyboardActions = KeyboardActions(onDone = { signIn() }),
+            trailingIcon = {
+                if (showPasswordError) {
+                    Icon(imageVector = Icons.Filled.Info, contentDescription = null)
+                } else {
+                    IconButton(onClick = { passwordHidden = !passwordHidden }) {
+                        val visibilityIcon = if (passwordHidden) Icons.Filled.Visibility else Icons.Filled.VisibilityOff
+                        Icon(imageVector = visibilityIcon, contentDescription = null)
+                    }
+                }
+            },
+            singleLine = true,
+            isError = showPasswordError,
+        )
+    }

    Box(contentAlignment = Alignment.Center) {
-        when (windowSizeClass.widthSizeClass) {
-            WindowWidthSizeClass.Compact, WindowWidthSizeClass.Medium -> {
+        when (windowSizeClass.windowWidthSizeClass) {
+            WindowWidthSizeClass.COMPACT, WindowWidthSizeClass.MEDIUM -> {
                Column(
                    modifier = Modifier.fillMaxSize().verticalScroll(rememberScrollState()).systemBarsPadding().padding(dimensionResource(id = R.dimen.keyline_margin)),
                    horizontalAlignment = Alignment.CenterHorizontally,
@@ -66,6 +193,7 @@ fun SignInScreen(navigator: DestinationsNavigator) {
                        contentDescription = null,
                        modifier = Modifier.padding(dimensionResource(id = R.dimen.keyline_margin)),
                    )
+                    UsernameAndPasswordTextField()
                    Text(
                        text = stringResource(id = R.string.app_waring),
                        modifier = Modifier.widthIn(max = dimensionResource(id = R.dimen.single_max_width)).padding(top = 24.dp),
@@ -74,7 +202,7 @@ fun SignInScreen(navigator: DestinationsNavigator) {
                    Text(
                        text = stringResource(id = R.string.app_waring_2),
                        modifier = Modifier.widthIn(max = dimensionResource(id = R.dimen.single_max_width)).padding(top = 12.dp),
-                        style = MaterialTheme.typography.headlineMedium,
+                        style = MaterialTheme.typography.titleLarge,
                    )
                    Spacer(modifier = Modifier.height(dimensionResource(id = R.dimen.keyline_margin)))
                    Row(modifier = Modifier.padding(top = dimensionResource(R.dimen.keyline_margin))) {
@@ -85,32 +213,49 @@ fun SignInScreen(navigator: DestinationsNavigator) {
                            Text(text = stringResource(id = R.string.register))
                        }
                        Button(
-                            onClick = { navigator.navigate(WebViewSignInScreenDestination) },
+                            onClick = ::signIn,
                            modifier = Modifier.weight(1f).padding(horizontal = 4.dp),
                        ) {
                            Text(text = stringResource(id = R.string.sign_in))
                        }
                    }
-                    TextButton(
-                        onClick = {
-                            Settings.needSignIn = false
-                            Settings.gallerySite = EhUrl.SITE_E
-                            navigator.popNavigate(StartDestination)
-                        },
-                    ) {
-                        Text(
-                            text = buildAnnotatedString {
-                                withStyle(
-                                    style = SpanStyle(textDecoration = TextDecoration.Underline),
-                                ) {
-                                    append(stringResource(id = R.string.guest_mode))
-                                }
+                    Row(modifier = Modifier.padding(horizontal = 4.dp), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                        TextButton(
+                            onClick = { navigator.navigate(WebViewSignInScreenDestination) },
+                            modifier = Modifier.weight(1f),
+                        ) {
+                            Text(
+                                text = buildAnnotatedString {
+                                    withStyle(
+                                        style = SpanStyle(textDecoration = TextDecoration.Underline),
+                                    ) {
+                                        append(stringResource(id = R.string.sign_in_via_webview))
+                                    }
+                                },
+                            )
+                        }
+                        TextButton(
+                            onClick = {
+                                Settings.needSignIn = false
+                                Settings.gallerySite = EhUrl.SITE_E
+                                navigator.popNavigate(StartDestination)
                            },
-                        )
+                            modifier = Modifier.weight(1f),
+                        ) {
+                            Text(
+                                text = buildAnnotatedString {
+                                    withStyle(
+                                        style = SpanStyle(textDecoration = TextDecoration.Underline),
+                                    ) {
+                                        append(stringResource(id = R.string.guest_mode))
+                                    }
+                                },
+                            )
+                        }
                    }
                }
            }
-            WindowWidthSizeClass.Expanded -> {
+            WindowWidthSizeClass.EXPANDED -> {
                Row(
                    modifier = Modifier.fillMaxSize().verticalScroll(rememberScrollState()).systemBarsPadding().padding(dimensionResource(id = R.dimen.keyline_margin)),
                    verticalAlignment = Alignment.CenterVertically,
@@ -133,17 +278,18 @@ fun SignInScreen(navigator: DestinationsNavigator) {
                        Text(
                            text = stringResource(id = R.string.app_waring_2),
                            modifier = Modifier.widthIn(max = 360.dp),
-                            style = MaterialTheme.typography.headlineMedium,
+                            style = MaterialTheme.typography.titleLarge,
                        )
                    }
                    Column(
                        modifier = Modifier.fillMaxWidth(),
                        horizontalAlignment = Alignment.CenterHorizontally,
                    ) {
-                        Spacer(modifier = Modifier.height(48.dp))
+                        UsernameAndPasswordTextField()
+                        Spacer(modifier = Modifier.height(8.dp))
                        Row(horizontalArrangement = Arrangement.Center) {
                            Button(
-                                onClick = { navigator.navigate(WebViewSignInScreenDestination) },
+                                onClick = ::signIn,
                                modifier = Modifier.padding(horizontal = 4.dp).width(128.dp),
                            ) {
                                Text(text = stringResource(id = R.string.sign_in))
@@ -156,27 +302,46 @@ fun SignInScreen(navigator: DestinationsNavigator) {
                            }
                        }
                        Spacer(modifier = Modifier.height(8.dp))
-                        TextButton(
-                            onClick = {
-                                Settings.needSignIn = false
-                                Settings.gallerySite = EhUrl.SITE_E
-                                navigator.popNavigate(StartDestination)
-                            },
-                            modifier = Modifier.padding(horizontal = 4.dp),
-                        ) {
-                            Text(
-                                text = buildAnnotatedString {
-                                    withStyle(
-                                        style = SpanStyle(textDecoration = TextDecoration.Underline),
-                                    ) {
-                                        append(stringResource(id = R.string.guest_mode))
-                                    }
+                        Row(horizontalArrangement = Arrangement.Center) {
+                            TextButton(
+                                onClick = { navigator.navigate(WebViewSignInScreenDestination) },
+                                modifier = Modifier.padding(horizontal = 4.dp).width(128.dp),
+                            ) {
+                                Text(
+                                    text = buildAnnotatedString {
+                                        withStyle(
+                                            style = SpanStyle(textDecoration = TextDecoration.Underline),
+                                        ) {
+                                            append(stringResource(id = R.string.sign_in_via_webview))
+                                        }
+                                    },
+                                )
+                            }
+                            TextButton(
+                                onClick = {
+                                    Settings.needSignIn = false
+                                    Settings.gallerySite = EhUrl.SITE_E
+                                    navigator.popNavigate(StartDestination)
                                },
-                            )
+                                modifier = Modifier.padding(horizontal = 4.dp).width(128.dp),
+                            ) {
+                                Text(
+                                    text = buildAnnotatedString {
+                                        withStyle(
+                                            style = SpanStyle(textDecoration = TextDecoration.Underline),
+                                        ) {
+                                            append(stringResource(id = R.string.guest_mode))
+                                        }
+                                    },
+                                )
+                            }
                        }
                    }
                }
            }
        }
+        if (isProgressIndicatorVisible) {
+            CircularProgressIndicator()
+        }
    }
 }
@@ -13,21 +13,20 @@ import com.google.accompanist.web.rememberWebViewState
 import com.hippo.ehviewer.client.EhCookieStore
 import com.hippo.ehviewer.client.EhUrl
 import com.hippo.ehviewer.client.EhUtils
-import com.hippo.ehviewer.ui.LockDrawer
 import com.hippo.ehviewer.ui.StartDestination
 import com.hippo.ehviewer.ui.screen.popNavigate
 import com.hippo.ehviewer.util.setDefaultSettings
 import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.annotation.RootGraph
 import com.ramcosta.composedestinations.navigation.DestinationsNavigator
 import eu.kanade.tachiyomi.util.lang.launchIO
 import eu.kanade.tachiyomi.util.lang.withNonCancellableContext
 import eu.kanade.tachiyomi.util.lang.withUIContext
 import io.ktor.http.Url

-@Destination
+@Destination<RootGraph>
@Composable
 fun WebViewSignInScreen(navigator: DestinationsNavigator) {
-    LockDrawer(true)
    val coroutineScope = rememberCoroutineScope()
    val state = rememberWebViewState(url = EhUrl.URL_SIGN_IN)
    val client = remember {
@@ -2,6 +2,8 @@ package com.hippo.ehviewer.ui.main

 import android.os.Parcelable
 import kotlinx.parcelize.Parcelize
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.Transient

 object AdvanceTable {
    const val SH = 0x1
@@ -12,7 +14,9 @@ object AdvanceTable {
 }

@Parcelize
+@Serializable
 data class AdvancedSearchOption(
+    @Transient
    val advanceSearch: Int = 0,
    val minRating: Int = 0,
    val fromPage: Int = 0,
@@ -0,0 +1,112 @@
+package com.hippo.ehviewer.ui.main
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.GridItemSpan
+import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.foundation.lazy.grid.items
+import androidx.compose.material3.Button
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import com.hippo.ehviewer.R
+import com.hippo.ehviewer.client.parser.Archive
+import com.hippo.ehviewer.client.parser.Funds
+
+@Composable
+fun ArchiveList(
+    funds: Funds,
+    items: List<Archive>,
+    onItemClick: (Archive) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val currentFunds = stringResource(R.string.current_funds)
+    val archiveFree = stringResource(R.string.archive_free)
+    val archiveOriginal = stringResource(R.string.archive_original)
+    val archiveResample = stringResource(R.string.archive_resample)
+    val fundsStyle = MaterialTheme.typography.labelLarge
+    val (hAtH, nonHAtH) = remember(items) { items.partition { it.isHAtH } }
+    LazyVerticalGrid(
+        columns = GridCells.Fixed(2),
+        modifier = modifier,
+        contentPadding = PaddingValues(horizontal = 8.dp, vertical = 16.dp),
+        verticalArrangement = Arrangement.spacedBy(8.dp),
+    ) {
+        item(span = { GridItemSpan(maxLineSpan) }) {
+            Text(text = currentFunds, textAlign = TextAlign.Center)
+        }
+        item {
+            FundsItem(
+                type = "GP",
+                amount = funds.gp,
+                modifier = Modifier.fillMaxWidth(),
+                textStyle = fundsStyle,
+            )
+        }
+        item {
+            FundsItem(
+                type = "C",
+                amount = funds.credit,
+                modifier = Modifier.fillMaxWidth(),
+                textStyle = fundsStyle,
+            )
+        }
+        items(nonHAtH) {
+            ArchiveItem(
+                name = if (it.res == "org") archiveOriginal else archiveResample,
+                cost = if (it.cost == "Free!") archiveFree else it.cost,
+                size = it.size,
+                onClick = { onItemClick(it) },
+            )
+        }
+        item(span = { GridItemSpan(maxLineSpan) }) {
+            Column(horizontalAlignment = Alignment.CenterHorizontally) {
+                HorizontalDivider(modifier = Modifier.padding(vertical = 8.dp))
+                Text(text = "H@H")
+            }
+        }
+        items(hAtH) {
+            ArchiveItem(
+                name = if (it.res == "org") archiveOriginal else it.name,
+                cost = if (it.cost == "Free") archiveFree else it.cost,
+                size = it.size,
+                onClick = { onItemClick(it) },
+            )
+        }
+    }
+}
+
+@Composable
+private fun ArchiveItem(
+    name: String,
+    cost: String,
+    size: String,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val labelStyle = MaterialTheme.typography.labelMedium
+    Column(modifier = modifier, horizontalAlignment = Alignment.CenterHorizontally) {
+        Text(
+            text = cost,
+            style = labelStyle,
+        )
+        Button(onClick = onClick) {
+            Text(text = name)
+        }
+        Text(
+            text = size,
+            style = labelStyle,
+        )
+    }
+}
@@ -2,10 +2,10 @@ package com.hippo.ehviewer.ui.main

 import androidx.compose.foundation.background
 import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.aspectRatio
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Pause
@@ -18,19 +18,24 @@ import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.ProvideTextStyle
 import androidx.compose.material3.ShapeDefaults
 import androidx.compose.material3.Text
+import androidx.compose.material3.minimumInteractiveComponentSize
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.movableContentOf
 import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.layout.layoutId
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.constraintlayout.compose.ConstraintLayout
+import androidx.constraintlayout.compose.ConstraintSet
+import androidx.constraintlayout.compose.Dimension
+import arrow.core.Tuple9
 import com.hippo.ehviewer.R
 import com.hippo.ehviewer.Settings
 import com.hippo.ehviewer.client.EhUtils
@@ -40,6 +45,51 @@ import com.hippo.ehviewer.ui.tools.CrystalCard
 import com.hippo.ehviewer.ui.tools.GalleryListCardRating
 import com.hippo.ehviewer.util.FileUtils

+private val ids = Tuple9(1, 2, 3, 4, 5, 6, 7, 8, 9)
+
+private val constraintSet = ConstraintSet {
+    val (
+        titleRef, uploaderRef, ratingRef, categoryRef, actionsRef, stateTextRef,
+        progressBarRef, progressTextRef, speedRef,
+    ) = createRefsFor(1, 2, 3, 4, 5, 6, 7, 8, 9)
+    constrain(titleRef) {
+        top.linkTo(parent.top)
+        width = Dimension.matchParent
+    }
+    constrain(uploaderRef) {
+        start.linkTo(parent.start)
+        bottom.linkTo(actionsRef.top)
+    }
+    constrain(ratingRef) {
+        start.linkTo(parent.start)
+        top.linkTo(actionsRef.top, 1.dp)
+    }
+    constrain(categoryRef) {
+        start.linkTo(parent.start)
+        bottom.linkTo(parent.bottom)
+    }
+    constrain(progressBarRef) {
+        bottom.linkTo(actionsRef.top)
+        width = Dimension.matchParent
+    }
+    constrain(progressTextRef) {
+        bottom.linkTo(progressBarRef.top)
+        start.linkTo(progressBarRef.start)
+    }
+    constrain(speedRef) {
+        bottom.linkTo(progressBarRef.top)
+        end.linkTo(progressBarRef.end)
+    }
+    constrain(actionsRef) {
+        end.linkTo(parent.end, (-4).dp)
+        bottom.linkTo(parent.bottom, (-4).dp)
+    }
+    constrain(stateTextRef) {
+        end.linkTo(parent.end)
+        bottom.linkTo(actionsRef.top)
+    }
+}
+
@Composable
 fun DownloadCard(
    onClick: () -> Unit,
@@ -48,143 +98,122 @@ fun DownloadCard(
    onStart: () -> Unit,
    onStop: () -> Unit,
    info: DownloadInfo,
+    selectMode: Boolean,
    modifier: Modifier = Modifier,
    interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
-) {
-    CrystalCard(
-        modifier = modifier,
-        onClick = onClick,
-        onLongClick = onLongClick,
-        interactionSource = interactionSource,
-    ) {
-        Row {
-            Card(onClick = onThumbClick) {
+) = CrystalCard(modifier = modifier, onClick = onClick, onLongClick = onLongClick, interactionSource = interactionSource) {
+    Row {
+        val thumb = remember {
+            movableContentOf<DownloadInfo> {
                EhAsyncCropThumb(
-                    key = info,
-                    modifier = Modifier.aspectRatio(DEFAULT_ASPECT).fillMaxSize(),
+                    key = it,
+                    modifier = Modifier.aspectRatio(DEFAULT_RATIO).fillMaxSize(),
                )
            }
-
-            val stateFailed = stringResource(R.string.download_state_failed)
-            val stateFailed2 = stringResource(R.string.download_state_failed_2, info.legacy)
-            val downloadState by DownloadManager.collectDownloadState(info.gid)
-            val stateText = when (downloadState) {
-                DownloadInfo.STATE_NONE -> stringResource(R.string.download_state_none)
-                DownloadInfo.STATE_WAIT -> stringResource(R.string.download_state_wait)
-                DownloadInfo.STATE_DOWNLOAD -> null
-                DownloadInfo.STATE_FAILED -> if (info.legacy <= 0) stateFailed else stateFailed2
-                DownloadInfo.STATE_FINISH -> stringResource(R.string.download_state_finish)
-                else -> null // Chill, will be removed soon
+        }
+        if (selectMode) {
+            Card {
+                thumb(info)
            }
-            ConstraintLayout(modifier = Modifier.padding(8.dp, 4.dp).fillMaxSize()) {
-                val (
-                    titleRef, uploaderRef, ratingRef, categoryRef, actionsRef, stateTextRef,
-                    progressBarRef, progressTextRef, speedRef,
-                ) = createRefs()
-                Text(
-                    text = EhUtils.getSuitableTitle(info),
-                    maxLines = 2,
-                    modifier = Modifier.constrainAs(titleRef) {
-                        top.linkTo(parent.top)
-                        start.linkTo(parent.start)
-                    }.fillMaxWidth(),
-                    overflow = TextOverflow.Ellipsis,
-                    style = MaterialTheme.typography.titleSmall,
-                )
-                if (downloadState != DownloadInfo.STATE_DOWNLOAD) {
-                    ProvideTextStyle(MaterialTheme.typography.labelLarge) {
-                        info.uploader?.let {
-                            Text(
-                                text = it,
-                                modifier = Modifier.constrainAs(uploaderRef) {
-                                    start.linkTo(parent.start)
-                                    bottom.linkTo(ratingRef.top)
-                                }.alpha(if (info.disowned) 0.5f else 1f),
-                                maxLines = 1,
-                                overflow = TextOverflow.Ellipsis,
-                            )
-                        }
-                        GalleryListCardRating(
-                            rating = info.rating,
-                            modifier = Modifier.constrainAs(ratingRef) {
-                                start.linkTo(parent.start)
-                                bottom.linkTo(categoryRef.top)
-                            },
-                        )
-                        val categoryColor = EhUtils.getCategoryColor(info.category)
-                        val categoryText = EhUtils.getCategory(info.category).uppercase()
+        } else {
+            Card(onClick = onThumbClick) {
+                thumb(info)
+            }
+        }
+        val stateFailed = stringResource(R.string.download_state_failed)
+        val stateFailed2 = stringResource(R.string.download_state_failed_2, info.legacy)
+        val downloadState by DownloadManager.collectDownloadState(info.gid)
+        val stateText = when (downloadState) {
+            DownloadInfo.STATE_NONE -> stringResource(R.string.download_state_none)
+            DownloadInfo.STATE_WAIT -> stringResource(R.string.download_state_wait)
+            DownloadInfo.STATE_DOWNLOAD -> null
+            DownloadInfo.STATE_FAILED -> if (info.legacy <= 0) stateFailed else stateFailed2
+            DownloadInfo.STATE_FINISH -> stringResource(R.string.download_state_finish)
+            else -> null // Chill, will be removed soon
+        }
+        ConstraintLayout(
+            modifier = Modifier.padding(start = 8.dp, top = 2.dp, end = 4.dp, bottom = 4.dp).fillMaxSize(),
+            constraintSet = constraintSet,
+        ) {
+            val (
+                titleRef, uploaderRef, ratingRef, categoryRef, actionsRef, stateTextRef,
+                progressBarRef, progressTextRef, speedRef,
+            ) = ids
+            Text(
+                text = EhUtils.getSuitableTitle(info),
+                maxLines = 2,
+                modifier = Modifier.layoutId(titleRef),
+                overflow = TextOverflow.Ellipsis,
+                style = MaterialTheme.typography.titleSmall,
+            )
+            if (downloadState != DownloadInfo.STATE_DOWNLOAD) {
+                ProvideTextStyle(MaterialTheme.typography.labelLarge) {
+                    info.uploader?.let {
                        Text(
-                            text = categoryText,
-                            modifier = Modifier.constrainAs(categoryRef) {
-                                start.linkTo(parent.start)
-                                bottom.linkTo(parent.bottom)
-                            }.clip(ShapeDefaults.Small).background(categoryColor).padding(vertical = 2.dp, horizontal = 8.dp),
-                            color = if (Settings.harmonizeCategoryColor) Color.Unspecified else EhUtils.categoryTextColor,
-                            textAlign = TextAlign.Center,
+                            text = it,
+                            modifier = Modifier.layoutId(uploaderRef).alpha(if (info.disowned) 0.5f else 1f),
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis,
                        )
                    }
-                } else {
-                    val (total, finished, speed) = DownloadManager.updatedDownloadInfo(info) {
-                        Triple(total, finished, speed)
-                    }
-                    ProvideTextStyle(MaterialTheme.typography.labelMedium) {
-                        if (total <= 0 || finished < 0) {
-                            LinearProgressIndicator(
-                                modifier = Modifier.constrainAs(progressBarRef) {
-                                    bottom.linkTo(actionsRef.top)
-                                }.fillMaxWidth(),
-                            )
-                        } else {
-                            LinearProgressIndicator(
-                                progress = { finished.toFloat() / total.toFloat() },
-                                modifier = Modifier.constrainAs(progressBarRef) {
-                                    bottom.linkTo(actionsRef.top)
-                                }.fillMaxWidth(),
-                            )
-                            Text(
-                                text = "$finished/$total",
-                                modifier = Modifier.constrainAs(progressTextRef) {
-                                    bottom.linkTo(progressBarRef.top)
-                                    start.linkTo(progressBarRef.start)
-                                },
-                            )
-                        }
-                        Text(
-                            text = FileUtils.humanReadableByteCount(speed.coerceAtLeast(0), false) + "/S",
-                            modifier = Modifier.constrainAs(speedRef) {
-                                bottom.linkTo(progressBarRef.top)
-                                end.linkTo(progressBarRef.end)
-                            },
-                        )
-                    }
-                }
-                Row(
-                    verticalAlignment = Alignment.CenterVertically,
-                    modifier = Modifier.constrainAs(actionsRef) {
-                        end.linkTo(parent.end)
-                        bottom.linkTo(parent.bottom)
-                    },
-                ) {
-                    if (downloadState == DownloadInfo.STATE_WAIT || downloadState == DownloadInfo.STATE_DOWNLOAD) {
-                        IconButton(onClick = onStop) {
-                            Icon(imageVector = Icons.Default.Pause, contentDescription = null)
-                        }
-                    } else {
-                        IconButton(onClick = onStart) {
-                            Icon(imageVector = Icons.Default.PlayArrow, contentDescription = null)
-                        }
-                    }
-                }
-                if (stateText != null) {
+                    GalleryListCardRating(
+                        rating = info.rating,
+                        modifier = Modifier.layoutId(ratingRef),
+                    )
+                    val categoryColor = EhUtils.getCategoryColor(info.category)
+                    val categoryText = EhUtils.getCategory(info.category).uppercase()
                    Text(
-                        text = stateText,
-                        modifier = Modifier.constrainAs(stateTextRef) {
-                            end.linkTo(parent.end, 16.dp)
-                            bottom.linkTo(actionsRef.top)
-                        },
-                        style = MaterialTheme.typography.titleSmall,
+                        text = categoryText,
+                        modifier = Modifier.layoutId(categoryRef).clip(ShapeDefaults.Small)
+                            .background(categoryColor).padding(vertical = 2.dp, horizontal = 8.dp),
+                        color = if (Settings.harmonizeCategoryColor) Color.Unspecified else EhUtils.categoryTextColor,
+                        textAlign = TextAlign.Center,
                    )
                }
+            } else {
+                val (total, finished, speed) = DownloadManager.updatedDownloadInfo(info) {
+                    Triple(total, finished, speed)
+                }
+                ProvideTextStyle(MaterialTheme.typography.labelMedium) {
+                    if (total <= 0 || finished < 0) {
+                        LinearProgressIndicator(modifier = Modifier.layoutId(progressBarRef))
+                    } else {
+                        LinearProgressIndicator(
+                            progress = { finished.toFloat() / total.toFloat() },
+                            modifier = Modifier.layoutId(progressBarRef),
+                        )
+                        Text(
+                            text = "$finished/$total",
+                            modifier = Modifier.layoutId(progressTextRef),
+                        )
+                    }
+                    Text(
+                        text = FileUtils.humanReadableByteCount(speed.coerceAtLeast(0), false) + "/S",
+                        modifier = Modifier.layoutId(speedRef),
+                    )
+                }
+            }
+            val running = downloadState == DownloadInfo.STATE_WAIT || downloadState == DownloadInfo.STATE_DOWNLOAD
+            val icon = remember {
+                movableContentOf<Boolean> {
+                    Icon(imageVector = if (it) Icons.Default.Pause else Icons.Default.PlayArrow, contentDescription = null)
+                }
+            }
+            if (selectMode) {
+                Box(modifier = Modifier.layoutId(actionsRef).minimumInteractiveComponentSize()) {
+                    icon(running)
+                }
+            } else {
+                IconButton(onClick = if (running) onStop else onStart, modifier = Modifier.layoutId(actionsRef)) {
+                    icon(running)
+                }
+            }
+            if (stateText != null) {
+                Text(
+                    text = stateText,
+                    modifier = Modifier.layoutId(stateTextRef),
+                    style = MaterialTheme.typography.labelLarge,
+                )
            }
        }
    }
@@ -7,11 +7,10 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.painter.Painter
 import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.platform.LocalContext
+import coil3.Image
 import coil3.compose.AsyncImage
-import coil3.compose.AsyncImagePainter
 import coil3.request.ImageRequest
 import com.hippo.ehviewer.client.data.GalleryInfo
 import com.hippo.ehviewer.ktbuilder.imageRequest
@@ -29,13 +28,15 @@ fun requestOf(model: GalleryInfo): ImageRequest {
 fun EhAsyncThumb(
    model: GalleryInfo,
    modifier: Modifier = Modifier,
-    placeholder: Painter? = null,
+    onSuccess: ((Image) -> Unit)? = null,
    contentScale: ContentScale = ContentScale.Fit,
 ) = AsyncImage(
    model = requestOf(model),
    contentDescription = null,
    modifier = modifier,
-    placeholder = placeholder,
+    onSuccess = onSuccess?.let { callback ->
+        { callback(it.result.image) }
+    },
    contentScale = contentScale,
 )

@@ -49,11 +50,9 @@ fun EhAsyncCropThumb(
        model = requestOf(key),
        contentDescription = null,
        modifier = modifier,
-        onState = {
-            if (it is AsyncImagePainter.State.Success) {
-                if (it.result.image.shouldCrop) {
-                    contentScale = ContentScale.Crop
-                }
+        onSuccess = {
+            if (it.result.image.shouldCrop) {
+                contentScale = ContentScale.Crop
            }
        },
        contentScale = contentScale,
@@ -3,7 +3,6 @@ package com.hippo.ehviewer.ui.main
 import androidx.activity.compose.PredictiveBackHandler
 import androidx.compose.animation.core.Animatable
 import androidx.compose.animation.core.AnimationSpec
-import androidx.compose.animation.core.EaseOut
 import androidx.compose.animation.core.tween
 import androidx.compose.foundation.MutatePriority
 import androidx.compose.foundation.MutatorMutex
@@ -12,6 +11,7 @@ import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.navigationBarsPadding
+import androidx.compose.foundation.layout.offset
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Close
@@ -23,7 +23,6 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.Stable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.snapshotFlow
 import androidx.compose.ui.Alignment
@@ -31,27 +30,27 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.layout.layout
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.util.lerp
+import com.hippo.ehviewer.ui.tools.PredictiveBackEasing
 import com.hippo.ehviewer.ui.tools.delegateSnapshotUpdate
 import com.hippo.ehviewer.ui.tools.snackBarPadding
-import eu.kanade.tachiyomi.util.lang.launchIO
 import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import moe.tarsin.coroutines.onEachLatest
-import moe.tarsin.coroutines.runSuspendCatching

-enum class FabLayoutValue {
-    Hidden,
-    Primary,
-    Expand,
-}
+@Stable
+enum class FabLayoutValue { Hidden, Primary, Expand }

+@Stable
@Composable
-fun rememberFabLayoutState(initialValue: FabLayoutValue = FabLayoutValue.Primary): FabLayoutState {
-    return remember { FabLayoutState(initialValue) }
+fun rememberFabLayoutState(initialValue: FabLayoutValue = FabLayoutValue.Primary) = remember {
+    FabLayoutState(initialValue)
 }

@Stable
@@ -97,9 +96,11 @@ class FabLayoutState(
 }

 fun interface FabBuilder {
-    fun onClick(icon: ImageVector, that: suspend () -> Unit)
+    fun onClick(icon: ImageVector, autoClose: Boolean, that: suspend () -> Unit)
+    fun onClick(icon: ImageVector, that: suspend () -> Unit) = onClick(icon, true, that)
 }

+context(CoroutineScope)
@Composable
 fun FabLayout(
    hidden: Boolean,
@@ -132,7 +133,11 @@ fun FabLayout(
        record { buildFab(builder) }
        transform { onEachLatest { state.waitCollapse() } }
    }
-    val coroutineScope = rememberCoroutineScope()
+
+    val density = LocalDensity.current
+    val interval = remember(density) { with(density) { FabInterval.roundToPx() } }
+    val padding = remember(density) { with(density) { FabPadding.roundToPx() } }
+
    if (updatedExpanded && autoCancel) {
        Spacer(
            modifier = Modifier.fillMaxSize().pointerInput(Unit) {
@@ -140,77 +145,76 @@ fun FabLayout(
            },
        )
    }
-    val appearState by state.appearProgress.asState()
+
+    val animatedProgress by state.expandProgress.asState()
+    PredictiveBackHandler(updatedExpanded) { flow ->
+        try {
+            state.mutatorMutex.mutate(MutatePriority.UserInput) {
+                flow.collect {
+                    val eased = PredictiveBackEasing.transform(it.progress)
+                    state.expandProgress.snapTo(1 - eased)
+                }
+            }
+            onExpandChanged(false)
+        } catch (e: CancellationException) {
+            launch { state.expand() }
+        }
+    }
    Box(
-        modifier = Modifier.fillMaxSize().navigationBarsPadding().padding(16.dp).snackBarPadding(),
+        modifier = Modifier.fillMaxSize().navigationBarsPadding().snackBarPadding(),
        contentAlignment = Alignment.BottomEnd,
    ) {
-        Box(
-            modifier = Modifier.graphicsLayer {
+        if (!state.appearProgress.isRunning && !updatedHidden) {
+            Box(
+                modifier = Modifier.fillMaxSize().graphicsLayer { alpha = animatedProgress },
+                contentAlignment = Alignment.BottomEnd,
+            ) {
+                with(secondaryFab) {
+                    forEachIndexed { index, (imageVector, autoClose, onClick) ->
+                        SmallFloatingActionButton(
+                            onClick = {
+                                launch(Dispatchers.Default) {
+                                    onClick()
+                                    if (autoClose) onExpandChanged(false)
+                                }
+                            },
+                            modifier = Modifier.padding(20.dp).offset {
+                                val distance = lerp(0, interval * (size - index) + padding, animatedProgress)
+                                IntOffset(0, -distance)
+                            },
+                        ) {
+                            Icon(imageVector = imageVector, contentDescription = null)
+                        }
+                    }
+                }
+            }
+        }
+        val appearState by state.appearProgress.asState()
+        FloatingActionButton(
+            onClick = { onExpandChanged(!updatedExpanded) },
+            modifier = Modifier.padding(16.dp).graphicsLayer {
                rotationZ = lerp(-90f, 0f, appearState)
                scaleX = appearState
                scaleY = appearState
            },
-            contentAlignment = Alignment.Center,
        ) {
-            val animatedProgress by state.expandProgress.asState()
-            PredictiveBackHandler(updatedExpanded) { flow ->
-                try {
-                    state.mutatorMutex.mutate(MutatePriority.UserInput) {
-                        flow.collect {
-                            val eased = EaseOut.transform(it.progress)
-                            state.expandProgress.snapTo(1 - eased)
-                        }
-                    }
-                    onExpandChanged(false)
-                } catch (e: CancellationException) {
-                    coroutineScope.launch {
-                        state.expand()
-                    }
-                }
-            }
-            FloatingActionButton(onClick = { onExpandChanged(!updatedExpanded) }) {
-                Icon(
-                    imageVector = Icons.Default.Close,
-                    contentDescription = null,
-                    modifier = Modifier.graphicsLayer {
-                        rotationZ = lerp(-135f, 0f, animatedProgress)
-                    },
-                )
-            }
-            secondaryFab.run {
-                forEachIndexed { index, (imageVector, onClick) ->
-                    SmallFloatingActionButton(
-                        onClick = {
-                            coroutineScope.launchIO {
-                                runSuspendCatching {
-                                    onClick()
-                                }
-                                onExpandChanged(false)
-                            }
-                        },
-                        modifier = Modifier.layout { measurable, constraints ->
-                            val placeable = measurable.measure(constraints)
-                            layout(placeable.width, placeable.height) {
-                                val distance = lerp(0, 150 * (size - index) + 50, animatedProgress)
-                                placeable.placeRelative(0, -distance, -(size - index).toFloat())
-                            }
-                        }.graphicsLayer {
-                            alpha = animatedProgress
-                        },
-                    ) {
-                        Icon(imageVector = imageVector, contentDescription = null)
-                    }
-                }
-            }
+            Icon(
+                imageVector = Icons.Default.Close,
+                contentDescription = null,
+                modifier = Modifier.graphicsLayer {
+                    rotationZ = lerp(-135f, 0f, animatedProgress)
+                },
+            )
        }
    }
 }

 private fun buildFab(builder: FabBuilder.() -> Unit) = buildList {
-    builder { icon, action ->
-        add(icon to action)
+    builder { icon, autoClose, action ->
+        add(Triple(icon, autoClose, action))
    }
 }

+private val FabInterval = 56.dp // Small FAB height + 16 dp
+private val FabPadding = 8.dp // (FAB height - small FAB height) / 2
 const val FAB_ANIMATE_TIME = 300
@@ -0,0 +1,32 @@
+package com.hippo.ehviewer.ui.main
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.material3.Badge
+import androidx.compose.material3.LocalTextStyle
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun FundsItem(
+    type: String,
+    amount: String,
+    modifier: Modifier = Modifier,
+    textStyle: TextStyle = LocalTextStyle.current,
+) {
+    Row(
+        modifier = modifier,
+        horizontalArrangement = Arrangement.spacedBy(4.dp, Alignment.CenterHorizontally),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Badge(containerColor = MaterialTheme.colorScheme.primaryContainer) {
+            Text(text = type)
+        }
+        Text(text = amount, style = textStyle)
+    }
+}
@@ -5,12 +5,13 @@ import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.aspectRatio
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.layout.widthIn
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Download
@@ -25,16 +26,14 @@ import androidx.compose.material3.Text
 import androidx.compose.material3.contentColorFor
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
-import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.graphics.Brush
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.painter.BrushPainter
-import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.layout.layoutId
 import androidx.compose.ui.text.font.FontStyle
 import androidx.compose.ui.text.style.TextAlign
@@ -42,6 +41,7 @@ import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.constraintlayout.compose.ConstraintLayout
 import androidx.constraintlayout.compose.ConstraintSet
+import androidx.constraintlayout.compose.Dimension
 import arrow.core.Tuple7
 import com.hippo.ehviewer.Settings
 import com.hippo.ehviewer.client.EhUtils
@@ -60,15 +60,15 @@ private val constraintSet = ConstraintSet {
        createRefsFor(1, 2, 3, 4, 5, 6, 7)
    constrain(titleRef) {
        top.linkTo(parent.top)
-        start.linkTo(parent.start)
+        width = Dimension.matchParent
    }
    constrain(uploaderRef) {
        start.linkTo(parent.start)
-        bottom.linkTo(ratingRef.top)
+        bottom.linkTo(iconsRef.top)
    }
    constrain(ratingRef) {
        start.linkTo(parent.start)
-        bottom.linkTo(categoryRef.top)
+        top.linkTo(iconsRef.top, 1.dp)
    }
    constrain(categoryRef) {
        start.linkTo(parent.start)
@@ -76,7 +76,7 @@ private val constraintSet = ConstraintSet {
    }
    constrain(iconsRef) {
        end.linkTo(parent.end)
-        bottom.linkTo(postedRef.top)
+        bottom.linkTo(categoryRef.top)
    }
    constrain(favRef) {
        end.linkTo(parent.end)
@@ -84,7 +84,7 @@ private val constraintSet = ConstraintSet {
    }
    constrain(postedRef) {
        end.linkTo(parent.end)
-        bottom.linkTo(parent.bottom)
+        linkTo(categoryRef.top, parent.bottom)
    }
 }

@@ -107,15 +107,18 @@ fun GalleryInfoListItem(
        Card {
            EhAsyncCropThumb(
                key = info,
-                modifier = Modifier.aspectRatio(DEFAULT_ASPECT).fillMaxSize(),
+                modifier = Modifier.aspectRatio(DEFAULT_RATIO).fillMaxSize(),
            )
        }
-        ConstraintLayout(modifier = Modifier.padding(8.dp, 4.dp).fillMaxSize(), constraintSet = constraintSet) {
+        ConstraintLayout(
+            modifier = Modifier.padding(start = 8.dp, top = 2.dp, end = 4.dp, bottom = 4.dp).fillMaxSize(),
+            constraintSet = constraintSet,
+        ) {
            val (titleRef, uploaderRef, ratingRef, categoryRef, postedRef, favRef, iconsRef) = ids
            Text(
                text = EhUtils.getSuitableTitle(info),
                maxLines = 2,
-                modifier = Modifier.layoutId(titleRef).fillMaxWidth(),
+                modifier = Modifier.layoutId(titleRef),
                overflow = TextOverflow.Ellipsis,
                style = MaterialTheme.typography.titleSmall,
            )
@@ -145,6 +148,8 @@ fun GalleryInfoListItem(
                    verticalAlignment = Alignment.CenterVertically,
                    modifier = Modifier.layoutId(iconsRef),
                ) {
+                    // Placeholder to reserve minimum height
+                    Text(text = "")
                    val download by DownloadManager.collectContainDownloadInfo(info.gid)
                    if (download) {
                        Icon(
@@ -153,7 +158,9 @@ fun GalleryInfoListItem(
                            modifier = Modifier.size(16.dp),
                        )
                    }
-                    Text(text = info.simpleLanguage.orEmpty())
+                    info.simpleLanguage?.let {
+                        Text(text = it)
+                    }
                    if (info.pages != 0 && showPages) {
                        Text(text = "${info.pages}P")
                    }
@@ -163,11 +170,12 @@ fun GalleryInfoListItem(
                    verticalAlignment = Alignment.CenterVertically,
                    modifier = Modifier.layoutId(favRef),
                ) {
+                    // Placeholder to reserve minimum height
+                    Text(text = "")
                    if (isInFavScene) {
-                        Text(
-                            text = info.favoriteNote.orEmpty(),
-                            fontStyle = FontStyle.Italic,
-                        )
+                        info.favoriteNote?.let {
+                            Text(text = it, fontStyle = FontStyle.Italic)
+                        }
                    } else {
                        val showFav by FavouriteStatusRouter.collectAsState(info) { it != NOT_FAVORITED }
                        if (showFav) {
@@ -176,7 +184,9 @@ fun GalleryInfoListItem(
                                contentDescription = null,
                                modifier = Modifier.size(16.dp),
                            )
-                            Text(text = info.favoriteName.orEmpty())
+                            info.favoriteName?.let {
+                                Text(text = it)
+                            }
                        }
                    }
                }
@@ -195,7 +205,8 @@ fun GalleryInfoGridItem(
    onLongClick: () -> Unit,
    info: GalleryInfo,
    modifier: Modifier = Modifier,
-    badgeText: String? = info.simpleLanguage,
+    showLanguage: Boolean = true,
+    showPages: Boolean = true,
    interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
 ) = ElevatedCard(
    modifier = modifier,
@@ -204,19 +215,20 @@ fun GalleryInfoGridItem(
    interactionSource = interactionSource,
 ) {
    Box {
-        val placeholder = remember {
-            val aspect = if (info.thumbHeight != 0) {
-                (info.thumbWidth.toFloat() / info.thumbHeight).coerceIn(MIN_ASPECT, MAX_ASPECT)
+        var ratio by remember(info) {
+            val ratio = if (info.thumbHeight != 0) {
+                (info.thumbWidth.toFloat() / info.thumbHeight).coerceIn(MIN_RATIO, MAX_RATIO)
            } else {
-                DEFAULT_ASPECT
+                DEFAULT_RATIO
            }
-            BrushPainter(Brush.linearGradient(PlaceholderColors, end = Offset(aspect, 1f)))
+            mutableFloatStateOf(ratio)
        }
        EhAsyncThumb(
            model = info,
-            modifier = Modifier.fillMaxWidth(),
-            placeholder = placeholder,
-            contentScale = ContentScale.Crop,
+            modifier = Modifier.aspectRatio(ratio),
+            onSuccess = {
+                ratio = (it.width.toFloat() / it.height).coerceIn(MIN_RATIO, MAX_RATIO)
+            },
        )
        val categoryColor = EhUtils.getCategoryColor(info.category)
        Badge(
@@ -224,15 +236,20 @@ fun GalleryInfoGridItem(
            containerColor = categoryColor,
            contentColor = if (Settings.harmonizeCategoryColor) contentColorFor(categoryColor) else EhUtils.categoryTextColor,
        ) {
-            if (badgeText != null) {
-                Text(text = badgeText)
+            val shouldShowLanguage = showLanguage && info.simpleLanguage != null
+            if (showPages && info.pages > 0) {
+                Text(text = "${info.pages}")
+                if (shouldShowLanguage) {
+                    Spacer(modifier = Modifier.width(4.dp))
+                }
+            }
+            if (shouldShowLanguage) {
+                Text(text = "${info.simpleLanguage}")
            }
        }
    }
 }

-private val PlaceholderColors = listOf(Color.Transparent, Color.Transparent)
-
-private const val MIN_ASPECT = 0.33F
-private const val MAX_ASPECT = 1.5F
-const val DEFAULT_ASPECT = 0.67F
+private const val MIN_RATIO = 0.5F
+private const val MAX_RATIO = 1.5F
+const val DEFAULT_RATIO = 0.67F
@@ -6,6 +6,7 @@ import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.offset
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.widthIn
@@ -25,19 +26,24 @@ import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.ShapeDefaults
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
-import androidx.compose.material3.pulltorefresh.PullToRefreshState
+import androidx.compose.material3.pulltorefresh.PullToRefreshDefaults
+import androidx.compose.material3.pulltorefresh.pullToRefresh
+import androidx.compose.material3.pulltorefresh.rememberPullToRefreshState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.Stable
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.runtime.snapshotFlow
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
-import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.res.dimensionResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
 import androidx.paging.LoadState
@@ -54,7 +60,10 @@ import com.hippo.ehviewer.ui.screen.collectDetailSizeAsState
 import com.hippo.ehviewer.ui.tools.FastScrollLazyVerticalGrid
 import com.hippo.ehviewer.ui.tools.FastScrollLazyVerticalStaggeredGrid
 import com.hippo.ehviewer.util.displayString
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.drop
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch

@Stable
 operator fun PaddingValues.plus(r: PaddingValues) = object : PaddingValues {
@@ -65,6 +74,7 @@ operator fun PaddingValues.plus(r: PaddingValues) = object : PaddingValues {
    override fun calculateTopPadding() = l.calculateTopPadding() + r.calculateTopPadding()
 }

+context(CoroutineScope)
@Composable
 fun GalleryList(
    modifier: Modifier = Modifier,
@@ -76,20 +86,41 @@ fun GalleryList(
    detailItemContent: @Composable (LazyGridItemScope.(BaseGalleryInfo) -> Unit),
    thumbListState: LazyStaggeredGridState = rememberLazyStaggeredGridState(),
    thumbItemContent: @Composable (LazyStaggeredGridItemScope.(BaseGalleryInfo) -> Unit),
-    refreshState: PullToRefreshState,
+    searchBarOffsetY: () -> Int,
    scrollToTopOnRefresh: Boolean = true,
    onRefresh: () -> Unit,
    onLoading: () -> Unit,
 ) {
    val marginH = dimensionResource(id = R.dimen.gallery_list_margin_h)
    val marginV = dimensionResource(id = R.dimen.gallery_list_margin_v)
-    val combinedModifier = contentModifier.nestedScroll(refreshState.nestedScrollConnection)
-    Box(modifier = modifier.fillMaxSize()) {
+
+    var isRefreshing by remember { mutableStateOf(false) }
+    val refreshState = rememberPullToRefreshState()
+    Box(
+        modifier = modifier.fillMaxSize().pullToRefresh(
+            isRefreshing = isRefreshing,
+            state = refreshState,
+            enabled = data.loadState.refresh is LoadState.NotLoading,
+        ) {
+            isRefreshing = true
+            launch {
+                if (data.loadState.prepend.endOfPaginationReached) {
+                    onRefresh()
+                } else {
+                    data.retry()
+                }
+                snapshotFlow { data.loadState }.drop(1).first { state ->
+                    state.prepend !is LoadState.Loading && state.refresh !is LoadState.Loading
+                }
+                isRefreshing = false
+            }
+        },
+    ) {
        if (listMode == 0) {
            val columnWidth by collectDetailSizeAsState()
            FastScrollLazyVerticalGrid(
                columns = GridCells.Adaptive(columnWidth),
-                modifier = combinedModifier,
+                modifier = contentModifier,
                state = detailListState,
                contentPadding = contentPadding + PaddingValues(marginH, marginV),
                verticalArrangement = Arrangement.spacedBy(dimensionResource(R.dimen.gallery_list_interval)),
@@ -118,7 +149,7 @@ fun GalleryList(
            val thumbColumns by Settings.thumbColumns.collectAsState()
            FastScrollLazyVerticalStaggeredGrid(
                columns = StaggeredGridCells.Fixed(thumbColumns),
-                modifier = combinedModifier,
+                modifier = contentModifier,
                state = thumbListState,
                verticalItemSpacing = gridInterval,
                horizontalArrangement = Arrangement.spacedBy(gridInterval),
@@ -144,23 +175,8 @@ fun GalleryList(
            }
        }

-        if (refreshState.isRefreshing) {
-            LaunchedEffect(Unit) {
-                if (data.loadState.prepend.endOfPaginationReached) {
-                    onRefresh()
-                } else {
-                    data.retry()
-                }
-                snapshotFlow { data.loadState }.drop(1).collect { state ->
-                    if (state.prepend !is LoadState.Loading && state.refresh !is LoadState.Loading) {
-                        refreshState.endRefresh()
-                    }
-                }
-            }
-        }
-
        when (val state = data.loadState.refresh) {
-            is LoadState.Loading -> if (!refreshState.isRefreshing && scrollToTopOnRefresh) {
+            is LoadState.Loading -> if (!isRefreshing && scrollToTopOnRefresh) {
                LaunchedEffect(Unit) {
                    onLoading()
                }
@@ -195,6 +211,13 @@ fun GalleryList(
                ErrorTip(modifier = Modifier.widthIn(max = 228.dp), text = stringResource(id = R.string.gallery_list_empty_hit))
            }
        }
+
+        PullToRefreshDefaults.Indicator(
+            state = refreshState,
+            isRefreshing = isRefreshing,
+            modifier = Modifier.align(Alignment.TopCenter).padding(top = contentPadding.calculateTopPadding())
+                .offset { IntOffset(0, searchBarOffsetY()) },
+        )
    }
 }

@@ -90,7 +90,7 @@ fun EhPreviewItem(
    Box(contentAlignment = Alignment.Center) {
        CrystalCard(
            onClick = onClick,
-            modifier = Modifier.aspectRatio(DEFAULT_ASPECT),
+            modifier = Modifier.aspectRatio(DEFAULT_RATIO),
        ) {
            if (galleryPreview != null) {
                EhAsyncPreview(
@@ -12,9 +12,7 @@ import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.FilterAlt
 import androidx.compose.material.icons.filled.Info
-import androidx.compose.material.icons.outlined.FilterAlt
 import androidx.compose.material3.FilterChip
 import androidx.compose.material3.Icon
 import androidx.compose.material3.ListItem
@@ -39,8 +37,11 @@ import com.hippo.ehviewer.Settings
 import com.hippo.ehviewer.asMutableState
 import com.hippo.ehviewer.client.EhTagDatabase
 import com.hippo.ehviewer.client.EhUtils
-import com.hippo.ehviewer.client.data.GalleryInfo
+import com.hippo.ehviewer.client.data.GalleryInfo.Companion.S_LANG_TAGS
+import com.hippo.ehviewer.collectAsState
+import com.hippo.ehviewer.ui.tools.DropdownFilterChip
 import com.hippo.ehviewer.ui.tools.LocalDialogState
+import com.hippo.ehviewer.ui.tools.thenIf
 import com.hippo.ehviewer.util.toIntOrDefault
 import kotlinx.coroutines.launch

@@ -68,10 +69,11 @@ fun SearchFilter(
    val scope = rememberCoroutineScope()
    val context = LocalContext.current
    val dialogState = LocalDialogState.current
+    val animateItems by Settings.animateItems.collectAsState()
    fun isCategoryChecked(bit: Int) = category and bit != 0
    val categories = remember(category) { categoryTable.sortedBy { !isCategoryChecked(it.first) } }
    LazyRow(
-        contentPadding = PaddingValues(horizontal = 16.dp, vertical = 8.dp),
+        contentPadding = PaddingValues(start = 8.dp, top = 8.dp, end = 16.dp),
        horizontalArrangement = Arrangement.spacedBy(8.dp),
    ) {
        // Workaround for the first item's animation
@@ -82,44 +84,48 @@ fun SearchFilter(
                selected = isCategoryChecked(it.first),
                onClick = { onCategoryChanged(category xor it.first) },
                label = { Text(text = stringResource(id = it.second)) },
-                modifier = Modifier.animateItemPlacement(),
+                modifier = Modifier.thenIf(animateItems) { animateItem() },
            )
        }
    }
-    var languageFilter by Settings.languageFilter.asMutableState()
-    val languages = remember {
-        GalleryInfo.S_LANG_TAGS.map { tag ->
-            tag.substringAfter(':').let {
-                if (EhTagDatabase.initialized && EhTagDatabase.isTranslatable(context)) {
-                    EhTagDatabase.getTranslation("l", it) ?: it
-                } else {
-                    it
-                }
-            }
-        }
-    }
    Row(
        modifier = Modifier.horizontalScroll(rememberScrollState()).padding(horizontal = 16.dp, vertical = 8.dp),
        horizontalArrangement = Arrangement.spacedBy(8.dp),
    ) {
        val any = stringResource(id = R.string.any)
        val languageStr = stringResource(id = R.string.key_language)
-        FilterChip(
-            selected = languageFilter != -1,
-            onClick = {
-                scope.launch {
-                    val items = listOf(any, *languages.toTypedArray())
-                    languageFilter = dialogState.showSingleChoice(items, languageFilter + 1) - 1
+        val languages = remember {
+            val translatable = EhTagDatabase.initialized && EhTagDatabase.isTranslatable(context)
+            List(S_LANG_TAGS.size + 1) { i ->
+                if (i == 0) {
+                    any
+                } else {
+                    val tag = S_LANG_TAGS[i - 1].substringAfter(':')
+                    if (translatable) {
+                        EhTagDatabase.getTranslation("l", tag) ?: tag
+                    } else {
+                        tag
+                    }
                }
+            }
+        }
+        var languageFilter by Settings.languageFilter.asMutableState()
+        DropdownFilterChip(
+            label = languageStr,
+            menuItems = languages,
+            selectedItemIndex = languageFilter + 1,
+            onSelectedItemIndexChange = {
+                languageFilter = it - 1
            },
-            label = {
-                Text(text = if (languageFilter == -1) languageStr else languages[languageFilter])
-            },
-            trailingIcon = {
-                Icon(
-                    imageVector = if (languageFilter == -1) Icons.Outlined.FilterAlt else Icons.Default.FilterAlt,
-                    contentDescription = null,
-                )
+        )
+        val minRatingItems = stringArrayResource(id = R.array.search_min_rating)
+        val minRatingStr = stringResource(id = R.string.search_sr)
+        DropdownFilterChip(
+            label = minRatingStr,
+            menuItems = minRatingItems.asList(),
+            selectedItemIndex = (advancedOption.minRating - 1).coerceAtLeast(0),
+            onSelectedItemIndexChange = {
+                onAdvancedOptionChanged(advancedOption.copy(minRating = if (it == 0) 0 else it + 1))
            },
        )
        val pageErr1 = stringResource(R.string.search_sp_err1)
@@ -201,19 +207,6 @@ fun SearchFilter(
            },
            label = { Text(text = pagesText) },
        )
-        val minRatingItems = stringArrayResource(id = R.array.search_min_rating)
-        val minRatingStr = stringResource(id = R.string.search_sr)
-        val minRatingIndex = (advancedOption.minRating - 1).coerceAtLeast(0)
-        FilterChip(
-            selected = advancedOption.minRating != 0,
-            onClick = {
-                scope.launch {
-                    val selected = dialogState.showSingleChoice(minRatingItems.toList(), minRatingIndex)
-                    onAdvancedOptionChanged(advancedOption.copy(minRating = if (selected == 0) 0 else selected + 1))
-                }
-            },
-            label = { Text(text = minRatingStr + minRatingItems[minRatingIndex]) },
-        )
        fun checked(bit: Int) = advancedOption.advanceSearch and bit != 0
        fun AdvancedSearchOption.inv(bit: Int) = onAdvancedOptionChanged(copy(advanceSearch = advanceSearch xor bit))
        FilterChip(
@@ -0,0 +1,93 @@
+package com.hippo.ehviewer.ui.main
+
+import androidx.compose.foundation.MarqueeSpacing
+import androidx.compose.foundation.basicMarquee
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.minimumInteractiveComponentSize
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import com.hippo.ehviewer.R
+import com.hippo.ehviewer.client.parser.Torrent
+import com.hippo.ehviewer.client.parser.format
+
+@Composable
+fun TorrentList(
+    items: List<Torrent>,
+    onItemClick: (Torrent) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val title = stringResource(R.string.torrents)
+    Column(
+        modifier = modifier.padding(vertical = 8.dp),
+        horizontalAlignment = Alignment.CenterHorizontally,
+    ) {
+        Text(text = title, style = MaterialTheme.typography.headlineSmall)
+        val labelStyle = MaterialTheme.typography.labelLarge
+        LazyColumn(
+            contentPadding = PaddingValues(vertical = 16.dp),
+            verticalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+            items(items) {
+                Column(
+                    modifier = Modifier.clickable { onItemClick(it) }.minimumInteractiveComponentSize()
+                        .padding(horizontal = 8.dp),
+                ) {
+                    Text(
+                        text = it.name,
+                        modifier = Modifier.basicMarquee(
+                            spacing = MarqueeSpacing(16.dp),
+                            velocity = 60.dp,
+                        ),
+                        color = MaterialTheme.colorScheme.primary,
+                    )
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        verticalAlignment = Alignment.CenterVertically,
+                    ) {
+                        Text(
+                            text = it.posted,
+                            modifier = Modifier.weight(2.5f),
+                            color = if (it.outdated) MaterialTheme.colorScheme.error else Color.Unspecified,
+                            style = labelStyle,
+                        )
+                        Text(
+                            text = it.uploader,
+                            modifier = Modifier.weight(2.5f),
+                            overflow = TextOverflow.Ellipsis,
+                            maxLines = 1,
+                            style = labelStyle,
+                        )
+                        Text(
+                            text = it.size,
+                            modifier = Modifier.weight(2f),
+                            style = labelStyle,
+                            textAlign = TextAlign.End,
+                        )
+                        Text(
+                            text = it.format(),
+                            modifier = Modifier.weight(3f),
+                            style = labelStyle,
+                            textAlign = TextAlign.End,
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
@@ -3,6 +3,7 @@ package com.hippo.ehviewer.ui.reader
 import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.LazyListState
@@ -39,18 +40,20 @@ fun GalleryPager(
    onSelectPage: (ReaderPage) -> Unit,
    onMenuRegionClick: () -> Unit,
    modifier: Modifier = Modifier,
+    contentPadding: PaddingValues = PaddingValues(0.dp),
 ) {
    val items = pageLoader.pages
    when (type) {
        DEFAULT, LEFT_TO_RIGHT, RIGHT_TO_LEFT -> {
-            val zoomableState = rememberZoomableState(zoomSpec = zoomSpec)
            HorizontalPager(
                state = pagerState,
                modifier = modifier,
+                contentPadding = contentPadding,
                reverseLayout = type == RIGHT_TO_LEFT,
                key = { it },
            ) { index ->
                val page = items[index]
+                val zoomableState = rememberZoomableState(zoomSpec = zoomSpec)
                val status by page.status.collectAsState()
                val boxModifier = if (status == Page.State.READY) {
                    Modifier.zoomable(
@@ -79,13 +82,14 @@ fun GalleryPager(
            }
        }
        VERTICAL -> {
-            val zoomableState = rememberZoomableState(zoomSpec = zoomSpec)
            VerticalPager(
                state = pagerState,
                modifier = modifier,
+                contentPadding = contentPadding,
                key = { it },
            ) { index ->
                val page = items[index]
+                val zoomableState = rememberZoomableState(zoomSpec = zoomSpec)
                val status by page.status.collectAsState()
                val boxModifier = if (status == Page.State.READY) {
                    Modifier.zoomable(
@@ -132,6 +136,7 @@ fun GalleryPager(
                    },
                ),
                state = lazyListState,
+                contentPadding = contentPadding,
                verticalArrangement = Arrangement.spacedBy(if (type != WEBTOON) 15.dp else 0.dp),
            ) {
                items(items, key = { it.index }) { page ->
@@ -86,6 +86,10 @@ suspend fun save(page: ReaderPage) {
    val cannotSave = getString(R.string.error_cant_save_image)
    if (granted) {
        val filename = getImageFilename(page.index)
+        if (filename == null) {
+            showSnackbar(cannotSave)
+            return
+        }
        val extension = FileUtils.getExtensionFromFilename(filename)
        val mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension) ?: "image/jpeg"
        val values = ContentValues()
@@ -133,6 +137,10 @@ suspend fun save(page: ReaderPage) {
 context(SnackbarHostState, Context, PageLoader2)
 suspend fun saveTo(page: ReaderPage) {
    val filename = getImageFilename(page.index)
+    if (filename == null) {
+        showSnackbar(getString(R.string.error_cant_save_image))
+        return
+    }
    val extension = FileUtils.getExtensionFromFilename(filename)
    val mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension) ?: "image/jpeg"
    page.runSuspendCatching {
@@ -7,12 +7,15 @@ import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.verticalScroll
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalView
 import androidx.compose.ui.res.stringArrayResource
 import androidx.compose.ui.res.stringResource
 import com.hippo.ehviewer.R
 import com.hippo.ehviewer.Settings
 import com.hippo.ehviewer.asMutableState
+import com.hippo.ehviewer.util.isAtLeastP

@Composable
 fun ReaderGeneralSetting() = Column(modifier = Modifier.verticalScroll(rememberScrollState()).navigationBarsPadding()) {
@@ -39,11 +42,15 @@ fun ReaderGeneralSetting() = Column(modifier = Modifier.verticalScroll(rememberS
        title = stringResource(id = R.string.pref_fullscreen),
        field = fullscreen,
    )
-    AnimatedVisibility(visible = fullscreen.value) {
-        SwitchChoice(
-            title = stringResource(id = R.string.pref_cutout_short),
-            field = Settings.cutoutShort.asMutableState(),
-        )
+    val view = LocalView.current
+    val hasDisplayCutout = remember(view) { isAtLeastP && view.rootWindowInsets.displayCutout != null }
+    if (hasDisplayCutout) {
+        AnimatedVisibility(visible = fullscreen.value) {
+            SwitchChoice(
+                title = stringResource(id = R.string.pref_cutout_short),
+                field = Settings.cutoutShort.asMutableState(),
+            )
+        }
    }
    SwitchChoice(
        title = stringResource(id = R.string.pref_keep_screen_on),
@@ -70,7 +70,7 @@ private fun PagerSetting() = Column {
                title = stringResource(id = R.string.pref_read_with_tapping_inverted),
                entries = stringArrayResource(id = R.array.invert_tapping_mode),
                values = arrayOf("0", "1", "2", "3"),
-                field = Settings.readerWebtoonNavInverted.asMutableState(),
+                field = Settings.readerPagerNavInverted.asMutableState(),
            )
            SwitchChoice(
                title = stringResource(id = R.string.pref_navigate_pan),
@@ -4,10 +4,17 @@ import androidx.compose.animation.animateColorAsState
 import androidx.compose.foundation.background
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.WindowInsetsSides
+import androidx.compose.foundation.layout.asPaddingValues
+import androidx.compose.foundation.layout.displayCutout
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.navigationBarsPadding
-import androidx.compose.foundation.layout.statusBarsIgnoringVisibility
+import androidx.compose.foundation.layout.only
+import androidx.compose.foundation.layout.safeDrawing
+import androidx.compose.foundation.layout.systemBars
+import androidx.compose.foundation.layout.windowInsetsPadding
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.foundation.pager.rememberPagerState
 import androidx.compose.material3.BottomSheetDefaults
@@ -24,12 +31,15 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
+import androidx.compose.runtime.snapshotFlow
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.BlendMode
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.input.pointer.util.VelocityTrackerAddPointsFix
 import androidx.compose.ui.res.colorResource
+import androidx.compose.ui.unit.dp
+import androidx.core.view.WindowInsetsControllerCompat
+import com.google.accompanist.systemuicontroller.rememberSystemUiController
 import com.hippo.ehviewer.R
 import com.hippo.ehviewer.Settings
 import com.hippo.ehviewer.client.data.BaseGalleryInfo
@@ -38,10 +48,10 @@ import com.hippo.ehviewer.download.DownloadManager
 import com.hippo.ehviewer.download.archiveFile
 import com.hippo.ehviewer.gallery.ArchivePageLoader
 import com.hippo.ehviewer.gallery.EhPageLoader
-import com.hippo.ehviewer.ui.LockDrawer
 import com.hippo.ehviewer.ui.composing
 import com.hippo.ehviewer.ui.tools.Deferred
 import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.annotation.RootGraph
 import com.ramcosta.composedestinations.navigation.DestinationsNavigator
 import eu.kanade.tachiyomi.ui.reader.PageIndicatorText
 import eu.kanade.tachiyomi.ui.reader.ReaderAppBars
@@ -53,19 +63,9 @@ import kotlin.coroutines.resume
 import kotlinx.coroutines.launch
 import moe.tarsin.kt.unreachable

-@Destination
+@Destination<RootGraph>
@Composable
 fun ReaderScreen(info: BaseGalleryInfo, page: Int = -1, navigator: DestinationsNavigator) = composing(navigator) {
-    // Workaround for incorrect fling velocity on zoom gesture end
-    // https://github.com/saket/telephoto/issues/71
-    DisposableEffect(Unit) {
-        VelocityTrackerAddPointsFix = false
-        onDispose {
-            VelocityTrackerAddPointsFix = true
-        }
-    }
-
-    LockDrawer(true)
    ConfigureKeepScreenOn()
    val pageLoader = remember {
        val archive = DownloadManager.getDownloadInfo(info.gid)?.archiveFile
@@ -85,6 +85,16 @@ fun ReaderScreen(info: BaseGalleryInfo, page: Int = -1, navigator: DestinationsN
    val showSeekbar by Settings.showReaderSeekbar.collectAsState()
    val readingMode by Settings.readingMode.collectAsState { ReadingModeType.fromPreference(it) }
    val volumeKeysEnabled by Settings.readWithVolumeKeys.collectAsState()
+    val fullscreen by Settings.fullscreen.collectAsState()
+    val cutoutShort by Settings.cutoutShort.collectAsState()
+    val uiController = rememberSystemUiController()
+    DisposableEffect(uiController) {
+        uiController.systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+        onDispose {
+            uiController.isSystemBarsVisible = true
+            uiController.systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_DEFAULT
+        }
+    }
    Deferred({ pageLoader.awaitReady() }) {
        val lazyListState = rememberLazyListState()
        val pagerState = rememberPagerState { pageLoader.size }
@@ -93,6 +103,13 @@ fun ReaderScreen(info: BaseGalleryInfo, page: Int = -1, navigator: DestinationsN
        Box {
            var appbarVisible by remember { mutableStateOf(false) }
            val bgColor by collectBackgroundColorAsState()
+            if (fullscreen) {
+                LaunchedEffect(Unit) {
+                    snapshotFlow { appbarVisible }.collect {
+                        uiController.isSystemBarsVisible = it
+                    }
+                }
+            }
            VolumeKeysHandler(
                enabled = { volumeKeysEnabled && !appbarVisible },
                movePrevious = { syncState.sliderScrollTo(syncState.sliderValue - 1) },
@@ -111,8 +128,9 @@ fun ReaderScreen(info: BaseGalleryInfo, page: Int = -1, navigator: DestinationsN
                                val state = rememberModalBottomSheetState()
                                ModalBottomSheet(
                                    onDismissRequest = { dispose() },
+                                    modifier = Modifier.windowInsetsPadding(WindowInsets.safeDrawing.only(WindowInsetsSides.Top)),
                                    sheetState = state,
-                                    windowInsets = WindowInsets.statusBarsIgnoringVisibility,
+                                    contentWindowInsets = { WindowInsets(0) },
                                ) {
                                    ReaderPageSheetMeta(
                                        retry = { pageLoader.retryPage(page.index) },
@@ -130,6 +148,15 @@ fun ReaderScreen(info: BaseGalleryInfo, page: Int = -1, navigator: DestinationsN
                },
                onMenuRegionClick = { appbarVisible = !appbarVisible },
                modifier = Modifier.background(bgColor),
+                contentPadding = if (fullscreen) {
+                    if (cutoutShort) {
+                        PaddingValues(0.dp)
+                    } else {
+                        WindowInsets.displayCutout.asPaddingValues()
+                    }
+                } else {
+                    WindowInsets.systemBars.asPaddingValues()
+                },
            )
            val brightness by Settings.customBrightness.collectAsState()
            val brightnessValue by Settings.customBrightnessValue.collectAsState()
@@ -152,7 +179,7 @@ fun ReaderScreen(info: BaseGalleryInfo, page: Int = -1, navigator: DestinationsN
                colorBlendMode = colorOverlayMode,
            )
            val showPageNumber by Settings.showPageNumber.collectAsState()
-            if (showPageNumber) {
+            if (showPageNumber && !appbarVisible) {
                CompositionLocalProvider(LocalTextStyle provides MaterialTheme.typography.bodySmall) {
                    PageIndicatorText(
                        currentPage = syncState.sliderValue,
@@ -179,10 +206,11 @@ fun ReaderScreen(info: BaseGalleryInfo, page: Int = -1, navigator: DestinationsN
                            )
                            ModalBottomSheet(
                                onDismissRequest = { dispose() },
+                                modifier = Modifier.windowInsetsPadding(WindowInsets.safeDrawing.only(WindowInsetsSides.Top)),
                                // Yeah, I know color state should not be read here, but we have to do it...
                                scrimColor = scrim,
                                dragHandle = null,
-                                windowInsets = WindowInsets.statusBarsIgnoringVisibility,
+                                contentWindowInsets = { WindowInsets(0) },
                            ) {
                                SettingsPager(modifier = Modifier.fillMaxSize()) { page ->
                                    isColorFilter = page == 2
@@ -8,7 +8,6 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.Stable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.runtime.snapshotFlow
@@ -16,7 +15,7 @@ import com.hippo.ehviewer.Settings
 import com.hippo.ehviewer.gallery.PageLoader2
 import kotlin.math.absoluteValue
 import kotlinx.coroutines.flow.collectLatest
-import kotlinx.coroutines.flow.mapNotNull
+import kotlinx.coroutines.flow.filterNotNull

@Stable
 class SliderPagerDoubleSync(
@@ -24,8 +23,10 @@ class SliderPagerDoubleSync(
    private val pagerState: PagerState,
    private val pageLoader: PageLoader2,
 ) {
-    private var sliderFollowPager by mutableStateOf(true)
-    var sliderValue by mutableIntStateOf(1)
+    private var requestScroll = true
+    private var sliderFollowPager = true
+    var sliderValue by mutableIntStateOf(pageLoader.startPage + 1)
+        private set

    fun sliderScrollTo(index: Int) {
        sliderFollowPager = false
@@ -37,52 +38,55 @@ class SliderPagerDoubleSync(
        val fling by lazyListState.interactionSource.collectIsDraggedAsState()
        val pagerFling by pagerState.interactionSource.collectIsDraggedAsState()
        if (fling || pagerFling) sliderFollowPager = true
-        val startPage = remember { pageLoader.startPage }
        val currentIndexFlow = remember(webtoon) {
+            requestScroll = true
            if (webtoon) {
-                snapshotFlow { lazyListState.layoutInfo }.mapNotNull { info ->
-                    info.visibleItemsInfo.lastOrNull {
-                        it.offset <= maxOf(info.viewportStartOffset, info.viewportEndOffset - it.size)
-                    }?.index
-                }
+                snapshotFlow {
+                    with(lazyListState.layoutInfo) {
+                        visibleItemsInfo.lastOrNull {
+                            it.offset <= maxOf(viewportStartOffset, viewportEndOffset - it.size)
+                        }?.index
+                    }
+                }.filterNotNull()
            } else {
                snapshotFlow { pagerState.currentPage }
            }
        }
-        if (sliderFollowPager) {
-            LaunchedEffect(currentIndexFlow) {
-                currentIndexFlow.collect { index ->
+        LaunchedEffect(currentIndexFlow) {
+            currentIndexFlow.collect { index ->
+                if (sliderFollowPager && !requestScroll) {
                    sliderValue = index + 1
                    pageLoader.startPage = index
                }
            }
-        } else {
-            LaunchedEffect(webtoon) {
-                snapshotFlow { sliderValue - 1 }.collectLatest { index ->
-                    if (webtoon) {
-                        val noAnim = (index - lazyListState.firstVisibleItemIndex).absoluteValue > SMOOTH_SCROLL_THRESHOLD || !Settings.pageTransitions.value
-                        if (noAnim) {
-                            lazyListState.scrollToItem(index)
-                        } else {
-                            lazyListState.animateScrollToItem(index)
-                        }
+        }
+        LaunchedEffect(webtoon) {
+            snapshotFlow { sliderValue - 1 }.collectLatest { index ->
+                if (sliderFollowPager && !requestScroll) return@collectLatest
+                if (webtoon) {
+                    if (requestScroll) {
+                        lazyListState.requestScrollToItem(index)
+                        requestScroll = false
                    } else {
-                        val noAnim = (index - pagerState.currentPage).absoluteValue > SMOOTH_SCROLL_THRESHOLD || !Settings.pageTransitions.value
-                        if (noAnim) {
-                            pagerState.scrollToPage(index)
+                        if (smoothScroll((index - lazyListState.firstVisibleItemIndex))) {
+                            lazyListState.animateScrollToItem(index)
                        } else {
+                            lazyListState.scrollToItem(index)
+                        }
+                    }
+                } else {
+                    if (requestScroll) {
+                        pagerState.requestScrollToPage(index)
+                        requestScroll = false
+                    } else {
+                        if (smoothScroll((index - pagerState.currentPage))) {
                            pagerState.animateScrollToPage(index)
+                        } else {
+                            pagerState.scrollToPage(index)
                        }
                    }
-                    pageLoader.startPage = index
                }
-            }
-        }
-        LaunchedEffect(Unit) {
-            if (webtoon) {
-                lazyListState.scrollToItem(startPage)
-            } else {
-                pagerState.scrollToPage(startPage)
+                pageLoader.startPage = index
            }
        }
    }
@@ -100,4 +104,7 @@ fun rememberSliderPagerDoubleSyncState(
    }
 }

+private fun smoothScroll(distance: Int) =
+    distance.absoluteValue < SMOOTH_SCROLL_THRESHOLD && Settings.pageTransitions.value
+
 private const val SMOOTH_SCROLL_THRESHOLD = 50
@@ -29,6 +29,7 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalConfiguration
 import androidx.compose.ui.unit.dp
+import kotlin.math.roundToInt

@Composable
 fun SpinnerChoice(title: String, entries: Array<String>, values: Array<String>, field: MutableState<Int>) {
@@ -97,9 +98,7 @@ fun SliderChoice(
    ) {
        startSlot()
        val configuration = LocalConfiguration.current
-        // https://m3.material.io/components/sliders/specs
-        // Tick width is 2 dp
-        val maxTickCount = configuration.screenWidthDp / 6
+        val maxTickCount = configuration.screenWidthDp / (SliderDefaults.TickSize.value * 2.5f).roundToInt()
        val steps = range.last - range.first - 1
        val showTicks = steps < maxTickCount
        Slider(
@@ -0,0 +1,5 @@
+package com.hippo.ehviewer.ui.screen
+
+// https://github.com/Kotlin/KEEP/blob/context-parameters/proposals/context-parameters.md#standard-library-support
+context(T)
+inline fun <reified T> implicit(): T = this@T
@@ -2,18 +2,20 @@ package com.hippo.ehviewer.ui.screen

 import android.os.Parcelable
 import com.hippo.ehviewer.dao.DownloadInfo
+import com.hippo.ehviewer.download.DownloadsFilterMode
 import com.hippo.ehviewer.util.containsIgnoreCase
 import kotlinx.parcelize.Parcelize

@Parcelize
 data class DownloadsFilterState(
+    val mode: DownloadsFilterMode,
    val label: String?,
    val state: Int = -1,
    val keyword: String = "",
 ) : Parcelable

 fun DownloadsFilterState.take(info: DownloadInfo) =
-    (label == "" || info.label == label) && (state == -1 || info.state == state) &&
+    mode.take(info, label) && (state == -1 || info.state == state) &&
        with(info) {
            title.containsIgnoreCase(keyword) || titleJpn.containsIgnoreCase(keyword) ||
                simpleTags?.any { it.containsIgnoreCase(keyword) } ?: false
@@ -1,5 +1,7 @@
 package com.hippo.ehviewer.ui.screen

+import android.app.Activity
+import android.content.Context
 import android.content.Intent
 import android.view.ViewConfiguration
 import androidx.compose.animation.Crossfade
@@ -12,8 +14,6 @@ import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.WindowInsetsSides
 import androidx.compose.foundation.layout.asPaddingValues
-import androidx.compose.foundation.layout.calculateEndPadding
-import androidx.compose.foundation.layout.calculateStartPadding
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.only
@@ -31,6 +31,7 @@ import androidx.compose.material.icons.automirrored.filled.Sort
 import androidx.compose.material.icons.automirrored.filled.ViewList
 import androidx.compose.material.icons.filled.Delete
 import androidx.compose.material.icons.filled.DoneAll
+import androidx.compose.material.icons.filled.Download
 import androidx.compose.material.icons.filled.Edit
 import androidx.compose.material.icons.filled.FilterList
 import androidx.compose.material.icons.filled.GridView
@@ -38,6 +39,7 @@ import androidx.compose.material.icons.filled.MoreVert
 import androidx.compose.material.icons.filled.NewLabel
 import androidx.compose.material.icons.filled.Pause
 import androidx.compose.material.icons.filled.PlayArrow
+import androidx.compose.material.icons.filled.Reorder
 import androidx.compose.material.icons.filled.Settings
 import androidx.compose.material.icons.filled.Shuffle
 import androidx.compose.material3.DropdownMenu
@@ -47,13 +49,15 @@ import androidx.compose.material3.IconButton
 import androidx.compose.material3.ListItem
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.SwipeToDismissBoxDefaults
-import androidx.compose.material3.SwipeToDismissBoxState
 import androidx.compose.material3.SwipeToDismissBoxValue
 import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.fork.SwipeToDismissBox
+import androidx.compose.material3.fork.SwipeToDismissBoxState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateListOf
@@ -70,10 +74,7 @@ import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.input.nestedscroll.NestedScrollConnection
 import androidx.compose.ui.input.nestedscroll.NestedScrollSource
 import androidx.compose.ui.input.nestedscroll.nestedScroll
-import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.platform.LocalLayoutDirection
-import androidx.compose.ui.platform.LocalView
 import androidx.compose.ui.res.dimensionResource
 import androidx.compose.ui.res.stringArrayResource
 import androidx.compose.ui.res.stringResource
@@ -84,79 +85,97 @@ import com.hippo.ehviewer.EhDB
 import com.hippo.ehviewer.R
 import com.hippo.ehviewer.Settings
 import com.hippo.ehviewer.asMutableState
+import com.hippo.ehviewer.client.EhTagDatabase
+import com.hippo.ehviewer.client.data.TagNamespace
 import com.hippo.ehviewer.collectAsState
 import com.hippo.ehviewer.dao.DownloadInfo
 import com.hippo.ehviewer.download.DownloadManager
-import com.hippo.ehviewer.download.DownloadManager.labelList
+import com.hippo.ehviewer.download.DownloadManager.downloadInfoList
 import com.hippo.ehviewer.download.DownloadService
+import com.hippo.ehviewer.download.DownloadsFilterMode
 import com.hippo.ehviewer.download.SortMode
 import com.hippo.ehviewer.icons.EhIcons
 import com.hippo.ehviewer.icons.big.Download
+import com.hippo.ehviewer.ui.DrawerHandle
 import com.hippo.ehviewer.ui.LocalSideSheetState
-import com.hippo.ehviewer.ui.LockDrawer
-import com.hippo.ehviewer.ui.MainActivity
 import com.hippo.ehviewer.ui.composing
 import com.hippo.ehviewer.ui.confirmRemoveDownloadRange
 import com.hippo.ehviewer.ui.main.DownloadCard
 import com.hippo.ehviewer.ui.main.FAB_ANIMATE_TIME
 import com.hippo.ehviewer.ui.main.FabLayout
 import com.hippo.ehviewer.ui.main.GalleryInfoGridItem
+import com.hippo.ehviewer.ui.main.plus
 import com.hippo.ehviewer.ui.navToReader
 import com.hippo.ehviewer.ui.showMoveDownloadLabelList
 import com.hippo.ehviewer.ui.tools.Deferred
-import com.hippo.ehviewer.ui.tools.DragHandle
 import com.hippo.ehviewer.ui.tools.FastScrollLazyColumn
 import com.hippo.ehviewer.ui.tools.FastScrollLazyVerticalStaggeredGrid
-import com.hippo.ehviewer.ui.tools.SwipeToDismissBox2
+import com.hippo.ehviewer.ui.tools.HapticFeedbackType
 import com.hippo.ehviewer.ui.tools.delegateSnapshotUpdate
-import com.hippo.ehviewer.ui.tools.draggingHapticFeedback
+import com.hippo.ehviewer.ui.tools.rememberHapticFeedback
 import com.hippo.ehviewer.ui.tools.rememberInVM
-import com.hippo.ehviewer.util.findActivity
+import com.hippo.ehviewer.ui.tools.thenIf
 import com.hippo.ehviewer.util.mapToLongArray
+import com.hippo.ehviewer.util.takeAndClear
+import com.jamal.composeprefs3.ui.ifTrueThen
 import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.annotation.RootGraph
 import com.ramcosta.composedestinations.navigation.DestinationsNavigator
 import eu.kanade.tachiyomi.util.lang.launchIO
 import eu.kanade.tachiyomi.util.lang.withNonCancellableContext
 import eu.kanade.tachiyomi.util.lang.withUIContext
 import kotlin.math.roundToInt
-import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import moe.tarsin.coroutines.onEachLatest
 import sh.calvin.reorderable.ReorderableItem
-import sh.calvin.reorderable.rememberReorderableLazyColumnState
+import sh.calvin.reorderable.rememberReorderableLazyListState

-@Destination
+@Destination<RootGraph>
@Composable
 fun DownloadsScreen(navigator: DestinationsNavigator) = composing(navigator) {
    var gridView by Settings.gridView.asMutableState()
    var sortMode by Settings.downloadSortMode.asMutableState()
-    var filterState by rememberSaveable { mutableStateOf(DownloadsFilterState(Settings.recentDownloadLabel.value)) }
+    val filterMode by Settings.downloadFilterMode.collectAsState { DownloadsFilterMode.from(it) }
+    var filterState by rememberSaveable { mutableStateOf(DownloadsFilterState(filterMode, Settings.recentDownloadLabel.value)) }
    var invalidateKey by rememberSaveable { mutableStateOf(false) }
-    var searchBarOffsetY by remember(filterState.label) { mutableIntStateOf(0) }
+    var searchBarExpanded by rememberSaveable { mutableStateOf(false) }
+    var searchBarOffsetY by remember { mutableIntStateOf(0) }
+    val animateItems by Settings.animateItems.collectAsState()

    var fabExpanded by remember { mutableStateOf(false) }
    var fabHidden by remember { mutableStateOf(false) }
    val checkedInfoMap = remember { mutableStateMapOf<Long, DownloadInfo>() }
    val selectMode by rememberUpdatedState(checkedInfoMap.isNotEmpty())
-    LockDrawer(selectMode)
+    DrawerHandle(!selectMode && !searchBarExpanded)

-    val context = LocalContext.current
-    val activity = remember { findActivity<MainActivity>() }
    val density = LocalDensity.current
-    val view = LocalView.current
+    val canTranslate = Settings.showTagTranslations && EhTagDatabase.isTranslatable(implicit<Context>()) && EhTagDatabase.initialized
+    val ehTags = EhTagDatabase.takeIf { canTranslate }
+    fun String.translateArtist() = ehTags?.getTranslation(TagNamespace.Artist.toPrefix(), this) ?: this
    val positionalThreshold = SwipeToDismissBoxDefaults.positionalThreshold
    val allName = stringResource(R.string.download_all)
    val defaultName = stringResource(R.string.default_download_label_name)
+    val unknownName = stringResource(R.string.unknown_artists)
+    val emptyLabelName = when (filterMode) {
+        DownloadsFilterMode.ARTIST -> unknownName
+        DownloadsFilterMode.CUSTOM -> defaultName
+    }
    val title = stringResource(
        R.string.scene_download_title,
-        with(filterState) { if (label == "") allName else label ?: defaultName },
+        with(filterState) {
+            when (label) {
+                "" -> allName
+                null -> emptyLabelName
+                else -> if (mode == DownloadsFilterMode.ARTIST) label.translateArtist() else label
+            }
+        },
    )
    val hint = stringResource(R.string.search_bar_hint, title)
    val sortModes = stringArrayResource(id = R.array.download_sort_modes)
    val downloadStates = stringArrayResource(id = R.array.download_state)
    val list = remember(filterState, invalidateKey) {
-        DownloadManager.downloadInfoList.filterTo(mutableStateListOf()) { info ->
+        downloadInfoList.filterTo(mutableStateListOf()) { info ->
            filterState.take(info)
        }
    }
@@ -167,21 +186,42 @@ fun DownloadsScreen(navigator: DestinationsNavigator) = composing(navigator) {
    val labelEmpty = stringResource(R.string.label_text_is_empty)
    val defaultInvalid = stringResource(R.string.label_text_is_invalid)
    val labelExists = stringResource(R.string.label_text_exist)
-    val downloadsCount by rememberInVM { EhDB.downloadsCount }.collectAsState(emptyMap())
-    val totalCount = remember(downloadsCount) { downloadsCount.values.sum() }
+    val downloadsCountGroupByArtist by rememberInVM { EhDB.downloadsCountByArtist }.collectAsState(emptyMap())
+    val downloadsCountGroupByLabel by rememberInVM { EhDB.downloadsCountByLabel }.collectAsState(emptyMap())
+    val downloadsCount = when (filterMode) {
+        DownloadsFilterMode.CUSTOM -> downloadsCountGroupByLabel
+        DownloadsFilterMode.ARTIST -> downloadsCountGroupByArtist
+    }
+    val artistList = remember(downloadsCountGroupByArtist) {
+        downloadsCountGroupByArtist.keys.mapNotNull { artist -> artist?.let { it to it } }
+    }
+    val labelList by remember {
+        derivedStateOf {
+            DownloadManager.labelList.map { it.id!! to it.label }
+        }
+    }
+    val groupList = when (filterMode) {
+        DownloadsFilterMode.CUSTOM -> labelList
+        DownloadsFilterMode.ARTIST -> artistList
+    }
+    val totalCount = remember(downloadsCountGroupByLabel) { downloadsCountGroupByLabel.values.sum() }

    fun switchLabel(label: String?) {
        Settings.recentDownloadLabel.value = label
        filterState = filterState.copy(label = label)
    }

-    with(activity) {
-        ProvideSideSheetContent { drawerState ->
-            fun closeSheet() = launch { drawerState.close() }
-            TopAppBar(
-                title = { Text(text = labelsStr) },
-                windowInsets = WindowInsets(0, 0, 0, 0),
-                actions = {
+    LaunchedEffect(filterState) {
+        searchBarOffsetY = 0
+    }
+
+    ProvideSideSheetContent { drawerState ->
+        fun closeSheet() = launch { drawerState.close() }
+        TopAppBar(
+            title = { Text(text = labelsStr) },
+            windowInsets = WindowInsets(0, 0, 0, 0),
+            actions = {
+                if (DownloadsFilterMode.CUSTOM == filterMode) {
                    IconButton(
                        onClick = {
                            launch {
@@ -203,7 +243,12 @@ fun DownloadsScreen(navigator: DestinationsNavigator) = composing(navigator) {
                    IconButton(
                        onClick = {
                            launch {
-                                showSelectActions(R.string.default_download_label) {
+                                val selected = if (!Settings.hasDefaultDownloadLabel) {
+                                    0
+                                } else {
+                                    DownloadManager.labelList.indexOfFirst { it.label == Settings.defaultDownloadLabel } + 2
+                                }
+                                awaitSelectAction(R.string.default_download_label, selected) {
                                    onSelect(letMeSelect) {
                                        Settings.hasDefaultDownloadLabel = false
                                    }
@@ -211,147 +256,181 @@ fun DownloadsScreen(navigator: DestinationsNavigator) = composing(navigator) {
                                        Settings.hasDefaultDownloadLabel = true
                                        Settings.defaultDownloadLabel = null
                                    }
-                                    labelList.forEach { (label) ->
+                                    DownloadManager.labelList.forEach { (label) ->
                                        onSelect(label) {
                                            Settings.hasDefaultDownloadLabel = true
                                            Settings.defaultDownloadLabel = label
                                        }
                                    }
-                                }
+                                }()
                            }
                        },
                    ) {
-                        Icon(imageVector = Icons.Default.Settings, contentDescription = null)
+                        Icon(imageVector = Icons.Default.Download, contentDescription = null)
                    }
-                },
-            )
-
-            val labelsListState = rememberLazyListState()
-            val reorderableLabelState = rememberReorderableLazyColumnState(labelsListState) { from, to ->
-                val fromPosition = from.index - 2
-                val toPosition = to.index - 2
-                labelList.apply { add(toPosition, removeAt(fromPosition)) }
-                view.performHapticFeedback(draggingHapticFeedback)
-            }
-            var fromIndex by remember { mutableIntStateOf(-1) }
-            LazyColumn(
-                modifier = Modifier.fillMaxSize(),
-                state = labelsListState,
-                contentPadding = WindowInsets.systemBars.only(WindowInsetsSides.Bottom).asPaddingValues(),
-            ) {
-                stickyHeader {
-                    ListItem(
-                        modifier = Modifier.clickable {
-                            switchLabel("")
-                            closeSheet()
-                        },
-                        tonalElevation = 1.dp,
-                        shadowElevation = 1.dp,
-                        headlineContent = {
-                            Text("$allName [$totalCount]")
-                        },
-                    )
                }
-                stickyHeader {
-                    ListItem(
-                        modifier = Modifier.clickable {
-                            switchLabel(null)
-                            closeSheet()
-                        },
-                        tonalElevation = 1.dp,
-                        shadowElevation = 1.dp,
-                        headlineContent = {
-                            Text("$defaultName [${downloadsCount.getOrDefault(null, 0)}]")
-                        },
-                    )
-                }
-                itemsIndexed(labelList, key = { _, item -> item.id!! }) { index, (item) ->
-                    // Not using rememberSwipeToDismissBoxState to prevent LazyColumn from reusing it
-                    val dismissState = remember { SwipeToDismissBoxState(SwipeToDismissBoxValue.Settled, density, positionalThreshold = positionalThreshold) }
-                    LaunchedEffect(dismissState) {
-                        snapshotFlow { dismissState.currentValue }.collect {
-                            if (it == SwipeToDismissBoxValue.EndToStart) {
-                                runCatching {
-                                    awaitPermissionOrCancel(confirmText = R.string.delete) {
-                                        Text(text = stringResource(R.string.delete_label, item))
-                                    }
-                                }.onSuccess {
-                                    DownloadManager.deleteLabel(item)
-                                    when (filterState.label) {
-                                        item -> switchLabel("")
-                                        null -> invalidateKey = !invalidateKey
-                                    }
-                                }.onFailure {
-                                    dismissState.reset()
+                val custom = stringResource(R.string.select_grouping_mode_custom)
+                val artist = stringResource(R.string.select_grouping_mode_artist)
+                IconButton(
+                    onClick = {
+                        launch {
+                            awaitSelectAction(R.string.select_grouping_mode) {
+                                val select = { mode: DownloadsFilterMode ->
+                                    filterState = filterState.copy(mode = mode, label = "")
+                                    Settings.downloadFilterMode.value = mode.flag
+                                    Settings.recentDownloadLabel.value = ""
                                }
+                                onSelect(custom) { select(DownloadsFilterMode.CUSTOM) }
+                                onSelect(artist) { select(DownloadsFilterMode.ARTIST) }
+                            }()
+                        }
+                    },
+                ) {
+                    Icon(imageVector = Icons.Default.Settings, contentDescription = null)
+                }
+            },
+        )
+
+        val labelsListState = rememberLazyListState()
+        val editEnable = DownloadsFilterMode.CUSTOM == filterMode
+        val hapticFeedback = rememberHapticFeedback()
+        val reorderableLabelState = rememberReorderableLazyListState(labelsListState) { from, to ->
+            val fromPosition = from.index - 2
+            val toPosition = to.index - 2
+            DownloadManager.labelList.apply { add(toPosition, removeAt(fromPosition)) }
+            hapticFeedback.performHapticFeedback(HapticFeedbackType.MOVE)
+        }
+        var fromIndex by remember { mutableIntStateOf(-1) }
+        LazyColumn(
+            modifier = Modifier.fillMaxSize(),
+            state = labelsListState,
+            contentPadding = WindowInsets.systemBars.only(WindowInsetsSides.Bottom).asPaddingValues(),
+        ) {
+            item {
+                ListItem(
+                    modifier = Modifier.clickable {
+                        switchLabel("")
+                        closeSheet()
+                    },
+                    tonalElevation = 1.dp,
+                    shadowElevation = 1.dp,
+                    headlineContent = {
+                        Text("$allName [$totalCount]")
+                    },
+                )
+            }
+            item {
+                ListItem(
+                    modifier = Modifier.clickable {
+                        switchLabel(null)
+                        closeSheet()
+                    },
+                    tonalElevation = 1.dp,
+                    shadowElevation = 1.dp,
+                    headlineContent = {
+                        Text("$emptyLabelName [${downloadsCount.getOrDefault(null, 0)}]")
+                    },
+                )
+            }
+
+            itemsIndexed(groupList, key = { _, (id) -> id }) { itemIndex, (id, label) ->
+                val index by rememberUpdatedState(itemIndex)
+                val item by rememberUpdatedState(label)
+                // Not using rememberSwipeToDismissBoxState to prevent LazyColumn from reusing it
+                val dismissState = remember { SwipeToDismissBoxState(SwipeToDismissBoxValue.Settled, density, positionalThreshold = positionalThreshold) }
+                LaunchedEffect(dismissState) {
+                    snapshotFlow { dismissState.currentValue }.collect {
+                        if (it == SwipeToDismissBoxValue.EndToStart) {
+                            runCatching {
+                                awaitPermissionOrCancel(confirmText = R.string.delete) {
+                                    Text(text = stringResource(R.string.delete_label, item))
+                                }
+                            }.onSuccess {
+                                DownloadManager.deleteLabel(item)
+                                when (filterState.label) {
+                                    item -> switchLabel("")
+                                    null -> invalidateKey = !invalidateKey
+                                }
+                            }.onFailure {
+                                dismissState.reset()
                            }
                        }
                    }
-                    ReorderableItem(reorderableLabelState, key = item) { isDragging ->
-                        SwipeToDismissBox2(
-                            state = dismissState,
-                            backgroundContent = {},
-                        ) {
-                            val elevation by animateDpAsState(
-                                if (isDragging) {
-                                    8.dp // md.sys.elevation.level4
-                                } else {
-                                    1.dp // md.sys.elevation.level1
-                                },
-                                label = "elevation",
-                            )
-                            ListItem(
-                                modifier = Modifier.clickable {
-                                    switchLabel(item)
-                                    closeSheet()
-                                },
-                                tonalElevation = 1.dp,
-                                shadowElevation = elevation,
-                                headlineContent = {
-                                    Text("$item [${downloadsCount.getOrDefault(item, 0)}]")
-                                },
-                                trailingContent = {
-                                    Row {
-                                        IconButton(
-                                            onClick = {
-                                                launch {
-                                                    val new = awaitInputText(initial = item, title = renameLabel, hint = labelsStr) { text ->
-                                                        when {
-                                                            text.isBlank() -> labelEmpty
-                                                            text == defaultName -> defaultInvalid
-                                                            DownloadManager.containLabel(text) -> labelExists
-                                                            else -> null
-                                                        }
-                                                    }
-                                                    DownloadManager.renameLabel(item, new)
-                                                    if (filterState.label == item) {
-                                                        switchLabel(new)
+                }
+                ReorderableItem(reorderableLabelState, enabled = editEnable, key = id) { isDragging ->
+                    SwipeToDismissBox(
+                        state = dismissState,
+                        backgroundContent = {},
+                        enableDismissFromStartToEnd = false,
+                        gesturesEnabled = editEnable,
+                    ) {
+                        val elevation by animateDpAsState(
+                            if (isDragging) {
+                                8.dp // md.sys.elevation.level4
+                            } else {
+                                1.dp // md.sys.elevation.level1
+                            },
+                            label = "elevation",
+                        )
+                        ListItem(
+                            modifier = Modifier.clickable {
+                                switchLabel(item)
+                                closeSheet()
+                            },
+                            tonalElevation = 1.dp,
+                            shadowElevation = elevation,
+                            headlineContent = {
+                                val name = if (filterMode == DownloadsFilterMode.ARTIST) label.translateArtist() else label
+                                Text("$name [${downloadsCount.getOrDefault(item, 0)}]")
+                            },
+                            trailingContent = editEnable.ifTrueThen {
+                                Row {
+                                    IconButton(
+                                        onClick = {
+                                            launch {
+                                                val new = awaitInputText(initial = item, title = renameLabel, hint = labelsStr) { text ->
+                                                    when {
+                                                        text.isBlank() -> labelEmpty
+                                                        text == defaultName -> defaultInvalid
+                                                        DownloadManager.containLabel(text) -> labelExists
+                                                        else -> null
                                                    }
                                                }
-                                            },
-                                        ) {
-                                            Icon(imageVector = Icons.Default.Edit, contentDescription = null)
-                                        }
-                                        DragHandle(
+                                                DownloadManager.renameLabel(item, new)
+                                                if (filterState.label == item) {
+                                                    switchLabel(new)
+                                                }
+                                            }
+                                        },
+                                    ) {
+                                        Icon(imageVector = Icons.Default.Edit, contentDescription = null)
+                                    }
+                                    IconButton(
+                                        onClick = {},
+                                        modifier = Modifier.draggableHandle(
                                            onDragStarted = {
+                                                hapticFeedback.performHapticFeedback(HapticFeedbackType.START)
                                                fromIndex = index
                                            },
                                            onDragStopped = {
+                                                hapticFeedback.performHapticFeedback(HapticFeedbackType.END)
                                                if (fromIndex != -1) {
                                                    if (fromIndex != index) {
                                                        val range = if (fromIndex < index) fromIndex..index else index..fromIndex
-                                                        val toUpdate = labelList.slice(range)
+                                                        val toUpdate = DownloadManager.labelList.slice(range)
                                                        toUpdate.zip(range).forEach { it.first.position = it.second }
                                                        launchIO { EhDB.updateDownloadLabel(toUpdate) }
                                                    }
                                                    fromIndex = -1
                                                }
                                            },
-                                        )
+                                        ),
+                                    ) {
+                                        Icon(imageVector = Icons.Default.Reorder, contentDescription = null)
                                    }
-                                },
-                            )
-                        }
+                                }
+                            },
+                        )
                    }
                }
            }
@@ -359,14 +438,15 @@ fun DownloadsScreen(navigator: DestinationsNavigator) = composing(navigator) {
    }

    SearchBarScreen(
+        onApplySearch = { filterState = filterState.copy(keyword = it) },
+        expanded = searchBarExpanded,
+        onExpandedChange = {
+            searchBarExpanded = it
+            fabHidden = it
+            if (it) checkedInfoMap.clear()
+        },
        title = title,
        searchFieldHint = hint,
-        onApplySearch = { filterState = filterState.copy(keyword = it) },
-        onSearchExpanded = {
-            checkedInfoMap.clear()
-            fabHidden = true
-        },
-        onSearchHidden = { fabHidden = false },
        searchBarOffsetY = { searchBarOffsetY },
        trailingIcon = {
            var expanded by remember { mutableStateOf(false) }
@@ -390,9 +470,9 @@ fun DownloadsScreen(navigator: DestinationsNavigator) = composing(navigator) {
                    text = { Text(text = stringResource(id = R.string.download_start_all)) },
                    onClick = {
                        expanded = false
-                        val intent = Intent(activity, DownloadService::class.java)
+                        val intent = Intent(implicit<Activity>(), DownloadService::class.java)
                        intent.action = DownloadService.ACTION_START_ALL
-                        ContextCompat.startForegroundService(activity, intent)
+                        ContextCompat.startForegroundService(implicit<Activity>(), intent)
                    },
                )
                DropdownMenuItem(
@@ -424,27 +504,19 @@ fun DownloadsScreen(navigator: DestinationsNavigator) = composing(navigator) {
                    onClick = {
                        expanded = false
                        val gidList = list.filter { it.state != DownloadInfo.STATE_FINISH }.asReversed().mapToLongArray(DownloadInfo::gid)
-                        val intent = Intent(activity, DownloadService::class.java)
+                        val intent = Intent(implicit<Activity>(), DownloadService::class.java)
                        intent.action = DownloadService.ACTION_START_RANGE
                        intent.putExtra(DownloadService.KEY_GID_LIST, gidList)
-                        ContextCompat.startForegroundService(activity, intent)
+                        ContextCompat.startForegroundService(implicit<Activity>(), intent)
                    },
                )
            }
        },
    ) { contentPadding ->
        val height by collectListThumbSizeAsState()
-        val layoutDirection = LocalLayoutDirection.current
-        val marginH = dimensionResource(id = R.dimen.gallery_list_margin_h)
-        val marginV = dimensionResource(id = R.dimen.gallery_list_margin_v)
-        val realPadding = PaddingValues(
-            top = contentPadding.calculateTopPadding() + marginV,
-            bottom = contentPadding.calculateBottomPadding() + marginV,
-            start = contentPadding.calculateStartPadding(layoutDirection) + marginH,
-            end = contentPadding.calculateEndPadding(layoutDirection) + marginH,
-        )
+        val realPadding = contentPadding + PaddingValues(dimensionResource(id = R.dimen.gallery_list_margin_h), dimensionResource(id = R.dimen.gallery_list_margin_v))
        val searchBarConnection = remember {
-            val slop = ViewConfiguration.get(context).scaledTouchSlop
+            val slop = ViewConfiguration.get(implicit<Context>()).scaledTouchSlop
            val topPaddingPx = with(density) { contentPadding.calculateTopPadding().roundToPx() }
            object : NestedScrollConnection {
                override fun onPostScroll(consumed: Offset, available: Offset, source: NestedScrollSource): Offset {
@@ -464,6 +536,7 @@ fun DownloadsScreen(navigator: DestinationsNavigator) = composing(navigator) {
            launchIO { EhDB.putHistoryInfo(info.galleryInfo) }
            navToReader(info.galleryInfo)
        }
+
        Crossfade(targetState = gridView, label = "Downloads") { showGridView ->
            if (showGridView) {
                val gridInterval = dimensionResource(R.dimen.gallery_grid_interval)
@@ -475,13 +548,13 @@ fun DownloadsScreen(navigator: DestinationsNavigator) = composing(navigator) {
                    horizontalArrangement = Arrangement.spacedBy(gridInterval),
                    contentPadding = realPadding,
                ) {
-                    items(list) { info ->
+                    items(list, key = { it.gid }) { info ->
                        GalleryInfoGridItem(
                            onClick = ::onItemClick.partially1(info),
-                            onLongClick = { navigator.navigate(info.galleryInfo.asDst()) },
+                            onLongClick = { navigate(info.galleryInfo.asDst()) },
                            info = info,
-                            modifier = Modifier.animateItemPlacement(),
-                            badgeText = info.pages.takeIf { it > 0 }?.toString(),
+                            modifier = Modifier.thenIf(animateItems) { animateItem() },
+                            showLanguage = false,
                        )
                    }
                }
@@ -493,7 +566,10 @@ fun DownloadsScreen(navigator: DestinationsNavigator) = composing(navigator) {
                ) {
                    items(list, key = { it.gid }) { info ->
                        val checked = info.gid in checkedInfoMap
-                        CheckableItem(checked = checked, modifier = Modifier.animateItemPlacement()) { interactionSource ->
+                        CheckableItem(
+                            checked = checked,
+                            modifier = Modifier.thenIf(animateItems) { animateItem() },
+                        ) { interactionSource ->
                            DownloadCard(
                                onClick = {
                                    if (selectMode) {
@@ -507,19 +583,20 @@ fun DownloadsScreen(navigator: DestinationsNavigator) = composing(navigator) {
                                    }
                                },
                                onThumbClick = {
-                                    navigator.navigate(info.galleryInfo.asDst())
+                                    navigate(info.galleryInfo.asDst())
                                },
                                onLongClick = {
                                    checkedInfoMap[info.gid] = info
                                },
                                onStart = {
-                                    val intent = Intent(activity, DownloadService::class.java)
+                                    val intent = Intent(implicit<Activity>(), DownloadService::class.java)
                                    intent.action = DownloadService.ACTION_START
                                    intent.putExtra(DownloadService.KEY_GALLERY_INFO, info.galleryInfo)
-                                    ContextCompat.startForegroundService(activity, intent)
+                                    ContextCompat.startForegroundService(implicit<Activity>(), intent)
                                },
                                onStop = { launchIO { DownloadManager.stopDownload(info.gid) } },
                                info = info,
+                                selectMode = selectMode,
                                modifier = Modifier.height(height),
                                interactionSource = interactionSource,
                            )
@@ -576,7 +653,7 @@ fun DownloadsScreen(navigator: DestinationsNavigator) = composing(navigator) {
            }
            onClick(Icons.AutoMirrored.Default.Sort) {
                val oldMode = SortMode.from(sortMode)
-                val (selected, checked) = showSelectItemWithCheckBox(
+                val (selected, checked) = awaitSelectItemWithCheckBox(
                    sortModes.toList(),
                    R.string.sort_by,
                    R.string.group_by_download_label,
@@ -589,7 +666,7 @@ fun DownloadsScreen(navigator: DestinationsNavigator) = composing(navigator) {
                invalidateKey = !invalidateKey
            }
            onClick(Icons.Default.FilterList) {
-                val state = showSingleChoice(
+                val state = awaitSingleChoice(
                    downloadStates.toList(),
                    filterState.state + 1,
                    R.string.download_filter,
@@ -597,31 +674,28 @@ fun DownloadsScreen(navigator: DestinationsNavigator) = composing(navigator) {
                filterState = filterState.copy(state = state)
            }
        } else {
-            onClick(Icons.Default.DoneAll) {
+            onClick(Icons.Default.DoneAll, autoClose = false) {
                val info = list.associateBy { it.gid }
                checkedInfoMap.putAll(info)
-                throw CancellationException()
            }
            onClick(Icons.Default.PlayArrow) {
-                val gidList = checkedInfoMap.run { toMap().values.also { clear() } }
-                    .mapToLongArray(DownloadInfo::gid)
-                val intent = Intent(activity, DownloadService::class.java)
+                val gidList = checkedInfoMap.takeAndClear().mapToLongArray(DownloadInfo::gid)
+                val intent = Intent(implicit<Activity>(), DownloadService::class.java)
                intent.action = DownloadService.ACTION_START_RANGE
                intent.putExtra(DownloadService.KEY_GID_LIST, gidList)
-                ContextCompat.startForegroundService(context, intent)
+                ContextCompat.startForegroundService(implicit<Context>(), intent)
            }
            onClick(Icons.Default.Pause) {
-                val gidList = checkedInfoMap.run { toMap().values.also { clear() } }
-                    .mapToLongArray(DownloadInfo::gid)
+                val gidList = checkedInfoMap.takeAndClear().mapToLongArray(DownloadInfo::gid)
                DownloadManager.stopRangeDownload(gidList)
            }
            onClick(Icons.Default.Delete) {
-                val infoList = checkedInfoMap.run { toMap().values.also { clear() } }
+                val infoList = checkedInfoMap.takeAndClear()
                confirmRemoveDownloadRange(infoList)
                list.removeAll(infoList)
            }
            onClick(Icons.AutoMirrored.Default.DriveFileMove) {
-                val infoList = checkedInfoMap.run { toMap().values.also { clear() } }
+                val infoList = checkedInfoMap.takeAndClear()
                val toLabel = showMoveDownloadLabelList(infoList)
                with(filterState) {
                    if (label != "" && label != toLabel) {
@@ -632,9 +706,3 @@ fun DownloadsScreen(navigator: DestinationsNavigator) = composing(navigator) {
        }
    }
 }
-
-object DownloadsFragment {
-    const val KEY_GID = "gid"
-    const val KEY_ACTION = "action"
-    const val ACTION_CLEAR_DOWNLOAD_SERVICE = "clear_download_service"
-}
@@ -1,6 +1,8 @@
 package com.hippo.ehviewer.ui.screen

+import android.content.Context
 import android.view.ViewConfiguration
+import androidx.collection.MutableLongSet
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.WindowInsets
@@ -26,7 +28,6 @@ import androidx.compose.material3.ListItem
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBar
-import androidx.compose.material3.pulltorefresh.rememberPullToRefreshState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
@@ -43,62 +44,66 @@ import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.input.nestedscroll.NestedScrollConnection
 import androidx.compose.ui.input.nestedscroll.NestedScrollSource
 import androidx.compose.ui.input.nestedscroll.nestedScroll
-import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.res.stringResource
 import androidx.lifecycle.viewModelScope
-import androidx.paging.LoadState
 import androidx.paging.Pager
 import androidx.paging.PagingConfig
 import androidx.paging.PagingSource
 import androidx.paging.PagingState
 import androidx.paging.cachedIn
 import androidx.paging.compose.collectAsLazyPagingItems
+import androidx.paging.filter
 import com.hippo.ehviewer.EhDB
 import com.hippo.ehviewer.R
 import com.hippo.ehviewer.Settings
-import com.hippo.ehviewer.client.EhCookieStore
 import com.hippo.ehviewer.client.EhEngine
 import com.hippo.ehviewer.client.data.BaseGalleryInfo
 import com.hippo.ehviewer.client.data.FavListUrlBuilder
 import com.hippo.ehviewer.collectAsState
 import com.hippo.ehviewer.icons.EhIcons
 import com.hippo.ehviewer.icons.filled.GoTo
+import com.hippo.ehviewer.ui.DrawerHandle
 import com.hippo.ehviewer.ui.LocalSideSheetState
-import com.hippo.ehviewer.ui.LockDrawer
+import com.hippo.ehviewer.ui.awaitSelectDate
 import com.hippo.ehviewer.ui.composing
 import com.hippo.ehviewer.ui.main.FAB_ANIMATE_TIME
 import com.hippo.ehviewer.ui.main.FabLayout
 import com.hippo.ehviewer.ui.main.GalleryInfoGridItem
 import com.hippo.ehviewer.ui.main.GalleryInfoListItem
 import com.hippo.ehviewer.ui.main.GalleryList
-import com.hippo.ehviewer.ui.showDatePicker
 import com.hippo.ehviewer.ui.startDownload
 import com.hippo.ehviewer.ui.tools.delegateSnapshotUpdate
 import com.hippo.ehviewer.ui.tools.foldToLoadResult
 import com.hippo.ehviewer.ui.tools.rememberInVM
-import com.hippo.ehviewer.util.displayString
+import com.hippo.ehviewer.ui.tools.thenIf
 import com.hippo.ehviewer.util.mapToLongArray
+import com.hippo.ehviewer.util.takeAndClear
 import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.annotation.RootGraph
 import com.ramcosta.composedestinations.navigation.DestinationsNavigator
 import eu.kanade.tachiyomi.util.lang.withIOContext
 import eu.kanade.tachiyomi.util.lang.withUIContext
 import kotlin.math.roundToInt
-import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
 import moe.tarsin.coroutines.onEachLatest
 import moe.tarsin.coroutines.runSuspendCatching
+import moe.tarsin.coroutines.runSwallowingWithUI

-@Destination
+@Destination<RootGraph>
@Composable
 fun FavouritesScreen(navigator: DestinationsNavigator) = composing(navigator) {
    // Immutables
    val localFavName = stringResource(R.string.local_favorites)
    val cloudFavName = stringResource(R.string.cloud_favorites)
+    val animateItems by Settings.animateItems.collectAsState()
+    val hasSignedIn by Settings.hasSignedIn.collectAsState()

    // Meta State
    var urlBuilder by rememberSaveable { mutableStateOf(FavListUrlBuilder(favCat = Settings.recentFavCat)) }
+    var searchBarExpanded by rememberSaveable { mutableStateOf(false) }
    var searchBarOffsetY by remember { mutableIntStateOf(0) }

    // Derived State
@@ -107,7 +112,7 @@ fun FavouritesScreen(navigator: DestinationsNavigator) = composing(navigator) {
    val favCatName = remember(urlBuilder) {
        when (val favCat = urlBuilder.favCat) {
            in 0..9 -> Settings.favCat[favCat]
-            FavListUrlBuilder.FAV_CAT_LOCAL -> localFavName
+            FavListUrlBuilder.FAV_CAT_LOCAL -> localFavName.also { searchBarOffsetY = 0 }
            else -> cloudFavName
        }
    }
@@ -116,7 +121,6 @@ fun FavouritesScreen(navigator: DestinationsNavigator) = composing(navigator) {
    } else {
        stringResource(R.string.favorites_title_2, favCatName, keyword)
    }
-    val context = LocalContext.current
    val density = LocalDensity.current
    val localFavCountFlow = rememberInVM { EhDB.localFavCount }
    val searchBarHint = stringResource(R.string.search_bar_hint, favCatName)
@@ -161,7 +165,14 @@ fun FavouritesScreen(navigator: DestinationsNavigator) = composing(navigator) {
                    }
                }
            }
-        }.flow.cachedIn(viewModelScope)
+        }.flow.map { pagingData ->
+            // https://github.com/FooIbar/EhViewer/issues/1190
+            // Workaround for duplicate items when sorting by favorited time
+            val gidSet = MutableLongSet(50)
+            pagingData.filter {
+                gidSet.add(it.gid)
+            }
+        }.cachedIn(viewModelScope)
    }.collectAsLazyPagingItems()

    fun refresh(newUrlBuilder: FavListUrlBuilder = urlBuilder.copy(jumpTo = null, prev = null, next = null)) {
@@ -182,7 +193,7 @@ fun FavouritesScreen(navigator: DestinationsNavigator) = composing(navigator) {
            }
        }
        val localFav = stringResource(id = R.string.local_favorites) to localFavCount
-        val faves = if (EhCookieStore.hasSignedIn()) {
+        val faves = if (hasSignedIn) {
            arrayOf(
                localFav,
                stringResource(id = R.string.cloud_favorites) to Settings.favCloudCount,
@@ -210,26 +221,22 @@ fun FavouritesScreen(navigator: DestinationsNavigator) = composing(navigator) {
        }
    }

-    val refreshState = rememberPullToRefreshState {
-        data.loadState.refresh is LoadState.NotLoading
-    }
-
    var fabExpanded by remember { mutableStateOf(false) }
    var fabHidden by remember { mutableStateOf(false) }
    val checkedInfoMap = remember { mutableStateMapOf<Long, BaseGalleryInfo>() }
    val selectMode = checkedInfoMap.isNotEmpty()
-    LockDrawer(selectMode)
+    DrawerHandle(!selectMode && !searchBarExpanded)

    SearchBarScreen(
+        onApplySearch = { refresh(FavListUrlBuilder(urlBuilder.favCat, it)) },
+        expanded = searchBarExpanded,
+        onExpandedChange = {
+            searchBarExpanded = it
+            fabHidden = it
+            if (it) checkedInfoMap.clear()
+        },
        title = title,
        searchFieldHint = searchBarHint,
-        onApplySearch = { refresh(FavListUrlBuilder(urlBuilder.favCat, it)) },
-        onSearchExpanded = {
-            checkedInfoMap.clear()
-            fabHidden = true
-        },
-        onSearchHidden = { fabHidden = false },
-        refreshState = refreshState,
        tagNamespace = !isLocalFav,
        searchBarOffsetY = { searchBarOffsetY },
        trailingIcon = {
@@ -243,7 +250,7 @@ fun FavouritesScreen(navigator: DestinationsNavigator) = composing(navigator) {
        val height by collectListThumbSizeAsState()
        val showPages by Settings.showGalleryPages.collectAsState()
        val searchBarConnection = remember {
-            val slop = ViewConfiguration.get(context).scaledTouchSlop
+            val slop = ViewConfiguration.get(implicit<Context>()).scaledTouchSlop
            val topPaddingPx = with(density) { contentPadding.calculateTopPadding().roundToPx() }
            object : NestedScrollConnection {
                override fun onPostScroll(consumed: Offset, available: Offset, source: NestedScrollSource): Offset {
@@ -265,7 +272,10 @@ fun FavouritesScreen(navigator: DestinationsNavigator) = composing(navigator) {
            listMode = listMode,
            detailItemContent = { info ->
                val checked = info.gid in checkedInfoMap
-                CheckableItem(checked = checked, modifier = Modifier.animateItemPlacement()) { interactionSource ->
+                CheckableItem(
+                    checked = checked,
+                    modifier = Modifier.thenIf(animateItems) { animateItem() },
+                ) { interactionSource ->
                    GalleryInfoListItem(
                        onClick = {
                            if (selectMode) {
@@ -275,7 +285,7 @@ fun FavouritesScreen(navigator: DestinationsNavigator) = composing(navigator) {
                                    checkedInfoMap[info.gid] = info
                                }
                            } else {
-                                navigator.navigate(info.asDst())
+                                navigate(info.asDst())
                            }
                        },
                        onLongClick = {
@@ -291,7 +301,10 @@ fun FavouritesScreen(navigator: DestinationsNavigator) = composing(navigator) {
            },
            thumbItemContent = { info ->
                val checked = info.gid in checkedInfoMap
-                CheckableItem(checked = checked, modifier = Modifier.animateItemPlacement()) { interactionSource ->
+                CheckableItem(
+                    checked = checked,
+                    modifier = Modifier.thenIf(animateItems) { animateItem() },
+                ) { interactionSource ->
                    GalleryInfoGridItem(
                        onClick = {
                            if (selectMode) {
@@ -301,18 +314,19 @@ fun FavouritesScreen(navigator: DestinationsNavigator) = composing(navigator) {
                                    checkedInfoMap[info.gid] = info
                                }
                            } else {
-                                navigator.navigate(info.asDst())
+                                navigate(info.asDst())
                            }
                        },
                        onLongClick = {
                            checkedInfoMap[info.gid] = info
                        },
                        info = info,
+                        showPages = showPages,
                        interactionSource = interactionSource,
                    )
                }
            },
-            refreshState = refreshState,
+            searchBarOffsetY = { searchBarOffsetY },
            scrollToTopOnRefresh = urlBuilder.favCat != FavListUrlBuilder.FAV_CAT_LOCAL,
            onRefresh = { refresh() },
            onLoading = { searchBarOffsetY = 0 },
@@ -342,16 +356,12 @@ fun FavouritesScreen(navigator: DestinationsNavigator) = composing(navigator) {
            if (isLocalFav) {
                onClick(Icons.Default.Shuffle) {
                    val random = EhDB.randomLocalFav()
-                    withUIContext {
-                        navigator.navigate(random.asDst())
-                    }
+                    withUIContext { navigate(random.asDst()) }
                }
            }
            onClick(EhIcons.Default.GoTo) {
-                launch {
-                    val date = showDatePicker()
-                    refresh(urlBuilder.copy(jumpTo = date))
-                }
+                val date = awaitSelectDate()
+                refresh(urlBuilder.copy(jumpTo = date))
            }
            onClick(Icons.Default.Refresh) {
                refresh()
@@ -360,43 +370,47 @@ fun FavouritesScreen(navigator: DestinationsNavigator) = composing(navigator) {
                refresh(urlBuilder.copy(jumpTo = null, prev = "1-0", next = null))
            }
        } else {
-            onClick(Icons.Default.DoneAll) {
+            onClick(Icons.Default.DoneAll, autoClose = false) {
                val info = data.itemSnapshotList.items.associateBy { it.gid }
                checkedInfoMap.putAll(info)
-                throw CancellationException()
            }
            onClick(Icons.Default.Download) {
-                val info = checkedInfoMap.run { toMap().values.also { clear() } }
-                startDownload(context, false, *info.toTypedArray())
+                val info = checkedInfoMap.takeAndClear()
+                runSwallowingWithUI {
+                    startDownload(implicit<Context>(), false, *info.toTypedArray())
+                }
            }
            onClick(Icons.Default.Delete) {
-                val info = checkedInfoMap.run { toMap().values.also { clear() } }
+                val info = checkedInfoMap.takeAndClear()
                awaitPermissionOrCancel(title = R.string.delete_favorites_dialog_title) {
                    Text(text = stringResource(R.string.delete_favorites_dialog_message, info.size))
                }
                val srcCat = urlBuilder.favCat
-                if (srcCat == FavListUrlBuilder.FAV_CAT_LOCAL) { // Delete local fav
-                    EhDB.removeLocalFavorites(info)
-                } else {
-                    val delList = info.mapToLongArray(BaseGalleryInfo::gid)
-                    EhEngine.modifyFavorites(delList, srcCat, -1)
+                runSwallowingWithUI {
+                    if (srcCat == FavListUrlBuilder.FAV_CAT_LOCAL) { // Delete local fav
+                        EhDB.removeLocalFavorites(info)
+                    } else {
+                        val delList = info.mapToLongArray(BaseGalleryInfo::gid)
+                        EhEngine.modifyFavorites(delList, srcCat, -1)
+                    }
                }
+                // We refresh anyway as cloud data maybe partially modified
                data.refresh()
            }
            onClick(Icons.AutoMirrored.Default.DriveFileMove) {
                // First is local favorite, the other 10 is cloud favorite
                val items = buildList {
                    add(localFavName)
-                    if (EhCookieStore.hasSignedIn()) {
+                    if (hasSignedIn) {
                        addAll(Settings.favCat)
                    }
                }
-                val index = showSelectItem(items, R.string.move_favorites_dialog_title)
+                val index = awaitSelectItem(items, R.string.move_favorites_dialog_title)
                val srcCat = urlBuilder.favCat
                val dstCat = if (index == 0) FavListUrlBuilder.FAV_CAT_LOCAL else index - 1
-                val info = checkedInfoMap.run { toMap().values.also { clear() } }
+                val info = checkedInfoMap.takeAndClear()
                if (srcCat != dstCat) {
-                    runSuspendCatching {
+                    runSwallowingWithUI {
                        if (srcCat == FavListUrlBuilder.FAV_CAT_LOCAL) {
                            // Move from local to cloud
                            val galleryList = info.map { it.gid to it.token }
@@ -410,11 +424,9 @@ fun FavouritesScreen(navigator: DestinationsNavigator) = composing(navigator) {
                            val gidArray = info.mapToLongArray(BaseGalleryInfo::gid)
                            EhEngine.modifyFavorites(gidArray, srcCat, dstCat)
                        }
-                    }.onSuccess {
-                        data.refresh()
-                    }.onFailure {
-                        showSnackbar(it.displayString())
                    }
+                    // We refresh anyway as cloud data maybe partially modified
+                    data.refresh()
                }
            }
        }
@@ -7,7 +7,7 @@ import android.text.style.ForegroundColorSpan
 import android.text.style.RelativeSizeSpan
 import android.text.style.StyleSpan
 import android.widget.TextView
-import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.Crossfade
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -40,8 +40,7 @@ import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
-import androidx.compose.material3.pulltorefresh.PullToRefreshContainer
-import androidx.compose.material3.pulltorefresh.rememberPullToRefreshState
+import androidx.compose.material3.pulltorefresh.PullToRefreshBox
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
@@ -63,6 +62,8 @@ import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.platform.LocalTextToolbar
 import androidx.compose.ui.res.dimensionResource
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.fromHtml
 import androidx.compose.ui.text.input.TextFieldValue
 import androidx.compose.ui.unit.Constraints
 import androidx.compose.ui.unit.dp
@@ -72,25 +73,26 @@ import androidx.core.text.inSpans
 import androidx.core.text.parseAsHtml
 import com.hippo.ehviewer.EhApplication
 import com.hippo.ehviewer.R
-import com.hippo.ehviewer.client.EhCookieStore
+import com.hippo.ehviewer.Settings
 import com.hippo.ehviewer.client.EhEngine
 import com.hippo.ehviewer.client.EhFilter.remember
 import com.hippo.ehviewer.client.EhUrl
 import com.hippo.ehviewer.client.data.GalleryComment
 import com.hippo.ehviewer.client.data.ListUrlBuilder
+import com.hippo.ehviewer.collectAsState
 import com.hippo.ehviewer.dao.Filter
 import com.hippo.ehviewer.dao.FilterMode
-import com.hippo.ehviewer.ui.LockDrawer
 import com.hippo.ehviewer.ui.composing
 import com.hippo.ehviewer.ui.jumpToReaderByPage
 import com.hippo.ehviewer.ui.legacy.CoilImageGetter
 import com.hippo.ehviewer.ui.main.GalleryCommentCard
+import com.hippo.ehviewer.ui.main.plus
 import com.hippo.ehviewer.ui.openBrowser
 import com.hippo.ehviewer.ui.tools.animateFloatMergePredictiveBackAsState
 import com.hippo.ehviewer.ui.tools.normalizeSpan
 import com.hippo.ehviewer.ui.tools.rememberBBCodeTextToolbar
 import com.hippo.ehviewer.ui.tools.snackBarPadding
-import com.hippo.ehviewer.ui.tools.toAnnotatedString
+import com.hippo.ehviewer.ui.tools.thenIf
 import com.hippo.ehviewer.ui.tools.toBBCode
 import com.hippo.ehviewer.ui.tools.updateSpan
 import com.hippo.ehviewer.util.ReadableTime
@@ -98,9 +100,9 @@ import com.hippo.ehviewer.util.TextUrl
 import com.hippo.ehviewer.util.addTextToClipboard
 import com.hippo.ehviewer.util.displayString
 import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.annotation.RootGraph
 import com.ramcosta.composedestinations.navigation.DestinationsNavigator
 import eu.kanade.tachiyomi.util.lang.launchIO
-import eu.kanade.tachiyomi.util.lang.withIOContext
 import eu.kanade.tachiyomi.util.lang.withUIContext
 import eu.kanade.tachiyomi.util.system.logcat
 import kotlin.math.roundToInt
@@ -143,13 +145,13 @@ private fun Context.generateComment(

 private val MinimumContentPaddingEditText = 88.dp

-@Destination
+@Destination<RootGraph>
@Composable
 fun GalleryCommentsScreen(gid: Long, navigator: DestinationsNavigator) = composing(navigator) {
-    LockDrawer(true)
    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
    var commenting by rememberSaveable { mutableStateOf(false) }
    val animationProgress by animateFloatMergePredictiveBackAsState(enable = commenting) { commenting = false }
+    val animateItems by Settings.animateItems.collectAsState()

    val galleryDetail = remember { EhApplication.galleryDetailCache[gid]!! }
    val userCommentBackField = remember { mutableStateOf(TextFieldValue()) }
@@ -239,7 +241,7 @@ fun GalleryCommentsScreen(gid: Long, navigator: DestinationsNavigator) = composi
            }
        }
    }
-    val hasSignedIn = remember { EhCookieStore.hasSignedIn() }
+    val hasSignedIn by Settings.hasSignedIn.collectAsState()
    Scaffold(
        modifier = Modifier.nestedScroll(scrollBehavior.nestedScrollConnection),
        topBar = {
@@ -272,16 +274,20 @@ fun GalleryCommentsScreen(gid: Long, navigator: DestinationsNavigator) = composi
    ) { paddingValues ->
        val keylineMargin = dimensionResource(id = R.dimen.keyline_margin)
        var editTextMeasured by remember { mutableStateOf(MinimumContentPaddingEditText) }
-        val refreshState = rememberPullToRefreshState()
-        if (refreshState.isRefreshing) {
-            LaunchedEffect(Unit) {
-                runSuspendCatching {
-                    withIOContext { refreshComment(true) }
+        var isRefreshing by remember { mutableStateOf(false) }
+        PullToRefreshBox(
+            isRefreshing = isRefreshing,
+            onRefresh = {
+                isRefreshing = true
+                launchIO {
+                    runSuspendCatching {
+                        refreshComment(true)
+                    }
+                    isRefreshing = false
                }
-                refreshState.endRefresh()
-            }
-        }
-        Box(modifier = Modifier.fillMaxSize().imePadding().nestedScroll(refreshState.nestedScrollConnection)) {
+            },
+            modifier = Modifier.fillMaxSize().imePadding(),
+        ) {
            val additionalPadding = if (commenting) {
                editTextMeasured
            } else {
@@ -299,10 +305,7 @@ fun GalleryCommentsScreen(gid: Long, navigator: DestinationsNavigator) = composi
            LazyColumn(
                modifier = Modifier.padding(horizontal = keylineMargin),
                verticalArrangement = Arrangement.spacedBy(8.dp),
-                contentPadding = PaddingValues(
-                    top = paddingValues.calculateTopPadding(),
-                    bottom = paddingValues.calculateBottomPadding() + additionalPadding,
-                ),
+                contentPadding = paddingValues + PaddingValues(bottom = additionalPadding),
            ) {
                items(
                    items = comments.comments,
@@ -326,7 +329,7 @@ fun GalleryCommentsScreen(gid: Long, navigator: DestinationsNavigator) = composi
                        }
                    }

-                    suspend fun doCommentAction(comment: GalleryComment) = showSelectActions {
+                    suspend fun doCommentAction(comment: GalleryComment) = awaitSelectAction {
                        onSelect(copyComment) {
                            addTextToClipboard(comment.comment.parseAsHtml())
                        }
@@ -335,7 +338,7 @@ fun GalleryCommentsScreen(gid: Long, navigator: DestinationsNavigator) = composi
                        }
                        if (comment.editable) {
                            onSelect(editComment) {
-                                userComment = TextFieldValue(comment.comment.parseAsHtml().toAnnotatedString())
+                                userComment = TextFieldValue(AnnotatedString.fromHtml(comment.comment))
                                commentId = comment.id
                                commenting = true
                            }
@@ -355,10 +358,10 @@ fun GalleryCommentsScreen(gid: Long, navigator: DestinationsNavigator) = composi
                                showCommentVoteStatus(comment)
                            }
                        }
-                    }
+                    }()

                    GalleryCommentCard(
-                        modifier = Modifier.animateItemPlacement(),
+                        modifier = Modifier.thenIf(animateItems) { animateItem() },
                        comment = item,
                        onUserClick = {
                            navigate(
@@ -376,34 +379,32 @@ fun GalleryCommentsScreen(gid: Long, navigator: DestinationsNavigator) = composi
                }
                if (comments.hasMore) {
                    item {
-                        AnimatedVisibility(refreshing) {
-                            Box(modifier = Modifier.fillMaxWidth()) {
-                                CircularProgressIndicator(
-                                    modifier = Modifier.align(Alignment.Center).padding(keylineMargin),
-                                )
-                            }
-                        }
-                        AnimatedVisibility(!refreshing) {
-                            TextButton(
-                                onClick = {
-                                    launchIO {
-                                        refreshing = true
-                                        runSuspendCatching { refreshComment(true) }
-                                        refreshing = false
-                                    }
-                                },
-                                modifier = Modifier.fillMaxWidth().padding(keylineMargin),
+                        Crossfade(targetState = refreshing, modifier = Modifier.padding(keylineMargin), label = "refreshing") {
+                            Box(
+                                modifier = Modifier.fillMaxWidth().height(40.dp),
+                                contentAlignment = Alignment.Center,
                            ) {
-                                Text(text = stringResource(id = R.string.click_more_comments))
+                                if (it) {
+                                    CircularProgressIndicator()
+                                } else {
+                                    TextButton(
+                                        onClick = {
+                                            launchIO {
+                                                refreshing = true
+                                                runSuspendCatching { refreshComment(true) }
+                                                refreshing = false
+                                            }
+                                        },
+                                        modifier = Modifier.fillMaxWidth(),
+                                    ) {
+                                        Text(text = stringResource(id = R.string.click_more_comments))
+                                    }
+                                }
                            }
                        }
                    }
                }
            }
-            PullToRefreshContainer(
-                state = refreshState,
-                modifier = Modifier.align(Alignment.TopCenter).padding(top = paddingValues.calculateTopPadding()),
-            )
            Surface(
                modifier = Modifier.align(Alignment.BottomCenter).layout { measurable, constraints ->
                    val origin = measurable.measure(constraints)
@@ -56,13 +56,10 @@ import androidx.compose.material3.SnackbarResult
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.material3.TopAppBarDefaults
-import androidx.compose.material3.windowsizeclass.WindowWidthSizeClass
-import androidx.compose.material3.windowsizeclass.calculateWindowSizeClass
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableFloatStateOf
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -78,8 +75,9 @@ import androidx.compose.ui.res.dimensionResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
+import androidx.core.net.toUri
 import androidx.core.text.parseAsHtml
-import arrow.core.left
+import androidx.window.core.layout.WindowWidthSizeClass
 import arrow.core.partially1
 import coil3.imageLoader
 import com.hippo.ehviewer.EhApplication.Companion.galleryDetailCache
@@ -105,10 +103,6 @@ import com.hippo.ehviewer.client.data.findBaseInfo
 import com.hippo.ehviewer.client.exception.EhException
 import com.hippo.ehviewer.client.exception.NoHAtHClientException
 import com.hippo.ehviewer.client.getImageKey
-import com.hippo.ehviewer.client.parser.ArchiveParser
-import com.hippo.ehviewer.client.parser.HomeParser
-import com.hippo.ehviewer.client.parser.TorrentResult
-import com.hippo.ehviewer.client.parser.format
 import com.hippo.ehviewer.coil.justDownload
 import com.hippo.ehviewer.collectAsState
 import com.hippo.ehviewer.dao.DownloadInfo
@@ -118,7 +112,6 @@ import com.hippo.ehviewer.download.DownloadManager as EhDownloadManager
 import com.hippo.ehviewer.ktbuilder.imageRequest
 import com.hippo.ehviewer.spider.SpiderDen
 import com.hippo.ehviewer.ui.GalleryInfoBottomSheet
-import com.hippo.ehviewer.ui.LockDrawer
 import com.hippo.ehviewer.ui.MainActivity
 import com.hippo.ehviewer.ui.composing
 import com.hippo.ehviewer.ui.confirmRemoveDownload
@@ -127,11 +120,13 @@ import com.hippo.ehviewer.ui.destinations.GalleryPreviewScreenDestination
 import com.hippo.ehviewer.ui.getFavoriteIcon
 import com.hippo.ehviewer.ui.jumpToReaderByPage
 import com.hippo.ehviewer.ui.legacy.CoilImageGetter
+import com.hippo.ehviewer.ui.main.ArchiveList
 import com.hippo.ehviewer.ui.main.EhPreviewItem
 import com.hippo.ehviewer.ui.main.GalleryCommentCard
 import com.hippo.ehviewer.ui.main.GalleryDetailErrorTip
 import com.hippo.ehviewer.ui.main.GalleryDetailHeaderCard
 import com.hippo.ehviewer.ui.main.GalleryTags
+import com.hippo.ehviewer.ui.main.TorrentList
 import com.hippo.ehviewer.ui.modifyFavorites
 import com.hippo.ehviewer.ui.navToReader
 import com.hippo.ehviewer.ui.openBrowser
@@ -141,6 +136,7 @@ import com.hippo.ehviewer.ui.tools.FilledTertiaryIconButton
 import com.hippo.ehviewer.ui.tools.FilledTertiaryIconToggleButton
 import com.hippo.ehviewer.ui.tools.GalleryDetailRating
 import com.hippo.ehviewer.ui.tools.GalleryRatingBar
+import com.hippo.ehviewer.ui.tools.LocalWindowSizeClass
 import com.hippo.ehviewer.ui.tools.rememberInVM
 import com.hippo.ehviewer.ui.tools.rememberLambda
 import com.hippo.ehviewer.util.AppConfig
@@ -156,6 +152,7 @@ import com.hippo.ehviewer.util.isAtLeastQ
 import com.hippo.ehviewer.util.requestPermission
 import com.hippo.unifile.asUniFile
 import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.annotation.RootGraph
 import com.ramcosta.composedestinations.navigation.DestinationsNavigator
 import eu.kanade.tachiyomi.util.lang.launchIO
 import eu.kanade.tachiyomi.util.lang.launchUI
@@ -163,6 +160,10 @@ import eu.kanade.tachiyomi.util.lang.withIOContext
 import eu.kanade.tachiyomi.util.lang.withUIContext
 import eu.kanade.tachiyomi.util.system.logcat
 import kotlin.math.roundToInt
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.async
 import kotlinx.coroutines.launch
 import kotlinx.parcelize.Parcelize
 import moe.tarsin.coroutines.runSuspendCatching
@@ -210,10 +211,9 @@ private fun List<GalleryTagGroup>.getArtistTag(): String? {
    return null
 }

-@Destination
+@Destination<RootGraph>
@Composable
 fun GalleryDetailScreen(args: GalleryDetailScreenArgs, navigator: DestinationsNavigator) = composing(navigator) {
-    LockDrawer(true)
    var galleryInfo by remember {
        val casted = args as? GalleryInfoArgs
        mutableStateOf<GalleryInfo?>(casted?.galleryInfo)
@@ -292,13 +292,13 @@ fun GalleryDetailScreen(args: GalleryDetailScreenArgs, navigator: DestinationsNa
        }
    }

-    var mArchiveFormParamOr by remember { mutableStateOf<String?>(null) }
-    var mArchiveList by remember { mutableStateOf<List<ArchiveParser.Archive>?>(null) }
-    var mCurrentFunds by remember { mutableStateOf<HomeParser.Funds?>(null) }
+    val archiveResult = remember(galleryInfo) {
+        async(Dispatchers.IO + Job(), CoroutineStart.LAZY) {
+            val detail = galleryInfo as GalleryDetail
+            EhEngine.getArchiveList(detail.archiveUrl!!, gid, token)
+        }
+    }

-    val archiveFree = stringResource(R.string.archive_free)
-    val archiveOriginal = stringResource(R.string.archive_original)
-    val archiveResample = stringResource(R.string.archive_resample)
    val failureNoHath = stringResource(R.string.download_archive_failure_no_hath)
    val noArchive = stringResource(R.string.no_archives)
    val downloadStarted = stringResource(R.string.download_archive_started)
@@ -310,42 +310,19 @@ fun GalleryDetailScreen(args: GalleryDetailScreenArgs, navigator: DestinationsNa
            if (galleryDetail.apiUid < 0) {
                showSnackbar(signInFirst)
            } else {
-                Unit.runSuspendCatching {
-                    if (mArchiveList == null) {
-                        val result = bgWork {
-                            withIOContext {
-                                EhEngine.getArchiveList(galleryDetail.archiveUrl!!, gid, token)
-                            }
-                        }
-                        mArchiveFormParamOr = result.paramOr
-                        mArchiveList = result.archiveList
-                        mCurrentFunds = result.funds
-                    }
-                    if (mArchiveList!!.isEmpty()) {
+                runSuspendCatching {
+                    val (paramOr, archiveList, funds) = bgWork { archiveResult.await() }
+                    if (archiveList.isEmpty()) {
                        showSnackbar(noArchive)
                    } else {
-                        val items = mArchiveList!!.map {
-                            it.run {
-                                if (isHAtH) {
-                                    val costStr = if (cost == "Free") archiveFree else cost
-                                    "[H@H] $name [$size] [$costStr]"
-                                } else {
-                                    val nameStr = if (res == "org") archiveOriginal else archiveResample
-                                    val costStr = if (cost == "Free!") archiveFree else cost
-                                    "$nameStr [$size] [$costStr]"
-                                }
-                            }
+                        val selected = showNoButton {
+                            ArchiveList(
+                                funds = funds,
+                                items = archiveList,
+                                onItemClick = { dismissWith(it) },
+                            )
                        }
-                        var fundsGP = mCurrentFunds!!.fundsGP.toString()
-                        // Ex GP numbers are rounded down to the nearest thousand
-                        if (EhUtils.isExHentai) {
-                            fundsGP += "+"
-                        }
-                        val title = getString(R.string.current_funds, fundsGP, mCurrentFunds!!.fundsC)
-                        val selected = showSelectItem(items, title.left())
-                        val res = mArchiveList!![selected].res
-                        val isHAtH = mArchiveList!![selected].isHAtH
-                        EhEngine.downloadArchive(gid, token, mArchiveFormParamOr!!, res, isHAtH)?.let {
+                        EhEngine.downloadArchive(gid, token, paramOr, selected.res, selected.isHAtH)?.let {
                            val uri = Uri.parse(it)
                            val intent = Intent().apply {
                                action = Intent.ACTION_VIEW
@@ -476,14 +453,14 @@ fun GalleryDetailScreen(args: GalleryDetailScreenArgs, navigator: DestinationsNa
            val items = galleryDetail.newerVersions.map {
                getString(R.string.newer_version_title, it.title, it.posted)
            }
-            val selected = showSelectItem(items)
+            val selected = awaitSelectItem(items)
            val info = galleryDetail.newerVersions[selected]
            withUIContext {
                // Can't use GalleryInfoArgs as thumbKey is null
                navigator.navigate(info.gid asDstWith info.token)
            }
        }
-        Spacer(modifier = Modifier.size(dimensionResource(id = R.dimen.keyline_margin)))
+        Spacer(modifier = Modifier.size(keylineMargin))
        if (galleryDetail.newerVersions.isNotEmpty()) {
            Box(contentAlignment = Alignment.Center) {
                CrystalCard(
@@ -493,7 +470,7 @@ fun GalleryDetailScreen(args: GalleryDetailScreenArgs, navigator: DestinationsNa
                }
                Text(text = stringResource(id = R.string.newer_version_available))
            }
-            Spacer(modifier = Modifier.size(dimensionResource(id = R.dimen.keyline_margin)))
+            Spacer(modifier = Modifier.size(keylineMargin))
        }
        Row(
            modifier = Modifier.fillMaxWidth().horizontalScroll(rememberScrollState()),
@@ -582,29 +559,30 @@ fun GalleryDetailScreen(args: GalleryDetailScreenArgs, navigator: DestinationsNa
                    )
                },
            )
-            val torrentText = stringResource(R.string.torrents)
+            val torrentText = stringResource(R.string.torrent_count, galleryDetail.torrentCount)
            val permissionDenied = stringResource(R.string.permission_denied)
            val downloadTorrentFailed = stringResource(R.string.download_torrent_failure)
            val downloadTorrentStarted = stringResource(R.string.download_torrent_started)
            val noTorrents = stringResource(R.string.no_torrents)
-            val noCurrentTorrents = stringResource(R.string.no_current_torrents)
-            var mTorrentList by remember { mutableStateOf<TorrentResult?>(null) }
-            suspend fun showTorrentDialog() {
-                if (mTorrentList == null) {
-                    mTorrentList = bgWork {
-                        withIOContext {
-                            EhEngine.getTorrentList(galleryDetail.torrentUrl!!, gid, token)
-                        }
-                    }
+            val torrentResult = remember(galleryDetail) {
+                async(Dispatchers.IO + Job(), CoroutineStart.LAZY) {
+                    EhEngine.getTorrentList(galleryDetail.torrentUrl!!, gid, token)
                }
-                if (mTorrentList!!.isEmpty()) {
-                    showSnackbar(noCurrentTorrents)
+            }
+            suspend fun showTorrentDialog() {
+                val torrentList = bgWork { torrentResult.await() }
+                if (torrentList.isEmpty()) {
+                    showSnackbar(noTorrents)
                } else {
-                    val items = mTorrentList!!.map { it.format() }
-                    val selected = showSelectItem(items, R.string.torrents, false)
-                    val url = mTorrentList!![selected].url
-                    val name = "${mTorrentList!![selected].name}.torrent"
-                    val r = DownloadManager.Request(Uri.parse(url))
+                    val selected = showNoButton(false) {
+                        TorrentList(
+                            items = torrentList,
+                            onItemClick = { dismissWith(it) },
+                        )
+                    }
+                    val url = selected.url
+                    val name = "${selected.name}.torrent"
+                    val r = DownloadManager.Request(url.toUri())
                    r.setDestinationInExternalPublicDir(
                        Environment.DIRECTORY_DOWNLOADS,
                        AppConfig.APP_DIRNAME + "/" + FileUtils.sanitizeFilename(name),
@@ -639,7 +617,7 @@ fun GalleryDetailScreen(args: GalleryDetailScreenArgs, navigator: DestinationsNa
                },
            )
        }
-        Spacer(modifier = Modifier.size(dimensionResource(id = R.dimen.keyline_margin)))
+        Spacer(modifier = Modifier.size(keylineMargin))
        fun getAllRatingText(rating: Float, ratingCount: Int): String {
            return getString(
                R.string.rating_text,
@@ -659,23 +637,22 @@ fun GalleryDetailScreen(args: GalleryDetailScreenArgs, navigator: DestinationsNa
                    showSnackbar(signInFirst)
                    return@launchIO
                }
-                awaitPermissionOrCancel(title = R.string.rate) {
+                val pendingRating = awaitResult(galleryDetail.rating.coerceAtLeast(.5f), title = R.string.rate) {
                    Column(modifier = Modifier.fillMaxWidth(), horizontalAlignment = Alignment.CenterHorizontally) {
-                        var rating by remember { mutableFloatStateOf(galleryDetail.rating.coerceAtLeast(.5f)) }
-                        var text by remember { mutableIntStateOf(getRatingText(rating)) }
+                        var text by remember { mutableIntStateOf(getRatingText(expectedValue)) }
                        Text(text = stringResource(id = text), style = MaterialTheme.typography.bodyLarge)
-                        Spacer(modifier = Modifier.size(dimensionResource(id = R.dimen.keyline_margin)))
+                        Spacer(modifier = Modifier.size(keylineMargin))
                        GalleryRatingBar(
-                            rating = rating,
+                            rating = expectedValue,
                            onRatingChange = {
-                                rating = it.coerceAtLeast(.5f)
-                                text = getRatingText(rating)
+                                expectedValue = it.coerceAtLeast(.5f)
+                                text = getRatingText(expectedValue)
                            },
                        )
                    }
                }
                galleryDetail.runSuspendCatching {
-                    EhEngine.rateGallery(apiUid, apiKey, gid, token, rating)
+                    EhEngine.rateGallery(apiUid, apiKey, gid, token, pendingRating)
                }.onSuccess { result ->
                    galleryInfo = galleryDetail.apply {
                        rating = result.rating
@@ -695,11 +672,11 @@ fun GalleryDetailScreen(args: GalleryDetailScreenArgs, navigator: DestinationsNa
                horizontalAlignment = Alignment.CenterHorizontally,
            ) {
                GalleryDetailRating(rating = galleryDetail.rating)
-                Spacer(modifier = Modifier.size(dimensionResource(id = R.dimen.keyline_margin)))
+                Spacer(modifier = Modifier.size(keylineMargin))
                Text(text = ratingText)
            }
        }
-        Spacer(modifier = Modifier.size(dimensionResource(id = R.dimen.keyline_margin)))
+        Spacer(modifier = Modifier.size(keylineMargin))
        val tags = galleryDetail.tags
        if (tags.isEmpty()) {
            Box(
@@ -732,7 +709,7 @@ fun GalleryDetailScreen(args: GalleryDetailScreenArgs, navigator: DestinationsNa
                        tag
                    }
                    launchIO {
-                        showSelectActions {
+                        awaitSelectAction {
                            with(activity) {
                                onSelect(copy) {
                                    addTextToClipboard(tag)
@@ -755,12 +732,12 @@ fun GalleryDetailScreen(args: GalleryDetailScreenArgs, navigator: DestinationsNa
                                    onSelect(downTag) { galleryDetail.voteTag(tag, -1) }
                                }
                            }
-                        }
+                        }()
                    }
                },
            )
        }
-        Spacer(modifier = Modifier.size(dimensionResource(id = R.dimen.keyline_margin)))
+        Spacer(modifier = Modifier.size(keylineMargin))
        if (Settings.showComments) {
            GalleryDetailComment(galleryDetail.comments.comments)
            Spacer(modifier = Modifier.size(dimensionResource(id = R.dimen.strip_item_padding_v)))
@@ -774,7 +751,7 @@ fun GalleryDetailScreen(args: GalleryDetailScreenArgs, navigator: DestinationsNa
        modifier: Modifier,
    ) {
        val galleryDetail = galleryInfo.asGalleryDetail()
-        val windowSizeClass = calculateWindowSizeClass(activity)
+        val windowSizeClass = LocalWindowSizeClass.current
        val thumbColumns by Settings.thumbColumns.collectAsState()
        val readText = stringResource(R.string.read)
        val startPage by rememberInVM {
@@ -821,7 +798,7 @@ fun GalleryDetailScreen(args: GalleryDetailScreenArgs, navigator: DestinationsNa
        if (showBottomSheet && galleryDetail != null) {
            ModalBottomSheet(
                onDismissRequest = { showBottomSheet = false },
-                windowInsets = WindowInsets(0, 0, 0, 0),
+                contentWindowInsets = { WindowInsets(0, 0, 0, 0) },
            ) {
                GalleryInfoBottomSheet(galleryDetail, navigator)
            }
@@ -855,8 +832,8 @@ fun GalleryDetailScreen(args: GalleryDetailScreenArgs, navigator: DestinationsNa
            }
        }

-        when (windowSizeClass.widthSizeClass) {
-            WindowWidthSizeClass.Medium, WindowWidthSizeClass.Compact -> LazyVerticalGrid(
+        when (windowSizeClass.windowWidthSizeClass) {
+            WindowWidthSizeClass.MEDIUM, WindowWidthSizeClass.COMPACT -> LazyVerticalGrid(
                columns = GridCells.Fixed(thumbColumns),
                contentPadding = contentPadding,
                modifier = modifier.padding(horizontal = keylineMargin),
@@ -894,7 +871,7 @@ fun GalleryDetailScreen(args: GalleryDetailScreenArgs, navigator: DestinationsNa
                            BelowHeader(galleryDetail)
                        } else {
                            Box(
-                                modifier = Modifier.fillMaxSize(),
+                                modifier = Modifier.fillMaxSize().padding(keylineMargin),
                                contentAlignment = Alignment.Center,
                            ) {
                                CircularProgressIndicator()
@@ -907,7 +884,7 @@ fun GalleryDetailScreen(args: GalleryDetailScreenArgs, navigator: DestinationsNa
                }
            }

-            WindowWidthSizeClass.Expanded -> LazyVerticalGrid(
+            WindowWidthSizeClass.EXPANDED -> LazyVerticalGrid(
                columns = GridCells.Fixed(thumbColumns),
                contentPadding = contentPadding,
                modifier = modifier.padding(horizontal = keylineMargin),
@@ -954,7 +931,7 @@ fun GalleryDetailScreen(args: GalleryDetailScreenArgs, navigator: DestinationsNa
                            BelowHeader(galleryDetail)
                        } else {
                            Box(
-                                modifier = Modifier.fillMaxSize(),
+                                modifier = Modifier.fillMaxSize().padding(keylineMargin),
                                contentAlignment = Alignment.Center,
                            ) {
                                CircularProgressIndicator()
@@ -1097,7 +1074,7 @@ fun GalleryDetailScreen(args: GalleryDetailScreenArgs, navigator: DestinationsNa
                                    } else {
                                        val info = galleryInfo!!
                                        val uri = awaitActivityResult(
-                                            CreateDocument("application/x-cbz"),
+                                            CreateDocument("application/vnd.comicbook+zip"),
                                            EhUtils.getSuitableTitle(info) + ".cbz",
                                        )
                                        val dirname = downloadInfo?.dirname
@@ -18,6 +18,7 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.res.dimensionResource
 import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
 import com.hippo.ehviewer.R
 import com.hippo.ehviewer.Settings
 import com.hippo.ehviewer.collectAsState
@@ -63,7 +64,7 @@ fun collectListThumbSizeAsState(): State<Dp> {
    val density = LocalDensity.current
    return Settings.listThumbSize.collectAsState {
        with(density) {
-            it.toDp() * 9
+            (it.toDp() * 9).coerceAtLeast(120.dp)
        }
    }
 }
@@ -1,5 +1,6 @@
 package com.hippo.ehviewer.ui.screen

+import android.content.Context
 import android.net.Uri
 import android.view.ViewConfiguration
 import androidx.activity.result.contract.ActivityResultContracts
@@ -17,25 +18,22 @@ import androidx.compose.foundation.layout.calculateStartPadding
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.imePadding
 import androidx.compose.foundation.layout.only
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.systemBars
-import androidx.compose.foundation.layout.windowInsetsPadding
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.grid.rememberLazyGridState
 import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.foundation.lazy.staggeredgrid.rememberLazyStaggeredGridState
-import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.text.input.rememberTextFieldState
 import androidx.compose.foundation.text.input.setTextAndPlaceCursorAtEnd
-import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.Help
 import androidx.compose.material.icons.automirrored.filled.LastPage
 import androidx.compose.material.icons.filled.Add
 import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material.icons.filled.Reorder
 import androidx.compose.material.icons.filled.Search
 import androidx.compose.material.icons.filled.Shuffle
 import androidx.compose.material.icons.outlined.Bookmarks
@@ -47,11 +45,11 @@ import androidx.compose.material3.IconButton
 import androidx.compose.material3.ListItem
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.SwipeToDismissBoxDefaults
-import androidx.compose.material3.SwipeToDismissBoxState
 import androidx.compose.material3.SwipeToDismissBoxValue
 import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBar
-import androidx.compose.material3.pulltorefresh.rememberPullToRefreshState
+import androidx.compose.material3.fork.SwipeToDismissBox
+import androidx.compose.material3.fork.SwipeToDismissBoxState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.Stable
@@ -74,7 +72,6 @@ import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.platform.LocalLayoutDirection
-import androidx.compose.ui.platform.LocalView
 import androidx.compose.ui.res.dimensionResource
 import androidx.compose.ui.res.stringArrayResource
 import androidx.compose.ui.res.stringResource
@@ -84,7 +81,6 @@ import androidx.compose.ui.util.fastAny
 import androidx.compose.ui.util.fastForEach
 import androidx.compose.ui.util.lerp
 import androidx.lifecycle.viewModelScope
-import androidx.paging.LoadState
 import androidx.paging.Pager
 import androidx.paging.PagingConfig
 import androidx.paging.PagingSource
@@ -113,7 +109,9 @@ import com.hippo.ehviewer.collectAsState
 import com.hippo.ehviewer.dao.QuickSearch
 import com.hippo.ehviewer.icons.EhIcons
 import com.hippo.ehviewer.icons.filled.GoTo
+import com.hippo.ehviewer.ui.DrawerHandle
 import com.hippo.ehviewer.ui.LocalSideSheetState
+import com.hippo.ehviewer.ui.awaitSelectDate
 import com.hippo.ehviewer.ui.composing
 import com.hippo.ehviewer.ui.destinations.ProgressScreenDestination
 import com.hippo.ehviewer.ui.doGalleryInfoAction
@@ -125,21 +123,21 @@ import com.hippo.ehviewer.ui.main.GalleryInfoListItem
 import com.hippo.ehviewer.ui.main.GalleryList
 import com.hippo.ehviewer.ui.main.ImageSearch
 import com.hippo.ehviewer.ui.main.SearchFilter
-import com.hippo.ehviewer.ui.showDatePicker
 import com.hippo.ehviewer.ui.tools.Deferred
-import com.hippo.ehviewer.ui.tools.DragHandle
-import com.hippo.ehviewer.ui.tools.SwipeToDismissBox2
+import com.hippo.ehviewer.ui.tools.HapticFeedbackType
 import com.hippo.ehviewer.ui.tools.animateFloatMergePredictiveBackAsState
 import com.hippo.ehviewer.ui.tools.delegateSnapshotUpdate
-import com.hippo.ehviewer.ui.tools.draggingHapticFeedback
 import com.hippo.ehviewer.ui.tools.foldToLoadResult
+import com.hippo.ehviewer.ui.tools.rememberHapticFeedback
 import com.hippo.ehviewer.ui.tools.rememberInVM
+import com.hippo.ehviewer.ui.tools.rememberMutableStateInDataStore
 import com.hippo.ehviewer.ui.tools.snackBarPadding
 import com.hippo.ehviewer.util.FavouriteStatusRouter
 import com.hippo.ehviewer.util.pickVisualMedia
 import com.hippo.unifile.asUniFile
 import com.hippo.unifile.sha1
 import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.annotation.RootGraph
 import com.ramcosta.composedestinations.navigation.DestinationsNavigator
 import com.ramcosta.composedestinations.spec.Direction
 import eu.kanade.tachiyomi.util.lang.launchIO
@@ -152,39 +150,40 @@ import kotlinx.coroutines.launch
 import moe.tarsin.coroutines.onEachLatest
 import moe.tarsin.coroutines.runSuspendCatching
 import sh.calvin.reorderable.ReorderableItem
-import sh.calvin.reorderable.rememberReorderableLazyColumnState
+import sh.calvin.reorderable.rememberReorderableLazyListState

-@Destination
+@Destination<RootGraph>
@Composable
 fun HomePageScreen(navigator: DestinationsNavigator) = GalleryListScreen(ListUrlBuilder(), navigator)

-@Destination
+@Destination<RootGraph>
@Composable
 fun SubscriptionScreen(navigator: DestinationsNavigator) = GalleryListScreen(ListUrlBuilder(MODE_SUBSCRIPTION), navigator)

-@Destination
+@Destination<RootGraph>
@Composable
 fun WhatshotScreen(navigator: DestinationsNavigator) = GalleryListScreen(ListUrlBuilder(MODE_WHATS_HOT), navigator)

-@Destination
+@Destination<RootGraph>
@Composable
 fun ToplistScreen(navigator: DestinationsNavigator) = GalleryListScreen(ListUrlBuilder(MODE_TOPLIST, mKeyword = Settings.recentToplist), navigator)

-@Destination
+@Destination<RootGraph>
@Composable
 fun GalleryListScreen(lub: ListUrlBuilder, navigator: DestinationsNavigator) = composing(navigator) {
    val searchFieldState = rememberTextFieldState()
    var urlBuilder by rememberSaveable(lub) { mutableStateOf(lub) }
+    var searchBarExpanded by rememberSaveable { mutableStateOf(false) }
    var searchBarOffsetY by remember { mutableIntStateOf(0) }
    var showSearchLayout by rememberSaveable { mutableStateOf(false) }

-    var category by rememberSaveable { mutableIntStateOf(Settings.searchCategory) }
-    var searchMethod by rememberSaveable { mutableIntStateOf(1) }
-    var advancedSearchOption by rememberSaveable { mutableStateOf(AdvancedSearchOption()) }
+    var category by rememberMutableStateInDataStore("SearchCategory") { EhUtils.ALL_CATEGORY }
+    var advancedSearchOption by rememberMutableStateInDataStore("AdvancedSearchOption") { AdvancedSearchOption() }
    var imageUri by rememberSaveable { mutableStateOf<Uri?>(null) }

+    DrawerHandle(!searchBarExpanded)
+
    LaunchedEffect(urlBuilder) {
-        if (urlBuilder.mode == MODE_SUBSCRIPTION) searchMethod = 2
        if (urlBuilder.category != EhUtils.NONE) category = urlBuilder.category
        if (urlBuilder.mode != MODE_TOPLIST) {
            var keyword = urlBuilder.keyword.orEmpty()
@@ -367,14 +366,14 @@ fun GalleryListScreen(lub: ListUrlBuilder, navigator: DestinationsNavigator) = c
                },
                windowInsets = WindowInsets(0),
            )
-            val view = LocalView.current
            Box(modifier = Modifier.fillMaxSize()) {
                val quickSearchListState = rememberLazyListState()
-                val reorderableLazyListState = rememberReorderableLazyColumnState(quickSearchListState) { from, to ->
+                val hapticFeedback = rememberHapticFeedback()
+                val reorderableLazyListState = rememberReorderableLazyListState(quickSearchListState) { from, to ->
                    val fromIndex = from.index - 1
                    val toIndex = to.index - 1
                    quickSearchList.apply { add(toIndex, removeAt(fromIndex)) }
-                    view.performHapticFeedback(draggingHapticFeedback)
+                    hapticFeedback.performHapticFeedback(HapticFeedbackType.MOVE)
                }
                var fromIndex by remember { mutableIntStateOf(-1) }
                LazyColumn(
@@ -386,7 +385,8 @@ fun GalleryListScreen(lub: ListUrlBuilder, navigator: DestinationsNavigator) = c
                    stickyHeader {
                        HorizontalDivider()
                    }
-                    itemsIndexed(quickSearchList, key = { _, item -> item.id!! }) { index, item ->
+                    itemsIndexed(quickSearchList, key = { _, item -> item.id!! }) { itemIndex, item ->
+                        val index by rememberUpdatedState(itemIndex)
                        ReorderableItem(reorderableLazyListState, key = item.id!!) { isDragging ->
                            // Not using rememberSwipeToDismissBoxState to prevent LazyColumn from reusing it
                            val dismissState = remember { SwipeToDismissBoxState(SwipeToDismissBoxValue.Settled, density, positionalThreshold = positionalThreshold) }
@@ -400,11 +400,10 @@ fun GalleryListScreen(lub: ListUrlBuilder, navigator: DestinationsNavigator) = c
                                        }.onSuccess {
                                            EhDB.deleteQuickSearch(item)
                                            with(quickSearchList) {
-                                                val removeIndex = indexOf(item)
-                                                subList(removeIndex + 1, size).forEach {
+                                                subList(index + 1, size).forEach {
                                                    it.position--
                                                }
-                                                removeAt(removeIndex)
+                                                removeAt(index)
                                            }
                                        }.onFailure {
                                            dismissState.reset()
@@ -412,9 +411,10 @@ fun GalleryListScreen(lub: ListUrlBuilder, navigator: DestinationsNavigator) = c
                                    }
                                }
                            }
-                            SwipeToDismissBox2(
+                            SwipeToDismissBox(
                                state = dismissState,
                                backgroundContent = {},
+                                enableDismissFromStartToEnd = false,
                            ) {
                                val elevation by animateDpAsState(
                                    if (isDragging) {
@@ -442,22 +442,29 @@ fun GalleryListScreen(lub: ListUrlBuilder, navigator: DestinationsNavigator) = c
                                        Text(text = item.name)
                                    },
                                    trailingContent = {
-                                        DragHandle(
-                                            onDragStarted = {
-                                                fromIndex = index
-                                            },
-                                            onDragStopped = {
-                                                if (fromIndex != -1) {
-                                                    if (fromIndex != index) {
-                                                        val range = if (fromIndex < index) fromIndex..index else index..fromIndex
-                                                        val toUpdate = quickSearchList.slice(range)
-                                                        toUpdate.zip(range).forEach { it.first.position = it.second }
-                                                        launchIO { EhDB.updateQuickSearch(toUpdate) }
+                                        IconButton(
+                                            onClick = {},
+                                            modifier = Modifier.draggableHandle(
+                                                onDragStarted = {
+                                                    hapticFeedback.performHapticFeedback(HapticFeedbackType.START)
+                                                    fromIndex = index
+                                                },
+                                                onDragStopped = {
+                                                    hapticFeedback.performHapticFeedback(HapticFeedbackType.END)
+                                                    if (fromIndex != -1) {
+                                                        if (fromIndex != index) {
+                                                            val range = if (fromIndex < index) fromIndex..index else index..fromIndex
+                                                            val toUpdate = quickSearchList.slice(range)
+                                                            toUpdate.zip(range).forEach { it.first.position = it.second }
+                                                            launchIO { EhDB.updateQuickSearch(toUpdate) }
+                                                        }
+                                                        fromIndex = -1
                                                    }
-                                                    fromIndex = -1
-                                                }
-                                            },
-                                        )
+                                                },
+                                            ),
+                                        ) {
+                                            Icon(imageVector = Icons.Default.Reorder, contentDescription = null)
+                                        }
                                    },
                                )
                            }
@@ -476,10 +483,6 @@ fun GalleryListScreen(lub: ListUrlBuilder, navigator: DestinationsNavigator) = c
        }
    }

-    val refreshState = rememberPullToRefreshState {
-        data.loadState.refresh is LoadState.NotLoading
-    }
-
    var fabExpanded by remember { mutableStateOf(false) }
    var fabHidden by remember { mutableStateOf(false) }

@@ -539,13 +542,15 @@ fun GalleryListScreen(lub: ListUrlBuilder, navigator: DestinationsNavigator) = c
    }

    SearchBarScreen(
+        onApplySearch = ::onApplySearch,
+        expanded = searchBarExpanded,
+        onExpandedChange = {
+            searchBarExpanded = it
+            fabHidden = it
+        },
        title = suitableTitle,
        searchFieldState = searchFieldState,
        searchFieldHint = searchBarHint,
-        onApplySearch = ::onApplySearch,
-        onSearchExpanded = { fabHidden = true },
-        onSearchHidden = { fabHidden = false },
-        refreshState = refreshState,
        suggestionProvider = {
            GalleryDetailUrlParser.parse(it, false)?.run {
                GalleryDetailUrlSuggestion(gid, token)
@@ -573,12 +578,11 @@ fun GalleryListScreen(lub: ListUrlBuilder, navigator: DestinationsNavigator) = c
        filter = {
            SearchFilter(
                category = category,
-                onCategoryChanged = {
-                    Settings.searchCategory = it
-                    category = it
-                },
+                onCategoryChanged = { category = it },
                advancedOption = advancedSearchOption,
-                onAdvancedOptionChanged = { advancedSearchOption = it },
+                onAdvancedOptionChanged = {
+                    advancedSearchOption = it
+                },
            )
        },
        floatingActionButton = {
@@ -605,50 +609,44 @@ fun GalleryListScreen(lub: ListUrlBuilder, navigator: DestinationsNavigator) = c
        val layoutDirection = LocalLayoutDirection.current
        val marginH = dimensionResource(id = R.dimen.gallery_list_margin_h)
        val marginV = dimensionResource(id = R.dimen.gallery_list_margin_v)
-        Column(
-            modifier = Modifier.imePadding().verticalScroll(rememberScrollState())
-                .padding(
-                    top = contentPadding.calculateTopPadding() + marginV,
-                    start = contentPadding.calculateStartPadding(layoutDirection) + marginH,
-                    end = contentPadding.calculateEndPadding(layoutDirection) + marginH,
-                    bottom = 8.dp,
-                )
-                .windowInsetsPadding(WindowInsets.systemBars.only(WindowInsetsSides.Bottom))
-                .graphicsLayer {
-                    scaleX = 1 - animatedSearchLayout
-                    scaleY = 1 - animatedSearchLayout
-                    alpha = 1 - animatedSearchLayout
-                },
+        ElevatedCard(
+            modifier = Modifier.graphicsLayer {
+                scaleX = 1 - animatedSearchLayout
+                scaleY = 1 - animatedSearchLayout
+                alpha = 1 - animatedSearchLayout
+            }.padding(
+                top = contentPadding.calculateTopPadding() + marginV,
+                start = contentPadding.calculateStartPadding(layoutDirection) + marginH,
+                end = contentPadding.calculateEndPadding(layoutDirection) + marginH,
+                bottom = 8.dp,
+            ).padding(vertical = dimensionResource(id = R.dimen.search_layout_margin_v)),
        ) {
-            ElevatedCard(modifier = Modifier.padding(vertical = dimensionResource(id = R.dimen.search_layout_margin_v))) {
-                Column(
-                    modifier = Modifier.padding(
-                        horizontal = dimensionResource(id = R.dimen.search_category_padding_h),
-                        vertical = dimensionResource(id = R.dimen.search_category_padding_v),
-                    ).fillMaxWidth(),
-                    horizontalAlignment = Alignment.CenterHorizontally,
-                ) {
-                    Text(
-                        text = stringResource(id = R.string.search_image),
-                        modifier = Modifier.height(dimensionResource(id = R.dimen.search_category_title_height)),
-                        fontWeight = FontWeight.Bold,
-                        style = MaterialTheme.typography.titleMedium,
-                    )
-                    ImageSearch(
-                        image = imageUri,
-                        onSelectImage = {
-                            launch { imageUri = pickVisualMedia(ActivityResultContracts.PickVisualMedia.ImageOnly) }
-                        },
-                    )
-                }
+            Column(
+                modifier = Modifier.padding(
+                    horizontal = dimensionResource(id = R.dimen.search_category_padding_h),
+                    vertical = dimensionResource(id = R.dimen.search_category_padding_v),
+                ).fillMaxWidth(),
+                horizontalAlignment = Alignment.CenterHorizontally,
+            ) {
+                Text(
+                    text = stringResource(id = R.string.search_image),
+                    modifier = Modifier.height(dimensionResource(id = R.dimen.search_category_title_height)),
+                    fontWeight = FontWeight.Bold,
+                    style = MaterialTheme.typography.titleMedium,
+                )
+                ImageSearch(
+                    image = imageUri,
+                    onSelectImage = {
+                        launch { imageUri = pickVisualMedia(ActivityResultContracts.PickVisualMedia.ImageOnly) }
+                    },
+                )
            }
        }

        val height by collectListThumbSizeAsState()
        val showPages by Settings.showGalleryPages.collectAsState()
-        val context = LocalContext.current
        val searchBarConnection = remember {
-            val slop = ViewConfiguration.get(context).scaledTouchSlop
+            val slop = ViewConfiguration.get(implicit<Context>()).scaledTouchSlop
            val topPaddingPx = with(density) { contentPadding.calculateTopPadding().roundToPx() }
            object : NestedScrollConnection {
                override fun onPostScroll(consumed: Offset, available: Offset, source: NestedScrollSource): Offset {
@@ -689,9 +687,10 @@ fun GalleryListScreen(lub: ListUrlBuilder, navigator: DestinationsNavigator) = c
                    onClick = { navigate(info.asDst()) },
                    onLongClick = { launch { doGalleryInfoAction(info) } },
                    info = info,
+                    showPages = showPages,
                )
            },
-            refreshState = refreshState,
+            searchBarOffsetY = { searchBarOffsetY },
            onRefresh = {
                urlBuilder.setRange(0)
                data.refresh()
@@ -736,32 +735,26 @@ fun GalleryListScreen(lub: ListUrlBuilder, navigator: DestinationsNavigator) = c
                    val page = urlBuilder.mJumpTo?.toIntOrNull() ?: 0
                    val hint = getString(R.string.go_to_hint, page + 1, TOPLIST_PAGES)
                    val text = awaitInputText(title = gotoTitle, hint = hint, isNumber = true) { oriText ->
-                        val text = oriText.trim()
-                        val goTo = runCatching {
-                            text.toInt() - 1
-                        }.onFailure {
-                            return@awaitInputText invalidNum
-                        }.getOrThrow()
-                        if (goTo !in 0..<TOPLIST_PAGES) outOfRange else null
+                        when (oriText.trim().toIntOrNull()?.let { it - 1 }) {
+                            null -> invalidNum
+                            !in 0..<TOPLIST_PAGES -> outOfRange
+                            else -> null
+                        }
                    }.trim().toInt() - 1
                    urlBuilder.setJumpTo(text)
-                    data.refresh()
                } else {
-                    launch {
-                        val date = showDatePicker()
-                        urlBuilder.mJumpTo = date
-                        data.refresh()
-                    }
+                    val date = awaitSelectDate()
+                    urlBuilder.mJumpTo = date
                }
+                data.refresh()
            }
            onClick(Icons.AutoMirrored.Default.LastPage) {
                if (isTopList) {
                    urlBuilder.setJumpTo(TOPLIST_PAGES - 1)
-                    data.refresh()
                } else {
                    urlBuilder.setIndex("1", false)
-                    data.refresh()
                }
+                data.refresh()
            }
        }
    }
@@ -39,7 +39,6 @@ import com.hippo.ehviewer.coil.justDownload
 import com.hippo.ehviewer.collectAsState
 import com.hippo.ehviewer.ktbuilder.imageRequest
 import com.hippo.ehviewer.ktbuilder.launchIn
-import com.hippo.ehviewer.ui.LockDrawer
 import com.hippo.ehviewer.ui.composing
 import com.hippo.ehviewer.ui.main.EhPreviewItem
 import com.hippo.ehviewer.ui.navToReader
@@ -51,14 +50,14 @@ import com.hippo.ehviewer.ui.tools.getOffset
 import com.hippo.ehviewer.ui.tools.rememberInVM
 import com.hippo.ehviewer.util.flattenForEach
 import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.annotation.RootGraph
 import com.ramcosta.composedestinations.navigation.DestinationsNavigator
 import eu.kanade.tachiyomi.util.lang.withIOContext
 import moe.tarsin.coroutines.runSuspendCatching

-@Destination
+@Destination<RootGraph>
@Composable
 fun GalleryPreviewScreen(detail: GalleryDetail, toNextPage: Boolean, navigator: DestinationsNavigator) = composing(navigator) {
-    LockDrawer(true)
    val scrollBehaviour = TopAppBarDefaults.pinnedScrollBehavior()
    val pgSize = detail.previewList.size
    val state = rememberLazyGridState(initialFirstVisibleItemIndex = if (toNextPage) pgSize else 0)
@@ -15,7 +15,8 @@ import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.SwipeToDismissBoxValue
 import androidx.compose.material3.Text
-import androidx.compose.material3.rememberSwipeToDismissBoxState
+import androidx.compose.material3.fork.SwipeToDismissBox
+import androidx.compose.material3.fork.rememberSwipeToDismissBoxState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
@@ -46,30 +47,36 @@ import com.hippo.ehviewer.Settings
 import com.hippo.ehviewer.collectAsState
 import com.hippo.ehviewer.icons.EhIcons
 import com.hippo.ehviewer.icons.big.History
+import com.hippo.ehviewer.ui.DrawerHandle
 import com.hippo.ehviewer.ui.composing
 import com.hippo.ehviewer.ui.doGalleryInfoAction
 import com.hippo.ehviewer.ui.main.GalleryInfoListItem
 import com.hippo.ehviewer.ui.main.plus
 import com.hippo.ehviewer.ui.tools.Deferred
 import com.hippo.ehviewer.ui.tools.FastScrollLazyColumn
-import com.hippo.ehviewer.ui.tools.SwipeToDismissBox2
 import com.hippo.ehviewer.ui.tools.rememberInVM
+import com.hippo.ehviewer.ui.tools.thenIf
 import com.hippo.ehviewer.util.FavouriteStatusRouter
 import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.annotation.RootGraph
 import com.ramcosta.composedestinations.navigation.DestinationsNavigator
 import kotlin.math.roundToInt
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch

-@Destination
+@Destination<RootGraph>
@Composable
 fun HistoryScreen(navigator: DestinationsNavigator) = composing(navigator) {
    val title = stringResource(id = R.string.history)
    val hint = stringResource(R.string.search_bar_hint, title)
+    val animateItems by Settings.animateItems.collectAsState()

+    var searchBarExpanded by rememberSaveable { mutableStateOf(false) }
    var searchBarOffsetY by remember { mutableIntStateOf(0) }
    var keyword by rememberSaveable { mutableStateOf("") }

+    DrawerHandle(!searchBarExpanded)
+
    val density = LocalDensity.current
    val historyData = rememberInVM {
        Pager(config = PagingConfig(pageSize = 20, jumpThreshold = 40)) {
@@ -82,14 +89,14 @@ fun HistoryScreen(navigator: DestinationsNavigator) = composing(navigator) {
    }.collectAsLazyPagingItems()
    FavouriteStatusRouter.Observe(historyData)
    SearchBarScreen(
-        title = title,
-        searchFieldHint = hint,
        onApplySearch = {
            keyword = it
            historyData.refresh()
        },
-        onSearchExpanded = {},
-        onSearchHidden = {},
+        expanded = searchBarExpanded,
+        onExpandedChange = { searchBarExpanded = it },
+        title = title,
+        searchFieldHint = hint,
        searchBarOffsetY = { searchBarOffsetY },
        trailingIcon = {
            IconButton(onClick = {
@@ -138,10 +145,11 @@ fun HistoryScreen(navigator: DestinationsNavigator) = composing(navigator) {
                            true
                        },
                    )
-                    SwipeToDismissBox2(
+                    SwipeToDismissBox(
                        state = dismissState,
                        backgroundContent = {},
-                        modifier = Modifier.animateItemPlacement(),
+                        modifier = Modifier.thenIf(animateItems) { animateItem() },
+                        enableDismissFromStartToEnd = false,
                    ) {
                        GalleryInfoListItem(
                            onClick = { navigate(info.asDst()) },
@@ -1,7 +1,6 @@
 package com.hippo.ehviewer.ui.screen

 import androidx.annotation.MainThread
-import androidx.navigation.NavController
 import com.hippo.ehviewer.client.data.BaseGalleryInfo
 import com.hippo.ehviewer.client.data.ListUrlBuilder
 import com.hippo.ehviewer.client.parser.GalleryDetailUrlParser
@@ -34,19 +33,9 @@ fun DestinationsNavigator.navWithUrl(url: String): Boolean {

@MainThread
 fun DestinationsNavigator.popNavigate(direction: Direction) = navigate(direction) {
-    popUpTo(NavGraphs.root.route)
+    popUpTo(NavGraphs.root)
 }

-@MainThread
-fun NavController.navWithUrl(url: String): Boolean {
-    val dest = urlToDestination(url) ?: return false
-    navigate(dest)
-    return true
-}
-
-@MainThread
-fun NavController.navigate(direction: Direction) = navigate(direction.route)
-
 fun BaseGalleryInfo.asDst() = GalleryDetailScreenDestination(GalleryInfoArgs(this))

 infix fun Long.asDstWith(token: String) = GalleryDetailScreenDestination(TokenArgs(this, token))
@@ -24,17 +24,16 @@ import com.hippo.ehviewer.R
 import com.hippo.ehviewer.client.EhEngine
 import com.hippo.ehviewer.icons.EhIcons
 import com.hippo.ehviewer.icons.big.SadAndroid
-import com.hippo.ehviewer.ui.LockDrawer
 import com.hippo.ehviewer.util.displayString
 import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.annotation.RootGraph
 import com.ramcosta.composedestinations.navigation.DestinationsNavigator
 import eu.kanade.tachiyomi.util.lang.withUIContext
 import moe.tarsin.coroutines.runSuspendCatching

-@Destination
+@Destination<RootGraph>
@Composable
 fun ProgressScreen(gid: Long, token: String, page: Int, navigator: DestinationsNavigator) {
-    LockDrawer(true)
    val wrong = stringResource(id = R.string.error_something_wrong_happened)
    var error by rememberSaveable { mutableStateOf("") }
    LaunchedEffect(error) {
@@ -1,34 +1,31 @@
 package com.hippo.ehviewer.ui.screen

 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.focusable
 import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
 import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.WindowInsetsSides
 import androidx.compose.foundation.layout.asPaddingValues
-import androidx.compose.foundation.layout.displayCutoutPadding
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.ime
 import androidx.compose.foundation.layout.navigationBars
 import androidx.compose.foundation.layout.offset
 import androidx.compose.foundation.layout.only
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.foundation.layout.safeDrawing
+import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.statusBarsPadding
-import androidx.compose.foundation.layout.union
+import androidx.compose.foundation.layout.widthIn
 import androidx.compose.foundation.layout.windowInsetsPadding
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.text.input.TextFieldState
 import androidx.compose.foundation.text.input.clearText
-import androidx.compose.foundation.text.input.forEachTextValue
 import androidx.compose.foundation.text.input.rememberTextFieldState
 import androidx.compose.foundation.text.input.setTextAndPlaceCursorAtEnd
-import androidx.compose.foundation.text.input.textAsFlow
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.ArrowBack
 import androidx.compose.material.icons.automirrored.filled.MenuBook
@@ -41,18 +38,17 @@ import androidx.compose.material3.ListItemDefaults
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.SearchBar
 import androidx.compose.material3.SearchBarDefaults
+import androidx.compose.material3.SearchBarHorizontalPadding
+import androidx.compose.material3.SearchBarInputField
 import androidx.compose.material3.Text
-import androidx.compose.material3.pulltorefresh.PullToRefreshContainer
-import androidx.compose.material3.pulltorefresh.PullToRefreshState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
+import androidx.compose.runtime.snapshotFlow
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
@@ -61,24 +57,25 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.dp
-import arrow.fx.coroutines.mapIndexed
 import com.hippo.ehviewer.EhApplication.Companion.searchDatabase
 import com.hippo.ehviewer.R
 import com.hippo.ehviewer.Settings
 import com.hippo.ehviewer.client.EhTagDatabase
 import com.hippo.ehviewer.client.data.TagNamespace
+import com.hippo.ehviewer.collectAsState
 import com.hippo.ehviewer.dao.Search
 import com.hippo.ehviewer.dao.SearchDao
 import com.hippo.ehviewer.ui.LocalNavDrawerState
-import com.hippo.ehviewer.ui.LockDrawer
 import com.hippo.ehviewer.ui.tools.LocalDialogState
+import com.hippo.ehviewer.ui.tools.rememberCompositionActiveState
+import com.hippo.ehviewer.ui.tools.thenIf
 import com.jamal.composeprefs3.ui.ifNotNullThen
 import com.jamal.composeprefs3.ui.ifTrueThen
 import eu.kanade.tachiyomi.util.lang.launchIO
 import eu.kanade.tachiyomi.util.lang.launchUI
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.toList
 import kotlinx.coroutines.launch
@@ -96,31 +93,30 @@ abstract class Suggestion {
 }

 suspend fun SearchDao.suggestions(prefix: String, limit: Int) =
-    (if (prefix.isBlank()) list(limit) else rawSuggestions(prefix, limit)).map { it.query }
+    (if (prefix.isBlank()) list(limit) else rawSuggestions(prefix, limit))

@Composable
 fun SearchBarScreen(
+    onApplySearch: (String) -> Unit,
+    expanded: Boolean,
+    onExpandedChange: (Boolean) -> Unit,
    title: String? = null,
    searchFieldState: TextFieldState = rememberTextFieldState(),
    searchFieldHint: String? = null,
-    onApplySearch: (String) -> Unit,
-    onSearchExpanded: () -> Unit,
-    onSearchHidden: () -> Unit,
-    refreshState: PullToRefreshState? = null,
    suggestionProvider: SuggestionProvider? = null,
    tagNamespace: Boolean = false,
-    searchBarOffsetY: () -> Int,
-    trailingIcon: @Composable () -> Unit,
+    searchBarOffsetY: () -> Int = { 0 },
+    trailingIcon: @Composable () -> Unit = {},
    filter: @Composable (() -> Unit)? = null,
    floatingActionButton: @Composable () -> Unit = {},
    content: @Composable (PaddingValues) -> Unit,
 ) {
    var mSuggestionList by remember { mutableStateOf(emptyList<Suggestion>()) }
    val mSearchDatabase = searchDatabase.searchDao()
-    var active by rememberSaveable { mutableStateOf(false) }
    val scope = rememberCoroutineScope { Dispatchers.IO }
    val context = LocalContext.current
    val dialogState = LocalDialogState.current
+    val animateItems by Settings.animateItems.collectAsState()

    class TagSuggestion(
        override val hint: String?,
@@ -167,34 +163,21 @@ fun SearchBarScreen(
        mSuggestionList = mergedSuggestionFlow().toList()
    }

-    var shouldLockDrawer by remember { mutableStateOf(false) }
-    LockDrawer(shouldLockDrawer)
-
-    fun onSearchViewExpanded() {
-        onSearchExpanded()
-        shouldLockDrawer = true
-    }
-
-    fun onSearchViewHidden() {
-        shouldLockDrawer = false
-        onSearchHidden()
-    }
-
-    if (active) {
+    if (expanded) {
        LaunchedEffect(Unit) {
-            searchFieldState.forEachTextValue {
+            snapshotFlow { searchFieldState.text }.collectLatest {
                updateSuggestions()
            }
        }
    }

    fun hideSearchView() {
-        onSearchViewHidden()
-        active = false
+        onExpandedChange(false)
    }

    fun onApplySearch() {
-        val query = searchFieldState.text.trim().toString()
+        // May have invalid whitespaces if pasted from clipboard, replace them with spaces
+        val query = searchFieldState.text.trim().replace(WhitespaceRegex, " ")
        if (query.isNotEmpty()) {
            scope.launchIO {
                mSearchDatabase.deleteQuery(query)
@@ -217,86 +200,74 @@ fun SearchBarScreen(
        }
    }

-    val scrollAwayModifier = if (!active) {
-        Modifier.offset { IntOffset(0, searchBarOffsetY()) }
-    } else {
-        Modifier
-    }
-
-    Box(modifier = Modifier.fillMaxSize()) {
+    BoxWithConstraints(modifier = Modifier.fillMaxSize()) {
        Scaffold(
            topBar = {
                // Placeholder, fill immutable SearchBar padding
-                Spacer(
-                    modifier = Modifier.statusBarsPadding().displayCutoutPadding()
-                        .height(SearchBarDefaults.InputFieldHeight + 16.dp),
-                )
+                Spacer(modifier = Modifier.statusBarsPadding().height(SearchBarDefaults.InputFieldHeight + 16.dp))
            },
            floatingActionButton = floatingActionButton,
            content = content,
        )
-        if (refreshState != null) {
-            PullToRefreshContainer(
-                state = refreshState,
-                modifier = Modifier.align(Alignment.TopCenter).safeDrawingPadding()
-                    .padding(top = 48.dp) then scrollAwayModifier,
-            )
-        }
+        // https://issuetracker.google.com/337191298
+        // Workaround for can't exit SearchBar due to refocus in non-touch mode
+        Box(Modifier.size(1.dp).focusable())
+        val activeState = rememberCompositionActiveState()
        SearchBar(
-            modifier = Modifier.fillMaxWidth().align(Alignment.TopCenter) then scrollAwayModifier
+            modifier = Modifier.align(Alignment.TopCenter).thenIf(!expanded) { offset { IntOffset(0, searchBarOffsetY()) } }
                .windowInsetsPadding(WindowInsets.navigationBars.only(WindowInsetsSides.Horizontal)),
-            state = searchFieldState,
-            onSearch = {
-                hideSearchView()
-                onApplySearch()
-            },
-            active = active,
-            onActiveChange = {
-                if (it) {
-                    onSearchViewExpanded()
-                } else {
-                    onSearchViewHidden()
-                }
-                active = it
-            },
-            title = title.ifNotNullThen { Text(title!!, overflow = TextOverflow.Ellipsis) },
-            placeholder = searchFieldHint.ifNotNullThen { Text(searchFieldHint!!) },
-            leadingIcon = {
-                if (active) {
-                    IconButton(onClick = { hideSearchView() }) {
-                        Icon(Icons.AutoMirrored.Default.ArrowBack, contentDescription = null)
-                    }
-                } else {
-                    val drawerState = LocalNavDrawerState.current
-                    IconButton(onClick = { scope.launchUI { drawerState.open() } }) {
-                        Icon(Icons.Default.Menu, contentDescription = null)
-                    }
-                }
-            },
-            trailingIcon = {
-                if (active) {
-                    val hasText by searchFieldState.textAsFlow().mapIndexed { index, text ->
-                        // Workaround for https://github.com/FooIbar/EhViewer/issues/715
-                        if (index == 0) delay(700)
-                        text.isNotEmpty()
-                    }.collectAsState(false)
-                    if (hasText) {
-                        IconButton(onClick = { searchFieldState.clearText() }) {
-                            Icon(Icons.Default.Close, contentDescription = null)
+            inputField = {
+                SearchBarInputField(
+                    state = searchFieldState,
+                    onSearch = {
+                        hideSearchView()
+                        onApplySearch()
+                    },
+                    expanded = expanded,
+                    onExpandedChange = onExpandedChange,
+                    modifier = Modifier.widthIn(max = maxWidth - SearchBarHorizontalPadding * 2),
+                    label = title.ifNotNullThen {
+                        Text(title!!, overflow = TextOverflow.Ellipsis)
+                    }.takeUnless {
+                        val contentActive by activeState.state
+                        expanded || contentActive || searchFieldState.text.isNotEmpty()
+                    },
+                    placeholder = searchFieldHint.ifNotNullThen { Text(searchFieldHint!!) },
+                    leadingIcon = {
+                        if (expanded) {
+                            IconButton(onClick = { hideSearchView() }) {
+                                Icon(Icons.AutoMirrored.Default.ArrowBack, contentDescription = null)
+                            }
+                        } else {
+                            val drawerState = LocalNavDrawerState.current
+                            IconButton(onClick = { scope.launchUI { drawerState.open() } }) {
+                                Icon(Icons.Default.Menu, contentDescription = null)
+                            }
                        }
-                    }
-                } else {
-                    Row {
-                        trailingIcon()
-                    }
-                }
+                    },
+                    trailingIcon = {
+                        if (expanded) {
+                            if (searchFieldState.text.isNotEmpty()) {
+                                IconButton(onClick = { searchFieldState.clearText() }) {
+                                    Icon(Icons.Default.Close, contentDescription = null)
+                                }
+                            }
+                        } else {
+                            Row {
+                                trailingIcon()
+                            }
+                        }
+                    },
+                )
            },
+            expanded = expanded,
+            onExpandedChange = onExpandedChange,
        ) {
+            activeState.Anchor()
            filter?.invoke()
            LazyColumn(
                modifier = Modifier.fillMaxSize(),
-                contentPadding = WindowInsets.navigationBars.union(WindowInsets.ime)
-                    .only(WindowInsetsSides.Bottom).asPaddingValues(),
+                contentPadding = WindowInsets.safeDrawing.only(WindowInsetsSides.Bottom).asPaddingValues(),
            ) {
                // Workaround for prepending before the first item
                item {}
@@ -319,7 +290,7 @@ fun SearchBarScreen(
                            }
                        },
                        colors = ListItemDefaults.colors(containerColor = Color.Transparent),
-                        modifier = Modifier.clickable { it.onClick() }.animateItemPlacement(),
+                        modifier = Modifier.clickable { it.onClick() }.thenIf(animateItems) { animateItem() },
                    )
                }
            }
@@ -345,3 +316,5 @@ fun wrapTagKeyword(keyword: String, translate: Boolean = false): String {
        }
    }
 }
+
+private val WhitespaceRegex = Regex("\\s+")