Release 1.8.3.0

Just stop spamming for something like "I can install", If U still can't install then please SMASH YOUR DEVICE OR REPLACE YOUR GODDAMN SYSTEM
Nullability checks
2022-11-21 16:48:50 +08:00 · 2022-11-21 12:15:23 +08:00 · 2022-11-21 12:11:35 +08:00 · 2022-11-20 21:06:11 +08:00 · 2022-11-20 20:57:16 +08:00 · 2022-11-20 19:18:43 +08:00
641 changed files with 40154 additions and 33187 deletions
@@ -1,20 +0,0 @@
---
-name: 功能申请 / Feature request
-about: 有个想法 / Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
-
---
-
-**这个功能是用来解决问题的吗？ / Is your feature request related to a problem? Please describe.**
-描述这个问题。
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**描述你想要的解决方法 / Describe the solution you'd like**
-描述应通过何种行为来解决这个问题。
-A clear and concise description of what you want to happen.
-
-**备注 / Additional context**
-还有别的想说的吗？
-Add any other context or screenshots about the feature request here.
@@ -1,41 +0,0 @@
---
-name: Bug 反馈 / Bug report
-about: 出问题了 / Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
---
-
-**简略描述 / Describe the bug**
-大概说下是什么问题。
-A clear and concise description of what the bug is.
-
-**如何重现 / To Reproduce**
-重现的步骤：
-1. 打开什么什么
-2. 点击什么什么
-3. 出现什么什么问题
-Steps to reproduce the behavior:
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**预期行为 / Expected behavior**
-应该是什么样子的？
-A clear and concise description of what you expected to happen.
-
-**截图 / Screenshots**
-能截图的话就发截图，请注意风序良俗。
-If applicable, add screenshots to help explain your problem.
-
-**设备型号与 Android 版本 / Device model and Android version**
- - 设备型号：【比如 Pixel 6 XXXL】
- - Android 版本：【比如 Android 12.1】
- - Device model: [e.g. Pixel 6 XXXL]
- - Android version: [e.g. Android 12.1]
-
-**备注 / Additional context**
-还有什么想说的？
-Add any other context about the problem here.
@@ -0,0 +1,144 @@
+name: Bug 反馈 / Bug report
+description: 提交一个问题报告 / Create a bug report
+labels:
+  - "bug"
+body:
+  - type: markdown
+    attributes:
+      value: |
+        感谢您愿意为 Ehviewer-Overhauled 做出贡献！
+        提交问题报告前，还请首先完成文末的自查步骤
+
+        Thanks for your contribution on Ehviewer-Overhauled Project!
+        Please finish verify steps which list in the end first before create bug report
+
+  - type: textarea
+    id: reproduce
+    attributes:
+      label: 复现步骤 / Step to reproduce
+      description: |
+        在此处写下复现的方式
+        Describe how to reproduce here
+      placeholder: |
+        1.
+        2.
+        3.
+    validations:
+      required: true
+
+  - type: textarea
+    id : expected
+    attributes:
+      label: 预期行为 / Expected behaviour
+      description: |
+        在此处说明正常情况下应用的预期行为
+        Describe what should happened here
+      placeholder: |
+        它应该XXX...
+        It should be ...
+    validations:
+      required: true
+
+  - type: textarea
+    id: actual
+    attributes:
+      label: 实际行为 / Actual Behaviour
+      description: |
+        在此处描绘应用的实际行为，最好附上截图
+        Describe what actually happened here, screenshots is better
+      placeholder: |
+        实际上它XXX...
+        Actually it ...
+        [截图] / [Screenshots]
+    validations:
+      required: true
+
+  - type: textarea
+    id: more
+    attributes:
+      label: 备注 / Addition details
+      description: |
+        在此处写下其他您想说的内容
+        Describe addition details here
+      placeholder: |
+        其他有用的信息与附件
+        Additional details and attachments
+    validations:
+      required: false
+
+  - type: input
+    id: version
+    attributes:
+      label: EhViewer 版本号 / EhViewer version code
+      description: 您可以在设置 - 关于处找到版本号 / You can get version code in Settings - About
+      placeholder: 1.6.9.13
+    validations:
+      required: true
+
+  - type: input
+    id: ci
+    attributes:
+      label: EhViewer CI 版本 / EhViewer CI Version
+      description: 直接将对应 GitHub Action CI 下载页面网址填入即可 / Simply drop GitHub Action CI download page url here
+      placeholder: https://github.com/Ehviewer-Overhauled/Ehviewer/actions/runs/XXXXXXXXXX
+    validations:
+      required: true
+
+  - type: input
+    id: system
+    attributes:
+      label: Android 系统版本 / Android version
+      description: Android 分支名称 + 版本号 / AOSP fork name + version code
+      placeholder: MIUI 12.5, ArrowOS 12.1
+    validations:
+      required: true
+
+  - type: input
+    id: device
+    attributes:
+      label: 设备型号 / Device model
+      description: 在此填入设备型号 / Put device model here
+      placeholder: OnePlus 7 Pro, Xiaomi 12 Ultra
+    validations:
+      required: true
+
+  - type: input
+    id: SoC
+    attributes:
+      label: SoC 型号 / Soc model
+      description: 在此填入 SoC 型号 / Put Soc model here
+      placeholder: 骁龙 8+ Gen 1, Snapdragon 8+ Gen 1
+    validations:
+      required: true
+
+  - type: textarea
+    id: log
+    attributes:
+      label: 应用日志 / App logs
+      description: 您可以通过设置-高级-导出日志来获得日志文件 / You can get logs file in Settings - Advanced - Dump logcat
+      placeholder: 06-15 17:44:53.704 23382 23382 E ...
+    validations:
+      required: true
+
+  - type: checkboxes
+    id: check
+    attributes:
+      label: 自查步骤 / Verify steps
+      description: |
+        请确认您已经遵守所有必选项
+        Please ensure you have obtained all needed options
+      options:
+      - label: 如果您有足够的时间和能力，并愿意为此提交 PR ，请勾上此复选框 / Pull request is welcome. Check this if you want to start a pull request
+        required: false
+
+      - label: 您已仔细查看并知情 [Q&A](https://github.com/Ehviewer-Overhauled/Ehviewer/issues/61) 中的内容 / You have checked [Q&A](https://github.com/Ehviewer-Overhauled/Ehviewer/issues/61) carefully
+        required: true
+
+      - label: 您已搜索过 [Issue Tracker](https://github.com/Ehviewer-Overhauled/Ehviewer/issues)，没有找到类似内容 / I have searched on [Issue Tracker](https://github.com/Ehviewer-Overhauled/Ehviewer/issues), No duplicate or related open issue has been found
+        required: true
+
+      - label: 您确保这个 Issue 只提及一个问题。如果您有多个问题报告，烦请发起多个 Issue / Ensure there is only one bug report in this issue. Please make mutiply issue for mutiply bugs
+        required: true
+
+      - label: 您确保已使用最新 CI 版本测试，并且该问题在最新 CI 版本中并未解决 / This bug have not solved in latest CI version
+        required: true
@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+ - name: 所有其他问题 / All other questions
+   url: https://github.com/Ehviewer-Overhauled/Ehviewer/discussions
+   about: 转到 Discussions / Turn to discussions
@@ -0,0 +1,94 @@
+name: 功能请求 / Feature request
+description: 提出一个功能建议 / Suggest an idea
+labels:
+  - "enhancement"
+body:
+  - type: markdown
+    attributes:
+      value: |
+        感谢您愿意为 Ehviewer-Overhauled 做出贡献！
+        提交功能建议前，还请首先完成文末的自查步骤
+
+        Thanks for your contribution on Ehviewer-Overhauled Project!
+        Please finish verify steps which list in the end first before suggest an idea
+
+  - type: textarea
+    id: request
+    attributes:
+      label: 需求 / Requirement
+      description: |
+        在此处描述您的需求。这通常会是一个您想要的功能
+        Ddescribe what you need here.
+      placeholder: |
+          我需要 XXX 功能 ...
+          I want ABC feature ...
+    validations:
+      required: true
+
+  - type: textarea
+    id: impl
+    attributes:
+      label: 建议实现 / Suggested implements
+      description: |
+        在此处表述您建议的实现方式。如有可能，UI 类功能请求还请尽量附上图示
+        Describe your suggested implements here, It's recommend to add a photo if you are making a UI feature request.
+      placeholder: |
+          建议在 XX 处添加 XX ...
+          I recommend add ABC feature to DEF...
+          图片（如果有）/ Photos (if exists)
+    validations:
+      required: true
+
+  - type: textarea
+    id: more
+    attributes:
+      label: 备注 / Addition details
+      description: |
+        在此处写下其他您想说的内容
+        Describe addition details here
+      placeholder: |
+        其他有用的信息与附件
+        Additional details and attachments
+    validations:
+      required: false
+
+  - type: input
+    id: version
+    attributes:
+      label: EhViewer 版本号 / EhViewer version code
+      description: 您可以在设置 - 关于处找到版本号 / You can get version code in Settings - About
+      placeholder: 1.6.9.13
+    validations:
+      required: true
+
+  - type: input
+    id: ci
+    attributes:
+      label: EhViewer CI 版本 / EhViewer CI Version
+      description: 直接将对应 GitHub Action CI 下载页面网址填入即可 / Simply drop GitHub Action CI download page url here
+      placeholder: https://github.com/Ehviewer-Overhauled/Ehviewer/actions/runs/XXXXXXXXXX
+    validations:
+      required: true
+
+  - type: checkboxes
+    id: check
+    attributes:
+      label: 自查步骤 / Verify steps
+      description: |
+        请确认您已经遵守所有必选项
+        Please ensure you have obtained all needed options
+      options:
+      - label: 如果您有足够的时间和能力，并愿意为此提交 PR ，请勾上此复选框 / Pull request is welcome. Check this if you want to start a pull request
+        required: false
+
+      - label: 您已仔细查看并知情 [Q&A](https://github.com/Ehviewer-Overhauled/Ehviewer/issues/61) 中的内容 / You have checked [Q&A](https://github.com/Ehviewer-Overhauled/Ehviewer/issues/61) carefully
+        required: true
+
+      - label: 您已搜索过 [Issue Tracker](https://github.com/Ehviewer-Overhauled/Ehviewer/issues)，没有找到类似内容 / I have searched on [Issue Tracker](https://github.com/Ehviewer-Overhauled/Ehviewer/issues), No duplicate or related open issue has been found
+        required: true
+
+      - label: 您确保这个 Issue 只提及一个功能。如果您有多个功能请求，烦请发起多个 Issue / Ensure there is only one feature request in this issue. Please make mutiply issue for mutiply feature request
+        required: true
+
+      - label: 您确保已使用最新 CI 版本测试，并且该功能在最新 CI 版本中并未按照预期实现 / This feature don't implement correctly in latest CI version
+        required: true
@@ -1,11 +0,0 @@
---
-name: Sad Panda / 下载太慢 / Slow download speed
-about: 所有其他问题 / All other questions
-title: ''
-labels: ''
-assignees: ''
-
---
-
-加入我们的 Telegram 群组，[https://t.me/ehviewer](https://t.me/ehviewer)。温柔[大小]姐姐手把手帮你解决问题。
-Join our Telegram group, [https://t.me/ehviewer](https://t.me/ehviewer). Administrators will help you solve the problem.
@@ -1,57 +0,0 @@
-name: EhViewer
-
-on: 
- push:
-    branches:
-    - master
-
-jobs:
-  linux:
-    name: Build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: set up JDK 1.8
-        uses: actions/setup-java@v1
-        with:
-          java-version: 1.8
-      - uses: actions/cache@v1
-        with:
-          path: ~/.gradle/caches
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
-          restore-keys: |
-            ${{ runner.os }}-gradle-
-      - name: Build
-        env:
-          KEYSTORE_PASS: ${{ secrets.KEYSTORE_PASS }}
-          ALIAS_NAME: ${{ secrets.ALIAS_NAME }}
-          ALIAS_PASS: ${{ secrets.ALIAS_PASS }}
-        run: |
-          ./gradlew assembleRelease
-          echo ::set-env name=APK_FILE::$(find app/build/outputs/apk -name "*.apk")
-      - name: Create Release
-        id: create_release
-        uses: actions/create-release@latest
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
-        with:
-          tag_name: 1.7.4_${{ github.run_id }}
-          release_name: 1.7.4_${{ github.run_id }}
-          body: ""
-          draft: false
-          prerelease: true
-      - name: Upload Release Asset
-        id: upload-release-asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }} # This pulls from the CREATE RELEASE step above, referencing it's ID to get its outputs object, which include a `upload_url`. See this blog post for more info: https://jasonet.co/posts/new-features-of-github-actions/#passing-data-to-future-steps
-          asset_path: ${{ env.APK_FILE }}
-          asset_name: app-release.apk
-          asset_content_type: application/vnd.android.package-archive
-      - uses: actions/upload-artifact@master
-        name: Upload artifact
-        with:
-          name: EhViewer
-          path: app/build/outputs/
@@ -0,0 +1,58 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - '*'
+    tags-ignore:
+      - "*"
+
+jobs:
+  linux:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          submodules: 'recursive'
+
+      - name: Setup Java 19
+        uses: actions/setup-java@v3
+        with:
+          distribution: temurin
+          java-version: 19
+
+      - name: Install NDK
+        run: |
+          echo "y" | sudo ${ANDROID_HOME}/tools/bin/sdkmanager --install "ndk;25.1.8937393" --sdk_root=${ANDROID_SDK_ROOT} &> /dev/null
+
+      - name: Gradle Build
+        uses: gradle/gradle-build-action@v2
+        with:
+          gradle-home-cache-cleanup: true
+          arguments: assembleRelease
+
+      - name: Update ARM64
+        uses: actions/upload-artifact@v3
+        with:
+          name: arm64-v8a-${{ github.sha }}
+          path: app/build/outputs/apk/release/app-arm64-v8a-release.apk
+
+      - name: Update x86_64
+        uses: actions/upload-artifact@v3
+        with:
+          name: x86_64-${{ github.sha }}
+          path: app/build/outputs/apk/release/app-x86_64-release.apk
+
+      - name: Update ARM32
+        uses: actions/upload-artifact@v3
+        with:
+          name: armeabi-v7a-${{ github.sha }}
+          path: app/build/outputs/apk/release/app-armeabi-v7a-release.apk
+
+      - name: Update x86
+        uses: actions/upload-artifact@v3
+        with:
+          name: x86-${{ github.sha }}
+          path: app/build/outputs/apk/release/app-x86-release.apk
@@ -0,0 +1,52 @@
+name: Pull Request Check
+
+on: [pull_request]
+
+jobs:
+  linux:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          submodules: 'recursive'
+
+      - name: Setup Java 19
+        uses: actions/setup-java@v3
+        with:
+          distribution: temurin
+          java-version: 19
+
+      - name: Install NDK
+        run: |
+          echo "y" | sudo ${ANDROID_HOME}/tools/bin/sdkmanager --install "ndk;25.1.8937393" --sdk_root=${ANDROID_SDK_ROOT} &> /dev/null
+
+      - name: Gradle Build
+        uses: gradle/gradle-build-action@v2
+        with:
+          arguments: assembleRelease
+
+      - name: Update ARM64
+        uses: actions/upload-artifact@v3
+        with:
+          name: arm64-v8a-${{ github.sha }}
+          path: app/build/outputs/apk/release/app-arm64-v8a-release.apk
+
+      - name: Update x86_64
+        uses: actions/upload-artifact@v3
+        with:
+          name: x86_64-${{ github.sha }}
+          path: app/build/outputs/apk/release/app-x86_64-release.apk
+
+      - name: Update ARM32
+        uses: actions/upload-artifact@v3
+        with:
+          name: armeabi-v7a-${{ github.sha }}
+          path: app/build/outputs/apk/release/app-armeabi-v7a-release.apk
+
+      - name: Update x86
+        uses: actions/upload-artifact@v3
+        with:
+          name: x86-${{ github.sha }}
+          path: app/build/outputs/apk/release/app-x86-release.apk
@@ -0,0 +1,71 @@
+name: Releases
+
+on:
+  push:
+    tags:
+      - "*"
+
+jobs:
+  linux:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          submodules: 'recursive'
+
+      - name: Setup Java 19
+        uses: actions/setup-java@v3
+        with:
+          distribution: temurin
+          java-version: 19
+
+      - name: Install NDK
+        run: |
+          echo "y" | sudo ${ANDROID_HOME}/tools/bin/sdkmanager --install "ndk;25.1.8937393" --sdk_root=${ANDROID_SDK_ROOT} &> /dev/null
+
+      - name: Gradle Build
+        uses: gradle/gradle-build-action@v2
+        with:
+          arguments: assembleRelease
+
+      - name: Rename Apks
+        run: |
+          cp app/build/outputs/apk/release/app-universal-release.apk app/build/outputs/apk/release/EhViewer-universal-A12+.apk
+          cp app/build/outputs/apk/release/app-arm64-v8a-release.apk app/build/outputs/apk/release/EhViewer-arm64-v8a-A12+.apk
+          cp app/build/outputs/apk/release/app-x86_64-release.apk app/build/outputs/apk/release/EhViewer-x86_64-A12+.apk
+          cp app/build/outputs/apk/release/app-x86-release.apk app/build/outputs/apk/release/EhViewer-x86-A12+.apk
+          cp app/build/outputs/apk/release/app-armeabi-v7a-release.apk app/build/outputs/apk/release/EhViewer-armeabi-v7a-A12+.apk
+
+      - name: Releases
+        uses: softprops/action-gh-release@v1
+        with:
+          body: Bump Version
+          discussion_category_name: Announcements
+          files: |
+            app/build/outputs/apk/release/EhViewer-universal-A12+.apk
+            app/build/outputs/apk/release/EhViewer-arm64-v8a-A12+.apk
+            app/build/outputs/apk/release/EhViewer-x86_64-A12+.apk
+            app/build/outputs/apk/release/EhViewer-x86-A12+.apk
+            app/build/outputs/apk/release/EhViewer-armeabi-v7a-A12+.apk
+
+      - name: Collect Apks
+        run: |
+          mkdir app/build/outputs/apk/release/fdroid
+          cp app/build/outputs/apk/release/app-arm64-v8a-release.apk app/build/outputs/apk/release/fdroid/EhViewer-v$GITHUB_REF_NAME.apk
+          cp app/build/outputs/apk/release/app-armeabi-v7a-release.apk app/build/outputs/apk/release/fdroid/EhViewer-v$GITHUB_REF_NAME-armv7.apk
+
+      - name: Push Apks
+        uses: cpina/github-action-push-to-another-repository@v1.5
+        env:
+         SSH_DEPLOY_KEY: ${{ secrets.SSH_DEPLOY_KEY }}
+        with:
+          source-directory: app/build/outputs/apk/release/fdroid
+          destination-github-username: Ehviewer-Overhauled
+          destination-repository-name: fdroid-repo
+          user-name: 'github-actions[bot]'
+          user-email: 'github-actions[bot]@users.noreply.github.com'
+          target-branch: deploy
+          commit-message: Add apks from $GITHUB_REF
+          target-directory: fdroid/tmp-apks
@@ -1,12 +1,9 @@
-[submodule "native/src/main/jni/a7zip/p7zip/p7zip"]
-	path = native/src/main/jni/a7zip/p7zip/p7zip
-	url = https://github.com/seven332/p7zip.git
-[submodule "native/src/main/jni/image/libjpeg-turbo/libjpeg-turbo"]
-	path = native/src/main/jni/image/libjpeg-turbo/libjpeg-turbo
-	url = https://gitlab.com/NekoInverter/libjpeg-turbo.git
-[submodule "native/src/main/jni/image/giflib/giflib"]
-	path = native/src/main/jni/image/giflib/giflib
-	url = https://gitlab.com/NekoInverter/giflib.git
-[submodule "native/src/main/jni/image/libpng/libpng"]
-	path = native/src/main/jni/image/libpng/libpng
-	url = https://gitlab.com/NekoInverter/libpng.git
+[submodule "app/src/main/cpp/libarchive"]
+	path = app/src/main/cpp/libarchive
+	url = https://github.com/Ehviewer-Overhauled/libarchive
+[submodule "app/src/main/cpp/liblzma"]
+	path = app/src/main/cpp/liblzma
+	url = https://github.com/Ehviewer-Overhauled/xz
+[submodule "app/src/main/cpp/nettle/nettle"]
+	path = app/src/main/cpp/nettle/nettle
+	url = https://github.com/Ehviewer-Overhauled/nettle
@@ -1,202 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007

-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.

-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+                            Preamble

-   1. Definitions.
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.

-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.

-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.

-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.

-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.

-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.

-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.

-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.

-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.

-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
+  The precise terms and conditions for copying, distribution and
+modification follow.

-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
+                       TERMS AND CONDITIONS

-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
+  0. Definitions.

-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
+  "This License" refers to version 3 of the GNU General Public License.

-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.

-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.

-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.

-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
+  A "covered work" means either the unmodified Program or a work based
+on the Program.

-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.

-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.

-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.

-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
+  1. Source Code.

-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.

-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.

-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.

-   END OF TERMS AND CONDITIONS
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.

-   APPENDIX: How to apply the Apache License to your work.
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.

-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
+  The Corresponding Source for a work in source code form is that
+same work.

-   Copyright [yyyy] [name of copyright owner]
+  2. Basic Permissions.

-   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
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.

-       http://www.apache.org/licenses/LICENSE-2.0
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.

-   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.
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.
@@ -1,57 +1,108 @@
-### [下载](https://install.appcenter.ms/users/nekoinverter/apps/ehviewer/distribution_groups/public)
+<p align="right">
+  <strong>English<strong>
+  <span> | </span>
+  <a href="https://github.com/Ehviewer-Overhauled/Ehviewer/blob/1.8.x.x/docs/README/zh-cn.md">
+  简体中文
+  </a>
+  <span> | <span>
+  <a href="https://github.com/Ehviewer-Overhauled/Ehviewer/blob/1.8.x.x/docs/README/zh-tw.md">
+  正體中文
+  </a>
+</p>

-[Download](https://install.appcenter.ms/users/nekoinverter/apps/ehviewer/distribution_groups/public)
+<h1 align="center">
+  <img src="art/launcher_icon-web.svg" width="200">
+  <br>EhViewer<br>
+</h1>

-# EhViewer
+<p align="center">
+  <a href="https://github.com/Ehviewer-Overhauled/Ehviewer/actions/workflows/ci.yml">
+    <img src="https://github.com/Ehviewer-Overhauled/Ehviewer/actions/workflows/ci.yml/badge.svg" alt="Github Actions">
+  </a>
+  <a href="https://github.com/Ehviewer-Overhauled/Ehviewer/blob/1.8.x.x/LICENSE">
+    <img src="https://img.shields.io/github/license/Ehviewer-Overhauled/Ehviewer" alt="LICENSE">
+  </a>
+  <a href="https://www.codefactor.io/repository/github/Ehviewer-Overhauled/ehviewer">
+    <img src="https://www.codefactor.io/repository/github/Ehviewer-Overhauled/ehviewer/badge" alt="CodeFactor">
+  </a>
+  <a href="https://github.com/Ehviewer-Overhauled/Ehviewer/releases">
+    <img src="https://img.shields.io/github/v/release/Ehviewer-Overhauled/ehviewer?include_prereleases" alt="Release">
+  </a>
+  <a href="https://github.com/Ehviewer-Overhauled/Ehviewer/issues">
+    <img src="https://img.shields.io/github/issues/Ehviewer-Overhauled/ehviewer" alt="Issues">
+  </a>
+</p>

-![Icon](art/launcher_icon-web.png)
+<div align="center">
+  <h3>
+    <a href="https://github.com/Ehviewer-Overhauled/Ehviewer#description">
+    Description
+    </a>
+    <span> | </span>
+    <a href="https://github.com/Ehviewer-Overhauled/Ehviewer#download">
+    Download
+    </a>
+    <span> | </span>
+    <a href="https://github.com/Ehviewer-Overhauled/Ehviewer#screenshot">
+    Screenshot
+    </a>
+    <span> | </span>
+    <a href="https://github.com/Ehviewer-Overhauled/Ehviewer#thanks">
+    Thanks
+    </a>
+    <span> | </span>
+    <a href="https://github.com/Ehviewer-Overhauled/Ehviewer#license">
+    License
+    </a>
+  </h3>
+</div>

-这是一个 E-Hentai Android 平台的浏览器。

-An E-Hentai Application for Android.
+# Description

+EhViewer fork dedicated to lightweight and high-performance
+
+with Material Design 3 and Dynamic Color Support
+
+Maintained by Tarsin Norbin aka 飛鳥澪 (asuka-mio)
+
+Also thanks @txyyh for her help in docs, release notes, design and 1.7.x.x maintenance
+
+# Download
+
+<a href="https://github.com/Ehviewer-Overhauled/Ehviewer/releases"><img alt="Get it on GitHub" src="art/get-it-on-github.svg" width="200px"/></a> <a href="https://github.com/Ehviewer-Overhauled/fdroid-repo"><img alt="Git it on F-Droid" src="art/get-it-on-fdroid.svg" width="200px"/></a>
+
+There are two development branches: 1.8.x.x and 1.7.x.x . Version 1.8 only support platform api 31 (aka Android S) and above, also the develop mainline. Version 1.7 should only be used on Android 11 and below, since these platforms lack native api of image decoding.

 # Screenshot

 ![screenshot-01](art/screenshot-01.png)
-
+![screenshot-02](art/screenshot-02.png)

 # Thanks

-本项目受到了诸多开源项目的帮助
-
 Here is the libraries

- [AOSP](http://source.android.com/)
- [android-advancedrecyclerview](https://github.com/h6ah4i/android-advancedrecyclerview)
- [Apache Commons Lang](https://commons.apache.org/proper/commons-lang/)
- [apng](http://apng.sourceforge.net/)
- [giflib](http://giflib.sourceforge.net)
- [greenDAO](https://github.com/greenrobot/greenDAO)
+- [AOSP & AndroidX](http://source.android.com/)
+- [FullDraggableDrawer](https://github.com/PureWriter/FullDraggableDrawer)
+- [GnuTLS](https://gnutls.org/)
+- [material-components-android](https://github.com/material-components/material-components-android)
+- [material-design-icons](https://github.com/google/material-design-icons)
 - [jsoup](https://github.com/jhy/jsoup)
- [libjpeg-turbo](http://libjpeg-turbo.virtualgl.org/)
- [libpng](http://www.libpng.org/pub/png/libpng.html)
 - [okhttp](https://github.com/square/okhttp)
- [roaster](https://github.com/forge/roaster)
- [ShowcaseView](https://github.com/amlcurran/ShowcaseView)
- [Slabo](https://github.com/TiroTypeworks/Slabo)
- [TagSoup](http://home.ccil.org/~cowan/tagsoup/)
+- [RikkaX](https://github.com/RikkaApps/RikkaX)
+- [libarchive](http://www.libarchive.org/)
+- [XZ Utils](https://tukaani.org/xz/)


 # License

-    Copyright (C) 2014-2019 Hippo Seven
+    Copyright 2014-2019 Hippo Seven
+    Copyright 2020-2022 NekoInverter
+    Copyright 2022 Tarsin Norbin

-    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
+    EhViewer is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

-        http://www.apache.org/licenses/LICENSE-2.0
+    EhViewer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

-    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.
-
-ic_launcher 图标为 Hippo Seven 所有，所有权利保留
+    You should have received a copy of the GNU General Public License along with EhViewer. If not, see <https://www.gnu.org/licenses/>.
@@ -4,4 +4,5 @@ manifest-merger-release-report.txt
 /src/main/libs
 /src/main/obj
 # Intellij
-*.iml
+*.iml
+/.cxx
@@ -1,53 +1,58 @@
 plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
-    id 'kotlin-kapt'
+    id 'com.google.devtools.ksp'
 }

 android {
-    compileSdkVersion 32
-    buildToolsVersion "32.0.0"
-
-    Properties localProperties = new Properties()
-    if (project.rootProject.file('local.properties').exists()) {
-        localProperties.load(project.rootProject.file('local.properties').newDataInputStream())
-    }
+    compileSdkVersion 33
+    buildToolsVersion "33.0.0"
+    ndkVersion "25.1.8937393"

    splits {
        abi {
            enable = true
            reset()
-            include 'arm64-v8a', 'x86_64'
+            include 'arm64-v8a', 'x86_64', 'armeabi-v7a', 'x86'
+            universalApk = true
        }
    }

    signingConfigs {
-        if (localProperties.getProperty("storeFile") != null) {
-            sign {
-                storeFile file(localProperties.getProperty("storeFile"))
-                storePassword localProperties.getProperty("storePassword")
-                keyAlias localProperties.getProperty("keyAlias")
-                keyPassword localProperties.getProperty("keyPassword")
-            }
+        sign {
+            storeFile file(signStoreFile)
+            storePassword signStorePassword
+            keyAlias signkeyAlias
+            keyPassword signkeyPassword
        }
    }

    defaultConfig {
-        applicationId "io.github.nekoinverter.ehviewer"
-        minSdkVersion 31
-        targetSdkVersion 32
-        versionCode 114516
-        versionName "1.7.26.7"
+        applicationId "moe.tarsin.ehviewer"
+        minSdkVersion 28
+        targetSdkVersion 33
+        versionCode 180021
+        versionName "1.8.3.0"
        resConfigs 'zh', 'zh-rCN', 'zh-rHK', 'zh-rTW', 'es', 'ja', 'ko', 'fr', 'de', 'th'
    }

+    externalNativeBuild {
+        cmake {
+            path 'src/main/cpp/CMakeLists.txt'
+        }
+    }
+
    compileOptions {
-        sourceCompatibility JavaVersion.VERSION_11
-        targetCompatibility JavaVersion.VERSION_11
+        sourceCompatibility JavaVersion.VERSION_19
+        targetCompatibility JavaVersion.VERSION_19
    }

    kotlinOptions {
-        jvmTarget = '11'
+        jvmTarget = '19'
+        freeCompilerArgs += [
+                "-P",
+                "plugin:androidx.compose.compiler.plugins.kotlin:suppressKotlinVersionCompatibilityCheck=true"
+        ]
    }

    lint {
@@ -72,83 +77,122 @@ android {
            minifyEnabled true
            shrinkResources true
            proguardFiles 'proguard-rules.pro'
-            if (localProperties.getProperty("storeFile") != null) {
-                signingConfig signingConfigs.sign
-            }
+            signingConfig signingConfigs.sign
        }
        debug {
            applicationIdSuffix ".debug"
-            if (localProperties.getProperty("storeFile") != null) {
-                signingConfig signingConfigs.sign
-            } else {
-                signingConfig signingConfigs.debug
-            }
+            signingConfig signingConfigs.debug
        }
    }

-    sourceSets {
-        main {
-            java.srcDirs += 'src/main/java-gen'
-        }
+    buildFeatures {
+        compose true
    }
+
+    composeOptions {
+        kotlinCompilerExtensionVersion = "1.4.0-alpha02"
+    }
+
    namespace 'com.hippo.ehviewer'
 }

-tasks.withType(JavaCompile) {
-    task -> task.dependsOn ":daogenerator:executeDaoGenerator"
-}
-
 dependencies {
-    implementation 'androidx.activity:activity:1.4.0'
-    implementation 'androidx.biometric:biometric:1.1.0'
-    implementation 'androidx.browser:browser:1.4.0'
-    implementation 'androidx.core:core:1.7.0'
-    implementation 'androidx.dynamicanimation:dynamicanimation:1.1.0-alpha03'
-    implementation 'androidx.fragment:fragment:1.4.1'
+    def activity_version = "1.6.1"
+    implementation "androidx.activity:activity:$activity_version"
+    implementation "androidx.activity:activity-ktx:$activity_version"
+
+    implementation "androidx.annotation:annotation:1.5.0"
+    implementation "androidx.annotation:annotation-experimental:1.3.0"
+    implementation "androidx.appcompat:appcompat:1.6.0-rc01"
+
+    def arch_core_version = "2.1.0"
+    implementation "androidx.arch.core:core-common:$arch_core_version"
+    implementation "androidx.arch.core:core-runtime:$arch_core_version"
+
+    implementation "androidx.biometric:biometric-ktx:1.2.0-alpha05"
+    implementation "androidx.browser:browser:1.4.0"
+
+    def collection_version = "1.3.0-alpha02"
+    implementation "androidx.collection:collection:$collection_version"
+    implementation "androidx.collection:collection-ktx:$collection_version"
+
+    def compose_version = "1.3.1"
+    implementation "androidx.compose.animation:animation:$compose_version"
+    implementation "androidx.compose.foundation:foundation:$compose_version"
+    implementation "androidx.compose.foundation:foundation-layout:$compose_version"
+    implementation "androidx.compose.runtime:runtime:$compose_version"
+    implementation "androidx.compose.runtime:runtime-saveable:$compose_version"
+    implementation "androidx.compose.ui:ui:$compose_version"
+
+    implementation "androidx.compose.material3:material3:1.0.1"
+
+    implementation "androidx.constraintlayout:constraintlayout:2.2.0-alpha04"
+    implementation "androidx.coordinatorlayout:coordinatorlayout:1.2.0"
+
+    def core_version = "1.9.0"
+    implementation "androidx.core:core:$core_version"
+    implementation "androidx.core:core-ktx:$core_version"
+
+    implementation "androidx.customview:customview:1.2.0-alpha02"
+    implementation "androidx.dynamicanimation:dynamicanimation:1.1.0-alpha03"
+
+    def fragment_version = "1.6.0-alpha03"
+    implementation "androidx.fragment:fragment:$fragment_version"
+    implementation "androidx.fragment:fragment-ktx:$fragment_version"
+
+    def lifecycle_version = "2.6.0-alpha03"
+    implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
+    implementation "androidx.lifecycle:lifecycle-livedata-core-ktx:$lifecycle_version"
+    implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"
+    implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"
+    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
+    implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"
+
+    implementation "androidx.loader:loader:1.1.0"
+
+    def nav_version = "2.5.3"
+    implementation "androidx.navigation:navigation-fragment:$nav_version"
+    implementation "androidx.navigation:navigation-ui:$nav_version"
+    implementation "androidx.navigation:navigation-fragment-ktx:$nav_version"
+    implementation "androidx.navigation:navigation-ui-ktx:$nav_version"
+
+    implementation "androidx.paging:paging-runtime:3.2.0-alpha03"
+
    implementation 'androidx.preference:preference:1.2.0'
-    implementation 'androidx.recyclerview:recyclerview:1.2.1'
+    implementation 'androidx.recyclerview:recyclerview:1.3.0-rc01'
+
+    def room_version = "2.5.0-beta02"
+    implementation "androidx.room:room-runtime:$room_version"
+    annotationProcessor "androidx.room:room-compiler:$room_version"
+    implementation "androidx.room:room-paging:$room_version"
+
+    implementation 'androidx.startup:startup-runtime:1.2.0-alpha01'
    implementation 'androidx.swiperefreshlayout:swiperefreshlayout:1.2.0-alpha01'
-    implementation 'androidx.webkit:webkit:1.4.0'
+    implementation "androidx.transition:transition-ktx:1.4.1"
+    implementation "androidx.vectordrawable:vectordrawable:1.2.0-beta01"
+    implementation "androidx.vectordrawable:vectordrawable-animated:1.1.0"
+    implementation 'androidx.viewpager:viewpager:1.1.0-alpha01'
+    implementation 'androidx.viewpager2:viewpager2:1.1.0-beta01'
+    implementation 'androidx.webkit:webkit:1.5.0'
+
    implementation 'com.drakeet.drawer:drawer:1.0.3'
-    implementation 'com.google.android.material:material:1.6.0'
-    implementation 'com.getkeepsafe.taptargetview:taptargetview:1.13.3'
-    implementation 'com.github.seven332:beerbelly:0.1.4'
-    implementation 'com.github.seven332:glgallery:0.1.2'
-    implementation 'com.github.seven332:glview:0.1.0'
-    implementation 'com.github.seven332:glview-image:0.1.0'
-    implementation 'com.github.seven332:streampipe:0.1.0'
-    implementation 'com.github.seven332:tuxiang:0.1.6'
-    implementation 'com.github.seven332:unifile:9ec57bcd8f'
-    implementation 'com.github.seven332:yorozuya-thread:0.1.1'
-    implementation 'com.github.seven332:yorozuya-collect:0.1.4'
-    implementation 'com.h6ah4i.android.widget.advrecyclerview:advrecyclerview:1.0.0'
-    implementation 'com.squareup.okhttp3:okhttp:4.9.2'
-    implementation 'com.squareup.okhttp3:okhttp-dnsoverhttps:4.9.2'
-    implementation 'com.takisoft.preferencex:preferencex:1.1.0'
-    implementation 'com.gitlab.NekoInverter:yorozuya:723dc867a9'
-    implementation 'dev.rikka.rikkax.appcompat:appcompat:1.4.1'
-    implementation 'dev.rikka.rikkax.core:core:1.3.4'
-    implementation 'dev.rikka.rikkax.insets:insets:1.2.0'
+    implementation 'com.google.android.material:material:1.7.0'
+
+    implementation 'com.squareup.okhttp3:okhttp-bom:5.0.0-alpha.10'
+    implementation 'com.squareup.okhttp3:okhttp'
+    implementation 'com.squareup.okhttp3:okhttp-dnsoverhttps'
+
+    implementation 'dev.rikka.rikkax.core:core-ktx:1.4.1'
+    implementation 'dev.rikka.rikkax.insets:insets:1.3.0'
    implementation 'dev.rikka.rikkax.layoutinflater:layoutinflater:1.2.0'
-    implementation 'dev.rikka.rikkax.material:material:1.6.6'
-    implementation 'dev.rikka.rikkax.recyclerview:recyclerview-ktx:1.3.1'
-    implementation 'dev.rikka.rikkax.widget:borderview:1.1.0'
    implementation 'dev.rikka.rikkax.preference:simplemenu-preference:1.0.3'
-    implementation 'org.ccil.cowan.tagsoup:tagsoup:1.2.1'
-    implementation 'org.greenrobot:greendao:3.3.0'
-    implementation 'org.jsoup:jsoup:1.14.3'
-    implementation projects.native
+    implementation 'dev.rikka.rikkax.material:material-preference:2.0.0'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'
+    implementation 'org.jsoup:jsoup:1.15.3'
 }

 configurations.all {
-    resolutionStrategy {
-        force 'com.github.seven332:glgallery:25893283ca'
-        force 'com.github.seven332:glview:ba6aee61d7'
-        force 'com.github.seven332:glview-image:68d94b0fc2'
-
-        exclude group: 'com.github.seven332', module: 'okhttp'
-        exclude group: 'com.github.seven332', module: 'image'
-        exclude group: 'com.github.seven332', module: 'yorozuya'
-        exclude group: 'androidx.appcompat', module: 'appcompat'
-    }
+    exclude group: 'dev.rikka.rikkax.appcompat', module: 'appcompat'
+    exclude group: 'dev.rikka.rikkax.material', module: 'material'
+    exclude group: 'androidx.compose.material'
 }
@@ -7,28 +7,19 @@
    public static void throw*(...);
 }

-keep class com.hippo.ehviewer.ui.fragment.* extends com.hippo.ehviewer.ui.fragment.BaseFragment { }
-keep class com.hippo.ehviewer.ui.fragment.* extends com.hippo.ehviewer.ui.fragment.BasePreferenceFragment { }
+-keepclasseswithmembernames,includedescriptorclasses class * {
+    native <methods>;
+}
+
+-keep,allowoptimization class com.hippo.ehviewer.ui.fragment.* extends com.hippo.ehviewer.ui.fragment.BaseFragment { }
+-keep,allowoptimization class com.hippo.ehviewer.ui.fragment.* extends com.hippo.ehviewer.ui.fragment.BasePreferenceFragment { }

 -keepnames class com.hippo.ehviewer.ui.scene.* { }

-keep class com.hippo.ehviewer.dao.* { *; }
-
 -keepattributes SourceFile,LineNumberTable
+
 -renamesourcefileattribute
 -repackageclasses
 -allowaccessmodification
+-mergeinterfacesaggressively
 -overloadaggressively
-
-dontwarn net.sqlcipher.database.**
-dontwarn rx.**
-dontwarn org.conscrypt.ConscryptHostnameVerifier
-dontwarn org.conscrypt.Conscrypt$Version
-dontwarn org.bouncycastle.jsse.provider.BouncyCastleJsseProvider
-dontwarn org.bouncycastle.jsse.BCSSLSocket
-dontwarn org.openjsse.javax.net.ssl.SSLParameters
-dontwarn net.sqlcipher.Cursor
-dontwarn org.bouncycastle.jsse.BCSSLParameters
-dontwarn org.conscrypt.Conscrypt
-dontwarn org.openjsse.javax.net.ssl.SSLSocket
-dontwarn org.openjsse.net.ssl.OpenJSSE
@@ -14,16 +14,23 @@
  ~ limitations under the License.
 -->

-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">

+    <uses-feature
+        android:name="android.software.leanback"
+        android:required="false" />
+    <uses-feature
+        android:name="android.hardware.touchscreen"
+        android:required="false" />
+
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+
    <uses-permission
        android:name="android.permission.WRITE_EXTERNAL_STORAGE"
-        android:maxSdkVersion="28"
-        tools:ignore="ScopedStorage" />
+        android:maxSdkVersion="29" />

    <uses-feature
        android:glEsVersion="0x00020000"
@@ -34,18 +41,20 @@
        android:allowBackup="true"
        android:appCategory="image"
        android:dataExtractionRules="@xml/data_extraction_rules"
+        android:enableOnBackInvokedCallback="true"
        android:fullBackupContent="@xml/backup_scheme"
        android:hasFragileUserData="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:largeHeap="true"
+        android:localeConfig="@xml/locales_config"
        android:networkSecurityConfig="@xml/network_security_config"
        android:roundIcon="@mipmap/ic_launcher_round"
-        android:theme="@style/AppTheme"
-        tools:ignore="UnusedAttribute">
+        android:theme="@style/AppTheme">

        <activity
            android:name="com.hippo.ehviewer.ui.MainActivity"
+            android:banner="@mipmap/ic_leanback_banner"
            android:configChanges="screenSize"
            android:exported="true"
            android:launchMode="singleTask"
@@ -56,6 +65,11 @@
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>

+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LEANBACK_LAUNCHER" />
+            </intent-filter>
+
            <meta-data
                android:name="android.app.shortcuts"
                android:resource="@xml/shortcuts" />
@@ -91,8 +105,7 @@
            android:name="com.hippo.ehviewer.ui.GalleryActivity"
            android:configChanges="screenSize"
            android:exported="true"
-            android:launchMode="singleTask"
-            android:theme="@style/AppTheme.Gallery">
+            android:launchMode="singleTask">

            <intent-filter>
                <action android:name="android.intent.action.VIEW" />
@@ -110,35 +123,21 @@
                <data android:mimeType="application/x-7z-compressed" />
                <data android:mimeType="application/x-rar-compressed" />
                <data android:mimeType="application/x-zip-compressed" />
-            </intent-filter>
+                <data android:mimeType="application/x-tar" />
+                <data android:mimeType="application/x-xz" />
+                <data android:mimeType="application/gzip" />
+                <data android:mimeType="application/x-cbz" />
+                <data android:mimeType="application/x-cbr" />
+                <data android:mimeType="application/x-cbt" />
+                <data android:mimeType="application/x-cb7" />

-            <intent-filter>
-                <action android:name="android.intent.action.VIEW" />
-
-                <category android:name="android.intent.category.DEFAULT" />
-                <category android:name="android.intent.category.BROWSABLE" />
-
-                <data android:scheme="file" />
-                <data android:scheme="content" />
-                <data android:host="*" />
-                <data android:pathPattern=".*\\.7z" />
-                <data android:pathPattern=".*\\.rar" />
-                <data android:pathPattern=".*\\.zip" />
-            </intent-filter>
-
-            <intent-filter>
-                <action android:name="android.intent.action.VIEW" />
-
-                <category android:name="android.intent.category.DEFAULT" />
-                <category android:name="android.intent.category.BROWSABLE" />
-
-                <data android:scheme="file" />
-                <data android:scheme="content" />
-                <data android:host="*" />
-                <data android:mimeType="*/*" />
-                <data android:pathPattern=".*\\.7z" />
-                <data android:pathPattern=".*\\.rar" />
-                <data android:pathPattern=".*\\.zip" />
+                <!-- untested -->
+                <data android:mimeType="application/vnd.comicbook+zip" />
+                <data android:mimeType="application/vnd.comicbook-rar" />
+                <data android:mimeType="application/x-compressed-tar" />
+                <data android:mimeType="application/x-bzip-compressed-tar" />
+                <data android:mimeType="application/x-lzma-compressed-tar" />
+                <data android:mimeType="application/x-xz-compressed-tar" />
            </intent-filter>
        </activity>

@@ -148,6 +147,12 @@
            android:label="@string/settings"
            android:theme="@style/AppTheme" />

+        <activity
+            android:name="com.hippo.ehviewer.ui.SecurityActivity"
+            android:configChanges="screenSize"
+            android:label="@string/settings"
+            android:theme="@style/AppTheme" />
+
        <activity
            android:name="com.hippo.ehviewer.shortcuts.ShortcutsActivity"
            android:excludeFromRecents="true"
@@ -0,0 +1,50 @@
+project(ehviewer)
+cmake_minimum_required(VERSION 3.4.1)
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Ofast -fvisibility=hidden -fvisibility-inlines-hidden -ffunction-sections -fdata-sections -funroll-loops -flto=thin \
+           -mllvm -polly \
+           -mllvm -polly-run-dce \
+           -mllvm -polly-run-inliner \
+           -mllvm -polly-isl-arg=--no-schedule-serialize-sccs \
+           -mllvm -polly-ast-use-context \
+           -mllvm -polly-detect-keep-going \
+           -mllvm -polly-position=before-vectorizer \
+           -mllvm -polly-vectorizer=stripmine \
+           -mllvm -polly-detect-profitability-min-per-loop-insts=40 \
+           -mllvm -polly-invariant-load-hoisting")
+
+# Build GNUTLS libnettle
+add_subdirectory(nettle)
+
+# Configure libnettle support for libarchive
+include_directories(nettle)
+include_directories(.)
+set(HAVE_LIBNETTLE 1)
+set(HAVE_NETTLE_AES_H 1)
+set(HAVE_NETTLE_HMAC_H 1)
+set(HAVE_NETTLE_MD5_H 1)
+set(HAVE_NETTLE_PBKDF2_H 1)
+set(HAVE_NETTLE_RIPEMD160_H 1)
+set(HAVE_NETTLE_SHA_H 1)
+
+# Build liblzma
+add_subdirectory(liblzma)
+
+# Configure lzma support for libarchive
+include_directories(liblzma/src/liblzma/api)
+SET(HAVE_LIBLZMA 1)
+SET(HAVE_LZMA_H 1)
+SET(HAVE_LZMA_STREAM_ENCODER_MT 1)
+SET(HAVE_LZMADEC_H 1)
+SET(HAVE_LIBLZMADEC 1)
+
+# Configure libarchive link's static lib
+SET(LIBARCHIVE_CUSTOM_LIBS "liblzma" "nettle")
+
+# Build libarchive
+add_subdirectory(libarchive)
+
+# Build and link our app's native lib
+add_library(${PROJECT_NAME} SHARED archive.c image.c fdutils.c)
+target_include_directories(${PROJECT_NAME} PUBLIC libarchive/libarchive)
+target_link_libraries(${PROJECT_NAME} archive_static log jnigraphics GLESv2 -Wl,--gc-sections)
@@ -0,0 +1,363 @@
+/*
+ * Copyright 2022 Tarsin Norbin
+ *
+ * This file is part of EhViewer
+ *
+ * EhViewer is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * EhViewer is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * EhViewer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <pthread.h>
+#include <sys/mman.h>
+#include <syscall.h>
+
+#include <jni.h>
+#include <android/log.h>
+
+#include <archive.h>
+#include <archive_entry.h>
+
+#define LOG_TAG "libarchive_wrapper"
+
+#include "ehviewer.h"
+
+typedef struct {
+    int using;
+    int next_index;
+    struct archive *arc;
+    struct archive_entry *entry;
+} archive_ctx;
+
+pthread_mutex_t ctx_lock;
+static archive_ctx **ctx_pool;
+#define CTX_POOL_SIZE 20
+
+static bool need_encrypt = false;
+static char *passwd = NULL;
+static void *archiveAddr = NULL;
+static size_t archiveSize = 0;
+
+const char supportExt[9][6] = {
+        "jpeg",
+        "jpg",
+        "png",
+        "gif",
+        "webp",
+        "bmp",
+        "ico",
+        "wbmp",
+        "heif"
+};
+
+static inline int filename_is_playable_file(const char *name) {
+    const char *dotptr = strrchr(name, '.');
+    if (!dotptr++)
+        return false;
+    int i;
+    for (i = 0; i < 9; i++)
+        if (strcmp(dotptr, supportExt[i]) == 0)
+            return true;
+    return false;
+}
+
+static long archive_list_all_entries(archive_ctx *ctx) {
+    long count = 0;
+    while (archive_read_next_header(ctx->arc, &ctx->entry) == ARCHIVE_OK)
+        if (filename_is_playable_file(archive_entry_pathname(ctx->entry)))
+            count++;
+    if (!count)
+        LOGE("%s", archive_error_string(ctx->arc));
+    return count;
+}
+
+static void archive_release_ctx(archive_ctx *ctx) {
+    if (ctx) {
+        archive_read_close(ctx->arc);
+        archive_read_free(ctx->arc);
+        free(ctx);
+    }
+}
+
+static int archive_alloc_ctx(archive_ctx **ctxptr) {
+    archive_ctx *ctx;
+    int err;
+    ctx = calloc(1, sizeof(archive_ctx));
+    if (!ctx)
+        return -ENOMEM;
+    ctx->arc = archive_read_new();
+    ctx->using = 1;
+    if (!ctx->arc) {
+        free(ctx);
+        return -ENOMEM;
+    }
+    archive_read_support_format_tar(ctx->arc);
+    archive_read_support_format_7zip(ctx->arc);
+    archive_read_support_format_rar5(ctx->arc);
+    archive_read_support_format_zip(ctx->arc);
+    archive_read_support_filter_gzip(ctx->arc);
+    archive_read_support_filter_xz(ctx->arc);
+    archive_read_set_option(ctx->arc, "zip", "ignorecrc32", "1");
+    if (passwd)
+        archive_read_add_passphrase(ctx->arc, passwd);
+    err = archive_read_open_memory(ctx->arc, archiveAddr, archiveSize);
+    if (err) {
+        archive_read_free(ctx->arc);
+        free(ctx);
+        return err;
+    }
+    *ctxptr = ctx;
+    return 0;
+}
+
+static int archive_skip_to_index(archive_ctx *ctx, int index) {
+    assert(!(ctx->next_index > index));
+    while (archive_read_next_header(ctx->arc, &ctx->entry) == ARCHIVE_OK) {
+        if (!filename_is_playable_file(archive_entry_pathname(ctx->entry)))
+            continue;
+        if (ctx->next_index++ == index) {
+            return ctx->next_index - 1;
+        }
+    }
+    return ARCHIVE_FATAL;
+}
+
+static int archive_get_ctx(archive_ctx **ctxptr, int idx) {
+    int ret;
+    archive_ctx *ctx = NULL;
+    pthread_mutex_lock(&ctx_lock);
+    for (int i = 0; i < CTX_POOL_SIZE; i++) {
+        if (!ctx_pool[i])
+            continue;
+        if (ctx_pool[i]->using)
+            continue;
+        if (ctx_pool[i]->next_index > idx)
+            continue;
+        if (!ctx || ctx_pool[i]->next_index > ctx->next_index)
+            ctx = ctx_pool[i];
+        if (ctx->next_index == idx)
+            break;
+    }
+    if (ctx)
+        ctx->using = 1;
+    pthread_mutex_unlock(&ctx_lock);
+
+    if (!ctx) {
+        archive_ctx *victimCtx = NULL;
+        int victimIdx = 0;
+        int replace = 1;
+        ret = archive_alloc_ctx(&ctx);
+        if (ret)
+            return ret;
+        pthread_mutex_lock(&ctx_lock);
+        for (int i = 0; i < CTX_POOL_SIZE; i++) {
+            if (!ctx_pool[i]) {
+                ctx_pool[i] = ctx;
+                replace = 0;
+                break;
+            }
+            if (ctx_pool[i]->using)
+                continue;
+            if (!victimCtx || ctx_pool[i]->next_index > victimCtx->next_index) {
+                victimCtx = ctx_pool[i];
+                victimIdx = i;
+            }
+        }
+        if (replace) {
+            archive_release_ctx(victimCtx);
+            ctx_pool[victimIdx] = ctx;
+        }
+        pthread_mutex_unlock(&ctx_lock);
+    }
+    ret = archive_skip_to_index(ctx, idx);
+    if (ret != idx) {
+        ret = archive_errno(ctx->arc);
+        LOGE("Skip to index failed:%s", archive_error_string(ctx->arc));
+        archive_release_ctx(ctx);
+        return ret;
+    }
+    *ctxptr = ctx;
+    return 0;
+}
+
+JNIEXPORT jint JNICALL
+Java_com_hippo_UriArchiveAccessor_openArchive(JNIEnv *env, jobject thiz, jint fd, jlong size) {
+    EH_UNUSED(env);
+    EH_UNUSED(thiz);
+    archive_ctx *ctx = NULL;
+    archiveAddr = mmap64(0, size, PROT_READ, MAP_PRIVATE, fd, 0);
+    if (archiveAddr == MAP_FAILED) {
+        LOGE("%s%s", "mmap64 failed with error ", strerror(errno));
+        return 0;
+    }
+    archiveSize = size;
+    madvise_log_if_error(archiveAddr, archiveSize, MADV_WILLNEED);
+    pthread_mutex_init(&ctx_lock, 0);
+    ctx_pool = calloc(CTX_POOL_SIZE, sizeof(archive_ctx **));
+    if (!ctx_pool) {
+        LOGE("Allocate archive ctx pool failed:ENOMEM");
+        return 0;
+    }
+    long r = archive_alloc_ctx(&ctx);
+    if (r) {
+        if (r == -ENOMEM)
+            LOGE("%s", "Mem alloc failed");
+        r = 0;
+        LOGE("%s%s", "Archive open failed:", archive_error_string(ctx->arc));
+    } else {
+        r = archive_list_all_entries(ctx);
+        LOGI("%s%ld%s", "Found ", r, " image entries in archive");
+
+        // We must read through the file|vm then we can know whether it is encrypted
+        int encryptRet = archive_read_has_encrypted_entries(ctx->arc);
+        switch (encryptRet) {
+            case 1: // At lease 1 encrypted entry
+                need_encrypt = true;
+                break;
+            case 0: // format supports but no encrypted entry found
+            default:
+                need_encrypt = false;
+        }
+
+        int format = archive_format(ctx->arc);
+        switch (format) {
+            case ARCHIVE_FORMAT_ZIP:
+            case ARCHIVE_FORMAT_RAR_V5:
+                madvise_log_if_error(archiveAddr, archiveSize, MADV_SEQUENTIAL);
+                break;
+            case ARCHIVE_FORMAT_7ZIP: // Seek is bad
+                madvise_log_if_error(archiveAddr, archiveSize, MADV_RANDOM);
+                break;
+            default:;
+        }
+    }
+
+    archive_release_ctx(ctx);
+    return r;
+}
+
+JNIEXPORT jobject JNICALL
+Java_com_hippo_UriArchiveAccessor_extractToByteBuffer(JNIEnv *env, jobject thiz, jint index) {
+    EH_UNUSED(env);
+    EH_UNUSED(thiz);
+    archive_ctx *ctx = NULL;
+    int ret;
+    ret = archive_get_ctx(&ctx, index);
+    if (ret)
+        return 0;
+    long long size = archive_entry_size(ctx->entry);
+    void *buffer = malloc(size);
+    if (!buffer) {
+        ctx->using = 0;
+        LOGE("Allocate buffer for decompression failed:ENOMEM");
+        return 0;
+    }
+    ret = archive_read_data(ctx->arc, buffer, size);
+    ctx->using = 0;
+    if (ret == size)
+        return (*env)->NewDirectByteBuffer(env, buffer, size);
+    if (ret != size)
+        LOGE("%s", "No enough data read, WTF?");
+    if (ret < 0)
+        LOGE("%s%s", "Archive read failed:", archive_error_string(ctx->arc));
+    free(buffer);
+    return 0;
+}
+
+JNIEXPORT void JNICALL
+Java_com_hippo_UriArchiveAccessor_closeArchive(JNIEnv *env, jobject thiz) {
+    EH_UNUSED(env);
+    EH_UNUSED(thiz);
+    for (int i = 0; i < CTX_POOL_SIZE; i++)
+        archive_release_ctx(ctx_pool[i]);
+    free(passwd);
+    free(ctx_pool);
+    pthread_mutex_destroy(&ctx_lock);
+    passwd = NULL;
+    need_encrypt = false;
+    munmap(archiveAddr, archiveSize);
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_hippo_UriArchiveAccessor_needPassword(JNIEnv *env, jobject thiz) {
+    EH_UNUSED(env);
+    EH_UNUSED(thiz);
+    return need_encrypt;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_hippo_UriArchiveAccessor_providePassword(JNIEnv *env, jobject thiz, jstring str) {
+    EH_UNUSED(thiz);
+    struct archive_entry *entry;
+    archive_ctx *ctx;
+    jboolean ret = true;
+    int len = (*env)->GetStringUTFLength(env, str);
+    passwd = realloc(passwd, len * sizeof(char));
+    if (!passwd) {
+        LOGE("Allocate passwd buffer failed");
+        return false;
+    }
+    strcpy(passwd, (*env)->GetStringUTFChars(env, str, NULL));
+    archive_alloc_ctx(&ctx);
+    void *tmpBuf = alloca(4096);
+    while (archive_read_next_header(ctx->arc, &entry) == ARCHIVE_OK) {
+        if (!filename_is_playable_file(archive_entry_pathname(entry)))
+            continue;
+        if (!archive_entry_is_encrypted(entry))
+            continue;
+        if (archive_read_data(ctx->arc, tmpBuf, 4096) < ARCHIVE_OK) {
+            LOGE("%s%s", "Archive read failed:", archive_error_string(ctx->arc));
+            ret = false;
+        }
+        break;
+    }
+    archive_release_ctx(ctx);
+    return ret;
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_hippo_UriArchiveAccessor_getFilename(JNIEnv *env, jobject thiz, jint index) {
+    EH_UNUSED(env);
+    EH_UNUSED(thiz);
+    archive_ctx *ctx = NULL;
+    int ret;
+    ret = archive_get_ctx(&ctx, index);
+    if (ret)
+        return NULL;
+    jstring str = (*env)->NewStringUTF(env, archive_entry_pathname(ctx->entry));
+    ctx->using = 0;
+    return str;
+}
+
+JNIEXPORT void JNICALL
+Java_com_hippo_UriArchiveAccessor_extractToFd(JNIEnv *env, jobject thiz, jint index, jint fd) {
+    EH_UNUSED(env);
+    EH_UNUSED(thiz);
+    archive_ctx *ctx = NULL;
+    int ret;
+    ret = archive_get_ctx(&ctx, index);
+    if (!ret) {
+        archive_read_data_into_fd(ctx->arc, fd);
+        ctx->using = 0;
+    }
+}
+
+JNIEXPORT void JNICALL
+Java_com_hippo_UriArchiveAccessor_releaseByteBuffer(JNIEnv *env, jobject thiz, jobject buffer) {
+    void *addr = (*env)->GetDirectBufferAddress(env, buffer);
+    free(addr);
+}
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2022 Tarsin Norbin
+ *
+ * This file is part of EhViewer
+ *
+ * EhViewer is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * EhViewer is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * EhViewer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef EHVIEWER_EHVIEWER_H
+#define EHVIEWER_EHVIEWER_H
+
+#define EH_UNUSED(x) (void)x
+#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG ,__VA_ARGS__)
+#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG ,__VA_ARGS__)
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG ,__VA_ARGS__)
+#define LOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG ,__VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG ,__VA_ARGS__)
+#define LOGF(...) __android_log_print(ANDROID_LOG_FATAL, LOG_TAG ,__VA_ARGS__)
+
+#define madvise_log_if_error(addr, len, advice) \
+if (madvise(addr, len, advice))                 \
+    LOGE("%s%p%s%zu%s%d%s%s%s", "madvise addr:", addr, "len:", len, "with advice ", advice, " failed with error: ", strerror(errno), ", Ignored")
+
+#endif /* EHVIEWER_EHVIEWER_H */
@@ -0,0 +1,16 @@
+#include <jni.h>
+
+JNIEXPORT jint JNICALL
+Java_com_hippo_Native_getFd(JNIEnv *env, jclass clazz, jobject fileDescriptor) {
+    jint fd = -1;
+    jclass fdClass = (*env)->FindClass(env, "java/io/FileDescriptor");
+
+    if (fdClass != NULL) {
+        jfieldID fdClassDescriptorFieldID = (*env)->GetFieldID(env, fdClass, "descriptor", "I");
+        if (fdClassDescriptorFieldID != NULL && fileDescriptor != NULL) {
+            fd = (*env)->GetIntField(env, fileDescriptor, fdClassDescriptorFieldID);
+        }
+    }
+
+    return fd;
+}
@@ -0,0 +1,166 @@
+/*
+ * Copyright 2022 Tarsin Norbin
+ *
+ * This file is part of EhViewer
+ *
+ * EhViewer is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * EhViewer is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * EhViewer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <android/bitmap.h>
+#include <android/data_space.h>
+#include <android/log.h>
+
+#include <GLES2/gl2.h>
+#include <jni.h>
+
+#define TAG "ImageDecoder_wrapper"
+
+#include "ehviewer.h"
+
+#define IMAGE_TILE_MAX_SIZE (512 * 512)
+
+static char tile_buffer[IMAGE_TILE_MAX_SIZE * 4];
+
+bool copy_pixels(const void *src, int src_w, int src_h, int src_x, int src_y,
+                 void *dst, int dst_w, int dst_h, int dst_x, int dst_y,
+                 int width, int height) {
+    int left;
+    int line;
+    size_t line_stride;
+    int src_stride;
+    int src_pos;
+    int dst_pos;
+    size_t dst_blank_length;
+
+    // Sanitize
+    if (src_x < 0) {
+        width -= src_x;
+        dst_x -= src_x;
+        src_x = 0;
+    }
+    if (dst_x < 0) {
+        width -= dst_x;
+        src_x -= dst_x;
+        dst_x = 0;
+    }
+    if (width <= 0) {
+        return false;
+    }
+    if (src_y < 0) {
+        height -= src_y;
+        dst_y -= src_y;
+        src_y = 0;
+    }
+    if (dst_y < 0) {
+        height -= dst_y;
+        src_y -= dst_y;
+        dst_y = 0;
+    }
+    if (height <= 0) {
+        return false;
+    }
+    left = src_x + width - src_w;
+    if (left > 0) {
+        width -= left;
+    }
+    left = dst_x + width - dst_w;
+    if (left > 0) {
+        width -= left;
+    }
+    if (width <= 0) {
+        return false;
+    }
+    left = src_y + height - src_h;
+    if (left > 0) {
+        height -= left;
+    }
+    left = dst_y + height - dst_h;
+    if (left > 0) {
+        height -= left;
+    }
+    if (height <= 0) {
+        return false;
+    }
+
+    // Init
+    line_stride = (size_t) (width * 4);
+    src_stride = src_w * 4;
+    src_pos = src_y * src_stride + src_x * 4;
+    dst_pos = 0;
+
+    dst_blank_length = (size_t) (dst_y * dst_w + dst_x) * 4;
+
+    // First line
+    dst_pos += (int) dst_blank_length;
+    memcpy(dst + dst_pos, src + src_pos, line_stride);
+    dst_pos += (int) line_stride;
+    src_pos += src_stride;
+
+    // Other lines
+    dst_blank_length = (size_t) ((dst_w - width) * 4);
+    for (line = 1; line < height; line++) {
+        dst_pos += (int) dst_blank_length;
+        memcpy(dst + dst_pos, src + src_pos, line_stride);
+        dst_pos += (int) line_stride;
+        src_pos += src_stride;
+    }
+
+    return true;
+}
+
+JNIEXPORT void JNICALL
+Java_com_hippo_image_Image_nativeRender(JNIEnv *env, jclass clazz, jobject srcBitmap, jint src_x,
+                                        jint src_y, jobject dst, jint dst_x, jint dst_y, jint width,
+                                        jint height) {
+    AndroidBitmapInfo dstInfo;
+    AndroidBitmapInfo srcInfo;
+    void *srcPixels = NULL;
+    void *dstPixels = NULL;
+
+    AndroidBitmap_lockPixels(env, srcBitmap, &srcPixels);
+    AndroidBitmap_lockPixels(env, dst, &dstPixels);
+    AndroidBitmap_getInfo(env, srcBitmap, &srcInfo);
+    AndroidBitmap_getInfo(env, dst, &dstInfo);
+
+    copy_pixels(srcPixels, srcInfo.width, srcInfo.height, src_x, src_y, dstPixels, dstInfo.width,
+                dstInfo.height, dst_x, dst_y,
+                width,
+                height);
+
+    AndroidBitmap_unlockPixels(env, dst);
+    AndroidBitmap_unlockPixels(env, srcBitmap);
+}
+
+JNIEXPORT void JNICALL
+Java_com_hippo_image_Image_nativeTexImage(JNIEnv *env, jclass clazz, jobject bitmap, jboolean init,
+                                          jint offset_x, jint offset_y, jint width, jint height) {
+    if (width * height > IMAGE_TILE_MAX_SIZE)
+        return;
+    AndroidBitmapInfo info;
+    void *pixels = NULL;
+    AndroidBitmap_lockPixels(env, bitmap, &pixels);
+    AndroidBitmap_getInfo(env, bitmap, &info);
+    copy_pixels(pixels, info.width, info.height, offset_x, offset_y, tile_buffer, width, height, 0, 0, width, height);
+    AndroidBitmap_unlockPixels(env, bitmap);
+    if (init) {
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                     tile_buffer);
+    } else {
+        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE,
+                        tile_buffer);
+    }
+}
@@ -0,0 +1,239 @@
+cmake_minimum_required(VERSION 3.4.1)
+project(nettle C)
+
+set(LIBNETTLE_DEFINITIONS
+        -DHAVE_CONFIG_H)
+
+set(LIBNETTLE_SOURCES
+        nettle/aes-decrypt-internal.c
+        nettle/aes-decrypt.c
+        nettle/aes-decrypt-table.c
+        nettle/aes128-decrypt.c
+        nettle/aes192-decrypt.c
+        nettle/aes256-decrypt.c
+        nettle/aes-encrypt-internal.c
+        nettle/aes-encrypt.c
+        nettle/aes-encrypt-table.c
+        nettle/aes128-encrypt.c
+        nettle/aes192-encrypt.c
+        nettle/aes256-encrypt.c
+        nettle/aes-invert-internal.c
+        nettle/aes-set-key-internal.c
+        nettle/aes-set-encrypt-key.c
+        nettle/aes-set-decrypt-key.c
+        nettle/aes128-set-encrypt-key.c
+        nettle/aes128-set-decrypt-key.c
+        nettle/aes128-meta.c
+        nettle/aes192-set-encrypt-key.c
+        nettle/aes192-set-decrypt-key.c
+        nettle/aes192-meta.c
+        nettle/aes256-set-encrypt-key.c
+        nettle/aes256-set-decrypt-key.c
+        nettle/aes256-meta.c
+        nettle/nist-keywrap.c
+        nettle/arcfour.c
+        nettle/arcfour-crypt.c
+        nettle/arctwo.c
+        nettle/arctwo-meta.c
+        nettle/blowfish.c
+        nettle/blowfish-bcrypt.c
+        nettle/base16-encode.c
+        nettle/base16-decode.c
+        nettle/base16-meta.c
+        nettle/base64-encode.c
+        nettle/base64-decode.c
+        nettle/base64-meta.c
+        nettle/base64url-encode.c
+        nettle/base64url-decode.c
+        nettle/base64url-meta.c
+        nettle/buffer.c
+        nettle/buffer-init.c
+        nettle/camellia-crypt-internal.c
+        nettle/camellia-table.c
+        nettle/camellia-absorb.c
+        nettle/camellia-invert-key.c
+        nettle/camellia128-set-encrypt-key.c
+        nettle/camellia128-crypt.c
+        nettle/camellia128-set-decrypt-key.c
+        nettle/camellia128-meta.c
+        nettle/camellia192-meta.c
+        nettle/camellia256-set-encrypt-key.c
+        nettle/camellia256-crypt.c
+        nettle/camellia256-set-decrypt-key.c
+        nettle/camellia256-meta.c
+        nettle/cast128.c
+        nettle/cast128-meta.c
+        nettle/cbc.c
+        nettle/cbc-aes128-encrypt.c
+        nettle/cbc-aes192-encrypt.c
+        nettle/cbc-aes256-encrypt.c
+        nettle/ccm.c
+        nettle/ccm-aes128.c
+        nettle/ccm-aes192.c
+        nettle/ccm-aes256.c
+        nettle/cfb.c
+        nettle/siv-cmac.c
+        nettle/siv-cmac-aes128.c
+        nettle/siv-cmac-aes256.c
+        nettle/cnd-memcpy.c
+        nettle/chacha-crypt.c
+        nettle/chacha-core-internal.c
+        nettle/chacha-poly1305.c
+        nettle/chacha-poly1305-meta.c
+        nettle/chacha-set-key.c
+        nettle/chacha-set-nonce.c
+        nettle/ctr.c
+        nettle/ctr16.c
+        nettle/des.c
+        nettle/des3.c
+        nettle/eax.c
+        nettle/eax-aes128.c
+        nettle/eax-aes128-meta.c
+        nettle/ghash-set-key.c
+        nettle/ghash-update.c
+        nettle/gcm.c
+        nettle/gcm-aes.c
+        nettle/gcm-aes128.c
+        nettle/gcm-aes128-meta.c
+        nettle/gcm-aes192.c
+        nettle/gcm-aes192-meta.c
+        nettle/gcm-aes256.c
+        nettle/gcm-aes256-meta.c
+        nettle/gcm-camellia128.c
+        nettle/gcm-camellia128-meta.c
+        nettle/gcm-camellia256.c
+        nettle/gcm-camellia256-meta.c
+        nettle/cmac.c
+        nettle/cmac64.c
+        nettle/cmac-aes128.c
+        nettle/cmac-aes256.c
+        nettle/cmac-des3.c
+        nettle/cmac-aes128-meta.c
+        nettle/cmac-aes256-meta.c
+        nettle/cmac-des3-meta.c
+        nettle/gost28147.c
+        nettle/gosthash94.c
+        nettle/gosthash94-meta.c
+        nettle/hmac.c
+        nettle/hmac-gosthash94.c
+        nettle/hmac-md5.c
+        nettle/hmac-ripemd160.c
+        nettle/hmac-sha1.c
+        nettle/hmac-sha224.c
+        nettle/hmac-sha256.c
+        nettle/hmac-sha384.c
+        nettle/hmac-sha512.c
+        nettle/hmac-streebog.c
+        nettle/hmac-sm3.c
+        nettle/hmac-md5-meta.c
+        nettle/hmac-ripemd160-meta.c
+        nettle/hmac-sha1-meta.c
+        nettle/hmac-sha224-meta.c
+        nettle/hmac-sha256-meta.c
+        nettle/hmac-sha384-meta.c
+        nettle/hmac-sha512-meta.c
+        nettle/hmac-streebog-meta.c
+        nettle/hmac-sm3-meta.c
+        nettle/knuth-lfib.c
+        nettle/hkdf.c
+        nettle/md2.c
+        nettle/md2-meta.c
+        nettle/md4.c
+        nettle/md4-meta.c
+        nettle/md5.c
+        nettle/md5-compress.c
+        nettle/md5-compat.c
+        nettle/md5-meta.c
+        nettle/memeql-sec.c
+        nettle/memxor.c
+        nettle/memxor3.c
+        nettle/nettle-lookup-hash.c
+        nettle/nettle-meta-aeads.c
+        nettle/nettle-meta-armors.c
+        nettle/nettle-meta-ciphers.c
+        nettle/nettle-meta-hashes.c
+        nettle/nettle-meta-macs.c
+        nettle/pbkdf2.c
+        nettle/pbkdf2-hmac-gosthash94.c
+        nettle/pbkdf2-hmac-sha1.c
+        nettle/pbkdf2-hmac-sha256.c
+        nettle/pbkdf2-hmac-sha384.c
+        nettle/pbkdf2-hmac-sha512.c
+        nettle/poly1305-aes.c
+        nettle/poly1305-internal.c
+        nettle/realloc.c
+        nettle/ripemd160.c
+        nettle/ripemd160-compress.c
+        nettle/ripemd160-meta.c
+        nettle/salsa20-core-internal.c
+        nettle/salsa20-crypt-internal.c
+        nettle/salsa20-crypt.c
+        nettle/salsa20r12-crypt.c
+        nettle/salsa20-set-key.c
+        nettle/salsa20-set-nonce.c
+        nettle/salsa20-128-set-key.c
+        nettle/salsa20-256-set-key.c
+        nettle/sha1.c
+        nettle/sha1-compress.c
+        nettle/sha1-meta.c
+        nettle/sha256.c
+        nettle/sha256-compress.c
+        nettle/sha224-meta.c
+        nettle/sha256-meta.c
+        nettle/sha512.c
+        nettle/sha512-compress.c
+        nettle/sha384-meta.c
+        nettle/sha512-meta.c
+        nettle/sha512-224-meta.c
+        nettle/sha512-256-meta.c
+        nettle/sha3.c
+        nettle/sha3-permute.c
+        nettle/sha3-224.c
+        nettle/sha3-224-meta.c
+        nettle/sha3-256.c
+        nettle/sha3-256-meta.c
+        nettle/sha3-384.c
+        nettle/sha3-384-meta.c
+        nettle/sha3-512.c
+        nettle/sha3-512-meta.c
+        nettle/shake256.c
+        nettle/sm3.c
+        nettle/sm3-meta.c
+        nettle/serpent-set-key.c
+        nettle/serpent-encrypt.c
+        nettle/serpent-decrypt.c
+        nettle/serpent-meta.c
+        nettle/streebog.c
+        nettle/streebog-meta.c
+        nettle/twofish.c
+        nettle/twofish-meta.c
+        nettle/umac-nh.c
+        nettle/umac-nh-n.c
+        nettle/umac-l2.c
+        nettle/umac-l3.c
+        nettle/umac-poly64.c
+        nettle/umac-poly128.c
+        nettle/umac-set-key.c
+        nettle/umac32.c
+        nettle/umac64.c
+        nettle/umac96.c
+        nettle/umac128.c
+        nettle/version.c
+        nettle/write-be32.c
+        nettle/write-le32.c
+        nettle/write-le64.c
+        nettle/yarrow256.c
+        nettle/yarrow_key_event.c
+        nettle/xts.c
+        nettle/xts-aes128.c
+        nettle/xts-aes256.c
+        )
+
+set(LIBNETTLE_INCLUDES
+        ${CMAKE_CURRENT_SOURCE_DIR}
+        ${CMAKE_CURRENT_SOURCE_DIR}/nettle
+        )
+
+add_library(nettle STATIC ${LIBNETTLE_SOURCES})
+target_include_directories(nettle PUBLIC ${LIBNETTLE_INCLUDES})
+target_compile_definitions(nettle PRIVATE ${LIBNETTLE_DEFINITIONS})
@@ -0,0 +1,275 @@
+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define if building universal (internal helper macro) */
+/* #undef AC_APPLE_UNIVERSAL_BUILD */
+
+/* Define to 1 if using 'alloca.c'. */
+/* #undef C_ALLOCA */
+
+/* Define to 1 if you have 'alloca', as a function or macro. */
+#define HAVE_ALLOCA 1
+
+/* Define to 1 if <alloca.h> works. */
+#define HAVE_ALLOCA_H 1
+
+/* Define if __builtin_bswap64 is available */
+#define HAVE_BUILTIN_BSWAP64 1
+
+/* Define if clock_gettime is available */
+#define HAVE_CLOCK_GETTIME 1
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define if fcntl file locking is available */
+#define HAVE_FCNTL_LOCKING 1
+
+/* Define if the compiler understands __attribute__ */
+#define HAVE_GCC_ATTRIBUTE 1
+
+/* Define to 1 if you have the `getline' function. */
+#define HAVE_GETLINE 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have dlopen (with -ldl). */
+#define HAVE_LIBDL 1
+
+/* Define to 1 if you have the `gmp' library (-lgmp). */
+/* #undef HAVE_LIBGMP */
+
+/* Define if compiler and linker supports __attribute__ ifunc */
+#define HAVE_LINK_IFUNC 1
+
+/* Define to 1 if you have the <malloc.h> header file. */
+#define HAVE_MALLOC_H 1
+
+/* Define to 1 each of the following for which a native (ie. CPU specific)
+    implementation of the corresponding routine exists.  */
+/* #undef HAVE_NATIVE_memxor3 */
+/* #undef HAVE_NATIVE_aes_decrypt */
+/* #undef HAVE_NATIVE_aes_encrypt */
+/* #undef HAVE_NATIVE_aes128_decrypt */
+/* #undef HAVE_NATIVE_aes128_encrypt */
+/* #undef HAVE_NATIVE_aes128_invert_key */
+/* #undef HAVE_NATIVE_aes128_set_decrypt_key */
+/* #undef HAVE_NATIVE_aes128_set_encrypt_key */
+/* #undef HAVE_NATIVE_aes192_decrypt */
+/* #undef HAVE_NATIVE_aes192_encrypt */
+/* #undef HAVE_NATIVE_aes192_invert_key */
+/* #undef HAVE_NATIVE_aes192_set_decrypt_key */
+/* #undef HAVE_NATIVE_aes192_set_encrypt_key */
+/* #undef HAVE_NATIVE_aes256_decrypt */
+/* #undef HAVE_NATIVE_aes256_encrypt */
+/* #undef HAVE_NATIVE_aes256_invert_key */
+/* #undef HAVE_NATIVE_aes256_set_decrypt_key */
+/* #undef HAVE_NATIVE_aes256_set_encrypt_key */
+/* #undef HAVE_NATIVE_cbc_aes128_encrypt */
+/* #undef HAVE_NATIVE_cbc_aes192_encrypt */
+/* #undef HAVE_NATIVE_cbc_aes256_encrypt */
+/* #undef HAVE_NATIVE_chacha_core */
+/* #undef HAVE_NATIVE_chacha_2core */
+/* #undef HAVE_NATIVE_chacha_3core */
+/* #undef HAVE_NATIVE_chacha_4core */
+/* #undef HAVE_NATIVE_fat_chacha_2core */
+/* #undef HAVE_NATIVE_fat_chacha_3core */
+/* #undef HAVE_NATIVE_fat_chacha_4core */
+/* #undef HAVE_NATIVE_ecc_curve25519_modp */
+/* #undef HAVE_NATIVE_ecc_curve448_modp */
+/* #undef HAVE_NATIVE_ecc_secp192r1_modp */
+/* #undef HAVE_NATIVE_ecc_secp192r1_redc */
+/* #undef HAVE_NATIVE_ecc_secp224r1_modp */
+/* #undef HAVE_NATIVE_ecc_secp224r1_redc */
+/* #undef HAVE_NATIVE_ecc_secp256r1_modp */
+/* #undef HAVE_NATIVE_ecc_secp256r1_redc */
+/* #undef HAVE_NATIVE_ecc_secp384r1_modp */
+/* #undef HAVE_NATIVE_ecc_secp384r1_redc */
+/* #undef HAVE_NATIVE_ecc_secp521r1_modp */
+/* #undef HAVE_NATIVE_ecc_secp521r1_redc */
+/* #undef HAVE_NATIVE_ghash_set_key */
+/* #undef HAVE_NATIVE_ghash_update */
+/* #undef HAVE_NATIVE_salsa20_core */
+/* #undef HAVE_NATIVE_salsa20_2core */
+/* #undef HAVE_NATIVE_fat_salsa20_2core */
+/* #undef HAVE_NATIVE_sha1_compress */
+/* #undef HAVE_NATIVE_sha256_compress */
+/* #undef HAVE_NATIVE_sha512_compress */
+/* #undef HAVE_NATIVE_sha3_permute */
+/* #undef HAVE_NATIVE_umac_nh */
+/* #undef HAVE_NATIVE_umac_nh_n */
+
+/* Define to 1 if you have the <openssl/ecdsa.h> header file. */
+/* #undef HAVE_OPENSSL_ECDSA_H */
+
+/* Define to 1 if you have the <openssl/evp.h> header file. */
+/* #undef HAVE_OPENSSL_EVP_H */
+
+/* Define to 1 if you have the `secure_getenv' function. */
+/* #undef HAVE_SECURE_GETENV */
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdio.h> header file. */
+#define HAVE_STDIO_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the `strerror' function. */
+#define HAVE_STRERROR 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/time.h> header file. */
+#define HAVE_SYS_TIME_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the <valgrind/memcheck.h> header file. */
+/* #undef HAVE_VALGRIND_MEMCHECK_H */
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "nettle-bugs@lists.lysator.liu.se"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "nettle"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "nettle 3.8.1"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "nettle"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "3.8.1"
+
+/* The size of `long', as computed by sizeof. */
+#define SIZEOF_LONG __SIZEOF_LONG__
+
+/* The size of `size_t', as computed by sizeof. */
+#define SIZEOF_SIZE_T __SIZEOF_SIZE_T__
+
+/* If using the C implementation of alloca, define if you know the
+   direction of stack growth for your system; otherwise it will be
+   automatically deduced at runtime.
+	STACK_DIRECTION > 0 => grows toward higher addresses
+	STACK_DIRECTION < 0 => grows toward lower addresses
+	STACK_DIRECTION = 0 => direction of growth unknown */
+/* #undef STACK_DIRECTION */
+
+/* Define to 1 if all of the C90 standard headers exist (not just the ones
+   required in a freestanding environment). This macro is provided for
+   backward compatibility; new code need not use it. */
+#define STDC_HEADERS 1
+
+/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. This
+   macro is obsolete. */
+#define TIME_WITH_SYS_TIME 1
+
+/* Defined if public key features are enabled */
+/* #undef WITH_HOGWEED */
+
+/* Define if you have openssl's libcrypto (used for benchmarking) */
+/* #undef WITH_OPENSSL */
+
+/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
+   significant byte first (like Motorola and SPARC, unlike Intel). */
+#if defined AC_APPLE_UNIVERSAL_BUILD
+# if defined __BIG_ENDIAN__
+#  define WORDS_BIGENDIAN 1
+# endif
+#else
+# ifndef WORDS_BIGENDIAN
+/* #  undef WORDS_BIGENDIAN */
+# endif
+#endif
+
+/* Define to empty if `const' does not conform to ANSI C. */
+/* #undef const */
+
+/* Define to `int' if <sys/types.h> doesn't define. */
+/* #undef gid_t */
+
+/* Define to `__inline__' or `__inline' if that's what the C compiler
+   calls it, or to nothing if 'inline' is not supported under any name.  */
+#ifndef __cplusplus
+/* #undef inline */
+#endif
+
+/* Define to `unsigned int' if <sys/types.h> does not define. */
+/* #undef size_t */
+
+/* Define to `int' if <sys/types.h> doesn't define. */
+/* #undef uid_t */
+
+/* AIX requires this to be the first thing in the file.  */
+#ifndef __GNUC__
+# if HAVE_ALLOCA_H
+#  include <alloca.h>
+# else
+#  ifdef _AIX
+ #pragma alloca
+#  else
+#   ifndef alloca /* predefined by HP cc +Olibcalls */
+char *alloca ();
+#   endif
+#  endif
+/* Needed for alloca on windows */
+#  if HAVE_MALLOC_H
+#   include <malloc.h>
+#  endif
+# endif
+#else /* defined __GNUC__ */
+# if HAVE_ALLOCA_H
+#  include <alloca.h>
+# else
+/* Needed for alloca on windows, also with gcc */
+#  if HAVE_MALLOC_H
+#   include <malloc.h>
+#  endif
+# endif
+#endif
+
+
+#if HAVE_STRERROR
+#define STRERROR strerror
+#else
+#define STRERROR(x) (sys_errlist[x])
+#endif
+
+
+#if __GNUC__ && HAVE_GCC_ATTRIBUTE
+# define NORETURN __attribute__ ((__noreturn__))
+# define PRINTF_STYLE(f, a) __attribute__ ((__format__ (__printf__, f, a)))
+# define UNUSED __attribute__ ((__unused__))
+#else
+# define NORETURN
+# define PRINTF_STYLE(f, a)
+# define UNUSED
+#endif
+
+
+#if defined(__x86_64__) || defined(__arch64__)
+# define HAVE_NATIVE_64_BIT 1
+#else
+/* Needs include of <limits.h> before use. */
+# define HAVE_NATIVE_64_BIT (SIZEOF_LONG * CHAR_BIT >= 64)
+#endif
+
@@ -0,0 +1 @@
+ 
@@ -0,0 +1 @@
+ 
@@ -0,0 +1,64 @@
+/* version.h
+
+   Information about library version.
+
+   Copyright (C) 2015 Red Hat, Inc.
+   Copyright (C) 2015 Niels Möller
+
+   This file is part of GNU Nettle.
+
+   GNU Nettle is free software: you can redistribute it and/or
+   modify it under the terms of either:
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 2 of the License, or (at your
+       option) any later version.
+
+   or both in parallel, as here.
+
+   GNU Nettle is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see http://www.gnu.org/licenses/.
+*/
+
+#ifndef NETTLE_VERSION_H_INCLUDED
+#define NETTLE_VERSION_H_INCLUDED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Individual version numbers in decimal */
+#define NETTLE_VERSION_MAJOR 3
+#define NETTLE_VERSION_MINOR 8
+
+#define NETTLE_USE_MINI_GMP 0
+
+/* We need a preprocessor constant for GMP_NUMB_BITS, simply using
+   sizeof(mp_limb_t) * CHAR_BIT is not good enough. */
+#if NETTLE_USE_MINI_GMP
+# define GMP_NUMB_BITS n/a
+#endif
+
+int
+nettle_version_major (void);
+
+int
+nettle_version_minor (void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NETTLE_VERSION_H_INCLUDED */
@@ -1,45 +0,0 @@
-package androidx.recyclerview.widget;
-
-import android.content.Context;
-import android.util.AttributeSet;
-import android.view.MotionEvent;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-
-public class BridgeRecyclerView extends RecyclerView {
-    public BridgeRecyclerView(@NonNull Context context) {
-        super(context);
-    }
-
-    public BridgeRecyclerView(@NonNull Context context, @Nullable AttributeSet attrs) {
-        super(context, attrs);
-    }
-
-    public BridgeRecyclerView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
-        super(context, attrs, defStyleAttr);
-    }
-
-    @Override
-    void scrollStep(int dx, int dy, @Nullable int[] consumed) {
-        try {
-            super.scrollStep(dx, dy, consumed);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    @Override
-    public boolean scrollByInternal(int x, int y, MotionEvent ev, int type) {
-        return super.scrollByInternal(x, y, ev, type);
-    }
-
-    @Override
-    protected void onLayout(boolean changed, int l, int t, int r, int b) {
-        try {
-            super.onLayout(changed, l, t, r, b);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-}
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2022 Tarsin Norbin
+ *
+ * This file is part of EhViewer
+ *
+ * EhViewer is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * EhViewer is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with EhViewer.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.hippo
+
+import java.io.FileDescriptor
+
+object Native {
+    @JvmStatic
+    fun initialize() {
+        System.loadLibrary("ehviewer")
+    }
+
+    @JvmStatic
+    external fun getFd(fd: FileDescriptor?): Int
+}
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2022 Tarsin Norbin
+ *
+ * This file is part of EhViewer
+ *
+ * EhViewer is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * EhViewer is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with EhViewer.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.hippo
+
+import android.content.Context
+import android.net.Uri
+import java.nio.ByteBuffer
+
+class UriArchiveAccessor(ctx: Context, uri: Uri) {
+    val pfd by lazy { ctx.contentResolver.openFileDescriptor(uri, "r")!! }
+    fun open(): Int {
+        return openArchive(pfd.fd, pfd.statSize)
+    }
+
+    private external fun openArchive(fd: Int, size: Long): Int
+    external fun extractToByteBuffer(index: Int): ByteBuffer?
+
+    external fun releaseByteBuffer(buffer: ByteBuffer)
+    external fun extractToFd(index: Int, fd: Int)
+    external fun getFilename(index: Int): String
+    external fun needPassword(): Boolean
+    external fun providePassword(str: String): Boolean
+    private external fun closeArchive()
+    fun close() {
+        closeArchive()
+        pfd.close()
+    }
+}
@@ -0,0 +1,23 @@
+package com.hippo.app
+
+import android.content.Context
+import android.os.Build
+import android.view.WindowManager
+import androidx.appcompat.app.AlertDialog
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+
+open class BaseDialogBuilder constructor(
+    context: Context
+) : MaterialAlertDialogBuilder(context) {
+    override fun create(): AlertDialog {
+        return super.create().apply {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                window?.run {
+                    addFlags(WindowManager.LayoutParams.FLAG_BLUR_BEHIND)
+                    addFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND)
+                    attributes.blurBehindRadius = 32
+                }
+            }
+        }
+    }
+}
@@ -1,47 +0,0 @@
-/*
- * 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.app;
-
-import android.annotation.SuppressLint;
-import android.content.Context;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.widget.CheckBox;
-
-import com.google.android.material.dialog.MaterialAlertDialogBuilder;
-import com.hippo.ehviewer.R;
-
-public class CheckBoxDialogBuilder extends MaterialAlertDialogBuilder {
-
-    private final CheckBox mCheckBox;
-
-    @SuppressLint("InflateParams")
-    public CheckBoxDialogBuilder(Context context, String message, String checkText, boolean checked) {
-        super(context);
-        View view = LayoutInflater.from(getContext()).inflate(R.layout.dialog_checkbox_builder, null);
-        setView(view);
-        setMessage(message);
-        mCheckBox = view.findViewById(R.id.checkbox);
-        mCheckBox.setText(checkText);
-        mCheckBox.setChecked(checked);
-        view.setOnClickListener(v -> mCheckBox.toggle());
-    }
-
-    public boolean isChecked() {
-        return mCheckBox.isChecked();
-    }
-}
@@ -0,0 +1,44 @@
+/*
+ * 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.app
+
+import android.content.Context
+import android.view.LayoutInflater
+import android.widget.CheckBox
+import com.hippo.ehviewer.R
+
+class CheckBoxDialogBuilder constructor(
+    context: Context,
+    message: String?,
+    checkText: String?,
+    checked: Boolean
+) : BaseDialogBuilder(
+    context
+) {
+    private val mCheckBox: CheckBox
+    val isChecked: Boolean
+        get() = mCheckBox.isChecked
+
+    init {
+        val view = LayoutInflater.from(getContext()).inflate(R.layout.dialog_checkbox_builder, null)
+        setView(view)
+        setMessage(message)
+        mCheckBox = view.findViewById(R.id.checkbox)
+        mCheckBox.text = checkText
+        mCheckBox.isChecked = checked
+        view.setOnClickListener { mCheckBox.toggle() }
+    }
+}
@@ -1,86 +0,0 @@
-/*
- * 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.app;
-
-import android.annotation.SuppressLint;
-import android.content.Context;
-import android.content.DialogInterface;
-import android.view.KeyEvent;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.widget.Button;
-import android.widget.EditText;
-import android.widget.TextView;
-
-import androidx.annotation.NonNull;
-import androidx.appcompat.app.AlertDialog;
-
-import com.google.android.material.dialog.MaterialAlertDialogBuilder;
-import com.google.android.material.textfield.TextInputLayout;
-import com.hippo.ehviewer.R;
-
-public class EditTextDialogBuilder extends MaterialAlertDialogBuilder implements EditText.OnEditorActionListener {
-
-    private final TextInputLayout mTextInputLayout;
-    private final EditText mEditText;
-    private AlertDialog mDialog;
-
-    @SuppressLint("InflateParams")
-    public EditTextDialogBuilder(Context context, String text, String hint) {
-        super(context);
-        View view = LayoutInflater.from(getContext()).inflate(R.layout.dialog_edittext_builder, null);
-        setView(view);
-        mTextInputLayout = (TextInputLayout) view;
-        mEditText = view.findViewById(R.id.edit_text);
-        mEditText.setText(text);
-        mEditText.setSelection(mEditText.getText().length());
-        mEditText.setOnEditorActionListener(this);
-        mTextInputLayout.setHint(hint);
-    }
-
-    public EditText getEditText() {
-        return mEditText;
-    }
-
-    public String getText() {
-        return mEditText.getText().toString();
-    }
-
-    public void setError(CharSequence error) {
-        mTextInputLayout.setError(error);
-    }
-
-    @NonNull
-    @Override
-    public AlertDialog create() {
-        mDialog = super.create();
-        return mDialog;
-    }
-
-    @Override
-    public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
-        if (mDialog != null) {
-            Button button = mDialog.getButton(DialogInterface.BUTTON_POSITIVE);
-            if (button != null) {
-                button.performClick();
-            }
-            return true;
-        } else {
-            return false;
-        }
-    }
-}
@@ -0,0 +1,71 @@
+/*
+ * 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.app
+
+import android.content.Context
+import android.content.DialogInterface
+import android.view.KeyEvent
+import android.view.LayoutInflater
+import android.widget.EditText
+import android.widget.TextView
+import android.widget.TextView.OnEditorActionListener
+import androidx.appcompat.app.AlertDialog
+import com.google.android.material.textfield.TextInputLayout
+import com.hippo.ehviewer.R
+
+class EditTextDialogBuilder constructor(
+    context: Context,
+    text: String?,
+    hint: String?
+) : BaseDialogBuilder(
+    context
+), OnEditorActionListener {
+    private val mTextInputLayout: TextInputLayout
+    val editText: EditText
+    private var mDialog: AlertDialog? = null
+    val text: String
+        get() = editText.text.toString()
+
+    fun setError(error: CharSequence?) {
+        mTextInputLayout.error = error
+    }
+
+    override fun create(): AlertDialog {
+        mDialog = super.create()
+        return mDialog as AlertDialog
+    }
+
+    override fun onEditorAction(v: TextView?, p1: Int, event: KeyEvent?): Boolean {
+        return if (mDialog != null) {
+            val button = mDialog!!.getButton(DialogInterface.BUTTON_POSITIVE)
+            button?.performClick()
+            true
+        } else {
+            false
+        }
+    }
+
+    init {
+        val view = LayoutInflater.from(getContext()).inflate(R.layout.dialog_edittext_builder, null)
+        setView(view)
+        mTextInputLayout = view as TextInputLayout
+        editText = view.findViewById(R.id.edit_text)
+        editText.setText(text)
+        editText.setSelection(editText.text.length)
+        editText.setOnEditorActionListener(this)
+        mTextInputLayout.hint = hint
+    }
+}
@@ -0,0 +1,14 @@
+package com.hippo.app
+
+import android.content.Context
+import android.util.AttributeSet
+import android.view.HapticFeedbackConstants
+import com.google.android.material.slider.Slider
+
+class HapticSlider @JvmOverloads constructor(
+    context: Context, attrs: AttributeSet? = null
+) : Slider(context, attrs) {
+    init {
+        addOnChangeListener { _, _, _ -> performHapticFeedback(HapticFeedbackConstants.CLOCK_TICK) }
+    }
+}
@@ -1,73 +0,0 @@
-/*
- * 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.app;
-
-import android.annotation.SuppressLint;
-import android.content.Context;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.widget.ArrayAdapter;
-import android.widget.CheckBox;
-import android.widget.ListView;
-
-import androidx.annotation.NonNull;
-import androidx.appcompat.app.AlertDialog;
-
-import com.google.android.material.dialog.MaterialAlertDialogBuilder;
-import com.hippo.ehviewer.R;
-import com.hippo.yorozuya.ViewUtils;
-
-public class ListCheckBoxDialogBuilder extends MaterialAlertDialogBuilder {
-
-    private final CheckBox mCheckBox;
-
-    private AlertDialog mDialog;
-
-    @SuppressLint("InflateParams")
-    public ListCheckBoxDialogBuilder(Context context, CharSequence[] items,
-                                     final OnItemClickListener listener, String checkText, boolean checked) {
-        super(context);
-        View view = LayoutInflater.from(getContext()).inflate(R.layout.dialog_list_checkbox_builder, null);
-        setView(view);
-        ListView listView = (ListView) ViewUtils.$$(view, R.id.list_view);
-        mCheckBox = (CheckBox) ViewUtils.$$(view, R.id.checkbox);
-        listView.setAdapter(new ArrayAdapter<>(getContext(), R.layout.item_select_dialog, items));
-        listView.setOnItemClickListener((parent, view1, position, id) -> {
-            if (listener != null) {
-                listener.onItemClick(ListCheckBoxDialogBuilder.this, mDialog, position);
-            }
-            mDialog.dismiss();
-        });
-        mCheckBox.setText(checkText);
-        mCheckBox.setChecked(checked);
-    }
-
-    public boolean isChecked() {
-        return mCheckBox.isChecked();
-    }
-
-    @NonNull
-    @Override
-    public AlertDialog create() {
-        mDialog = super.create();
-        return mDialog;
-    }
-
-    public interface OnItemClickListener {
-        void onItemClick(ListCheckBoxDialogBuilder builder, AlertDialog dialog, int position);
-    }
-}
@@ -0,0 +1,64 @@
+/*
+ * 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.app
+
+import android.content.Context
+import android.view.LayoutInflater
+import android.view.View
+import android.widget.AdapterView
+import android.widget.ArrayAdapter
+import android.widget.CheckBox
+import android.widget.ListView
+import androidx.appcompat.app.AlertDialog
+import com.hippo.ehviewer.R
+import com.hippo.yorozuya.ViewUtils
+
+class ListCheckBoxDialogBuilder constructor(
+    context: Context, items: Array<CharSequence>,
+    listener: OnItemClickListener?, checkText: String?, checked: Boolean
+) : BaseDialogBuilder(
+    context
+) {
+    private val mCheckBox: CheckBox
+    private var mDialog: AlertDialog? = null
+    val isChecked: Boolean
+        get() = mCheckBox.isChecked
+
+    override fun create(): AlertDialog {
+        mDialog = super.create()
+        return mDialog as AlertDialog
+    }
+
+    interface OnItemClickListener {
+        fun onItemClick(builder: ListCheckBoxDialogBuilder?, dialog: AlertDialog?, position: Int)
+    }
+
+    init {
+        val view =
+            LayoutInflater.from(getContext()).inflate(R.layout.dialog_list_checkbox_builder, null)
+        setView(view)
+        val listView = ViewUtils.`$$`(view, R.id.list_view) as ListView
+        mCheckBox = ViewUtils.`$$`(view, R.id.checkbox) as CheckBox
+        listView.adapter = ArrayAdapter(getContext(), R.layout.item_select_dialog, items)
+        listView.onItemClickListener =
+            AdapterView.OnItemClickListener { _: AdapterView<*>?, _: View?, position: Int, _: Long ->
+                listener?.onItemClick(this@ListCheckBoxDialogBuilder, mDialog, position)
+                mDialog?.dismiss()
+            }
+        mCheckBox.text = checkText
+        mCheckBox.isChecked = checked
+    }
+}
@@ -0,0 +1,493 @@
+/*
+ * Copyright (C) 2015-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.beerbelly;
+
+import android.util.Log;
+import android.util.LruCache;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.hippo.streampipe.InputStreamPipe;
+import com.hippo.streampipe.OutputStreamPipe;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public abstract class BeerBelly<V> {
+
+    private static final String TAG = BeerBelly.class.getSimpleName();
+    private final boolean mHasMemoryCache;
+    private final boolean mHasDiskCache;
+    @Nullable
+    private MemoryCache<V> mMemoryCache;
+    @Nullable
+    private DiskCache<V> mDiskCache;
+
+    public BeerBelly(BeerBellyParams params) {
+        params.isValid();
+        mHasMemoryCache = params.hasMemoryCache;
+        mHasDiskCache = params.hasDiskCache;
+
+        if (mHasMemoryCache) {
+            initMemoryCache(params.memoryCacheMaxSize);
+        }
+
+        if (mHasDiskCache) {
+            initDiskCache(params.diskCacheDir, params.diskCacheMaxSize);
+        }
+    }
+
+    private void initMemoryCache(int maxSize) {
+        mMemoryCache = new MemoryCache<>(maxSize, this);
+    }
+
+    private void initDiskCache(File cacheDir, int maxSize) {
+        // Set up disk cache
+        try {
+            mDiskCache = new DiskCache<>(cacheDir, maxSize, this);
+        } catch (IOException e) {
+            Log.e(TAG, "Can't create disk cache", e);
+        }
+    }
+
+    protected abstract int sizeOf(String key, V value);
+
+    protected abstract void memoryEntryAdded(V value);
+
+    protected abstract void memoryEntryRemoved(boolean evicted, String key, V oldValue, V newValue);
+
+    protected abstract V read(@NonNull InputStreamPipe isPipe);
+
+    protected abstract boolean write(OutputStream os, V value);
+
+    @Nullable
+    public LruCache<String, V> getMemoryCache() {
+        return mMemoryCache;
+    }
+
+    @Nullable
+    public SimpleDiskCache getDiskCache() {
+        if (mDiskCache != null) {
+            return mDiskCache.mDiskCache;
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Check if have memory cache
+     *
+     * @return true if have memory cache
+     */
+    public boolean hasMemoryCache() {
+        return mHasMemoryCache;
+    }
+
+    /**
+     * Check if have disk cache
+     *
+     * @return true if have disk cache
+     */
+    public boolean hasDiskCache() {
+        return mHasDiskCache;
+    }
+
+    /**
+     * Get memory cache usage size
+     *
+     * @return {@code -1} for no memory cache
+     */
+    public int memorySize() {
+        if (mHasMemoryCache && mMemoryCache != null) {
+            return mMemoryCache.size();
+        } else {
+            return -1;
+        }
+    }
+
+    /**
+     * Get memory cache max size
+     *
+     * @return {@code -1} for no memory cache
+     */
+    public int memoryMaxSize() {
+        if (mHasMemoryCache && mMemoryCache != null) {
+            return mMemoryCache.maxSize();
+        } else {
+            return -1;
+        }
+    }
+
+    /**
+     * Get disk cache usage size
+     *
+     * @return {@code -1L} for no memory cache
+     */
+    public long diskSize() {
+        if (mHasDiskCache && mDiskCache != null) {
+            return mDiskCache.size();
+        } else {
+            return -1L;
+        }
+    }
+
+    /**
+     * Get disk cache max size
+     *
+     * @return {@code -1L} for no memory cache
+     */
+    public long diskMaxSize() {
+        if (mHasDiskCache && mDiskCache != null) {
+            return mDiskCache.getMaxSize();
+        } else {
+            return -1L;
+        }
+    }
+
+    /**
+     * Get value from memory cache
+     *
+     * @param key the key to get value
+     * @return the value you get, null for miss or no memory cache
+     */
+    public V getFromMemory(@NonNull String key) {
+        if (mHasMemoryCache && mMemoryCache != null) {
+            return mMemoryCache.get(key);
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Get value from disk cache. Override {@link #read(InputStreamPipe)} to do it
+     *
+     * @param key the key to get value
+     * @return the value you get, null for miss or no memory cache or get error
+     */
+    public V getFromDisk(@NonNull String key) {
+        if (mHasDiskCache && mDiskCache != null) {
+            return mDiskCache.get(key);
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Get value from memory cache and disk cache. If miss in memory cache and
+     * get in disk cache, it will put value from disk cache to memory cache.
+     *
+     * @param key the key to get value
+     * @return the value you get
+     */
+    public V get(@NonNull String key) {
+        V value = getFromMemory(key);
+
+        if (value != null) {
+            // Get it in memory cache
+            return value;
+        }
+
+        value = getFromDisk(key);
+
+        if (value != null) {
+            // Get it in disk cache
+            putToMemory(key, value);
+            return value;
+        }
+
+        return null;
+    }
+
+    /**
+     * Put value to memory cache
+     *
+     * @param key   the key
+     * @param value the value
+     * @return false if no memory cache
+     */
+    public boolean putToMemory(@NonNull String key, @NonNull V value) {
+        if (mHasMemoryCache && mMemoryCache != null) {
+            memoryEntryAdded(value);
+            mMemoryCache.put(key, value);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Put value to disk cache
+     *
+     * @param key   the key
+     * @param value the value
+     * @return false if no disk cache or get error
+     */
+    public boolean putToDisk(@NonNull String key, @NonNull V value) {
+        if (mHasDiskCache && mDiskCache != null) {
+            return mDiskCache.put(key, value);
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Put value to memory cache and disk cache
+     *
+     * @param key   the key
+     * @param value the value
+     */
+    public void put(@NonNull String key, @NonNull V value) {
+        putToMemory(key, value);
+        putToDisk(key, value);
+    }
+
+    public void removeFromMemory(@NonNull String key) {
+        if (mHasMemoryCache && mMemoryCache != null) {
+            mMemoryCache.remove(key);
+        }
+    }
+
+    public void removeFromDisk(@NonNull String key) {
+        if (mHasDiskCache && mDiskCache != null) {
+            mDiskCache.remove(key);
+        }
+    }
+
+    public void remove(@NonNull String key) {
+        removeFromMemory(key);
+        removeFromDisk(key);
+    }
+
+    public boolean pullFromDiskCache(@NonNull String key, @NonNull OutputStream os) {
+        if (mHasDiskCache && mDiskCache != null) {
+            return mDiskCache.pull(key, os);
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * @param key the key
+     * @param is  the input stream to store
+     * @return false if no disk cache or get error
+     */
+    public boolean putRawToDisk(@NonNull String key, @NonNull InputStream is) {
+        if (mHasDiskCache && mDiskCache != null) {
+            return mDiskCache.putRaw(key, is);
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Evicts all of the items from the memory cache
+     */
+    public void clearMemory() {
+        if (mHasMemoryCache && mMemoryCache != null) {
+            mMemoryCache.evictAll();
+        }
+    }
+
+    /**
+     * Clear disk cache
+     */
+    public void clearDisk() {
+        if (mHasDiskCache && mDiskCache != null) {
+            mDiskCache.clear();
+        }
+    }
+
+    public void flush() {
+        if (mHasDiskCache && mDiskCache != null) {
+            mDiskCache.flush();
+        }
+    }
+
+    /**
+     * Evicts all of the items from the memory cache and lets the system know
+     * now would be a good time to garbage collect
+     */
+    public void clear() {
+        clearMemory();
+        clearDisk();
+    }
+
+    /**
+     * A holder class that contains cache parameters.
+     */
+    public static class BeerBellyParams {
+
+        /**
+         * is memory cache available
+         */
+        public boolean hasMemoryCache = false;
+        /**
+         * the maximum number of bytes the memory cache should use to store
+         */
+        public int memoryCacheMaxSize = 0;
+        /**
+         * is disk cache available
+         */
+        public boolean hasDiskCache = false;
+        /**
+         * the dir to store disk cache
+         */
+        public File diskCacheDir = null;
+        /**
+         * the maximum number of bytes the disk cache should use to store
+         */
+        public int diskCacheMaxSize = 0;
+
+        /**
+         * Check BeerBellyParams is valid
+         */
+        public void isValid() throws IllegalStateException {
+            if (!hasMemoryCache && !hasDiskCache) {
+                throw new IllegalStateException("No memory cache and no disk cache. What can I do for you?");
+            }
+
+            if (hasMemoryCache && memoryCacheMaxSize <= 0) {
+                throw new IllegalStateException("Memory cache max size must be bigger than 0.");
+            }
+
+            if (hasDiskCache) {
+                if (diskCacheDir == null) {
+                    throw new IllegalStateException("Disk cache dir can't be null.");
+                }
+                if (diskCacheMaxSize <= 0) {
+                    throw new IllegalStateException("Disk cache max size must be bigger than 0.");
+                }
+            }
+        }
+    }
+
+    private static class DiskCache<E> {
+
+        private static final int IO_BUFFER_SIZE = 8 * 1024;
+
+        private final SimpleDiskCache mDiskCache;
+        private final BeerBelly<E> mParent;
+
+        private final File mCacheDir;
+        private final int mMaxSize;
+
+        public DiskCache(File cacheDir, int size, BeerBelly<E> parent) throws IOException {
+            mDiskCache = new SimpleDiskCache(cacheDir, size);
+            mParent = parent;
+
+            mCacheDir = cacheDir;
+            mMaxSize = size;
+        }
+
+        public File getCacheDir() {
+            return mCacheDir;
+        }
+
+        public int getMaxSize() {
+            return mMaxSize;
+        }
+
+        public long size() {
+            return mDiskCache.size();
+        }
+
+        public void flush() {
+            mDiskCache.flush();
+        }
+
+        public void clear() {
+            mDiskCache.clear();
+        }
+
+        public E get(String key) {
+            InputStreamPipe isPipe = mDiskCache.getInputStreamPipe(key);
+            if (isPipe == null) {
+                return null;
+            } else {
+                return mParent.read(isPipe);
+            }
+        }
+
+        public boolean put(String key, E value) {
+            OutputStreamPipe osPipe = mDiskCache.getOutputStreamPipe(key);
+            BufferedOutputStream buffOut = null;
+            try {
+                osPipe.obtain();
+                OutputStream os = osPipe.open();
+                buffOut = new BufferedOutputStream(os, IO_BUFFER_SIZE);
+                return mParent.write(os, value);
+            } catch (IOException e) {
+                return false;
+            } finally {
+                Util.closeQuietly(buffOut);
+                osPipe.close();
+                osPipe.release();
+            }
+        }
+
+        public boolean putRaw(String key, InputStream is) {
+            return mDiskCache.put(key, is);
+        }
+
+        public void remove(String key) {
+            mDiskCache.remove(key);
+        }
+
+        public boolean pull(@NonNull String key, @NonNull OutputStream os) {
+            InputStreamPipe isPipe = mDiskCache.getInputStreamPipe(key);
+            if (isPipe == null) {
+                return false;
+            } else {
+                try {
+                    isPipe.obtain();
+                    InputStream is = isPipe.open();
+                    Util.copy(is, os);
+                    return true;
+                } catch (IOException e) {
+                    return false;
+                } finally {
+                    isPipe.close();
+                    isPipe.release();
+                }
+            }
+        }
+    }
+
+    private class MemoryCache<E> extends LruCache<String, E> {
+
+        public BeerBelly<E> mParent;
+
+        public MemoryCache(int maxSize, BeerBelly<E> parent) {
+            super(maxSize);
+            mParent = parent;
+        }
+
+        @Override
+        protected int sizeOf(String key, E value) {
+            return mParent.sizeOf(key, value);
+        }
+
+        @Override
+        protected void entryRemoved(boolean evicted, String key, E oldValue, E newValue) {
+            mParent.memoryEntryRemoved(evicted, key, oldValue, newValue);
+        }
+    }
+}
@@ -0,0 +1,985 @@
+/*
+ * Copyright (C) 2011 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 com.hippo.beerbelly;
+
+import java.io.BufferedWriter;
+import java.io.Closeable;
+import java.io.EOFException;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FilterOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * A cache that uses a bounded amount of space on a filesystem. Each cache
+ * entry has a string key and a fixed number of values. Each key must match
+ * the regex <strong>[a-z0-9_-]{1,120}</strong>. Values are byte sequences,
+ * accessible as streams or files. Each value must be between {@code 0} and
+ * {@code Integer.MAX_VALUE} bytes in length.
+ *
+ * <p>The cache stores its data in a directory on the filesystem. This
+ * directory must be exclusive to the cache; the cache may delete or overwrite
+ * files from its directory. It is an error for multiple processes to use the
+ * same cache directory at the same time.
+ *
+ * <p>This cache limits the number of bytes that it will store on the
+ * filesystem. When the number of stored bytes exceeds the limit, the cache will
+ * remove entries in the background until the limit is satisfied. The limit is
+ * not strict: the cache may temporarily exceed it while waiting for files to be
+ * deleted. The limit does not include filesystem overhead or the cache
+ * journal so space-sensitive applications should set a conservative limit.
+ *
+ * <p>Clients call {@link #edit} to create or update the values of an entry. An
+ * entry may have only one editor at one time; if a value is not available to be
+ * edited then {@link #edit} will return null.
+ * <ul>
+ * <li>When an entry is being <strong>created</strong> it is necessary to
+ * supply a full set of values; the empty value should be used as a
+ * placeholder if necessary.
+ * <li>When an entry is being <strong>edited</strong>, it is not necessary
+ * to supply data for every value; values default to their previous
+ * value.
+ * </ul>
+ * Every {@link #edit} call must be matched by a call to {@link Editor#commit}
+ * or {@link Editor#abort}. Committing is atomic: a read observes the full set
+ * of values as they were before or after the commit, but never a mix of values.
+ *
+ * <p>Clients call {@link #get} to read a snapshot of an entry. The read will
+ * observe the value at the time that {@link #get} was called. Updates and
+ * removals after the call do not impact ongoing reads.
+ *
+ * <p>This class is tolerant of some I/O errors. If files are missing from the
+ * filesystem, the corresponding entries will be dropped from the cache. If
+ * an error occurs while writing a cache value, the edit will fail silently.
+ * Callers should handle other problems by catching {@code IOException} and
+ * responding appropriately.
+ */
+public final class DiskLruCache implements Closeable {
+    static final String JOURNAL_FILE = "journal";
+    static final String JOURNAL_FILE_TEMP = "journal.tmp";
+    static final String JOURNAL_FILE_BACKUP = "journal.bkp";
+    static final String MAGIC = "libcore.io.DiskLruCache";
+    static final String VERSION_1 = "1";
+    static final long ANY_SEQUENCE_NUMBER = -1;
+    static final String STRING_KEY_PATTERN = "[a-z0-9_-]{1,120}";
+    static final Pattern LEGAL_KEY_PATTERN = Pattern.compile(STRING_KEY_PATTERN);
+    private static final String CLEAN = "CLEAN";
+    private static final String DIRTY = "DIRTY";
+    private static final String REMOVE = "REMOVE";
+    private static final String READ = "READ";
+
+    /*
+     * This cache uses a journal file named "journal". A typical journal file
+     * looks like this:
+     *     libcore.io.DiskLruCache
+     *     1
+     *     100
+     *     2
+     *
+     *     CLEAN 3400330d1dfc7f3f7f4b8d4d803dfcf6 832 21054
+     *     DIRTY 335c4c6028171cfddfbaae1a9c313c52
+     *     CLEAN 335c4c6028171cfddfbaae1a9c313c52 3934 2342
+     *     REMOVE 335c4c6028171cfddfbaae1a9c313c52
+     *     DIRTY 1ab96a171faeeee38496d8b330771a7a
+     *     CLEAN 1ab96a171faeeee38496d8b330771a7a 1600 234
+     *     READ 335c4c6028171cfddfbaae1a9c313c52
+     *     READ 3400330d1dfc7f3f7f4b8d4d803dfcf6
+     *
+     * The first five lines of the journal form its header. They are the
+     * constant string "libcore.io.DiskLruCache", the disk cache's version,
+     * the application's version, the value count, and a blank line.
+     *
+     * Each of the subsequent lines in the file is a record of the state of a
+     * cache entry. Each line contains space-separated values: a state, a key,
+     * and optional state-specific values.
+     *   o DIRTY lines track that an entry is actively being created or updated.
+     *     Every successful DIRTY action should be followed by a CLEAN or REMOVE
+     *     action. DIRTY lines without a matching CLEAN or REMOVE indicate that
+     *     temporary files may need to be deleted.
+     *   o CLEAN lines track a cache entry that has been successfully published
+     *     and may be read. A publish line is followed by the lengths of each of
+     *     its values.
+     *   o READ lines track accesses for LRU.
+     *   o REMOVE lines track entries that have been deleted.
+     *
+     * The journal file is appended to as cache operations occur. The journal may
+     * occasionally be compacted by dropping redundant lines. A temporary file named
+     * "journal.tmp" will be used during compaction; that file should be deleted if
+     * it exists when the cache is opened.
+     */
+    private static final OutputStream NULL_OUTPUT_STREAM = new OutputStream() {
+        @Override
+        public void write(int b) {
+            // Eat all writes silently. Nom nom.
+        }
+    };
+    /**
+     * This cache uses a single background thread to evict entries.
+     */
+    final ThreadPoolExecutor executorService =
+            new ThreadPoolExecutor(0, 1, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
+    private final File directory;
+    private final File journalFile;
+    private final File journalFileTmp;
+    private final File journalFileBackup;
+    private final int appVersion;
+    private final int valueCount;
+    private final LinkedHashMap<String, Entry> lruEntries =
+            new LinkedHashMap<>(0, 0.75f, true);
+    private long maxSize;
+    private long size = 0;
+    private Writer journalWriter;
+    private int redundantOpCount;
+    /**
+     * To differentiate between old and current snapshots, each entry is given
+     * a sequence number each time an edit is committed. A snapshot is stale if
+     * its sequence number is not equal to its entry's sequence number.
+     */
+    private long nextSequenceNumber = 0;
+
+    private DiskLruCache(File directory, int appVersion, int valueCount, long maxSize) {
+        this.directory = directory;
+        this.appVersion = appVersion;
+        this.journalFile = new File(directory, JOURNAL_FILE);
+        this.journalFileTmp = new File(directory, JOURNAL_FILE_TEMP);
+        this.journalFileBackup = new File(directory, JOURNAL_FILE_BACKUP);
+        this.valueCount = valueCount;
+        this.maxSize = maxSize;
+    }
+
+    /**
+     * Opens the cache in {@code directory}, creating a cache if none exists
+     * there.
+     *
+     * @param directory  a writable directory
+     * @param valueCount the number of values per cache entry. Must be positive.
+     * @param maxSize    the maximum number of bytes this cache should use to store
+     * @throws IOException if reading or writing the cache directory fails
+     */
+    public static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize)
+            throws IOException {
+        if (maxSize <= 0) {
+            throw new IllegalArgumentException("maxSize <= 0");
+        }
+        if (valueCount <= 0) {
+            throw new IllegalArgumentException("valueCount <= 0");
+        }
+
+        // If a bkp file exists, use it instead.
+        File backupFile = new File(directory, JOURNAL_FILE_BACKUP);
+        if (backupFile.exists()) {
+            File journalFile = new File(directory, JOURNAL_FILE);
+            // If journal file also exists just delete backup file.
+            if (journalFile.exists()) {
+                backupFile.delete();
+            } else {
+                renameTo(backupFile, journalFile, false);
+            }
+        }
+
+        // Prefer to pick up where we left off.
+        DiskLruCache cache = new DiskLruCache(directory, appVersion, valueCount, maxSize);
+        if (cache.journalFile.exists()) {
+            try {
+                cache.readJournal();
+                cache.processJournal();
+                return cache;
+            } catch (IOException journalIsCorrupt) {
+                System.out
+                        .println("DiskLruCache "
+                                + directory
+                                + " is corrupt: "
+                                + journalIsCorrupt.getMessage()
+                                + ", removing");
+                cache.delete();
+            }
+        }
+
+        // Create a new empty cache.
+        directory.mkdirs();
+        cache = new DiskLruCache(directory, appVersion, valueCount, maxSize);
+        cache.rebuildJournal();
+        return cache;
+    }
+
+    private static void deleteIfExists(File file) throws IOException {
+        if (file.exists() && !file.delete()) {
+            throw new IOException();
+        }
+    }
+
+    private static void renameTo(File from, File to, boolean deleteDestination) throws IOException {
+        if (deleteDestination) {
+            deleteIfExists(to);
+        }
+        if (!from.renameTo(to)) {
+            throw new IOException();
+        }
+    }    private final Callable<Void> cleanupCallable = new Callable<>() {
+        public Void call() throws Exception {
+            synchronized (DiskLruCache.this) {
+                if (journalWriter == null) {
+                    return null; // Closed.
+                }
+                trimToSize();
+                if (journalRebuildRequired()) {
+                    rebuildJournal();
+                    redundantOpCount = 0;
+                }
+            }
+            return null;
+        }
+    };
+
+    private static String inputStreamToString(InputStream in) throws IOException {
+        return Util.readFully(new InputStreamReader(in, Util.UTF_8));
+    }
+
+    private void readJournal() throws IOException {
+        StrictLineReader reader = new StrictLineReader(new FileInputStream(journalFile), Util.US_ASCII);
+        try {
+            String magic = reader.readLine();
+            String version = reader.readLine();
+            String appVersionString = reader.readLine();
+            String valueCountString = reader.readLine();
+            String blank = reader.readLine();
+            if (!MAGIC.equals(magic)
+                    || !VERSION_1.equals(version)
+                    || !Integer.toString(appVersion).equals(appVersionString)
+                    || !Integer.toString(valueCount).equals(valueCountString)
+                    || !"".equals(blank)) {
+                throw new IOException("unexpected journal header: [" + magic + ", " + version + ", "
+                        + valueCountString + ", " + blank + "]");
+            }
+
+            int lineCount = 0;
+            while (true) {
+                try {
+                    readJournalLine(reader.readLine());
+                    lineCount++;
+                } catch (EOFException endOfJournal) {
+                    break;
+                }
+            }
+            redundantOpCount = lineCount - lruEntries.size();
+
+            // If we ended on a truncated line, rebuild the journal before appending to it.
+            if (reader.hasUnterminatedLine()) {
+                rebuildJournal();
+            } else {
+                journalWriter = new BufferedWriter(new OutputStreamWriter(
+                        new FileOutputStream(journalFile, true), Util.US_ASCII));
+            }
+        } finally {
+            Util.closeQuietly(reader);
+        }
+    }
+
+    private void readJournalLine(String line) throws IOException {
+        int firstSpace = line.indexOf(' ');
+        if (firstSpace == -1) {
+            throw new IOException("unexpected journal line: " + line);
+        }
+
+        int keyBegin = firstSpace + 1;
+        int secondSpace = line.indexOf(' ', keyBegin);
+        final String key;
+        if (secondSpace == -1) {
+            key = line.substring(keyBegin);
+            if (firstSpace == REMOVE.length() && line.startsWith(REMOVE)) {
+                lruEntries.remove(key);
+                return;
+            }
+        } else {
+            key = line.substring(keyBegin, secondSpace);
+        }
+
+        Entry entry = lruEntries.get(key);
+        if (entry == null) {
+            entry = new Entry(key);
+            lruEntries.put(key, entry);
+        }
+
+        if (secondSpace != -1 && firstSpace == CLEAN.length() && line.startsWith(CLEAN)) {
+            String[] parts = line.substring(secondSpace + 1).split(" ");
+            entry.readable = true;
+            entry.currentEditor = null;
+            entry.setLengths(parts);
+        } else if (secondSpace == -1 && firstSpace == DIRTY.length() && line.startsWith(DIRTY)) {
+            entry.currentEditor = new Editor(entry);
+        } else if (secondSpace == -1 && firstSpace == READ.length() && line.startsWith(READ)) {
+            // This work was already done by calling lruEntries.get().
+        } else {
+            throw new IOException("unexpected journal line: " + line);
+        }
+    }
+
+    /**
+     * Computes the initial size and collects garbage as a part of opening the
+     * cache. Dirty entries are assumed to be inconsistent and will be deleted.
+     */
+    private void processJournal() throws IOException {
+        deleteIfExists(journalFileTmp);
+        for (Iterator<Entry> i = lruEntries.values().iterator(); i.hasNext(); ) {
+            Entry entry = i.next();
+            if (entry.currentEditor == null) {
+                for (int t = 0; t < valueCount; t++) {
+                    size += entry.lengths[t];
+                }
+            } else {
+                entry.currentEditor = null;
+                for (int t = 0; t < valueCount; t++) {
+                    deleteIfExists(entry.getCleanFile(t));
+                    deleteIfExists(entry.getDirtyFile(t));
+                }
+                i.remove();
+            }
+        }
+    }
+
+    /**
+     * Creates a new journal that omits redundant information. This replaces the
+     * current journal if it exists.
+     */
+    private synchronized void rebuildJournal() throws IOException {
+        if (journalWriter != null) {
+            journalWriter.close();
+        }
+
+        try (Writer writer = new BufferedWriter(
+                new OutputStreamWriter(new FileOutputStream(journalFileTmp), Util.US_ASCII))) {
+            writer.write(MAGIC);
+            writer.write("\n");
+            writer.write(VERSION_1);
+            writer.write("\n");
+            writer.write(Integer.toString(appVersion));
+            writer.write("\n");
+            writer.write(Integer.toString(valueCount));
+            writer.write("\n");
+            writer.write("\n");
+
+            for (Entry entry : lruEntries.values()) {
+                if (entry.currentEditor != null) {
+                    writer.write(DIRTY + ' ' + entry.key + '\n');
+                } else {
+                    writer.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');
+                }
+            }
+        }
+
+        if (journalFile.exists()) {
+            renameTo(journalFile, journalFileBackup, true);
+        }
+        renameTo(journalFileTmp, journalFile, false);
+        journalFileBackup.delete();
+
+        journalWriter = new BufferedWriter(
+                new OutputStreamWriter(new FileOutputStream(journalFile, true), Util.US_ASCII));
+    }
+
+    /**
+     * Return {@code true} if it contains the key
+     */
+    public synchronized boolean contain(String key) {
+        checkNotClosed();
+        validateKey(key);
+        Entry entry = lruEntries.get(key);
+        return entry != null && entry.readable;
+    }
+
+    /**
+     * Returns a snapshot of the entry named {@code key}, or null if it doesn't
+     * exist is not currently readable. If a value is returned, it is moved to
+     * the head of the LRU queue.
+     */
+    public synchronized Snapshot get(String key) throws IOException {
+        checkNotClosed();
+        validateKey(key);
+        Entry entry = lruEntries.get(key);
+        if (entry == null) {
+            return null;
+        }
+
+        if (!entry.readable) {
+            return null;
+        }
+
+        // Open all streams eagerly to guarantee that we see a single published
+        // snapshot. If we opened streams lazily then the streams could come
+        // from different edits.
+        InputStream[] ins = new InputStream[valueCount];
+        try {
+            for (int i = 0; i < valueCount; i++) {
+                ins[i] = new FileInputStream(entry.getCleanFile(i));
+            }
+        } catch (FileNotFoundException e) {
+            // A file must have been deleted manually!
+            for (int i = 0; i < valueCount; i++) {
+                if (ins[i] != null) {
+                    Util.closeQuietly(ins[i]);
+                } else {
+                    break;
+                }
+            }
+            return null;
+        }
+
+        redundantOpCount++;
+        journalWriter.append(READ + ' ').append(key).append(String.valueOf('\n'));
+        if (journalRebuildRequired()) {
+            executorService.submit(cleanupCallable);
+        }
+
+        return new Snapshot(key, entry.sequenceNumber, ins, entry.lengths);
+    }
+
+    /**
+     * Returns an editor for the entry named {@code key}, or null if another
+     * edit is in progress.
+     */
+    public Editor edit(String key) throws IOException {
+        return edit(key, ANY_SEQUENCE_NUMBER);
+    }
+
+    private synchronized Editor edit(String key, long expectedSequenceNumber) throws IOException {
+        checkNotClosed();
+        validateKey(key);
+        Entry entry = lruEntries.get(key);
+        if (expectedSequenceNumber != ANY_SEQUENCE_NUMBER && (entry == null
+                || entry.sequenceNumber != expectedSequenceNumber)) {
+            return null; // Snapshot is stale.
+        }
+        if (entry == null) {
+            entry = new Entry(key);
+            lruEntries.put(key, entry);
+        } else if (entry.currentEditor != null) {
+            return null; // Another edit is in progress.
+        }
+
+        Editor editor = new Editor(entry);
+        entry.currentEditor = editor;
+
+        // Flush the journal before creating files to prevent file leaks.
+        journalWriter.write(DIRTY + ' ' + key + '\n');
+        journalWriter.flush();
+        return editor;
+    }
+
+    /**
+     * Returns the directory where this cache stores its data.
+     */
+    public File getDirectory() {
+        return directory;
+    }
+
+    /**
+     * Returns the maximum number of bytes that this cache should use to store
+     * its data.
+     */
+    public synchronized long getMaxSize() {
+        return maxSize;
+    }
+
+    /**
+     * Changes the maximum number of bytes the cache can store and queues a job
+     * to trim the existing store, if necessary.
+     */
+    public synchronized void setMaxSize(long maxSize) {
+        this.maxSize = maxSize;
+        executorService.submit(cleanupCallable);
+    }
+
+    /**
+     * Returns the number of bytes currently being used to store the values in
+     * this cache. This may be greater than the max size if a background
+     * deletion is pending.
+     */
+    public synchronized long size() {
+        return size;
+    }
+
+    private synchronized void completeEdit(Editor editor, boolean success) throws IOException {
+        Entry entry = editor.entry;
+        if (entry.currentEditor != editor) {
+            throw new IllegalStateException();
+        }
+
+        // If this edit is creating the entry for the first time, every index must have a value.
+        if (success && !entry.readable) {
+            for (int i = 0; i < valueCount; i++) {
+                if (!editor.written[i]) {
+                    editor.abort();
+                    throw new IllegalStateException("Newly created entry didn't create value for index " + i);
+                }
+                if (!entry.getDirtyFile(i).exists()) {
+                    editor.abort();
+                    return;
+                }
+            }
+        }
+
+        for (int i = 0; i < valueCount; i++) {
+            File dirty = entry.getDirtyFile(i);
+            if (success) {
+                if (dirty.exists()) {
+                    File clean = entry.getCleanFile(i);
+                    dirty.renameTo(clean);
+                    long oldLength = entry.lengths[i];
+                    long newLength = clean.length();
+                    entry.lengths[i] = newLength;
+                    size = size - oldLength + newLength;
+                }
+            } else {
+                deleteIfExists(dirty);
+            }
+        }
+
+        redundantOpCount++;
+        entry.currentEditor = null;
+        if (entry.readable | success) {
+            entry.readable = true;
+            journalWriter.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');
+            if (success) {
+                entry.sequenceNumber = nextSequenceNumber++;
+            }
+        } else {
+            lruEntries.remove(entry.key);
+            journalWriter.write(REMOVE + ' ' + entry.key + '\n');
+        }
+        journalWriter.flush();
+
+        if (size > maxSize || journalRebuildRequired()) {
+            executorService.submit(cleanupCallable);
+        }
+    }
+
+    /**
+     * We only rebuild the journal when it will halve the size of the journal
+     * and eliminate at least 2000 ops.
+     */
+    private boolean journalRebuildRequired() {
+        final int redundantOpCompactThreshold = 2000;
+        return redundantOpCount >= redundantOpCompactThreshold //
+                && redundantOpCount >= lruEntries.size();
+    }
+
+    /**
+     * Drops the entry for {@code key} if it exists and can be removed. Entries
+     * actively being edited cannot be removed.
+     *
+     * @return true if an entry was removed.
+     */
+    public synchronized boolean remove(String key) throws IOException {
+        checkNotClosed();
+        validateKey(key);
+        Entry entry = lruEntries.get(key);
+        if (entry == null || entry.currentEditor != null) {
+            return false;
+        }
+
+        for (int i = 0; i < valueCount; i++) {
+            File file = entry.getCleanFile(i);
+            if (file.exists() && !file.delete()) {
+                throw new IOException("failed to delete " + file);
+            }
+            size -= entry.lengths[i];
+            entry.lengths[i] = 0;
+        }
+
+        redundantOpCount++;
+        journalWriter.append(REMOVE + ' ').append(key).append(String.valueOf('\n'));
+        lruEntries.remove(key);
+
+        if (journalRebuildRequired()) {
+            executorService.submit(cleanupCallable);
+        }
+
+        return true;
+    }
+
+    /**
+     * Returns true if this cache has been closed.
+     */
+    public synchronized boolean isClosed() {
+        return journalWriter == null;
+    }
+
+    private void checkNotClosed() {
+        if (journalWriter == null) {
+            throw new IllegalStateException("cache is closed");
+        }
+    }
+
+    /**
+     * Force buffered operations to the filesystem.
+     */
+    public synchronized void flush() throws IOException {
+        checkNotClosed();
+        trimToSize();
+        journalWriter.flush();
+    }
+
+    /**
+     * Closes this cache. Stored values will remain on the filesystem.
+     */
+    public synchronized void close() throws IOException {
+        if (journalWriter == null) {
+            return; // Already closed.
+        }
+        for (Entry entry : new ArrayList<>(lruEntries.values())) {
+            if (entry.currentEditor != null) {
+                entry.currentEditor.abort();
+            }
+        }
+        trimToSize();
+        journalWriter.close();
+        journalWriter = null;
+    }
+
+    private void trimToSize() throws IOException {
+        while (size > maxSize) {
+            Map.Entry<String, Entry> toEvict = lruEntries.entrySet().iterator().next();
+            remove(toEvict.getKey());
+        }
+    }
+
+    /**
+     * Closes the cache and deletes all of its stored values. This will delete
+     * all files in the cache directory including files that weren't created by
+     * the cache.
+     */
+    public void delete() throws IOException {
+        close();
+        Util.deleteContents(directory);
+    }
+
+    private void validateKey(String key) {
+        Matcher matcher = LEGAL_KEY_PATTERN.matcher(key);
+        if (!matcher.matches()) {
+            throw new IllegalArgumentException("keys must match regex "
+                    + STRING_KEY_PATTERN + ": \"" + key + "\"");
+        }
+    }
+
+    /**
+     * A snapshot of the values for an entry.
+     */
+    public final class Snapshot implements Closeable {
+        private final String key;
+        private final long sequenceNumber;
+        private final InputStream[] ins;
+        private final long[] lengths;
+
+        private Snapshot(String key, long sequenceNumber, InputStream[] ins, long[] lengths) {
+            this.key = key;
+            this.sequenceNumber = sequenceNumber;
+            this.ins = ins;
+            this.lengths = lengths;
+        }
+
+        /**
+         * Returns an editor for this snapshot's entry, or null if either the
+         * entry has changed since this snapshot was created or if another edit
+         * is in progress.
+         */
+        public Editor edit() throws IOException {
+            return DiskLruCache.this.edit(key, sequenceNumber);
+        }
+
+        /**
+         * Returns the unbuffered stream with the value for {@code index}.
+         */
+        public InputStream getInputStream(int index) {
+            return ins[index];
+        }
+
+        /**
+         * Returns the string value for {@code index}.
+         */
+        public String getString(int index) throws IOException {
+            return inputStreamToString(getInputStream(index));
+        }
+
+        /**
+         * Returns the byte length of the value for {@code index}.
+         */
+        public long getLength(int index) {
+            return lengths[index];
+        }
+
+        public void close() {
+            for (InputStream in : ins) {
+                Util.closeQuietly(in);
+            }
+        }
+    }
+
+    /**
+     * Edits the values for an entry.
+     */
+    public final class Editor {
+        private final Entry entry;
+        private final boolean[] written;
+        private boolean hasErrors;
+        private boolean committed;
+
+        private Editor(Entry entry) {
+            this.entry = entry;
+            this.written = (entry.readable) ? null : new boolean[valueCount];
+        }
+
+        /**
+         * Returns an unbuffered input stream to read the last committed value,
+         * or null if no value has been committed.
+         */
+        public InputStream newInputStream(int index) {
+            synchronized (DiskLruCache.this) {
+                if (entry.currentEditor != this) {
+                    throw new IllegalStateException();
+                }
+                if (!entry.readable) {
+                    return null;
+                }
+                try {
+                    return new FileInputStream(entry.getCleanFile(index));
+                } catch (FileNotFoundException e) {
+                    return null;
+                }
+            }
+        }
+
+        /**
+         * Returns the last committed value as a string, or null if no value
+         * has been committed.
+         */
+        public String getString(int index) throws IOException {
+            InputStream in = newInputStream(index);
+            return in != null ? inputStreamToString(in) : null;
+        }
+
+        /**
+         * Returns a new unbuffered output stream to write the value at
+         * {@code index}. If the underlying output stream encounters errors
+         * when writing to the filesystem, this edit will be aborted when
+         * {@link #commit} is called. The returned output stream does not throw
+         * IOExceptions.
+         */
+        public OutputStream newOutputStream(int index) throws IOException {
+            if (index < 0 || index >= valueCount) {
+                throw new IllegalArgumentException("Expected index " + index + " to "
+                        + "be greater than 0 and less than the maximum value count "
+                        + "of " + valueCount);
+            }
+            synchronized (DiskLruCache.this) {
+                if (entry.currentEditor != this) {
+                    throw new IllegalStateException();
+                }
+                if (!entry.readable) {
+                    written[index] = true;
+                }
+                File dirtyFile = entry.getDirtyFile(index);
+                FileOutputStream outputStream;
+                try {
+                    outputStream = new FileOutputStream(dirtyFile);
+                } catch (FileNotFoundException e) {
+                    // Attempt to recreate the cache directory.
+                    directory.mkdirs();
+                    try {
+                        outputStream = new FileOutputStream(dirtyFile);
+                    } catch (FileNotFoundException e2) {
+                        // We are unable to recover. Silently eat the writes.
+                        return NULL_OUTPUT_STREAM;
+                    }
+                }
+                return new FaultHidingOutputStream(outputStream);
+            }
+        }
+
+        /**
+         * Sets the value at {@code index} to {@code value}.
+         */
+        public void set(int index, String value) throws IOException {
+            Writer writer = null;
+            try {
+                writer = new OutputStreamWriter(newOutputStream(index), Util.UTF_8);
+                writer.write(value);
+            } finally {
+                Util.closeQuietly(writer);
+            }
+        }
+
+        /**
+         * Commits this edit so it is visible to readers.  This releases the
+         * edit lock so another edit may be started on the same key.
+         */
+        public void commit() throws IOException {
+            if (hasErrors) {
+                completeEdit(this, false);
+                remove(entry.key); // The previous entry is stale.
+            } else {
+                completeEdit(this, true);
+            }
+            committed = true;
+        }
+
+        /**
+         * Aborts this edit. This releases the edit lock so another edit may be
+         * started on the same key.
+         */
+        public void abort() throws IOException {
+            completeEdit(this, false);
+        }
+
+        public void abortUnlessCommitted() {
+            if (!committed) {
+                try {
+                    abort();
+                } catch (IOException ignored) {
+                }
+            }
+        }
+
+        private class FaultHidingOutputStream extends FilterOutputStream {
+            private FaultHidingOutputStream(OutputStream out) {
+                super(out);
+            }
+
+            @Override
+            public void write(int oneByte) {
+                try {
+                    out.write(oneByte);
+                } catch (IOException e) {
+                    hasErrors = true;
+                }
+            }
+
+            @Override
+            public void write(byte[] buffer, int offset, int length) {
+                try {
+                    out.write(buffer, offset, length);
+                } catch (IOException e) {
+                    hasErrors = true;
+                }
+            }
+
+            @Override
+            public void close() {
+                try {
+                    out.close();
+                } catch (IOException e) {
+                    hasErrors = true;
+                }
+            }
+
+            @Override
+            public void flush() {
+                try {
+                    out.flush();
+                } catch (IOException e) {
+                    hasErrors = true;
+                }
+            }
+        }
+    }
+
+    private final class Entry {
+        private final String key;
+
+        /**
+         * Lengths of this entry's files.
+         */
+        private final long[] lengths;
+
+        /**
+         * True if this entry has ever been published.
+         */
+        private boolean readable;
+
+        /**
+         * The ongoing edit or null if this entry is not being edited.
+         */
+        private Editor currentEditor;
+
+        /**
+         * The sequence number of the most recently committed edit to this entry.
+         */
+        private long sequenceNumber;
+
+        private Entry(String key) {
+            this.key = key;
+            this.lengths = new long[valueCount];
+        }
+
+        public String getLengths() {
+            StringBuilder result = new StringBuilder();
+            for (long size : lengths) {
+                result.append(' ').append(size);
+            }
+            return result.toString();
+        }
+
+        /**
+         * Set lengths using decimal numbers like "10123".
+         */
+        private void setLengths(String[] strings) throws IOException {
+            if (strings.length != valueCount) {
+                throw invalidLengths(strings);
+            }
+
+            try {
+                for (int i = 0; i < strings.length; i++) {
+                    lengths[i] = Long.parseLong(strings[i]);
+                }
+            } catch (NumberFormatException e) {
+                throw invalidLengths(strings);
+            }
+        }
+
+        private IOException invalidLengths(String[] strings) throws IOException {
+            throw new IOException("unexpected journal line: " + java.util.Arrays.toString(strings));
+        }
+
+        public File getCleanFile(int i) {
+            return new File(directory, key + "." + i);
+        }
+
+        public File getDirtyFile(int i) {
+            return new File(directory, key + "." + i + ".tmp");
+        }
+    }
+
+
+
+
+}
@@ -0,0 +1,522 @@
+/*
+ * Copyright 2015-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.beerbelly;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.hippo.streampipe.InputStreamPipe;
+import com.hippo.streampipe.OutputStreamPipe;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+public class SimpleDiskCache {
+
+    private static final String TAG = SimpleDiskCache.class.getSimpleName();
+
+    /**
+     * Disk cache is free
+     */
+    private static final int STATE_DISK_CACHE_NONE = 0;
+
+    /**
+     * Disk cache is flushing or clearing
+     */
+    private static final int STATE_DISK_CACHE_IN_USE = 1;
+
+    /**
+     * Disk cache is reading or writing
+     */
+    private static final int STATE_DISK_CACHE_BUSY = 2;
+
+    private final File mCacheDir;
+    private final int mSize;
+    @NonNull
+    private final Map<String, CounterLock> mLockMap = new HashMap<>();
+    @NonNull
+    private final LockPool mLockPool = new LockPool();
+    private int mDiskCacheState;
+    @Nullable
+    private DiskLruCache mDiskLruCache;
+
+    public SimpleDiskCache(File cacheDir, int size) {
+        mCacheDir = cacheDir;
+        mSize = size;
+
+        try {
+            init();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * A hashing method that changes a string (like a URL) into a hash suitable
+     * for using as a disk filename.
+     *
+     * @param key The key used to store the file
+     */
+    private static String hashKeyForDisk(final String key) {
+        String cacheKey;
+        try {
+            final MessageDigest digest = MessageDigest.getInstance("MD5");
+            digest.update(key.getBytes());
+            cacheKey = bytesToHexString(digest.digest());
+        } catch (final NoSuchAlgorithmException e) {
+            cacheKey = String.valueOf(key.hashCode());
+        }
+        return cacheKey;
+    }
+
+    /**
+     * http://stackoverflow.com/questions/332079
+     *
+     * @param bytes The bytes to convert.
+     * @return A {@link String} converted from the bytes of a hashable key used
+     * to store a filename on the disk, to hex digits.
+     */
+    private static String bytesToHexString(final byte[] bytes) {
+        final StringBuilder builder = new StringBuilder();
+        for (final byte b : bytes) {
+            final String hex = Integer.toHexString(0xFF & b);
+            if (hex.length() == 1) {
+                builder.append('0');
+            }
+            builder.append(hex);
+        }
+        return builder.toString();
+    }
+
+    public synchronized boolean isValid() {
+        return mDiskLruCache != null;
+    }
+
+    private synchronized void init() throws IOException {
+        if (!isValid()) {
+            mDiskLruCache = DiskLruCache.open(mCacheDir, 1, 1, mSize);
+        }
+    }
+
+    public synchronized long size() {
+        if (null != mDiskLruCache) {
+            return mDiskLruCache.size();
+        } else {
+            return -1L;
+        }
+    }
+
+    public synchronized void flush() {
+        // Wait for cache available
+        while (mDiskCacheState != STATE_DISK_CACHE_NONE) {
+            try {
+                wait();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+        mDiskCacheState = STATE_DISK_CACHE_BUSY;
+
+        if (null != mDiskLruCache) {
+            try {
+                mDiskLruCache.flush();
+            } catch (IOException e) {
+                Log.e(TAG, "SimpleDiskCache flush", e);
+            }
+        }
+
+        mDiskCacheState = STATE_DISK_CACHE_NONE;
+        notifyAll();
+    }
+
+    public synchronized boolean clear() {
+        boolean result = true;
+        if (null == mDiskLruCache) {
+            return false;
+        }
+
+        // Wait for cache available
+        while (mDiskCacheState != STATE_DISK_CACHE_NONE) {
+            try {
+                wait();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+        mDiskCacheState = STATE_DISK_CACHE_BUSY;
+
+        try {
+            mDiskLruCache.delete();
+        } catch (IOException e) {
+            Log.e(TAG, "SimpleDiskCache clearCache", e);
+        }
+        mDiskLruCache = null;
+        try {
+            init();
+        } catch (IOException e) {
+            Log.e(TAG, "SimpleDiskCache init", e);
+            result = false;
+        }
+
+        mDiskCacheState = STATE_DISK_CACHE_NONE;
+        notifyAll();
+        return result;
+    }
+
+    private synchronized CounterLock obtainLock(String key) {
+        // Wait for clear over
+        while (mDiskCacheState == STATE_DISK_CACHE_BUSY) {
+            try {
+                wait();
+            } catch (InterruptedException e) {
+                // Empty
+            }
+        }
+        mDiskCacheState = STATE_DISK_CACHE_IN_USE;
+
+        // Get lock from key
+        CounterLock lock;
+        lock = mLockMap.get(key);
+        if (lock == null) {
+            lock = mLockPool.get();
+            mLockMap.put(key, lock);
+        }
+        lock.obtain();
+
+        return lock;
+    }
+
+    private synchronized void releaseLock(String key, CounterLock lock) {
+        lock.release();
+        if (lock.isFree()) {
+            mLockMap.remove(key);
+            mLockPool.push(lock);
+        }
+
+        if (mLockMap.isEmpty()) {
+            mDiskCacheState = STATE_DISK_CACHE_NONE;
+            notifyAll();
+        }
+    }
+
+    public boolean contain(@NonNull String key) {
+        String diskKey = hashKeyForDisk(key);
+        CounterLock lock = obtainLock(diskKey);
+        if (null == mDiskLruCache) {
+            releaseLock(diskKey, lock);
+            return false;
+        }
+        lock.readLock().lock();
+
+        boolean result = mDiskLruCache.contain(diskKey);
+
+        lock.readLock().unlock();
+        releaseLock(diskKey, lock);
+
+        return result;
+    }
+
+    public boolean remove(@NonNull String key) {
+        String diskKey = hashKeyForDisk(key);
+        CounterLock lock = obtainLock(diskKey);
+        if (null == mDiskLruCache) {
+            releaseLock(diskKey, lock);
+            return false;
+        }
+        lock.writeLock().lock();
+
+        boolean result;
+        try {
+            result = mDiskLruCache.remove(diskKey);
+        } catch (IOException e) {
+            e.printStackTrace();
+            result = false;
+        }
+
+        lock.writeLock().unlock();
+        releaseLock(diskKey, lock);
+
+        return result;
+    }
+
+    public boolean put(@NonNull String key, @NonNull InputStream is) {
+        String diskKey = hashKeyForDisk(key);
+        CounterLock lock = obtainLock(diskKey);
+        if (null == mDiskLruCache) {
+            releaseLock(diskKey, lock);
+            return false;
+        }
+        lock.writeLock().lock();
+
+        boolean result = false;
+        if (isValid()) {
+            result = putToDisk(diskKey, is);
+        }
+
+        lock.writeLock().unlock();
+        releaseLock(diskKey, lock);
+
+        return result;
+    }
+
+    private boolean putToDisk(String key, InputStream is) {
+        DiskLruCache.Editor editor = null;
+        OutputStream os = null;
+        boolean completeEdit = false;
+        try {
+            //noinspection ConstantConditions
+            editor = mDiskLruCache.edit(key);
+            if (editor == null) {
+                // The editor is in progress
+                return false;
+            }
+
+            os = editor.newOutputStream(0);
+            if (os != null) {
+                Util.copy(is, os);
+                completeEdit = true;
+                editor.commit();
+                return true;
+            } else {
+                // Can't get OutputStream
+                completeEdit = true;
+                editor.abort();
+                return false;
+            }
+        } catch (IOException e) {
+            Util.closeQuietly(os);
+            try {
+                if (!completeEdit && editor != null) {
+                    editor.abort();
+                }
+            } catch (IOException ignored) {
+            }
+            return false;
+        }
+    }
+
+    /**
+     * @param key the key of the target
+     * @return the InputStreamPipe, <code>null</code> for missing
+     */
+    @Nullable
+    public InputStreamPipe getInputStreamPipe(@NonNull String key) {
+        if (contain(key)) {
+            String diskKey = hashKeyForDisk(key);
+            return new CacheInputStreamPipe(diskKey);
+        } else {
+            return null;
+        }
+    }
+
+    @NonNull
+    public OutputStreamPipe getOutputStreamPipe(@NonNull String key) {
+        String diskKey = hashKeyForDisk(key);
+        return new CacheOutputStreamPipe(diskKey);
+    }
+
+    private class CacheInputStreamPipe implements InputStreamPipe {
+
+        private final String mKey;
+        private CounterLock mLock;
+        private DiskLruCache.Snapshot mCurrentSnapshot;
+
+        private CacheInputStreamPipe(String key) {
+            mKey = key;
+        }
+
+        @Override
+        public void obtain() {
+            if (mLock == null) {
+                mLock = obtainLock(mKey);
+                mLock.readLock().lock();
+            }
+        }
+
+        @Override
+        public void release() {
+            if (mCurrentSnapshot != null) {
+                throw new IllegalStateException("Please close it first");
+            }
+
+            if (mLock != null) {
+                mLock.readLock().unlock();
+                releaseLock(mKey, mLock);
+                mLock = null;
+            }
+        }
+
+        @Override
+        public @NonNull
+        InputStream open() throws IOException {
+            if (mLock == null) {
+                throw new IllegalStateException("Please obtain it first");
+            }
+            if (mCurrentSnapshot != null) {
+                throw new IllegalStateException("Please close it before reopen");
+            }
+            if (null == mDiskLruCache) {
+                throw new IOException("Can't find disk lru cache");
+            }
+
+            DiskLruCache.Snapshot snapshot;
+            snapshot = mDiskLruCache.get(mKey);
+            if (snapshot == null) {
+                throw new IOException("Miss the key " + mKey);
+            }
+            mCurrentSnapshot = snapshot;
+            return snapshot.getInputStream(0);
+        }
+
+        @Override
+        public void close() {
+            Util.closeQuietly(mCurrentSnapshot);
+            mCurrentSnapshot = null;
+        }
+    }
+
+    private class CacheOutputStreamPipe implements OutputStreamPipe {
+
+        private final String mKey;
+        private CounterLock mLock;
+        private DiskLruCache.Editor mCurrentEditor;
+
+        private CacheOutputStreamPipe(String key) {
+            mKey = key;
+        }
+
+        @Override
+        public void obtain() {
+            if (mLock == null) {
+                mLock = obtainLock(mKey);
+                mLock.writeLock().lock();
+            }
+        }
+
+        @Override
+        public void release() {
+            if (mCurrentEditor != null) {
+                throw new IllegalStateException("Please close it first");
+            }
+
+            if (mLock != null) {
+                mLock.writeLock().unlock();
+                releaseLock(mKey, mLock);
+                mLock = null;
+            }
+        }
+
+        @Override
+        public @NonNull
+        OutputStream open() throws IOException {
+            if (mLock == null) {
+                throw new IllegalStateException("Please obtain it first");
+            }
+            if (mCurrentEditor != null) {
+                throw new IllegalStateException("Please close it before reopen");
+            }
+            if (null == mDiskLruCache) {
+                throw new IOException("Can't find disk lru cache");
+            }
+
+            DiskLruCache.Editor editor = mDiskLruCache.edit(mKey);
+            if (editor == null) {
+                throw new IOException("Miss the key " + mKey);
+            }
+
+            OutputStream os;
+            try {
+                os = editor.newOutputStream(0);
+                mCurrentEditor = editor;
+                return os;
+            } catch (IOException e) {
+                // Get trouble
+                try {
+                    editor.abort();
+                } catch (IOException ex) {
+                    // Ignore
+                }
+                throw e;
+            }
+        }
+
+        @Override
+        public void close() {
+            if (mCurrentEditor != null) {
+                try {
+                    mCurrentEditor.commit();
+                } catch (IOException e) {
+                    // Empty
+                }
+                mCurrentEditor = null;
+            }
+        }
+    }
+
+    private class CounterLock extends ReentrantReadWriteLock {
+
+        private int mCount;
+
+        public boolean isFree() {
+            return mCount == 0;
+        }
+
+        public void release() {
+            if (--mCount < 0) {
+                throw new IllegalStateException("Release time is more than occupy time");
+            }
+        }
+
+        public void obtain() {
+            ++mCount;
+        }
+    }
+
+    private class LockPool {
+
+        private static final int MAX_SIZE = 10;
+
+        private final CounterLock[] mArray = new CounterLock[MAX_SIZE];
+        private final int mMaxSize = MAX_SIZE;
+        private int mSize;
+
+        public void push(CounterLock lock) {
+            if (lock != null && mSize < mMaxSize) {
+                mArray[mSize++] = lock;
+            }
+        }
+
+        public CounterLock get() {
+            if (mSize > 0) {
+                CounterLock lock = mArray[--mSize];
+                mArray[mSize] = null;
+                return lock;
+            } else {
+                return new CounterLock();
+            }
+        }
+    }
+}
@@ -0,0 +1,193 @@
+/*
+ * Copyright (C) 2012 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 com.hippo.beerbelly;
+
+import androidx.annotation.NonNull;
+
+import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.Charset;
+
+/**
+ * Buffers input from an {@link InputStream} for reading lines.
+ *
+ * <p>This class is used for buffered reading of lines. For purposes of this class, a line ends
+ * with "\n" or "\r\n". End of input is reported by throwing {@code EOFException}. Unterminated
+ * line at end of input is invalid and will be ignored, the caller may use {@code
+ * hasUnterminatedLine()} to detect it after catching the {@code EOFException}.
+ *
+ * <p>This class is intended for reading input that strictly consists of lines, such as line-based
+ * cache entries or cache journal. Unlike the {@link java.io.BufferedReader} which in conjunction
+ * with {@link java.io.InputStreamReader} provides similar functionality, this class uses different
+ * end-of-input reporting and a more restrictive definition of a line.
+ *
+ * <p>This class supports only charsets that encode '\r' and '\n' as a single byte with value 13
+ * and 10, respectively, and the representation of no other character contains these values.
+ * We currently check in constructor that the charset is one of US-ASCII, UTF-8 and ISO-8859-1.
+ * The default charset is US_ASCII.
+ */
+class StrictLineReader implements Closeable {
+    private static final byte CR = (byte) '\r';
+    private static final byte LF = (byte) '\n';
+
+    private final InputStream in;
+    private final Charset charset;
+
+    /*
+     * Buffered data is stored in {@code buf}. As long as no exception occurs, 0 <= pos <= end
+     * and the data in the range [pos, end) is buffered for reading. At end of input, if there is
+     * an unterminated line, we set end == -1, otherwise end == pos. If the underlying
+     * {@code InputStream} throws an {@code IOException}, end may remain as either pos or -1.
+     */
+    private byte[] buf;
+    private int pos;
+    private int end;
+
+    /**
+     * Constructs a new {@code LineReader} with the specified charset and the default capacity.
+     *
+     * @param in      the {@code InputStream} to read data from.
+     * @param charset the charset used to decode data. Only US-ASCII, UTF-8 and ISO-8859-1 are
+     *                supported.
+     * @throws NullPointerException     if {@code in} or {@code charset} is null.
+     * @throws IllegalArgumentException if the specified charset is not supported.
+     */
+    public StrictLineReader(InputStream in, Charset charset) {
+        this(in, 8192, charset);
+    }
+
+    /**
+     * Constructs a new {@code LineReader} with the specified capacity and charset.
+     *
+     * @param in       the {@code InputStream} to read data from.
+     * @param capacity the capacity of the buffer.
+     * @param charset  the charset used to decode data. Only US-ASCII, UTF-8 and ISO-8859-1 are
+     *                 supported.
+     * @throws NullPointerException     if {@code in} or {@code charset} is null.
+     * @throws IllegalArgumentException if {@code capacity} is negative or zero
+     *                                  or the specified charset is not supported.
+     */
+    public StrictLineReader(InputStream in, int capacity, Charset charset) {
+        if (in == null || charset == null) {
+            throw new NullPointerException();
+        }
+        if (capacity < 0) {
+            throw new IllegalArgumentException("capacity <= 0");
+        }
+        if (!(charset.equals(Util.US_ASCII))) {
+            throw new IllegalArgumentException("Unsupported encoding");
+        }
+
+        this.in = in;
+        this.charset = charset;
+        buf = new byte[capacity];
+    }
+
+    /**
+     * Closes the reader by closing the underlying {@code InputStream} and
+     * marking this reader as closed.
+     *
+     * @throws IOException for errors when closing the underlying {@code InputStream}.
+     */
+    public void close() throws IOException {
+        synchronized (in) {
+            if (buf != null) {
+                buf = null;
+                in.close();
+            }
+        }
+    }
+
+    /**
+     * Reads the next line. A line ends with {@code "\n"} or {@code "\r\n"},
+     * this end of line marker is not included in the result.
+     *
+     * @return the next line from the input.
+     * @throws IOException  for underlying {@code InputStream} errors.
+     * @throws EOFException for the end of source stream.
+     */
+    public String readLine() throws IOException {
+        synchronized (in) {
+            if (buf == null) {
+                throw new IOException("LineReader is closed");
+            }
+
+            // Read more data if we are at the end of the buffered data.
+            // Though it's an error to read after an exception, we will let {@code fillBuf()}
+            // throw again if that happens; thus we need to handle end == -1 as well as end == pos.
+            if (pos >= end) {
+                fillBuf();
+            }
+            // Try to find LF in the buffered data and return the line if successful.
+            for (int i = pos; i != end; ++i) {
+                if (buf[i] == LF) {
+                    int lineEnd = (i != pos && buf[i - 1] == CR) ? i - 1 : i;
+                    String res = new String(buf, pos, lineEnd - pos, charset);
+                    pos = i + 1;
+                    return res;
+                }
+            }
+
+            // Let's anticipate up to 80 characters on top of those already read.
+            ByteArrayOutputStream out = new ByteArrayOutputStream(end - pos + 80) {
+                @NonNull
+                @Override
+                public String toString() {
+                    int length = (count > 0 && buf[count - 1] == CR) ? count - 1 : count;
+                    return new String(buf, 0, length, charset);
+                }
+            };
+
+            while (true) {
+                out.write(buf, pos, end - pos);
+                // Mark unterminated line in case fillBuf throws EOFException or IOException.
+                end = -1;
+                fillBuf();
+                // Try to find LF in the buffered data and return the line if successful.
+                for (int i = pos; i != end; ++i) {
+                    if (buf[i] == LF) {
+                        if (i != pos) {
+                            out.write(buf, pos, i - pos);
+                        }
+                        pos = i + 1;
+                        return out.toString();
+                    }
+                }
+            }
+        }
+    }
+
+    public boolean hasUnterminatedLine() {
+        return end == -1;
+    }
+
+    /**
+     * Reads new input data into the buffer. Call only with pos == end or end == -1,
+     * depending on the desired outcome if the function throws.
+     */
+    private void fillBuf() throws IOException {
+        int result = in.read(buf, 0, buf.length);
+        if (result == -1) {
+            throw new EOFException();
+        }
+        pos = 0;
+        end = result;
+    }
+}
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2010 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 com.hippo.beerbelly;
+
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Reader;
+import java.io.StringWriter;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * Junk drawer of utility methods.
+ */
+final class Util {
+    static final Charset US_ASCII = StandardCharsets.US_ASCII;
+    static final Charset UTF_8 = StandardCharsets.UTF_8;
+    private static final int EOF = -1;
+    private static final int DEFAULT_BUFFER_SIZE = 1024 * 4;
+
+    private Util() {
+    }
+
+    static String readFully(Reader reader) throws IOException {
+        try (reader) {
+            StringWriter writer = new StringWriter();
+            char[] buffer = new char[1024];
+            int count;
+            while ((count = reader.read(buffer)) != -1) {
+                writer.write(buffer, 0, count);
+            }
+            return writer.toString();
+        }
+    }
+
+    /**
+     * Deletes the contents of {@code dir}. Throws an IOException if any file
+     * could not be deleted, or if {@code dir} is not a readable directory.
+     */
+    static void deleteContents(File dir) throws IOException {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            throw new IOException("not a readable directory: " + dir);
+        }
+        for (File file : files) {
+            if (file.isDirectory()) {
+                deleteContents(file);
+            }
+            if (!file.delete()) {
+                throw new IOException("failed to delete file: " + file);
+            }
+        }
+    }
+
+    static void closeQuietly(/*Auto*/Closeable closeable) {
+        if (closeable != null) {
+            try {
+                closeable.close();
+            } catch (RuntimeException rethrown) {
+                throw rethrown;
+            } catch (Exception ignored) {
+            }
+        }
+    }
+
+    /**
+     * Copy bytes from an <code>InputStream</code> to an
+     * <code>OutputStream</code>.
+     *
+     * @param input  the InputStream
+     * @param output the OutputStream
+     * @return the number of bytes copied
+     */
+    public static long copy(InputStream input, OutputStream output)
+            throws IOException {
+        byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
+        long count = 0;
+        int n;
+        while (EOF != (n = input.read(buffer))) {
+            output.write(buffer, 0, n);
+            count += n;
+        }
+        return count;
+    }
+}
@@ -25,7 +25,6 @@ import androidx.annotation.UiThread;

 import com.hippo.beerbelly.SimpleDiskCache;
 import com.hippo.okhttp.ChromeRequestBuilder;
-import com.hippo.streampipe.InputStreamPipe;
 import com.hippo.streampipe.OutputStreamPipe;

 import java.io.IOException;
@@ -35,8 +34,6 @@ import java.lang.ref.WeakReference;
 import java.util.concurrent.Executor;

 import okhttp3.Call;
-import okhttp3.HttpUrl;
-import okhttp3.MediaType;
 import okhttp3.OkHttpClient;
 import okhttp3.Request;
 import okhttp3.Response;
@@ -51,7 +48,6 @@ public final class ConacoTask<V> {
    private final WeakReference<Unikery<V>> mUnikeryWeakReference;
    private final String mKey;
    private final String mUrl;
-    private final DataContainer mDataContainer;
    private final boolean mUseMemoryCache;
    private final boolean mUseDiskCache;
    private final boolean mUseNetwork;
@@ -73,7 +69,6 @@ public final class ConacoTask<V> {
        mUnikeryWeakReference = new WeakReference<>(builder.mUnikery);
        mKey = builder.mKey;
        mUrl = builder.mUrl;
-        mDataContainer = builder.mDataContainer;
        mUseMemoryCache = builder.mUseMemoryCache;
        mUseDiskCache = builder.mUseDiskCache;
        mUseNetwork = builder.mUseNetwork;
@@ -85,42 +80,6 @@ public final class ConacoTask<V> {
        mConaco = builder.mConaco;
    }

-    private static void putFromDiskCacheToDataContainer(String key, ValueCache cache, DataContainer container) {
-        SimpleDiskCache diskCache = cache.getDiskCache();
-        if (diskCache != null) {
-            InputStreamPipe pipe = diskCache.getInputStreamPipe(key);
-            if (pipe != null) {
-                try {
-                    pipe.obtain();
-                    container.save(pipe.open(), -1L, null, null);
-                } catch (IOException e) {
-                    Log.d(TAG, "Can't save value from disk cache to data container");
-                    e.printStackTrace();
-                    container.remove();
-                } finally {
-                    pipe.close();
-                    pipe.release();
-                }
-            }
-        }
-    }
-
-    private static void putFromDataContainerToDiskCache(String key, ValueCache cache, DataContainer container) {
-        InputStreamPipe pipe = container.get();
-        if (pipe != null) {
-            try {
-                pipe.obtain();
-                cache.putRawToDisk(key, pipe.open());
-            } catch (IOException e) {
-                Log.w(TAG, "Can't save value from data container to disk cache", e);
-                cache.removeFromDisk(key);
-            } finally {
-                pipe.close();
-                pipe.release();
-            }
-        }
-    }
-
    int getId() {
        return mId;
    }
@@ -194,7 +153,6 @@ public final class ConacoTask<V> {
        } else if (mNetworkLoadTask != null) { // Getting from network
            mNetworkLoadTask.cancel(false);
            if (mCall != null) {
-                mCall.cancel();
                mCall = null;
            }
        }
@@ -219,7 +177,6 @@ public final class ConacoTask<V> {
        private Unikery<T> mUnikery;
        private String mKey;
        private String mUrl;
-        private DataContainer mDataContainer;
        private boolean mUseMemoryCache = true;
        private boolean mUseDiskCache = true;
        private boolean mUseNetwork = true;
@@ -262,11 +219,6 @@ public final class ConacoTask<V> {
            return this;
        }

-        public Builder<T> setDataContainer(DataContainer dataContainer) {
-            mDataContainer = dataContainer;
-            return this;
-        }
-
        boolean isUseMemoryCache() {
            return mUseMemoryCache;
        }
@@ -332,7 +284,7 @@ public final class ConacoTask<V> {
            if (mUnikery == null) {
                throw new IllegalStateException("Must set unikery");
            }
-            if (mKey == null && mUrl == null && mDataContainer == null) {
+            if (mKey == null && mUrl == null) {
                throw new IllegalStateException("At least one of mKey and mUrl and mDataContainer have to not be null");
            }
        }
@@ -352,26 +304,13 @@ public final class ConacoTask<V> {
            } else {
                V value = null;

-                // First check data container
-                if (mDataContainer != null && mDataContainer.isEnabled()) {
-                    InputStreamPipe isp = mDataContainer.get();
-                    if (isp != null) {
-                        value = mHelper.decode(isp);
-                    }
-                }
-
                // Then check disk cache
                if (mKey != null) {
                    if (value == null && mUseDiskCache) {
                        value = mCache.getFromDisk(mKey);
-                        // Put back to data container
-                        if (value != null && mDataContainer != null && mDataContainer.isEnabled()) {
-                            putFromDiskCacheToDataContainer(mKey, mCache, mDataContainer);
-                        }
                    }

                    if (value != null && mUseMemoryCache && mHelper.useMemoryCache(mKey, value)) {
-                        // Put it to memory
                        mCache.putToMemory(mKey, value);
                    }
                }
@@ -451,18 +390,6 @@ public final class ConacoTask<V> {
            }
        }

-        private boolean putToDataContainer(InputStream is, ResponseBody body) {
-            // Get media type
-            String mediaType;
-            MediaType mt = body.contentType();
-            if (mt != null) {
-                mediaType = mt.type() + '/' + mt.subtype();
-            } else {
-                mediaType = null;
-            }
-            return mDataContainer.save(is, body.contentLength(), mediaType, this);
-        }
-
        @Override
        protected V doInBackground(Void... params) {
            if (isNotNecessary(this)) {
@@ -489,7 +416,7 @@ public final class ConacoTask<V> {
                    return null;
                }

-                if ((mDataContainer == null || !mDataContainer.isEnabled()) && mKey != null) {
+                if (mKey != null) {
                    if (putToDiskCache(is, body.contentLength())) {
                        // Get object from disk cache
                        value = mCache.getFromDisk(mKey);
@@ -506,37 +433,6 @@ public final class ConacoTask<V> {
                        mCache.removeFromDisk(mKey);
                        return null;
                    }
-                } else if (mDataContainer != null && mDataContainer.isEnabled()) {
-                    // Check url Moved
-                    HttpUrl requestHttpUrl = request.url();
-                    HttpUrl responseHttpUrl = response.request().url();
-                    if (!responseHttpUrl.equals(requestHttpUrl)) {
-                        mDataContainer.onUrlMoved(mUrl, responseHttpUrl.url().toString());
-                    }
-
-                    // Put to data container
-                    if (!putToDataContainer(is, body)) {
-                        return null;
-                    }
-
-                    // Get value from data container
-                    InputStreamPipe isp = mDataContainer.get();
-                    if (isp == null) {
-                        return null;
-                    }
-                    value = mHelper.decode(isp);
-                    if (value == null) {
-                        mDataContainer.remove();
-                    } else if (mKey != null) {
-                        // Put to disk cache
-                        putFromDataContainerToDiskCache(mKey, mCache, mDataContainer);
-
-                        if (mUseMemoryCache && mHelper.useMemoryCache(mKey, value)) {
-                            // Put it to memory
-                            mCache.putToMemory(mKey, value);
-                        }
-                    }
-                    return value;
                } else {
                    return null;
                }
@@ -1,52 +0,0 @@
-/*
- * Copyright 2015-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.conaco;
-
-import androidx.annotation.Nullable;
-
-import com.hippo.streampipe.InputStreamPipe;
-
-import java.io.InputStream;
-
-public interface DataContainer {
-
-    /**
-     * Returns the enabled status for this DataContainer.
-     */
-    boolean isEnabled();
-
-    /**
-     * Get 304 or something like that
-     */
-    void onUrlMoved(String requestUrl, String responseUrl);
-
-    /**
-     * Save the {@code InputStream}
-     */
-    boolean save(InputStream is, long length, @Nullable String mediaType, @Nullable ProgressNotifier notify);
-
-    /**
-     * Get {@code InputStreamPipe} for saved before
-     */
-    @Nullable
-    InputStreamPipe get();
-
-    /**
-     * Remove saved stuff
-     */
-    void remove();
-}
@@ -1,131 +0,0 @@
-/*
- * Copyright 2017 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.database;
-
-/*
- * Created by Hippo on 2017/9/3.
- */
-
-import android.content.Context;
-import android.database.sqlite.SQLiteOpenHelper;
-import android.util.SparseArray;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-public class MSQLiteBuilder {
-
-    public static final String COLUMN_ID = "_id";
-
-    private static final Map<Class, String> JAVA_TYPE_TO_SQLITE_TYPE = new HashMap<>();
-
-    static {
-        JAVA_TYPE_TO_SQLITE_TYPE.put(boolean.class, "INTEGER NOT NULL DEFAULT 0");
-        JAVA_TYPE_TO_SQLITE_TYPE.put(byte.class, "INTEGER NOT NULL DEFAULT 0");
-        JAVA_TYPE_TO_SQLITE_TYPE.put(short.class, "INTEGER NOT NULL DEFAULT 0");
-        JAVA_TYPE_TO_SQLITE_TYPE.put(int.class, "INTEGER NOT NULL DEFAULT 0");
-        JAVA_TYPE_TO_SQLITE_TYPE.put(long.class, "INTEGER NOT NULL DEFAULT 0");
-        JAVA_TYPE_TO_SQLITE_TYPE.put(float.class, "REAL NOT NULL DEFAULT 0");
-        JAVA_TYPE_TO_SQLITE_TYPE.put(double.class, "REAL NOT NULL DEFAULT 0");
-        JAVA_TYPE_TO_SQLITE_TYPE.put(String.class, "TEXT");
-    }
-
-    private final SparseArray<List<String>> statementsMap = new SparseArray<>();
-    private int version = 0;
-    private List<String> statements;
-
-    private static String javaTypeToSQLiteType(Class clazz) {
-        String type = JAVA_TYPE_TO_SQLITE_TYPE.get(clazz);
-        if (type == null) {
-            throw new IllegalStateException("Unknown type: " + clazz);
-        }
-        return type;
-    }
-
-    /**
-     * Bump database version.
-     */
-    public MSQLiteBuilder version(int version) {
-        if (version <= this.version) {
-            throw new IllegalStateException("New version must be bigger than current version. "
-                    + "current version: " + this.version + ", new version: " + version + ".");
-        }
-        this.version = version;
-        this.statements = new ArrayList<>();
-        this.statementsMap.put(version, this.statements);
-        return this;
-    }
-
-    /**
-     * Creates a table with int {@link #COLUMN_ID} primary key.
-     */
-    public MSQLiteBuilder createTable(String table) {
-        return createTable(table, COLUMN_ID, int.class);
-    }
-
-    /**
-     * Creates a table.
-     */
-    public MSQLiteBuilder createTable(String table, String column, Class clazz) {
-        return statement("CREATE TABLE " + table + " (" + column + " " + javaTypeToSQLiteType(clazz) + " PRIMARY KEY);");
-    }
-
-    /**
-     * Drops a table.
-     */
-    public MSQLiteBuilder dropTable(String table) {
-        return statement("DROP TABLE " + table + ";");
-    }
-
-    /**
-     * Inserts a column to the table.
-     */
-    public MSQLiteBuilder insertColumn(String table, String column, Class clazz) {
-        return statement("ALTER TABLE " + table + " ADD COLUMN " + column + " " + javaTypeToSQLiteType(clazz) + ";");
-    }
-
-    /**
-     * Add a statement.
-     */
-    public MSQLiteBuilder statement(String statement) {
-        if (version == 0 || statements == null) {
-            throw new IllegalStateException("Call version() first!");
-        }
-        statements.add(statement);
-        return this;
-    }
-
-    /**
-     * Build a SQLiteOpenHelper from it.
-     */
-    public SQLiteOpenHelper build(Context context, String name, int version) {
-        return new MSQLiteOpenHelper(context, name, version, this);
-    }
-
-    List<String> getStatements(int oldVersion, int newVersion) {
-        List<String> result = new ArrayList<>();
-        for (int i = oldVersion + 1; i <= newVersion; ++i) {
-            List<String> list = statementsMap.get(i);
-            if (list != null) {
-                result.addAll(list);
-            }
-        }
-        return result;
-    }
-}
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2017 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.database
+
+import android.content.Context
+import android.database.sqlite.SQLiteOpenHelper
+import android.util.SparseArray
+
+class MSQLiteBuilder {
+    companion object {
+        const val COLUMN_ID = "_id"
+        private val JAVA_TYPE_TO_SQLITE_TYPE: MutableMap<Class<*>?, String> = HashMap()
+        private fun javaTypeToSQLiteType(clazz: Class<*>?): String {
+            return JAVA_TYPE_TO_SQLITE_TYPE[clazz]
+                ?: throw IllegalStateException("Unknown type: $clazz")
+        }
+
+        init {
+            JAVA_TYPE_TO_SQLITE_TYPE[Boolean::class.javaPrimitiveType] =
+                "INTEGER NOT NULL DEFAULT 0"
+            JAVA_TYPE_TO_SQLITE_TYPE[Byte::class.javaPrimitiveType] =
+                "INTEGER NOT NULL DEFAULT 0"
+            JAVA_TYPE_TO_SQLITE_TYPE[Short::class.javaPrimitiveType] =
+                "INTEGER NOT NULL DEFAULT 0"
+            JAVA_TYPE_TO_SQLITE_TYPE[Int::class.javaPrimitiveType] = "INTEGER NOT NULL DEFAULT 0"
+            JAVA_TYPE_TO_SQLITE_TYPE[Long::class.javaPrimitiveType] =
+                "INTEGER NOT NULL DEFAULT 0"
+            JAVA_TYPE_TO_SQLITE_TYPE[Float::class.javaPrimitiveType] =
+                "REAL NOT NULL DEFAULT 0"
+            JAVA_TYPE_TO_SQLITE_TYPE[Double::class.javaPrimitiveType] = "REAL NOT NULL DEFAULT 0"
+            JAVA_TYPE_TO_SQLITE_TYPE[String::class.java] = "TEXT"
+        }
+    }
+
+    private val statementsMap = SparseArray<List<String>?>()
+    private var version = 0
+    private var statements: MutableList<String>? = null
+
+    /**
+     * Bump database version.
+     */
+    fun version(version: Int): MSQLiteBuilder {
+        check(version > this.version) {
+            ("New version must be bigger than current version. "
+                    + "current version: " + this.version + ", new version: " + version + ".")
+        }
+        this.version = version
+        statements = ArrayList()
+        statementsMap.put(version, statements)
+        return this
+    }
+    /**
+     * Creates a table.
+     */
+    /**
+     * Creates a table with int [.COLUMN_ID] primary key.
+     */
+    @JvmOverloads
+    fun createTable(
+        table: String,
+        column: String = COLUMN_ID,
+        clazz: Class<*>? = Int::class.javaPrimitiveType
+    ): MSQLiteBuilder {
+        return statement("CREATE TABLE " + table + " (" + column + " " + javaTypeToSQLiteType(clazz) + " PRIMARY KEY);")
+    }
+
+    /**
+     * Drops a table.
+     */
+    fun dropTable(table: String): MSQLiteBuilder {
+        return statement("DROP TABLE $table;")
+    }
+
+    /**
+     * Inserts a column to the table.
+     */
+    fun insertColumn(table: String, column: String, clazz: Class<*>?): MSQLiteBuilder {
+        return statement(
+            "ALTER TABLE $table ADD COLUMN $column " + javaTypeToSQLiteType(
+                clazz
+            ) + ";"
+        )
+    }
+
+    /**
+     * Add a statement.
+     */
+    fun statement(statement: String): MSQLiteBuilder {
+        check(!(version == 0 || statements == null)) { "Call version() first!" }
+        statements!!.add(statement)
+        return this
+    }
+
+    /**
+     * Build a SQLiteOpenHelper from it.
+     */
+    fun build(context: Context?, name: String?, version: Int): SQLiteOpenHelper {
+        return MSQLiteOpenHelper(context, name, version, this)
+    }
+
+    fun getStatements(oldVersion: Int, newVersion: Int): List<String> {
+        val result: MutableList<String> = ArrayList()
+        for (i in oldVersion + 1..newVersion) {
+            val list = statementsMap[i]
+            if (list != null) {
+                result.addAll(list)
+            }
+        }
+        return result
+    }
+}
@@ -1,57 +0,0 @@
-/*
- * Copyright 2017 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.database;
-
-/*
- * Created by Hippo on 2017/9/4.
- */
-
-import android.content.Context;
-import android.database.sqlite.SQLiteDatabase;
-import android.database.sqlite.SQLiteOpenHelper;
-
-import com.hippo.util.SqlUtils;
-
-class MSQLiteOpenHelper extends SQLiteOpenHelper {
-
-    private final int version;
-    private final MSQLiteBuilder builder;
-
-    public MSQLiteOpenHelper(Context context, String name, int version, MSQLiteBuilder builder) {
-        super(context, name, null, version);
-        this.version = version;
-        this.builder = builder;
-    }
-
-    @Override
-    public void onCreate(SQLiteDatabase db) {
-        onUpgrade(db, 0, version);
-    }
-
-    @Override
-    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
-        for (String command : builder.getStatements(oldVersion, newVersion)) {
-            db.execSQL(command);
-        }
-    }
-
-    @Override
-    public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
-        SqlUtils.dropAllTable(db);
-        onCreate(db);
-    }
-}
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2017 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.database
+
+import android.content.Context
+import android.database.sqlite.SQLiteDatabase
+import android.database.sqlite.SQLiteOpenHelper
+import com.hippo.util.SqlUtils
+
+internal class MSQLiteOpenHelper(
+    context: Context?,
+    name: String?,
+    private val version: Int,
+    private val builder: MSQLiteBuilder
+) : SQLiteOpenHelper(context, name, null, version) {
+    override fun onCreate(db: SQLiteDatabase) {
+        onUpgrade(db, 0, version)
+    }
+
+    override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
+        for (command in builder.getStatements(oldVersion, newVersion)) {
+            db.execSQL(command)
+        }
+    }
+
+    override fun onDowngrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
+        SqlUtils.dropAllTable(db)
+        onCreate(db)
+    }
+}
@@ -16,6 +16,7 @@

 package com.hippo.drawable;

+import android.graphics.drawable.AnimatedImageDrawable;
 import android.graphics.drawable.Drawable;
 import android.util.Log;

@@ -25,8 +26,6 @@ import com.hippo.conaco.Conaco;
 import com.hippo.conaco.ConacoTask;
 import com.hippo.conaco.Unikery;
 import com.hippo.image.ImageBitmap;
-import com.hippo.image.ImageDrawable;
-import com.hippo.image.RecycledException;
 import com.hippo.widget.ObservedTextView;

 public class UnikeryDrawable extends WrapDrawable implements Unikery<ImageBitmap>,
@@ -38,6 +37,8 @@ public class UnikeryDrawable extends WrapDrawable implements Unikery<ImageBitmap
    private int mTaskId = Unikery.INVALID_ID;
    private String mUrl;

+    private ImageBitmap imageBitmap;
+
    public UnikeryDrawable(ObservedTextView textView, Conaco<ImageBitmap> conaco) {
        mTextView = textView;
        mTextView.setOnWindowAttachListener(this);
@@ -63,11 +64,11 @@ public class UnikeryDrawable extends WrapDrawable implements Unikery<ImageBitmap
    }

    private void clearDrawable() {
-        Drawable drawable = getDrawable();
-        if (drawable instanceof ImageDrawable) {
-            ((ImageDrawable) drawable).recycle();
-        }
        setDrawable(null);
+        if (imageBitmap != null) {
+            imageBitmap.release();
+            imageBitmap = null;
+        }
    }

    @Override
@@ -124,10 +125,10 @@ public class UnikeryDrawable extends WrapDrawable implements Unikery<ImageBitmap

    @Override
    public boolean onGetValue(@NonNull ImageBitmap value, int source) {
-        ImageDrawable drawable;
+        Drawable drawable;
        try {
-            drawable = new ImageDrawable(value);
-        } catch (RecycledException e) {
+            drawable = value.getDrawable();
+        } catch (Exception e) {
            Log.d(TAG, "The ImageBitmap is recycled", e);
            return false;
        }
@@ -135,7 +136,9 @@ public class UnikeryDrawable extends WrapDrawable implements Unikery<ImageBitmap
        clearDrawable();

        setDrawable(drawable);
-        drawable.start();
+        imageBitmap = value;
+        if (drawable instanceof AnimatedImageDrawable animatedImageDrawable)
+            animatedImageDrawable.start();

        return true;
    }
@@ -16,9 +16,7 @@

 package com.hippo.easyrecyclerview;

-import android.annotation.SuppressLint;
 import android.content.Context;
-import android.hardware.SensorManager;
 import android.os.Parcel;
 import android.os.Parcelable;
 import android.util.AttributeSet;
@@ -26,33 +24,20 @@ import android.util.SparseBooleanArray;
 import android.view.ActionMode;
 import android.view.Menu;
 import android.view.MenuItem;
-import android.view.MotionEvent;
 import android.view.View;
-import android.view.ViewConfiguration;
 import android.widget.Checkable;

 import androidx.annotation.NonNull;
 import androidx.collection.LongSparseArray;
-import androidx.core.view.ViewCompat;
-import androidx.recyclerview.widget.BridgeRecyclerView;
-import androidx.recyclerview.widget.LinearLayoutManager;
 import androidx.recyclerview.widget.RecyclerView;
-import androidx.recyclerview.widget.StaggeredGridLayoutManager;

-import com.hippo.ehviewer.Settings;
 import com.hippo.yorozuya.NumberUtils;

 /**
 * Add setChoiceMode for RecyclerView
 */
 // Get some code from twoway-view and AbsListView.
-public class EasyRecyclerView extends BridgeRecyclerView {
-
-    /**
-     * Represents an invalid position. All valid positions are in the range 0 to 1 less than the
-     * number of items in the current adapter.
-     */
-    public static final int INVALID_POSITION = -1;
+public class EasyRecyclerView extends RecyclerView {

    /**
     * Normal list that does not indicate choices
@@ -78,14 +63,8 @@ public class EasyRecyclerView extends BridgeRecyclerView {
     * The list allows multiple choices in custom action
     */
    public static final int CHOICE_MODE_MULTIPLE_CUSTOM = 4;
-    private static final float DECELERATION_RATE = (float) (Math.log(0.78) / Math.log(0.9));
    // Fling friction
-    private final float mFlingFriction = ViewConfiguration.getScrollFriction();
    public float pageScrollThreshold;
-    double flingMoveDistanceX;
-    double flingMoveDistanceY;
-    boolean canScrollVertical = true;
-    boolean canScrollHorizontally = true;
    /**
     * Wrapper for the multiple choice mode callback; AbsListView needs to perform
     * a few extra actions around what application code does.
@@ -131,30 +110,20 @@ public class EasyRecyclerView extends BridgeRecyclerView {
    private LongSparseArray<Integer> mCheckedIdStates;

    private Adapter<?> mAdapter;
-    private boolean isScrollBefore = false;
-    private int initialTouchX;
-    private int initialTouchY;
-    // A context-specific coefficient adjusted to physical values.
-    private float mPhysicalCoeff;
-    private int defaultOverflowItemScrollKeep;
-    private boolean enableScroll = false;

    public EasyRecyclerView(Context context) {
        super(context);
        EasyRecyclerView.this.init(context);
-        setEnableScroll(!Settings.getEInkMode());
    }

    public EasyRecyclerView(Context context, AttributeSet attrs) {
        super(context, attrs);
        EasyRecyclerView.this.init(context);
-        setEnableScroll(!Settings.getEInkMode());
    }

    public EasyRecyclerView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        EasyRecyclerView.this.init(context);
-        setEnableScroll(!Settings.getEInkMode());
    }

    public static void setViewChecked(View view, boolean checked) {
@@ -202,18 +171,7 @@ public class EasyRecyclerView extends BridgeRecyclerView {
        }
    }

-    /**
-     * Returns the number of items currently selected. This will only be valid
-     * if the choice mode is not {@link #CHOICE_MODE_NONE} (default).
-     *
-     * <p>To determine the specific items that are currently selected, use one of
-     * the <code>getChecked*</code> methods.
-     *
-     * @return The number of items currently selected
-     * @see #getCheckedItemPosition()
-     * @see #getCheckedItemPositions()
-     * @see #getCheckedItemIds()
-     */
+
    public int getCheckedItemCount() {
        return mCheckedItemCount;
    }
@@ -237,22 +195,6 @@ public class EasyRecyclerView extends BridgeRecyclerView {
        return false;
    }

-    /**
-     * Returns the currently checked item. The result is only valid if the choice
-     * mode has been set to {@link #CHOICE_MODE_SINGLE}.
-     *
-     * @return The position of the currently checked item or
-     * {@link #INVALID_POSITION} if nothing is selected
-     * @see #setChoiceMode(int)
-     */
-    public int getCheckedItemPosition() {
-        if (mChoiceMode == CHOICE_MODE_SINGLE && mCheckStates != null && mCheckStates.size() == 1) {
-            return mCheckStates.keyAt(0);
-        }
-
-        return INVALID_POSITION;
-    }
-
    /**
     * Returns the set of checked items in the list. The result is only valid if
     * the choice mode has not been set to {@link #CHOICE_MODE_NONE}.
@@ -269,30 +211,6 @@ public class EasyRecyclerView extends BridgeRecyclerView {
        return null;
    }

-    /**
-     * Returns the set of checked items ids. The result is only valid if the
-     * choice mode has not been set to {@link #CHOICE_MODE_NONE} and the adapter
-     * has stable IDs. ({@link android.widget.ListAdapter#hasStableIds()} == {@code true})
-     *
-     * @return A new array which contains the id of each checked item in the
-     * list.
-     */
-    public long[] getCheckedItemIds() {
-        if (mChoiceMode == CHOICE_MODE_NONE || mCheckedIdStates == null || mAdapter == null) {
-            return new long[0];
-        }
-
-        final LongSparseArray<Integer> idStates = mCheckedIdStates;
-        final int count = idStates.size();
-        final long[] ids = new long[count];
-
-        for (int i = 0; i < count; i++) {
-            ids[i] = idStates.keyAt(i);
-        }
-
-        return ids;
-    }
-
    public boolean isInCustomChoice() {
        return mCustomChoice;
    }
@@ -475,14 +393,6 @@ public class EasyRecyclerView extends BridgeRecyclerView {
        updateOnScreenCheckedViews();
    }

-    /**
-     * @return The current choice mode
-     * @see #setChoiceMode(int)
-     */
-    public int getChoiceMode() {
-        return mChoiceMode;
-    }
-
    /**
     * Defines the choice behavior for the List. By default, Lists do not have any choice behavior
     * ({@link #CHOICE_MODE_NONE}). By setting the choiceMode to {@link #CHOICE_MODE_SINGLE}, the
@@ -518,24 +428,6 @@ public class EasyRecyclerView extends BridgeRecyclerView {
        }
    }

-    /**
-     * Set a {@link MultiChoiceModeListener} that will manage the lifecycle of the
-     * selection {@link android.view.ActionMode}. Only used when the choice mode is set to
-     * {@link #CHOICE_MODE_MULTIPLE_MODAL}.
-     *
-     * @param listener Listener that will manage the selection mode
-     * @see #setChoiceMode(int)
-     */
-    public void setMultiChoiceModeListener(MultiChoiceModeListener listener) {
-        if (mMultiChoiceModeCallback == null) {
-            mMultiChoiceModeCallback = new MultiChoiceModeWrapper();
-        }
-        mMultiChoiceModeCallback.setWrapped(listener);
-    }
-
-    /**
-     * @param listener
-     */
    public void setCustomCheckedListener(CustomChoiceListener listener) {
        mCustomChoiceListener = listener;
    }
@@ -556,299 +448,13 @@ public class EasyRecyclerView extends BridgeRecyclerView {

    private void init(Context context) {
        float scale = context.getResources().getDisplayMetrics().density;
-        final float ppi = scale * 160.0f;
-        mPhysicalCoeff = SensorManager.GRAVITY_EARTH // g (m/s^2)
-                * 39.37f // inch/meter
-                * ppi
-                * 0.84f; // look and feel tuning
+        // g (m/s^2)
+        // inch/meter
+        // A context-specific coefficient adjusted to physical values.
+        // look and feel tuning
        pageScrollThreshold = scale * 80;
    }

-    public void setPageScrollThreshold(float pageScrollThreshold) {
-        this.pageScrollThreshold = pageScrollThreshold;
-    }
-
-    @SuppressLint("ClickableViewAccessibility")
-    @Override
-    public boolean onTouchEvent(MotionEvent e) {
-        if (enableScroll) {
-            return super.onTouchEvent(e);
-        }
-        boolean superTouchResult = super.onTouchEvent(e);
-        if (superTouchResult) {
-            switch (e.getAction()) {
-                case MotionEvent.ACTION_DOWN:
-                    initialTouchX = (int) (e.getX() + 0.5f);
-                    initialTouchY = (int) (e.getY() + 0.5f);
-                    break;
-                case MotionEvent.ACTION_MOVE:
-                    if (initialTouchX < 0 || initialTouchY < 0) {
-                        initialTouchX = (int) (e.getX() + 0.5f);
-                        initialTouchY = (int) (e.getY() + 0.5f);
-                    }
-                    break;
-                case MotionEvent.ACTION_UP:
-                    if (isScrollBefore) {
-                        int moveDistanceX = (int) (initialTouchX - e.getX() + flingMoveDistanceX);
-                        int moveDistanceY = (int) (initialTouchY - e.getY() + flingMoveDistanceY);
-                        onTouchScroll(moveDistanceX, moveDistanceY);
-                        initialTouchX = initialTouchY = -1;
-                    }
-                    break;
-            }
-            isScrollBefore = getScrollState() == SCROLL_STATE_DRAGGING;
-        }
-        return superTouchResult;
-    }
-
-    @Override
-    public boolean scrollByInternal(int x, int y, MotionEvent ev, int type) {
-        if (enableScroll) {
-            return super.scrollByInternal(x, y, ev, type);
-        }
-        //disable drag scroll effect，e-ink screen don't need it
-        return false;
-    }
-
-    @Override
-    public boolean fling(int velocityX, int velocityY) {
-        if (enableScroll) {
-            return super.fling(velocityX, velocityY);
-        }
-        flingMoveDistanceX = getSplineFlingDistance(velocityX) * Math.signum(velocityX);
-        flingMoveDistanceY = getSplineFlingDistance(velocityY) * Math.signum(velocityY);
-        //disable fling scroll effect,e-ink screen don't need it
-        return false;
-    }
-
-    protected void onTouchScroll(int dx, int dy) {
-        canScrollVertical = true;
-        canScrollHorizontally = true;
-        LayoutManager layout = getLayoutManager();
-        if (layout != null) {
-            if (dy > pageScrollThreshold) {
-                if (canScrollVertical && layout.canScrollVertically()) {
-                    canScrollVertical = false;
-                    onScrollDown();
-                } else if (canScrollHorizontally && layout.canScrollHorizontally()) {
-                    canScrollHorizontally = false;
-                    onScrollRight();
-                }
-            } else if (dy < -pageScrollThreshold) {
-                if (canScrollVertical && layout.canScrollVertically()) {
-                    canScrollVertical = false;
-                    onScrollUp();
-                } else if (canScrollHorizontally && layout.canScrollHorizontally()) {
-                    canScrollHorizontally = false;
-                    onScrollLeft();
-                }
-            }
-
-            if (dx > pageScrollThreshold) {
-                if (canScrollVertical && layout.canScrollVertically()) {
-                    onScrollDown();
-                } else if (canScrollHorizontally && layout.canScrollHorizontally()) {
-                    onScrollRight();
-                }
-            } else if (dx < -pageScrollThreshold) {
-                if (canScrollVertical && layout.canScrollVertically()) {
-                    onScrollUp();
-                } else if (canScrollHorizontally && layout.canScrollHorizontally()) {
-                    onScrollLeft();
-                }
-            }
-        }
-    }
-
-    protected void onScrollLeft() {
-        LayoutManager layout = getLayoutManager();
-        if (layout instanceof LinearLayoutManager) {
-            LinearLayoutManager realLayout = (LinearLayoutManager) layout;
-            int firstVisiblePosition = realLayout.findFirstVisibleItemPosition();
-            ViewHolder firstVisibleItem = findViewHolderForAdapterPosition(firstVisiblePosition);
-
-            if (firstVisibleItem == null) {
-                return;
-            }
-
-            //when the item width overscreen, findLastCompletelyVisibleItemPosition always return NO_POSITION
-            if (firstVisibleItem.itemView.getMeasuredWidth() > getMeasuredWidth()) {
-                super.scrollByInternal(-getMeasuredWidth() + defaultOverflowItemScrollKeep, 0, null, ViewCompat.TYPE_TOUCH);
-            } else if (firstVisibleItem.itemView.getMeasuredWidth() == getMeasuredWidth()) {
-                super.scrollByInternal(-getMeasuredWidth(), 0, null, ViewCompat.TYPE_TOUCH);
-            } else {
-                super.scrollByInternal(firstVisibleItem.itemView.getRight() - getMeasuredWidth(), 0, null, ViewCompat.TYPE_TOUCH);
-            }
-        } else if (layout instanceof StaggeredGridLayoutManager) {
-            StaggeredGridLayoutManager realLayout = (StaggeredGridLayoutManager) layout;
-            int[] firstVisiblePosition = realLayout.findFirstVisibleItemPositions(null);
-            ViewHolder[] firstVisibleItems = new ViewHolder[firstVisiblePosition.length];
-            for (int i = 0; i < firstVisiblePosition.length; i++) {
-                firstVisibleItems[i] = findViewHolderForAdapterPosition(firstVisiblePosition[i]);
-            }
-            int scrollDistance = Integer.MAX_VALUE;
-            for (ViewHolder firstVisibleItem : firstVisibleItems) {
-                if (firstVisibleItem != null) {
-                    if (firstVisibleItem.itemView.getRight() < scrollDistance) {
-                        scrollDistance = firstVisibleItem.itemView.getRight();
-                    }
-                }
-            }
-
-            if (scrollDistance == getMeasuredWidth()) {
-                scrollDistance = 0;
-            }
-            super.scrollByInternal(scrollDistance - getMeasuredWidth(), 0, null, ViewCompat.TYPE_TOUCH);
-        }
-    }
-
-    protected void onScrollRight() {
-        LayoutManager layout = getLayoutManager();
-        if (layout instanceof LinearLayoutManager) {
-            LinearLayoutManager realLayout = (LinearLayoutManager) layout;
-            int lastVisiblePosition = realLayout.findLastVisibleItemPosition();
-            ViewHolder lastVisibleItem = findViewHolderForAdapterPosition(lastVisiblePosition);
-
-            if (lastVisibleItem == null) {
-                return;
-            }
-
-            //when the item width overflow screen, findLastCompletelyVisibleItemPosition always return NO_POSITION
-            if (lastVisibleItem.itemView.getMeasuredWidth() > getMeasuredWidth()) {
-                super.scrollByInternal(getMeasuredWidth() - defaultOverflowItemScrollKeep, 0, null, ViewCompat.TYPE_TOUCH);
-            } else if (lastVisibleItem.itemView.getMeasuredWidth() == getMeasuredWidth()) {
-                super.scrollByInternal(getMeasuredWidth(), 0, null, ViewCompat.TYPE_TOUCH);
-            } else {
-                super.scrollByInternal(lastVisibleItem.itemView.getLeft(), 0, null, ViewCompat.TYPE_TOUCH);
-            }
-        } else if (layout instanceof StaggeredGridLayoutManager) {
-            StaggeredGridLayoutManager realLayout = (StaggeredGridLayoutManager) layout;
-            int[] lastVisiblePosition = realLayout.findLastVisibleItemPositions(null);
-            ViewHolder[] lastVisibleItems = new ViewHolder[lastVisiblePosition.length];
-            for (int i = 0; i < lastVisiblePosition.length; i++) {
-                lastVisibleItems[i] = findViewHolderForAdapterPosition(lastVisiblePosition[i]);
-            }
-            int scrollDistance = 0;
-            for (ViewHolder lastVisibleItem : lastVisibleItems) {
-                if (lastVisibleItem != null) {
-                    if (lastVisibleItem.itemView.getLeft() > scrollDistance) {
-                        scrollDistance = lastVisibleItem.itemView.getLeft();
-                    }
-                }
-            }
-            if (scrollDistance == 0) {
-                scrollDistance = getMeasuredWidth();
-            }
-            super.scrollByInternal(scrollDistance, 0, null, ViewCompat.TYPE_TOUCH);
-        }
-    }
-
-    protected void onScrollUp() {
-        LayoutManager layout = getLayoutManager();
-        if (layout instanceof LinearLayoutManager) {
-            LinearLayoutManager realLayout = (LinearLayoutManager) layout;
-            int firstVisiblePosition = realLayout.findFirstVisibleItemPosition();
-            ViewHolder firstVisibleItem = findViewHolderForAdapterPosition(firstVisiblePosition);
-
-            if (firstVisibleItem == null) {
-                return;
-            }
-
-            //when the item height overscreen, findLastCompletelyVisibleItemPosition always return NO_POSITION
-            if (firstVisibleItem.itemView.getMeasuredHeight() > getMeasuredHeight()) {
-                super.scrollByInternal(0, -getMeasuredHeight() + defaultOverflowItemScrollKeep, null, ViewCompat.TYPE_TOUCH);
-            } else if (firstVisibleItem.itemView.getMeasuredHeight() == getMeasuredHeight()) {
-                super.scrollByInternal(0, -getMeasuredHeight(), null, ViewCompat.TYPE_TOUCH);
-            } else {
-                super.scrollByInternal(0, firstVisibleItem.itemView.getBottom() - getMeasuredHeight(), null, ViewCompat.TYPE_TOUCH);
-            }
-        } else if (layout instanceof StaggeredGridLayoutManager) {
-            StaggeredGridLayoutManager realLayout = (StaggeredGridLayoutManager) layout;
-            int[] firstVisiblePosition = realLayout.findFirstVisibleItemPositions(null);
-            ViewHolder[] firstVisibleItems = new ViewHolder[firstVisiblePosition.length];
-            for (int i = 0; i < firstVisiblePosition.length; i++) {
-                firstVisibleItems[i] = findViewHolderForAdapterPosition(firstVisiblePosition[i]);
-            }
-            int scrollDistance = Integer.MAX_VALUE;
-            for (ViewHolder firstVisibleItem : firstVisibleItems) {
-                if (firstVisibleItem != null) {
-                    if (firstVisibleItem.itemView.getBottom() < scrollDistance) {
-                        scrollDistance = firstVisibleItem.itemView.getBaseline();
-                    }
-                }
-            }
-            if (scrollDistance == getMeasuredWidth()) {
-                scrollDistance = 0;
-            }
-            super.scrollByInternal(0, scrollDistance - getMeasuredHeight(), null, ViewCompat.TYPE_TOUCH);
-        }
-    }
-
-    protected void onScrollDown() {
-        LayoutManager layout = getLayoutManager();
-        if (layout instanceof LinearLayoutManager) {
-            LinearLayoutManager realLayout = (LinearLayoutManager) layout;
-            int lastVisiblePosition = realLayout.findLastVisibleItemPosition();
-            ViewHolder lastVisibleItem = findViewHolderForAdapterPosition(lastVisiblePosition);
-
-            if (lastVisibleItem == null) {
-                return;
-            }
-
-            //when the item height overflow screen, findLastCompletelyVisibleItemPosition always return NO_POSITION
-            if (lastVisibleItem.itemView.getMeasuredHeight() > getMeasuredHeight()) {
-                super.scrollByInternal(0, getMeasuredHeight() - defaultOverflowItemScrollKeep, null, ViewCompat.TYPE_TOUCH);
-            } else if (lastVisibleItem.itemView.getMeasuredHeight() == getMeasuredHeight()) {
-                super.scrollByInternal(0, getMeasuredHeight(), null, ViewCompat.TYPE_TOUCH);
-            } else {
-                super.scrollByInternal(0, lastVisibleItem.itemView.getTop(), null, ViewCompat.TYPE_TOUCH);
-            }
-        } else if (layout instanceof StaggeredGridLayoutManager) {
-            StaggeredGridLayoutManager realLayout = (StaggeredGridLayoutManager) layout;
-            int[] lastVisiblePosition = realLayout.findLastVisibleItemPositions(null);
-            ViewHolder[] lastVisibleItems = new ViewHolder[lastVisiblePosition.length];
-            for (int i = 0; i < lastVisiblePosition.length; i++) {
-                lastVisibleItems[i] = findViewHolderForAdapterPosition(lastVisiblePosition[i]);
-            }
-            int scrollDistance = 0;
-            for (ViewHolder lastVisibleItem : lastVisibleItems) {
-                if (lastVisibleItem != null) {
-                    if (lastVisibleItem.itemView.getTop() > scrollDistance) {
-                        scrollDistance = lastVisibleItem.itemView.getTop();
-                    }
-                }
-            }
-            if (scrollDistance == 0) {
-                scrollDistance = getMeasuredHeight();
-            }
-            super.scrollByInternal(0, scrollDistance, null, ViewCompat.TYPE_TOUCH);
-        }
-    }
-
-    @Override
-    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
-        super.onSizeChanged(w, h, oldw, oldh);
-        defaultOverflowItemScrollKeep = (int) (h * 0.05f);
-    }
-
-    private double getSplineDeceleration(int velocity) {
-        return Math.log(0.35f * Math.abs(velocity) / (mFlingFriction * mPhysicalCoeff));
-    }
-
-    private double getSplineFlingDistance(int velocity) {
-        final double l = getSplineDeceleration(velocity);
-        final double decelMinusOne = DECELERATION_RATE - 1.0;
-        return mFlingFriction * mPhysicalCoeff * Math.exp(DECELERATION_RATE / decelMinusOne * l);
-    }
-
-    public boolean isEnableScroll() {
-        return enableScroll;
-    }
-
-    public void setEnableScroll(boolean enableScroll) {
-        this.enableScroll = enableScroll;
-    }
-
    @Override
    public Parcelable onSaveInstanceState() {
        final SavedState ss = new SavedState(super.onSaveInstanceState());
@@ -1016,9 +622,6 @@ public class EasyRecyclerView extends BridgeRecyclerView {
    class MultiChoiceModeWrapper implements MultiChoiceModeListener {
        private MultiChoiceModeListener mWrapped;

-        public void setWrapped(MultiChoiceModeListener wrapped) {
-            mWrapped = wrapped;
-        }

        @SuppressWarnings("BooleanMethodIsAlwaysInverted")
        public boolean hasWrappedCallback() {
@@ -64,8 +64,7 @@ public final class LayoutManagerUtils {
            RecyclerView.LayoutManager layoutManager, Context context, int position,
            int millisecondsPerInch) {
        SimpleSmoothScroller smoothScroller;
-        if (layoutManager instanceof LinearLayoutManager) {
-            final LinearLayoutManager linearLayoutManager = (LinearLayoutManager) layoutManager;
+        if (layoutManager instanceof final LinearLayoutManager linearLayoutManager) {
            smoothScroller = new SimpleSmoothScroller(context, millisecondsPerInch) {
                @Override
                public PointF computeScrollVectorForPosition(int targetPosition) {
@@ -73,8 +72,7 @@ public final class LayoutManagerUtils {
                }
            };

-        } else if (layoutManager instanceof StaggeredGridLayoutManager) {
-            final StaggeredGridLayoutManager staggeredGridLayoutManager = (StaggeredGridLayoutManager) layoutManager;
+        } else if (layoutManager instanceof final StaggeredGridLayoutManager staggeredGridLayoutManager) {
            smoothScroller = new SimpleSmoothScroller(context, millisecondsPerInch) {
                @Override
                public PointF computeScrollVectorForPosition(int targetPosition) {
@@ -1,271 +0,0 @@
-/*
- * Copyright (C) 2015 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.easyrecyclerview;
-
-import android.graphics.Canvas;
-import android.graphics.Paint;
-import android.graphics.Rect;
-import android.view.View;
-
-import androidx.core.view.ViewCompat;
-import androidx.recyclerview.widget.LinearLayoutManager;
-import androidx.recyclerview.widget.RecyclerView;
-
-// Add overlap
-
-/**
- * Only work for {@link androidx.recyclerview.widget.LinearLayoutManager}.<br>
- * Show divider between item, just like
- * {@link android.widget.ListView#setDivider(android.graphics.drawable.Drawable)}
- */
-public class LinearDividerItemDecoration extends RecyclerView.ItemDecoration {
-    public static final int HORIZONTAL = LinearLayoutManager.HORIZONTAL;
-    public static final int VERTICAL = LinearLayoutManager.VERTICAL;
-    private final Rect mRect;
-    private final Paint mPaint;
-    private boolean mShowFirstDivider = false;
-    private boolean mShowLastDivider = false;
-    private int mOrientation;
-    private int mThickness;
-    private int mPaddingStart = 0;
-    private int mPaddingEnd = 0;
-
-    private boolean mOverlap = false;
-
-    private ShowDividerHelper mShowDividerHelper;
-
-    public LinearDividerItemDecoration(int orientation, int color, int thickness) {
-        mRect = new Rect();
-        mPaint = new Paint();
-        mPaint.setStyle(Paint.Style.FILL);
-        setOrientation(orientation);
-        setColor(color);
-        setThickness(thickness);
-    }
-
-    public void setShowDividerHelper(ShowDividerHelper showDividerHelper) {
-        mShowDividerHelper = showDividerHelper;
-    }
-
-    public void setOrientation(int orientation) {
-        if (orientation != HORIZONTAL && orientation != VERTICAL) {
-            throw new IllegalArgumentException("invalid orientation");
-        }
-        mOrientation = orientation;
-    }
-
-    public void setColor(int color) {
-        mPaint.setColor(color);
-    }
-
-    public void setThickness(int thickness) {
-        mThickness = thickness;
-    }
-
-    public void setShowFirstDivider(boolean showFirstDivider) {
-        mShowFirstDivider = showFirstDivider;
-    }
-
-    public void setShowLastDivider(boolean showLastDivider) {
-        mShowLastDivider = showLastDivider;
-    }
-
-    public void setPadding(int padding) {
-        setPaddingStart(padding);
-        setPaddingEnd(padding);
-    }
-
-    public void setPaddingStart(int paddingStart) {
-        mPaddingStart = paddingStart;
-    }
-
-    public void setPaddingEnd(int paddingEnd) {
-        mPaddingEnd = paddingEnd;
-    }
-
-    public void setOverlap(boolean overlap) {
-        mOverlap = overlap;
-    }
-
-    @Override
-    public void getItemOffsets(Rect outRect, View view,
-                               RecyclerView parent, RecyclerView.State state) {
-        if (parent.getAdapter() == null) {
-            outRect.set(0, 0, 0, 0);
-            return;
-        }
-
-        if (mOverlap) {
-            outRect.set(0, 0, 0, 0);
-            return;
-        }
-
-        final int position = parent.getChildLayoutPosition(view);
-        final int itemCount = parent.getAdapter().getItemCount();
-
-        if (mShowDividerHelper != null) {
-            if (mOrientation == VERTICAL) {
-                if (position == 0 && mShowDividerHelper.showDivider(0)) {
-                    outRect.top = mThickness;
-                }
-                if (mShowDividerHelper.showDivider(position + 1)) {
-                    outRect.bottom = mThickness;
-                }
-            } else {
-                if (position == 0 && mShowDividerHelper.showDivider(0)) {
-                    outRect.left = mThickness;
-                }
-                if (mShowDividerHelper.showDivider(position + 1)) {
-                    outRect.right = mThickness;
-                }
-            }
-        } else {
-            if (mOrientation == VERTICAL) {
-                if (position == 0 && mShowFirstDivider) {
-                    outRect.top = mThickness;
-                }
-                outRect.bottom = mThickness;
-                if (position == itemCount - 1 && !mShowLastDivider) {
-                    outRect.bottom = 0;
-                }
-            } else {
-                if (position == 0 && mShowFirstDivider) {
-                    outRect.left = mThickness;
-                }
-                outRect.right = mThickness;
-                if (position == itemCount - 1 && !mShowLastDivider) {
-                    outRect.right = 0;
-                }
-            }
-        }
-    }
-
-    @Override
-    public void onDrawOver(Canvas c, RecyclerView parent,
-                           RecyclerView.State state) {
-        RecyclerView.Adapter adapter = parent.getAdapter();
-        if (adapter == null) {
-            return;
-        }
-
-        int itemCount = adapter.getItemCount();
-        boolean overlap = mOverlap;
-
-        if (mOrientation == VERTICAL) {
-            final boolean isRtl = ViewCompat.getLayoutDirection(parent) == ViewCompat.LAYOUT_DIRECTION_RTL;
-            int mPaddingLeft;
-            int mPaddingRight;
-            if (isRtl) {
-                mPaddingLeft = mPaddingEnd;
-                mPaddingRight = mPaddingStart;
-            } else {
-                mPaddingLeft = mPaddingStart;
-                mPaddingRight = mPaddingEnd;
-            }
-
-            final int left = parent.getPaddingLeft() + mPaddingLeft;
-            final int right = parent.getWidth() - parent.getPaddingRight() - mPaddingRight;
-            final int childCount = parent.getChildCount();
-
-            for (int i = 0; i < childCount; i++) {
-                final View child = parent.getChildAt(i);
-                final RecyclerView.LayoutParams lp = (RecyclerView.LayoutParams) child.getLayoutParams();
-                final int position = parent.getChildLayoutPosition(child);
-
-                boolean show;
-                if (mShowDividerHelper != null) {
-                    show = mShowDividerHelper.showDivider(position + 1);
-                } else {
-                    show = position != itemCount - 1 || mShowLastDivider;
-                }
-                if (show) {
-                    int top = child.getBottom() + lp.bottomMargin;
-                    if (overlap) {
-                        top -= mThickness;
-                    }
-                    final int bottom = top + mThickness;
-                    mRect.set(left, top, right, bottom);
-                    c.drawRect(mRect, mPaint);
-                }
-
-                if (position == 0) {
-                    if (mShowDividerHelper != null) {
-                        show = mShowDividerHelper.showDivider(0);
-                    } else {
-                        show = mShowFirstDivider;
-                    }
-                    if (show) {
-                        int bottom = child.getTop() + lp.topMargin;
-                        if (overlap) {
-                            bottom += mThickness;
-                        }
-                        final int top = bottom - mThickness;
-                        mRect.set(left, top, right, bottom);
-                        c.drawRect(mRect, mPaint);
-                    }
-                }
-            }
-        } else {
-            final int top = parent.getPaddingTop() + mPaddingStart;
-            final int bottom = parent.getHeight() - parent.getPaddingBottom() - mPaddingEnd;
-            final int childCount = parent.getChildCount();
-
-            for (int i = 0; i < childCount; i++) {
-                final View child = parent.getChildAt(i);
-                final RecyclerView.LayoutParams lp = (RecyclerView.LayoutParams) child.getLayoutParams();
-                final int position = parent.getChildLayoutPosition(child);
-
-                boolean show;
-                if (mShowDividerHelper != null) {
-                    show = mShowDividerHelper.showDivider(position + 1);
-                } else {
-                    show = position != itemCount - 1 || mShowLastDivider;
-                }
-                if (show) {
-                    int left = child.getRight() + lp.rightMargin;
-                    if (overlap) {
-                        left -= mThickness;
-                    }
-                    final int right = left + mThickness;
-                    mRect.set(left, top, right, bottom);
-                    c.drawRect(mRect, mPaint);
-                }
-
-                if (position == 0) {
-                    if (mShowDividerHelper != null) {
-                        show = mShowDividerHelper.showDivider(0);
-                    } else {
-                        show = mShowFirstDivider;
-                    }
-                    if (show) {
-                        int right = child.getLeft() + lp.leftMargin;
-                        if (overlap) {
-                            right += mThickness;
-                        }
-                        final int left = right - mThickness;
-                        mRect.set(left, top, right, bottom);
-                        c.drawRect(mRect, mPaint);
-                    }
-                }
-            }
-        }
-    }
-
-    public interface ShowDividerHelper {
-        boolean showDivider(int index);
-    }
-}
@@ -26,7 +26,9 @@ import android.content.ServiceConnection;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 import android.os.AsyncTask;
+import android.os.Build;
 import android.os.Debug;
+import android.text.Html;
 import android.text.method.LinkMovementMethod;
 import android.util.Log;
 import android.view.View;
@@ -35,10 +37,15 @@ import android.widget.TextView;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.appcompat.app.AlertDialog;
+import androidx.appcompat.app.AppCompatDelegate;
 import androidx.collection.LruCache;
+import androidx.core.os.LocaleListCompat;
+import androidx.lifecycle.DefaultLifecycleObserver;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.lifecycle.ProcessLifecycleOwner;

-import com.google.android.material.dialog.MaterialAlertDialogBuilder;
 import com.hippo.Native;
+import com.hippo.app.BaseDialogBuilder;
 import com.hippo.beerbelly.SimpleDiskCache;
 import com.hippo.conaco.Conaco;
 import com.hippo.ehviewer.client.EhClient;
@@ -54,14 +61,12 @@ import com.hippo.ehviewer.client.parser.EventPaneParser;
 import com.hippo.ehviewer.download.DownloadManager;
 import com.hippo.ehviewer.spider.SpiderDen;
 import com.hippo.ehviewer.ui.CommonOperations;
-import com.hippo.image.Image;
+import com.hippo.ehviewer.ui.EhActivity;
 import com.hippo.image.ImageBitmap;
 import com.hippo.network.StatusCodeException;
 import com.hippo.scene.SceneApplication;
-import com.hippo.text.Html;
 import com.hippo.unifile.UniFile;
 import com.hippo.util.BitmapUtils;
-import com.hippo.util.ClipboardUtil;
 import com.hippo.util.ExceptionUtils;
 import com.hippo.util.IoThreadPoolExecutor;
 import com.hippo.util.ReadableTime;
@@ -91,8 +96,6 @@ import okhttp3.OkHttpClient;
 import okhttp3.Request;
 import okhttp3.Response;
 import okhttp3.ResponseBody;
-import rikka.material.app.DayNightDelegate;
-import rikka.material.app.LocaleDelegate;

 public class EhApplication extends SceneApplication {

@@ -104,6 +107,9 @@ public class EhApplication extends SceneApplication {
    private static final boolean DEBUG_PRINT_IMAGE_COUNT = false;
    private static final long DEBUG_PRINT_INTERVAL = 3000L;

+    public static boolean locked = true;
+    public static long locked_last_leave_time = 0;
+
    private static EhApplication instance;

    private final IntIdGenerator mIdGenerator = new IntIdGenerator();
@@ -180,10 +186,9 @@ public class EhApplication extends SceneApplication {
                        TrustManagerFactory.getDefaultAlgorithm());
                trustManagerFactory.init((KeyStore) null);
                TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();
-                if (trustManagers.length != 1 || !(trustManagers[0] instanceof X509TrustManager)) {
+                if (trustManagers.length != 1 || !(trustManagers[0] instanceof X509TrustManager trustManager)) {
                    throw new IllegalStateException("Unexpected default trust managers:" + Arrays.toString(trustManagers));
                }
-                X509TrustManager trustManager = (X509TrustManager) trustManagers[0];
                builder.sslSocketFactory(new EhSSLSocketFactory(), trustManager);
            } catch (Exception e) {
                e.printStackTrace();
@@ -297,14 +302,10 @@ public class EhApplication extends SceneApplication {
        return application.mFavouriteStatusRouter;
    }

-    @NonNull
-    public static String getDeveloperEmail() {
-        return "nekoworkshop$protonmail.com".replace('$', '@');
-    }
-
    @SuppressLint("StaticFieldLeak")
    @Override
    public void onCreate() {
+        ProcessLifecycleOwner.get().getLifecycle().addObserver(new EhlifecycleObserver());
        instance = this;

        Thread.UncaughtExceptionHandler handler = Thread.getDefaultUncaughtExceptionHandler();
@@ -325,25 +326,21 @@ public class EhApplication extends SceneApplication {
        super.onCreate();

        Native.initialize();
-        ClipboardUtil.initialize(this);
        GetText.initialize(this);
        StatusCodeException.initialize(this);
        Settings.initialize(this);
        ReadableTime.initialize(this);
-        Html.initialize(this);
        AppConfig.initialize(this);
        SpiderDen.initialize(this);
        EhDB.initialize(this);
        EhEngine.initialize();
        BitmapUtils.initialize(this);

-        if (EhDB.needMerge()) {
-            EhDB.mergeOldDB(this);
-        }
+        // Locales can be managed by system automatically above Snow Cone v2
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU)
+            AppCompatDelegate.setApplicationLocales(LocaleListCompat.create(Settings.getLocale()));

-        LocaleDelegate.setDefaultLocale(Settings.getLocale());
-        DayNightDelegate.setApplicationContext(this);
-        DayNightDelegate.setDefaultNightMode(Settings.getTheme());
+        AppCompatDelegate.setDefaultNightMode(Settings.getTheme());

        // Do io tasks in new thread
        //noinspection deprecation
@@ -430,7 +427,7 @@ public class EhApplication extends SceneApplication {
        Activity activity = getTopActivity();
        if (activity != null) {
            activity.runOnUiThread(() -> {
-                AlertDialog dialog = new MaterialAlertDialogBuilder(activity)
+                AlertDialog dialog = new BaseDialogBuilder(activity)
                        .setMessage(Html.fromHtml(html))
                        .setPositiveButton(android.R.string.ok, null)
                        .create();
@@ -493,9 +490,6 @@ public class EhApplication extends SceneApplication {
                    Log.i(TAG, "Native memory: " + FileUtils.humanReadableByteCount(
                            Debug.getNativeHeapAllocatedSize(), false));
                }
-                if (DEBUG_PRINT_IMAGE_COUNT) {
-                    Log.i(TAG, "Image count: " + Image.getImageCount());
-                }
                SimpleHandler.getInstance().postDelayed(this, DEBUG_PRINT_INTERVAL);
            }
        }.run();
@@ -533,9 +527,9 @@ public class EhApplication extends SceneApplication {
    }

    @Nullable
-    public Activity getTopActivity() {
+    public EhActivity getTopActivity() {
        if (!mActivityList.isEmpty()) {
-            return mActivityList.get(mActivityList.size() - 1);
+            return (EhActivity) mActivityList.get(mActivityList.size() - 1);
        } else {
            return null;
        }
@@ -587,4 +581,13 @@ public class EhApplication extends SceneApplication {
            return null;
        }
    }
+
+    static class EhlifecycleObserver implements DefaultLifecycleObserver {
+        @Override
+        public void onPause(@NonNull LifecycleOwner owner) {
+            if (!locked)
+                locked_last_leave_time = System.currentTimeMillis() / 1000;
+            locked = true;
+        }
+    }
 }
@@ -17,27 +17,24 @@
 package com.hippo.ehviewer;

 import android.content.Context;
-import android.database.Cursor;
 import android.database.sqlite.SQLiteDatabase;
-import android.database.sqlite.SQLiteOpenHelper;
 import android.net.Uri;
-import android.util.Log;

 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import androidx.paging.PagingSource;
+import androidx.room.Room;

 import com.hippo.ehviewer.client.data.GalleryInfo;
-import com.hippo.ehviewer.client.data.ListUrlBuilder;
-import com.hippo.ehviewer.dao.DaoMaster;
-import com.hippo.ehviewer.dao.DaoSession;
+import com.hippo.ehviewer.dao.BasicDao;
 import com.hippo.ehviewer.dao.DownloadDirname;
 import com.hippo.ehviewer.dao.DownloadDirnameDao;
 import com.hippo.ehviewer.dao.DownloadInfo;
 import com.hippo.ehviewer.dao.DownloadLabel;
 import com.hippo.ehviewer.dao.DownloadLabelDao;
 import com.hippo.ehviewer.dao.DownloadsDao;
+import com.hippo.ehviewer.dao.EhDatabase;
 import com.hippo.ehviewer.dao.Filter;
-import com.hippo.ehviewer.dao.FilterDao;
 import com.hippo.ehviewer.dao.HistoryDao;
 import com.hippo.ehviewer.dao.HistoryInfo;
 import com.hippo.ehviewer.dao.LocalFavoriteInfo;
@@ -46,14 +43,8 @@ import com.hippo.ehviewer.dao.QuickSearch;
 import com.hippo.ehviewer.dao.QuickSearchDao;
 import com.hippo.ehviewer.download.DownloadManager;
 import com.hippo.util.ExceptionUtils;
-import com.hippo.util.SqlUtils;
 import com.hippo.yorozuya.IOUtils;
 import com.hippo.yorozuya.ObjectUtils;
-import com.hippo.yorozuya.collect.SparseJLArray;
-
-import org.greenrobot.greendao.AbstractDao;
-import org.greenrobot.greendao.query.CloseableListIterator;
-import org.greenrobot.greendao.query.LazyList;

 import java.io.File;
 import java.io.FileInputStream;
@@ -65,15 +56,9 @@ import java.util.ArrayList;
 import java.util.List;

 public class EhDB {
+    private static final int CUR_DB_VER = 4;

-    private static final String TAG = EhDB.class.getSimpleName();
-
-    private static final int MAX_HISTORY_COUNT = 200;
-
-    private static DaoSession sDaoSession;
-
-    private static boolean sHasOldDB;
-    private static boolean sNewDB;
+    private static EhDatabase db;

    private static void upgradeDB(SQLiteDatabase db, int oldVersion) {
        switch (oldVersion) {
@@ -115,219 +100,12 @@ public class EhDB {
    }

    public static void initialize(Context context) {
-        sHasOldDB = context.getDatabasePath("data").exists();
-
-        DBOpenHelper helper = new DBOpenHelper(
-                context.getApplicationContext(), "eh.db", null);
-
-        SQLiteDatabase db = helper.getWritableDatabase();
-        DaoMaster daoMaster = new DaoMaster(db);
-
-        sDaoSession = daoMaster.newSession();
-    }
-
-    public static boolean needMerge() {
-        return sNewDB && sHasOldDB;
-    }
-
-    public static void mergeOldDB(Context context) {
-        sNewDB = false;
-
-        OldDBHelper oldDBHelper = new OldDBHelper(context);
-        SQLiteDatabase oldDB;
-        try {
-            oldDB = oldDBHelper.getReadableDatabase();
-        } catch (Throwable e) {
-            ExceptionUtils.throwIfFatal(e);
-            return;
-        }
-
-        // Get GalleryInfo list
-        SparseJLArray<GalleryInfo> map = new SparseJLArray<>();
-        try {
-            Cursor cursor = oldDB.rawQuery("select * from " + OldDBHelper.TABLE_GALLERY, null);
-            if (cursor != null) {
-                if (cursor.moveToFirst()) {
-                    while (!cursor.isAfterLast()) {
-                        GalleryInfo gi = new GalleryInfo();
-                        gi.gid = cursor.getInt(0);
-                        gi.token = cursor.getString(1);
-                        gi.title = cursor.getString(2);
-                        gi.posted = cursor.getString(3);
-                        gi.category = cursor.getInt(4);
-                        gi.thumb = cursor.getString(5);
-                        gi.uploader = cursor.getString(6);
-                        try {
-                            // In 0.6.x version, NaN is stored
-                            gi.rating = cursor.getFloat(7);
-                        } catch (Throwable e) {
-                            ExceptionUtils.throwIfFatal(e);
-                            gi.rating = -1.0f;
-                        }
-
-                        map.put(gi.gid, gi);
-
-                        cursor.moveToNext();
-                    }
-                }
-                cursor.close();
-            }
-        } catch (Throwable e) {
-            ExceptionUtils.throwIfFatal(e);
-            // Ignore
-        }
-
-        // Merge local favorites
-        try {
-            Cursor cursor = oldDB.rawQuery("select * from " + OldDBHelper.TABLE_LOCAL_FAVOURITE, null);
-            if (cursor != null) {
-                LocalFavoritesDao dao = sDaoSession.getLocalFavoritesDao();
-                if (cursor.moveToFirst()) {
-                    long i = 0L;
-                    while (!cursor.isAfterLast()) {
-                        // Get GalleryInfo first
-                        long gid = cursor.getInt(0);
-                        GalleryInfo gi = map.get(gid);
-                        if (gi == null) {
-                            Log.e(TAG, "Can't get GalleryInfo with gid: " + gid);
-                            cursor.moveToNext();
-                            continue;
-                        }
-
-                        LocalFavoriteInfo info = new LocalFavoriteInfo(gi);
-                        info.setTime(i);
-                        dao.insert(info);
-                        cursor.moveToNext();
-                        i++;
-                    }
-                }
-                cursor.close();
-            }
-        } catch (Throwable e) {
-            ExceptionUtils.throwIfFatal(e);
-            // Ignore
-        }
-
-
-        // Merge quick search
-        try {
-            Cursor cursor = oldDB.rawQuery("select * from " + OldDBHelper.TABLE_TAG, null);
-            if (cursor != null) {
-                QuickSearchDao dao = sDaoSession.getQuickSearchDao();
-                if (cursor.moveToFirst()) {
-                    while (!cursor.isAfterLast()) {
-                        QuickSearch quickSearch = new QuickSearch();
-
-                        int mode = cursor.getInt(2);
-                        String search = cursor.getString(4);
-                        String tag = cursor.getString(7);
-                        if (mode == ListUrlBuilder.MODE_UPLOADER && search != null &&
-                                search.startsWith("uploader:")) {
-                            search = search.substring("uploader:".length());
-                        }
-
-                        quickSearch.setTime(cursor.getInt(0));
-                        quickSearch.setName(cursor.getString(1));
-                        quickSearch.setMode(mode);
-                        quickSearch.setCategory(cursor.getInt(3));
-                        quickSearch.setKeyword(mode == ListUrlBuilder.MODE_TAG ? tag : search);
-                        quickSearch.setAdvanceSearch(cursor.getInt(5));
-                        quickSearch.setMinRating(cursor.getInt(6));
-
-                        dao.insert(quickSearch);
-                        cursor.moveToNext();
-                    }
-                }
-                cursor.close();
-            }
-        } catch (Throwable e) {
-            ExceptionUtils.throwIfFatal(e);
-            // Ignore
-        }
-
-        // Merge download info
-        try {
-            Cursor cursor = oldDB.rawQuery("select * from " + OldDBHelper.TABLE_DOWNLOAD, null);
-            if (cursor != null) {
-                DownloadsDao dao = sDaoSession.getDownloadsDao();
-                if (cursor.moveToFirst()) {
-                    long i = 0L;
-                    while (!cursor.isAfterLast()) {
-                        // Get GalleryInfo first
-                        long gid = cursor.getInt(0);
-                        GalleryInfo gi = map.get(gid);
-                        if (gi == null) {
-                            Log.e(TAG, "Can't get GalleryInfo with gid: " + gid);
-                            cursor.moveToNext();
-                            continue;
-                        }
-
-                        DownloadInfo info = new DownloadInfo(gi);
-                        int state = cursor.getInt(2);
-                        int legacy = cursor.getInt(3);
-                        if (state == DownloadInfo.STATE_FINISH && legacy > 0) {
-                            state = DownloadInfo.STATE_FAILED;
-                        }
-                        info.setState(state);
-                        info.setLegacy(legacy);
-                        if (cursor.getColumnCount() == 5) {
-                            info.setTime(cursor.getLong(4));
-                        } else {
-                            info.setTime(i);
-                        }
-                        dao.insert(info);
-                        cursor.moveToNext();
-                        i++;
-                    }
-                }
-                cursor.close();
-            }
-        } catch (Throwable e) {
-            ExceptionUtils.throwIfFatal(e);
-            // Ignore
-        }
-
-        try {
-            // Merge history info
-            Cursor cursor = oldDB.rawQuery("select * from " + OldDBHelper.TABLE_HISTORY, null);
-            if (cursor != null) {
-                HistoryDao dao = sDaoSession.getHistoryDao();
-                if (cursor.moveToFirst()) {
-                    while (!cursor.isAfterLast()) {
-                        // Get GalleryInfo first
-                        long gid = cursor.getInt(0);
-                        GalleryInfo gi = map.get(gid);
-                        if (gi == null) {
-                            Log.e(TAG, "Can't get GalleryInfo with gid: " + gid);
-                            cursor.moveToNext();
-                            continue;
-                        }
-
-                        HistoryInfo info = new HistoryInfo(gi);
-                        info.setMode(cursor.getInt(1));
-                        info.setTime(cursor.getLong(2));
-                        dao.insert(info);
-                        cursor.moveToNext();
-                    }
-                }
-                cursor.close();
-            }
-        } catch (Throwable e) {
-            ExceptionUtils.throwIfFatal(e);
-            // Ignore
-        }
-
-        try {
-            oldDBHelper.close();
-        } catch (Throwable e) {
-            ExceptionUtils.throwIfFatal(e);
-            // Ignore
-        }
+        db = Room.databaseBuilder(context, EhDatabase.class, "eh.db").allowMainThreadQueries().build();
    }

    public static synchronized List<DownloadInfo> getAllDownloadInfo() {
-        DownloadsDao dao = sDaoSession.getDownloadsDao();
-        List<DownloadInfo> list = dao.queryBuilder().orderDesc(DownloadsDao.Properties.Time).list();
+        DownloadsDao dao = db.downloadsDao();
+        List<DownloadInfo> list = dao.list();
        // Fix state
        for (DownloadInfo info : list) {
            if (info.state == DownloadInfo.STATE_WAIT || info.state == DownloadInfo.STATE_DOWNLOAD) {
@@ -339,7 +117,7 @@ public class EhDB {

    // Insert or update
    public static synchronized void putDownloadInfo(DownloadInfo downloadInfo) {
-        DownloadsDao dao = sDaoSession.getDownloadsDao();
+        DownloadsDao dao = db.downloadsDao();
        if (null != dao.load(downloadInfo.gid)) {
            // Update
            dao.update(downloadInfo);
@@ -349,13 +127,13 @@ public class EhDB {
        }
    }

-    public static synchronized void removeDownloadInfo(long gid) {
-        sDaoSession.getDownloadsDao().deleteByKey(gid);
+    public static synchronized void removeDownloadInfo(DownloadInfo downloadInfo) {
+        db.downloadsDao().delete(downloadInfo);
    }

    @Nullable
    public static synchronized String getDownloadDirname(long gid) {
-        DownloadDirnameDao dao = sDaoSession.getDownloadDirnameDao();
+        DownloadDirnameDao dao = db.downloadDirnameDao();
        DownloadDirname raw = dao.load(gid);
        if (raw != null) {
            return raw.getDirname();
@@ -368,7 +146,7 @@ public class EhDB {
     * Insert or update
     */
    public static synchronized void putDownloadDirname(long gid, String dirname) {
-        DownloadDirnameDao dao = sDaoSession.getDownloadDirnameDao();
+        DownloadDirnameDao dao = db.downloadDirnameDao();
        DownloadDirname raw = dao.load(gid);
        if (raw != null) { // Update
            raw.setDirname(dirname);
@@ -382,23 +160,23 @@ public class EhDB {
    }

    public static synchronized void removeDownloadDirname(long gid) {
-        DownloadDirnameDao dao = sDaoSession.getDownloadDirnameDao();
+        DownloadDirnameDao dao = db.downloadDirnameDao();
        dao.deleteByKey(gid);
    }

    public static synchronized void clearDownloadDirname() {
-        DownloadDirnameDao dao = sDaoSession.getDownloadDirnameDao();
+        DownloadDirnameDao dao = db.downloadDirnameDao();
        dao.deleteAll();
    }

    @NonNull
    public static synchronized List<DownloadLabel> getAllDownloadLabelList() {
-        DownloadLabelDao dao = sDaoSession.getDownloadLabelDao();
-        return dao.queryBuilder().orderAsc(DownloadLabelDao.Properties.Time).list();
+        DownloadLabelDao dao = db.downloadLabelDao();
+        return dao.list();
    }

    public static synchronized DownloadLabel addDownloadLabel(String label) {
-        DownloadLabelDao dao = sDaoSession.getDownloadLabelDao();
+        DownloadLabelDao dao = db.downloadLabelDao();
        DownloadLabel raw = new DownloadLabel();
        raw.setLabel(label);
        raw.setTime(System.currentTimeMillis());
@@ -409,13 +187,13 @@ public class EhDB {
    public static synchronized DownloadLabel addDownloadLabel(DownloadLabel raw) {
        // Reset id
        raw.setId(null);
-        DownloadLabelDao dao = sDaoSession.getDownloadLabelDao();
+        DownloadLabelDao dao = db.downloadLabelDao();
        raw.setId(dao.insert(raw));
        return raw;
    }

    public static synchronized void updateDownloadLabel(DownloadLabel raw) {
-        DownloadLabelDao dao = sDaoSession.getDownloadLabelDao();
+        DownloadLabelDao dao = db.downloadLabelDao();
        dao.update(raw);
    }

@@ -428,9 +206,8 @@ public class EhDB {
        int offset = reverse ? toPosition : fromPosition;
        int limit = reverse ? fromPosition - toPosition + 1 : toPosition - fromPosition + 1;

-        DownloadLabelDao dao = sDaoSession.getDownloadLabelDao();
-        List<DownloadLabel> list = dao.queryBuilder().orderAsc(DownloadLabelDao.Properties.Time)
-                .offset(offset).limit(limit).list();
+        DownloadLabelDao dao = db.downloadLabelDao();
+        List<DownloadLabel> list = dao.list(offset, limit);

        int step = reverse ? 1 : -1;
        int start = reverse ? limit - 1 : 0;
@@ -441,50 +218,44 @@ public class EhDB {
        }
        list.get(start).setTime(toTime);

-        dao.updateInTx(list);
+        dao.update(list);
    }

    public static synchronized void removeDownloadLabel(DownloadLabel raw) {
-        DownloadLabelDao dao = sDaoSession.getDownloadLabelDao();
+        DownloadLabelDao dao = db.downloadLabelDao();
        dao.delete(raw);
    }

    public static synchronized List<GalleryInfo> getAllLocalFavorites() {
-        LocalFavoritesDao dao = sDaoSession.getLocalFavoritesDao();
-        List<LocalFavoriteInfo> list = dao.queryBuilder().orderDesc(LocalFavoritesDao.Properties.Time).list();
-        List<GalleryInfo> result = new ArrayList<>();
-        result.addAll(list);
-        return result;
+        LocalFavoritesDao dao = db.localFavoritesDao();
+        List<LocalFavoriteInfo> list = dao.list();
+        return new ArrayList<>(list);
    }

    public static synchronized List<GalleryInfo> searchLocalFavorites(String query) {
-        query = SqlUtils.sqlEscapeString("%" + query + "%");
-        LocalFavoritesDao dao = sDaoSession.getLocalFavoritesDao();
-        List<LocalFavoriteInfo> list = dao.queryBuilder().orderDesc(LocalFavoritesDao.Properties.Time)
-                .where(LocalFavoritesDao.Properties.Title.like(query)).list();
-        List<GalleryInfo> result = new ArrayList<>();
-        result.addAll(list);
-        return result;
+        LocalFavoritesDao dao = db.localFavoritesDao();
+        List<LocalFavoriteInfo> list = dao.list();
+        return new ArrayList<>(list);
    }

    public static synchronized void removeLocalFavorites(long gid) {
-        sDaoSession.getLocalFavoritesDao().deleteByKey(gid);
+        db.localFavoritesDao().deleteByKey(gid);
    }

    public static synchronized void removeLocalFavorites(long[] gidArray) {
-        LocalFavoritesDao dao = sDaoSession.getLocalFavoritesDao();
+        LocalFavoritesDao dao = db.localFavoritesDao();
        for (long gid : gidArray) {
            dao.deleteByKey(gid);
        }
    }

    public static synchronized boolean containLocalFavorites(long gid) {
-        LocalFavoritesDao dao = sDaoSession.getLocalFavoritesDao();
+        LocalFavoritesDao dao = db.localFavoritesDao();
        return null != dao.load(gid);
    }

    public static synchronized void putLocalFavorites(GalleryInfo galleryInfo) {
-        LocalFavoritesDao dao = sDaoSession.getLocalFavoritesDao();
+        LocalFavoritesDao dao = db.localFavoritesDao();
        if (null == dao.load(galleryInfo.gid)) {
            LocalFavoriteInfo info;
            if (galleryInfo instanceof LocalFavoriteInfo) {
@@ -504,31 +275,31 @@ public class EhDB {
    }

    public static synchronized List<QuickSearch> getAllQuickSearch() {
-        QuickSearchDao dao = sDaoSession.getQuickSearchDao();
-        return dao.queryBuilder().orderAsc(QuickSearchDao.Properties.Time).list();
+        QuickSearchDao dao = db.quickSearchDao();
+        return dao.list();
    }

    public static synchronized void insertQuickSearch(QuickSearch quickSearch) {
-        QuickSearchDao dao = sDaoSession.getQuickSearchDao();
+        QuickSearchDao dao = db.quickSearchDao();
        quickSearch.id = null;
        quickSearch.time = System.currentTimeMillis();
        quickSearch.id = dao.insert(quickSearch);
    }

    public static synchronized void importQuickSearch(List<QuickSearch> quickSearchList) {
-        QuickSearchDao dao = sDaoSession.getQuickSearchDao();
+        QuickSearchDao dao = db.quickSearchDao();
        for (QuickSearch quickSearch : quickSearchList) {
            dao.insert(quickSearch);
        }
    }

    public static synchronized void updateQuickSearch(QuickSearch quickSearch) {
-        QuickSearchDao dao = sDaoSession.getQuickSearchDao();
+        QuickSearchDao dao = db.quickSearchDao();
        dao.update(quickSearch);
    }

    public static synchronized void deleteQuickSearch(QuickSearch quickSearch) {
-        QuickSearchDao dao = sDaoSession.getQuickSearchDao();
+        QuickSearchDao dao = db.quickSearchDao();
        dao.delete(quickSearch);
    }

@@ -541,9 +312,8 @@ public class EhDB {
        int offset = reverse ? toPosition : fromPosition;
        int limit = reverse ? fromPosition - toPosition + 1 : toPosition - fromPosition + 1;

-        QuickSearchDao dao = sDaoSession.getQuickSearchDao();
-        List<QuickSearch> list = dao.queryBuilder().orderAsc(QuickSearchDao.Properties.Time)
-                .offset(offset).limit(limit).list();
+        QuickSearchDao dao = db.quickSearchDao();
+        List<QuickSearch> list = dao.list(offset, limit);

        int step = reverse ? 1 : -1;
        int start = reverse ? limit - 1 : 0;
@@ -554,15 +324,19 @@ public class EhDB {
        }
        list.get(start).setTime(toTime);

-        dao.updateInTx(list);
+        dao.update(list);
    }

-    public static synchronized LazyList<HistoryInfo> getHistoryLazyList() {
-        return sDaoSession.getHistoryDao().queryBuilder().orderDesc(HistoryDao.Properties.Time).listLazy();
+    public static synchronized List<HistoryInfo> getHistoryList() {
+        return db.historyDao().list();
+    }
+
+    public static synchronized PagingSource<Integer, HistoryInfo> getHistoryLazyList() {
+        return db.historyDao().listLazy();
    }

    public static synchronized void putHistoryInfo(GalleryInfo galleryInfo) {
-        HistoryDao dao = sDaoSession.getHistoryDao();
+        HistoryDao dao = db.historyDao();
        HistoryInfo info = dao.load(galleryInfo.gid);
        if (null != info) {
            // Update time
@@ -573,49 +347,42 @@ public class EhDB {
            info = new HistoryInfo(galleryInfo);
            info.time = System.currentTimeMillis();
            dao.insert(info);
-            List<HistoryInfo> list = dao.queryBuilder().orderDesc(HistoryDao.Properties.Time)
-                    .limit(-1).offset(MAX_HISTORY_COUNT).list();
-            dao.deleteInTx(list);
        }
    }

    public static synchronized void putHistoryInfo(List<HistoryInfo> historyInfoList) {
-        HistoryDao dao = sDaoSession.getHistoryDao();
+        HistoryDao dao = db.historyDao();
        for (HistoryInfo info : historyInfoList) {
            if (null == dao.load(info.gid)) {
                dao.insert(info);
            }
        }
-
-        List<HistoryInfo> list = dao.queryBuilder().orderDesc(HistoryDao.Properties.Time)
-                .limit(-1).offset(MAX_HISTORY_COUNT).list();
-        dao.deleteInTx(list);
    }

    public static synchronized void deleteHistoryInfo(HistoryInfo info) {
-        HistoryDao dao = sDaoSession.getHistoryDao();
+        HistoryDao dao = db.historyDao();
        dao.delete(info);
    }

    public static synchronized void clearHistoryInfo() {
-        HistoryDao dao = sDaoSession.getHistoryDao();
+        HistoryDao dao = db.historyDao();
        dao.deleteAll();
    }

    public static synchronized List<Filter> getAllFilter() {
-        return sDaoSession.getFilterDao().queryBuilder().list();
+        return db.filterDao().list();
    }

    public static synchronized boolean addFilter(Filter filter) {
        Filter existFilter;
        try {
-            existFilter = sDaoSession.getFilterDao().queryBuilder().where(FilterDao.Properties.Text.eq(filter.text), FilterDao.Properties.Mode.eq(filter.mode)).unique();
+            existFilter = db.filterDao().load(filter.text, filter.mode);
        } catch (Exception e) {
            existFilter = null;
        }
        if (existFilter == null) {
            filter.setId(null);
-            filter.setId(sDaoSession.getFilterDao().insert(filter));
+            filter.setId(db.filterDao().insert(filter));
            return true;
        } else {
            return false;
@@ -623,23 +390,19 @@ public class EhDB {
    }

    public static synchronized void deleteFilter(Filter filter) {
-        sDaoSession.getFilterDao().delete(filter);
+        db.filterDao().delete(filter);
    }

    public static synchronized void triggerFilter(Filter filter) {
        filter.setEnable(!filter.enable);
-        sDaoSession.getFilterDao().update(filter);
+        db.filterDao().update(filter);
    }

-    private static <T> boolean copyDao(AbstractDao<T, ?> from, AbstractDao<T, ?> to) {
-        try (CloseableListIterator<T> iterator = from.queryBuilder().listIterator()) {
-            while (iterator.hasNext()) {
-                to.insert(iterator.next());
-            }
-        } catch (IOException e) {
-            return false;
-        }
-        return true;
+    private static <T> boolean copyDao(BasicDao<T> from, BasicDao<T> to) {
+        List<T> list = from.list();
+        for (T item : list)
+            to.insert(item);
+        return false;
    }

    public static synchronized boolean exportDB(Context context, Uri uri) {
@@ -647,31 +410,24 @@ public class EhDB {

        // Delete old export db
        context.deleteDatabase(ehExportName);
-
-        DBOpenHelper helper = new DBOpenHelper(context.getApplicationContext(), ehExportName, null);
+        EhDatabase newDb = Room.databaseBuilder(context, EhDatabase.class, ehExportName).allowMainThreadQueries().build();

        try {
            // Copy data to a export db
-            try (SQLiteDatabase db = helper.getWritableDatabase()) {
-                DaoMaster daoMaster = new DaoMaster(db);
-                DaoSession exportSession = daoMaster.newSession();
-                if (!copyDao(sDaoSession.getDownloadsDao(), exportSession.getDownloadsDao()))
-                    return false;
-                if (!copyDao(sDaoSession.getDownloadLabelDao(), exportSession.getDownloadLabelDao()))
-                    return false;
-                if (!copyDao(sDaoSession.getDownloadDirnameDao(), exportSession.getDownloadDirnameDao()))
-                    return false;
-                if (!copyDao(sDaoSession.getHistoryDao(), exportSession.getHistoryDao()))
-                    return false;
-                if (!copyDao(sDaoSession.getQuickSearchDao(), exportSession.getQuickSearchDao()))
-                    return false;
-                if (!copyDao(sDaoSession.getLocalFavoritesDao(), exportSession.getLocalFavoritesDao()))
-                    return false;
-                if (!copyDao(sDaoSession.getBookmarksDao(), exportSession.getBookmarksDao()))
-                    return false;
-                if (!copyDao(sDaoSession.getFilterDao(), exportSession.getFilterDao()))
-                    return false;
-            }
+            if (copyDao(db.downloadsDao(), newDb.downloadsDao()))
+                return false;
+            if (copyDao(db.downloadLabelDao(), newDb.downloadLabelDao()))
+                return false;
+            if (copyDao(db.downloadDirnameDao(), newDb.downloadDirnameDao()))
+                return false;
+            if (copyDao(db.historyDao(), newDb.historyDao()))
+                return false;
+            if (copyDao(db.quickSearchDao(), newDb.quickSearchDao()))
+                return false;
+            if (copyDao(db.localFavoritesDao(), newDb.localFavoritesDao()))
+                return false;
+            if (copyDao(db.filterDao(), newDb.filterDao()))
+                return false;

            // Copy export db to data dir
            File dbFile = context.getDatabasePath(ehExportName);
@@ -718,75 +474,95 @@ public class EhDB {
            inputStream.close();
            outputStream.close();

-            SQLiteDatabase db = SQLiteDatabase.openDatabase(
+            SQLiteDatabase oldDB = SQLiteDatabase.openDatabase(
                    file.getPath(), null, SQLiteDatabase.NO_LOCALIZED_COLLATORS);
-            int newVersion = DaoMaster.SCHEMA_VERSION;
-            int oldVersion = db.getVersion();
+            int newVersion = CUR_DB_VER;
+            int oldVersion = oldDB.getVersion();
            if (oldVersion < newVersion) {
-                upgradeDB(db, oldVersion);
-                db.setVersion(newVersion);
+                upgradeDB(oldDB, oldVersion);
+                oldDB.setVersion(newVersion);
            } else if (oldVersion > newVersion) {
                return context.getString(R.string.cant_read_the_file);
            }

-            DaoMaster daoMaster = new DaoMaster(db);
-            DaoSession session = daoMaster.newSession();
-
-            // Downloads
-            DownloadManager manager = EhApplication.getDownloadManager(context);
-            List<DownloadInfo> downloadInfoList = session.getDownloadsDao().queryBuilder().list();
-            manager.addDownload(downloadInfoList, false);
+            String tmpDBName = "tmp.db";
+            context.deleteDatabase(tmpDBName);
+            EhDatabase oldRoomDatabase = Room.databaseBuilder(context, EhDatabase.class, tmpDBName)
+                    .createFromFile(file).allowMainThreadQueries().build();

            // Download label
-            List<DownloadLabel> downloadLabelList = session.getDownloadLabelDao().queryBuilder().list();
-            manager.addDownloadLabel(downloadLabelList);
+            DownloadManager manager = EhApplication.getDownloadManager(context);
+            try {
+                List<DownloadLabel> downloadLabelList = oldRoomDatabase.downloadLabelDao().list();
+                manager.addDownloadLabel(downloadLabelList);
+            } catch (Exception ignored) {
+            }
+
+            // Downloads
+            try {
+                List<DownloadInfo> downloadInfoList = oldRoomDatabase.downloadsDao().list();
+                manager.addDownload(downloadInfoList, false);
+            } catch (Exception ignored) {
+            }

            // Download dirname
-            List<DownloadDirname> downloadDirnameList = session.getDownloadDirnameDao().queryBuilder().list();
-            for (DownloadDirname dirname : downloadDirnameList) {
-                putDownloadDirname(dirname.getGid(), dirname.getDirname());
+            try {
+                List<DownloadDirname> downloadDirnameList = oldRoomDatabase.downloadDirnameDao().list();
+                for (DownloadDirname dirname : downloadDirnameList) {
+                    putDownloadDirname(dirname.getGid(), dirname.getDirname());
+                }
+            } catch (Exception ignored) {
            }

            // History
-            List<HistoryInfo> historyInfoList = session.getHistoryDao().queryBuilder().list();
-            putHistoryInfo(historyInfoList);
+            try {
+                List<HistoryInfo> historyInfoList = oldRoomDatabase.historyDao().list();
+                putHistoryInfo(historyInfoList);
+            } catch (Exception ignored) {
+            }

            // QuickSearch
-            List<QuickSearch> quickSearchList = session.getQuickSearchDao().queryBuilder().list();
-            List<QuickSearch> currentQuickSearchList = sDaoSession.getQuickSearchDao().queryBuilder().list();
-            List<QuickSearch> importList = new ArrayList<>();
-            for (QuickSearch quickSearch : quickSearchList) {
-                String name = quickSearch.name;
-                for (QuickSearch q : currentQuickSearchList) {
-                    if (ObjectUtils.equal(q.name, name)) {
-                        // The same name
-                        name = null;
-                        break;
+            try {
+                List<QuickSearch> quickSearchList = oldRoomDatabase.quickSearchDao().list();
+                List<QuickSearch> currentQuickSearchList = db.quickSearchDao().list();
+                List<QuickSearch> importList = new ArrayList<>();
+                for (QuickSearch quickSearch : quickSearchList) {
+                    String name = quickSearch.name;
+                    for (QuickSearch q : currentQuickSearchList) {
+                        if (ObjectUtils.equal(q.name, name)) {
+                            // The same name
+                            name = null;
+                            break;
+                        }
                    }
+                    if (null == name) {
+                        continue;
+                    }
+                    importList.add(quickSearch);
                }
-                if (null == name) {
-                    continue;
-                }
-                importList.add(quickSearch);
+                importQuickSearch(importList);
+            } catch (Exception ignored) {
            }
-            importQuickSearch(importList);

            // LocalFavorites
-            List<LocalFavoriteInfo> localFavoriteInfoList = session.getLocalFavoritesDao().queryBuilder().list();
-            for (LocalFavoriteInfo info : localFavoriteInfoList) {
-                putLocalFavorites(info);
+            try {
+                List<LocalFavoriteInfo> localFavoriteInfoList = oldRoomDatabase.localFavoritesDao().list();
+                for (LocalFavoriteInfo info : localFavoriteInfoList) {
+                    putLocalFavorites(info);
+                }
+            } catch (Exception ignored) {
            }

-            // Bookmarks
-            // TODO
-
            // Filter
-            List<Filter> filterList = session.getFilterDao().queryBuilder().list();
-            List<Filter> currentFilterList = sDaoSession.getFilterDao().queryBuilder().list();
-            for (Filter filter : filterList) {
-                if (!currentFilterList.contains(filter)) {
-                    addFilter(filter);
+            try {
+                List<Filter> filterList = oldRoomDatabase.filterDao().list();
+                List<Filter> currentFilterList = db.filterDao().list();
+                for (Filter filter : filterList) {
+                    if (!currentFilterList.contains(filter)) {
+                        addFilter(filter);
+                    }
                }
+            } catch (Exception ignored) {
            }

            return null;
@@ -796,46 +572,4 @@ public class EhDB {
            return context.getString(R.string.cant_read_the_file);
        }
    }
-
-    private static class DBOpenHelper extends DaoMaster.OpenHelper {
-
-        public DBOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory) {
-            super(context, name, factory);
-        }
-
-        @Override
-        public void onCreate(SQLiteDatabase db) {
-            super.onCreate(db);
-            sNewDB = true;
-        }
-
-        @Override
-        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
-            upgradeDB(db, oldVersion);
-        }
-    }
-
-    private static class OldDBHelper extends SQLiteOpenHelper {
-
-        private static final String DB_NAME = "data";
-        private static final int VERSION = 4;
-
-        private static final String TABLE_GALLERY = "gallery";
-        private static final String TABLE_LOCAL_FAVOURITE = "local_favourite";
-        private static final String TABLE_TAG = "tag";
-        private static final String TABLE_DOWNLOAD = "download";
-        private static final String TABLE_HISTORY = "history";
-
-        public OldDBHelper(Context context) {
-            super(context, DB_NAME, null, VERSION);
-        }
-
-        @Override
-        public void onCreate(SQLiteDatabase db) {
-        }
-
-        @Override
-        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
-        }
-    }
 }
@@ -23,6 +23,7 @@ import com.hippo.conaco.ValueHelper;
 import com.hippo.image.ImageBitmap;
 import com.hippo.streampipe.InputStreamPipe;

+import java.io.FileInputStream;
 import java.io.IOException;

 public class ImageBitmapHelper implements ValueHelper<ImageBitmap> {
@@ -34,7 +35,8 @@ public class ImageBitmapHelper implements ValueHelper<ImageBitmap> {
    public ImageBitmap decode(@NonNull InputStreamPipe isPipe) {
        try {
            isPipe.obtain();
-            return ImageBitmap.decode(isPipe.open());
+            FileInputStream is = (FileInputStream) isPipe.open();
+            return ImageBitmap.decode(is);
        } catch (OutOfMemoryError | IOException e) {
            return null;
        } finally {
@@ -41,6 +41,7 @@ import com.hippo.yorozuya.NumberUtils;

 import java.io.File;
 import java.util.Locale;
+import java.util.Set;

 public class Settings {

@@ -49,6 +50,8 @@ public class Settings {
     ********************/

    public static final String KEY_THEME = "theme";
+
+    public static final String KEY_ACCOUNT = "account";
    public static final String KEY_BLACK_DARK_THEME = "black_dark_theme";
    public static final int THEME_LIGHT = 1;
    public static final int THEME_SYSTEM = -1;
@@ -75,6 +78,8 @@ public class Settings {
    public static final String KEY_DOWNLOAD_SAVE_SCHEME = "image_scheme";
    public static final String KEY_DOWNLOAD_SAVE_AUTHORITY = "image_authority";
    public static final String KEY_DOWNLOAD_SAVE_PATH = "image_path";
+
+    public static final String KEY_NOTIFICATION_REQUIRED = "notification_required";
    public static final String KEY_DOWNLOAD_SAVE_QUERY = "image_query";
    public static final String KEY_DOWNLOAD_SAVE_FRAGMENT = "image_fragment";
    public static final String KEY_MEDIA_SCAN = "media_scan";
@@ -86,7 +91,8 @@ public class Settings {
     ****** Advanced
     ********************/
    public static final String KEY_SAVE_PARSE_ERROR_BODY = "save_parse_error_body";
-    public static final String KEY_SECURITY = "security";
+    public static final String KEY_SECURITY = "require_unlock";
+    public static final String KEY_SECURITY_DELAY = "require_unlock_delay";
    public static final String DEFAULT_SECURITY = "";
    public static final String KEY_ENABLE_FINGERPRINT = "enable_fingerprint";
    public static final String KEY_READ_CACHE_SIZE = "read_cache_size";
@@ -94,11 +100,13 @@ public class Settings {
    public static final String KEY_BUILT_IN_HOSTS = "built_in_hosts_2";
    public static final String KEY_DOMAIN_FRONTING = "domain_fronting";
    public static final String KEY_APP_LANGUAGE = "app_language";
+    public static final String KEY_LIST_THUMB_SIZE = "list_tile_size";
    private static final String TAG = Settings.class.getSimpleName();
    private static final String KEY_VERSION_CODE = "version_code";
    private static final int DEFAULT_VERSION_CODE = 0;
    private static final String KEY_DISPLAY_NAME = "display_name";
    private static final String DEFAULT_DISPLAY_NAME = null;
+    private static final int DEFAULT_LIST_THUMB_SIZE = 40;
    private static final String KEY_AVATAR = "avatar";
    private static final String DEFAULT_AVATAR = null;
    private static final String KEY_SHOW_WARNING = "show_warning";
@@ -120,8 +128,6 @@ public class Settings {
    private static final int DEFAULT_DETAIL_SIZE = 0;
    private static final int DEFAULT_THUMB_SIZE = 1;
    private static final int DEFAULT_THUMB_RESOLUTION = 0;
-    private static final String KEY_FIX_THUMB_URL = "fix_thumb_url";
-    private static final boolean DEFAULT_FIX_THUMB_URL = false;
    private static final String KEY_SHOW_JPN_TITLE = "show_jpn_title";
    private static final boolean DEFAULT_SHOW_JPN_TITLE = false;
    private static final String KEY_SHOW_GALLERY_PAGES = "show_gallery_pages";
@@ -271,6 +277,9 @@ public class Settings {
    private static final int DEFAULT_DOWNLOAD_DELAY = 0;
    private static final String KEY_REQUEST_NEWS = "request_news";
    private static final boolean DEFAULT_REQUEST_NEWS = true;
+    private static final String KEY_ARCHIVE_PASSWDS = "archive_passwds";
+    public static boolean LIST_THUMB_SIZE_INITED = false;
+    private static int LIST_THUMB_SIZE = 40;
    private static Context sContext;
    private static SharedPreferences sSettingsPre;
    private static EhConfig sEhConfig;
@@ -384,6 +393,21 @@ public class Settings {
        sSettingsPre.edit().putString(key, value).apply();
    }

+    public static Set<String> getStringSet(String key) {
+        return sSettingsPre.getStringSet(key, null);
+    }
+
+    public static void putStringToStringSet(String key, String value) {
+        Set<String> set = getStringSet(key);
+        if (set == null)
+            set = Set.of(value);
+        else if (set.contains(value))
+            return;
+        else
+            set.add(value);
+        sSettingsPre.edit().putStringSet(key, set).apply();
+    }
+
    public static int getIntFromStr(String key, int defValue) {
        try {
            return NumberUtils.parseIntSafely(sSettingsPre.getString(key, Integer.toString(defValue)), defValue);
@@ -405,6 +429,7 @@ public class Settings {
        putInt(KEY_VERSION_CODE, value);
    }

+    @Nullable
    public static String getDisplayName() {
        return getString(KEY_DISPLAY_NAME, DEFAULT_DISPLAY_NAME);
    }
@@ -457,14 +482,6 @@ public class Settings {
        putBoolean(KEY_SELECT_SITE, value);
    }

-    public static boolean getQuickSearchTip() {
-        return getBoolean(KEY_QUICK_SEARCH_TIP, DEFAULT_QUICK_SEARCH_TIP);
-    }
-
-    public static void putQuickSearchTip(boolean value) {
-        putBoolean(KEY_QUICK_SEARCH_TIP, value);
-    }
-
    public static int getTheme() {
        return getIntFromStr(KEY_THEME, DEFAULT_THEME);
    }
@@ -540,10 +557,6 @@ public class Settings {
        return getIntFromStr(KEY_THUMB_RESOLUTION, DEFAULT_THUMB_RESOLUTION);
    }

-    public static boolean getFixThumbUrl() {
-        return getBoolean(KEY_FIX_THUMB_URL, DEFAULT_FIX_THUMB_URL);
-    }
-
    public static boolean getRequestNews() {
        return getBoolean(KEY_REQUEST_NEWS, DEFAULT_REQUEST_NEWS);
    }
@@ -594,14 +607,6 @@ public class Settings {
        putString(KEY_EXCLUDED_LANGUAGES, value);
    }

-    public static void putEInkMode(boolean value) {
-        putBoolean(KEY_E_INK_MODE, value);
-    }
-
-    public static boolean getEInkMode() {
-        return getBoolean(KEY_E_INK_MODE, DEFAULT_E_INK_MODE);
-    }
-
    public static boolean getMeteredNetworkWarning() {
        return getBoolean(KEY_METERED_NETWORK_WARNING, DEFAULT_METERED_NETWORK_WARNING);
    }
@@ -963,11 +968,11 @@ public class Settings {
        boolean writeFile = false;
        String userID = getString(KEY_USER_ID, null);
        File file = AppConfig.getFileInExternalAppDir(FILENAME_USER_ID);
-        if (null == userID || !isValidUserID(userID)) {
+        if (!isValidUserID(userID)) {
            writeXml = true;
            // Get use ID from out sd card file
            userID = FileUtils.read(file);
-            if (null == userID || !isValidUserID(userID)) {
+            if (!isValidUserID(userID)) {
                writeFile = true;
                userID = generateUserID();
            }
@@ -1044,22 +1049,22 @@ public class Settings {
        return getBoolean(KEY_SAVE_CRASH_LOG, DEFAULT_SAVE_CRASH_LOG);
    }

-    public static String getSecurity() {
-        return getString(KEY_SECURITY, DEFAULT_SECURITY);
+    public static boolean getSecurity() {
+        return getBoolean(KEY_SECURITY, false);
    }

-    public static void putSecurity(String value) {
-        putString(KEY_SECURITY, value);
+    public static void putSecurity(boolean value) {
+        putBoolean(KEY_SECURITY, value);
+    }
+
+    public static int getSecurityDelay() {
+        return getInt(KEY_SECURITY_DELAY, 0);
    }

    public static boolean getEnableFingerprint() {
        return getBoolean(KEY_ENABLE_FINGERPRINT, true);
    }

-    public static void putEnableFingerprint(boolean value) {
-        putBoolean(KEY_ENABLE_FINGERPRINT, value);
-    }
-
    public static int getReadCacheSize() {
        return getIntFromStr(KEY_READ_CACHE_SIZE, DEFAULT_READ_CACHE_SIZE);
    }
@@ -1159,4 +1164,30 @@ public class Settings {
    public static void putClipboardTextHashCode(int value) {
        putInt(KEY_CLIPBOARD_TEXT_HASH_CODE, value);
    }
+
+    public static Set<String> getArchivePasswds() {
+        return getStringSet(KEY_ARCHIVE_PASSWDS);
+    }
+
+    public static void putPasswdToArchivePasswds(String value) {
+        putStringToStringSet(KEY_ARCHIVE_PASSWDS, value);
+    }
+
+    public static int getListThumbSize() {
+        if (LIST_THUMB_SIZE_INITED) {
+            return LIST_THUMB_SIZE;
+        }
+        int size = 3 * getInt(KEY_LIST_THUMB_SIZE, DEFAULT_LIST_THUMB_SIZE);
+        LIST_THUMB_SIZE = size;
+        LIST_THUMB_SIZE_INITED = true;
+        return size;
+    }
+
+    public static boolean getNotificationRequired() {
+        return getBoolean(KEY_NOTIFICATION_REQUIRED, false);
+    }
+
+    public static void putNotificationRequired() {
+        putBoolean(KEY_NOTIFICATION_REQUIRED, true);
+    }
 }
@@ -1,3 +1,21 @@
+/*
+ * Copyright 2022 Tarsin Norbin
+ *
+ * This file is part of EhViewer
+ *
+ * EhViewer is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * EhViewer is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with EhViewer.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
 package com.hippo.ehviewer;

 import android.view.View;
@@ -245,12 +245,6 @@ public class EhEngine {
                }
            }
        }
-
-        if (Settings.getFixThumbUrl()) {
-            for (GalleryInfo info : list) {
-                info.thumb = EhUrl.getFixedPreviewThumbUrl(info.thumb);
-            }
-        }
    }

    public static GalleryListParser.Result getGalleryList(@Nullable EhClient.Task task, OkHttpClient okHttpClient,
@@ -1,3 +1,21 @@
+/*
+ * Copyright 2022 Tarsin Norbin
+ *
+ * This file is part of EhViewer
+ *
+ * EhViewer is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * EhViewer is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with EhViewer.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
 package com.hippo.ehviewer.client;

 import android.util.Log;
@@ -21,11 +21,6 @@ import androidx.annotation.NonNull;
 import com.hippo.ehviewer.Settings;
 import com.hippo.network.UrlBuilder;

-import java.util.List;
-import java.util.ListIterator;
-
-import okhttp3.HttpUrl;
-
 public class EhUrl {

    public static final int SITE_E = 0;
@@ -59,8 +54,6 @@ public class EhUrl {
    public static final String ORIGIN_EX = REFERER_EX;
    public static final String REFERER_E = "https://" + DOMAIN_E;
    public static final String ORIGIN_E = REFERER_E;
-    private static final String URL_PREFIX_THUMB_E = "https://ehgt.org/";
-    private static final String URL_PREFIX_THUMB_EX = "https://exhentai.org/t/";

    public static String getGalleryDetailUrl(long gid, String token) {
        return getGalleryDetailUrl(gid, token, 0, false);
@@ -200,44 +193,4 @@ public class EhUrl {
                return URL_WATCHED_EX;
        }
    }
-
-    public static String getThumbUrlPrefix() {
-        switch (Settings.getGallerySite()) {
-            default:
-                //case SITE_E:
-                return URL_PREFIX_THUMB_E;
-            //case SITE_EX:
-            //    return URL_PREFIX_THUMB_EX;
-        }
-    }
-
-    public static String getFixedPreviewThumbUrl(String originUrl) {
-        HttpUrl url = HttpUrl.parse(originUrl);
-        if (url == null) return originUrl;
-        List<String> pathSegments = url.pathSegments();
-        if (pathSegments.size() < 3) return originUrl;
-
-        ListIterator<String> iterator = pathSegments.listIterator(pathSegments.size());
-        // The last segments, like
-        // 317a1a254cd9c3269e71b2aa2671fe8d28c91097-260198-640-480-png_250.jpg
-        if (!iterator.hasPrevious()) return originUrl;
-        String lastSegment = iterator.previous();
-        // The second last segments, like
-        // 7a
-        if (!iterator.hasPrevious()) return originUrl;
-        String secondLastSegment = iterator.previous();
-        // The third last segments, like
-        // 31
-        if (!iterator.hasPrevious()) return originUrl;
-        String thirdLastSegment = iterator.previous();
-        // Check path segments
-        if (lastSegment != null && secondLastSegment != null
-                && thirdLastSegment != null
-                && lastSegment.startsWith(thirdLastSegment)
-                && lastSegment.startsWith(secondLastSegment, thirdLastSegment.length())) {
-            return getThumbUrlPrefix() + thirdLastSegment + "/" + secondLastSegment + "/" + lastSegment;
-        } else {
-            return originUrl;
-        }
-    }
 }
@@ -20,6 +20,7 @@ import android.content.Context;
 import android.graphics.Color;
 import android.text.TextUtils;

+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;

 import com.hippo.ehviewer.EhApplication;
@@ -94,6 +95,7 @@ public class EhUtils {
        return CATEGORY_VALUES[i];
    }

+    @NonNull
    public static String getCategory(int type) {
        int i;
        for (i = 0; i < CATEGORY_VALUES.length - 1; i++) {
@@ -1,3 +1,21 @@
+/*
+ * Copyright 2022 Tarsin Norbin
+ *
+ * This file is part of EhViewer
+ *
+ * EhViewer is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * EhViewer is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with EhViewer.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
 package com.hippo.ehviewer.client;

 import android.annotation.SuppressLint;
@@ -16,16 +16,17 @@

 package com.hippo.ehviewer.client.data;

+import android.os.Build;
 import android.os.Parcel;
 import android.os.Parcelable;
 import android.text.TextUtils;
-import android.util.Log;

 import com.hippo.ehviewer.client.EhUrl;
 import com.hippo.network.UrlBuilder;

 import java.io.UnsupportedEncodingException;
 import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;

 public class FavListUrlBuilder implements Parcelable {

@@ -44,7 +45,9 @@ public class FavListUrlBuilder implements Parcelable {
        }
    };
    private static final String TAG = FavListUrlBuilder.class.getSimpleName();
-    private int mIndex;
+    private String mPrev;
+    private String mNext;
+    private String mJumpTo;
    private String mKeyword;
    private int mFavCat = FAV_CAT_ALL;

@@ -52,7 +55,9 @@ public class FavListUrlBuilder implements Parcelable {
    }

    protected FavListUrlBuilder(Parcel in) {
-        this.mIndex = in.readInt();
+        this.mPrev = in.readString();
+        this.mNext = in.readString();
+        this.mJumpTo = in.readString();
        this.mKeyword = in.readString();
        this.mFavCat = in.readInt();
    }
@@ -61,8 +66,16 @@ public class FavListUrlBuilder implements Parcelable {
        return favCat >= 0 && favCat <= 9;
    }

-    public void setIndex(int index) {
-        mIndex = index;
+    public void setPrev(String prev) {
+        mPrev = prev;
+    }
+
+    public void setNext(String next) {
+        mNext = next;
+    }
+
+    public void setJumpTo(String jumpTo) {
+        mJumpTo = jumpTo;
    }

    public String getKeyword() {
@@ -93,20 +106,30 @@ public class FavListUrlBuilder implements Parcelable {
            ub.addQuery("favcat", "all");
        }
        if (!TextUtils.isEmpty(mKeyword)) {
-            try {
-                ub.addQuery("f_search", URLEncoder.encode(mKeyword, "UTF-8"));
-                // Name
-                ub.addQuery("sn", "on");
-                // Tags
-                ub.addQuery("st", "on");
-                // Note
-                ub.addQuery("sf", "on");
-            } catch (UnsupportedEncodingException e) {
-                Log.e(TAG, "Can't URLEncoder.encode " + mKeyword);
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                ub.addQuery("f_search", URLEncoder.encode(mKeyword, StandardCharsets.UTF_8));
+            } else {
+                try {
+                    ub.addQuery("f_search", URLEncoder.encode(mKeyword, StandardCharsets.UTF_8.displayName()));
+                } catch (UnsupportedEncodingException e) {
+                    e.printStackTrace();
+                }
            }
+            // Name
+            ub.addQuery("sn", "on");
+            // Tags
+            ub.addQuery("st", "on");
+            // Note
+            ub.addQuery("sf", "on");
        }
-        if (mIndex > 0) {
-            ub.addQuery("page", Integer.toString(mIndex));
+        if (mPrev != null && !mPrev.isEmpty()) {
+            ub.addQuery("prev", mPrev);
+        }
+        if (mNext != null && !mNext.isEmpty()) {
+            ub.addQuery("next", mNext);
+        }
+        if (mJumpTo != null && !mJumpTo.isEmpty()) {
+            ub.addQuery("seek", mJumpTo);
        }
        return ub.build();
    }
@@ -118,7 +141,9 @@ public class FavListUrlBuilder implements Parcelable {

    @Override
    public void writeToParcel(Parcel dest, int flags) {
-        dest.writeInt(this.mIndex);
+        dest.writeString(this.mPrev);
+        dest.writeString(this.mNext);
+        dest.writeString(this.mJumpTo);
        dest.writeString(this.mKeyword);
        dest.writeInt(this.mFavCat);
    }
@@ -20,6 +20,9 @@ import android.os.Parcel;
 import android.os.Parcelable;

 import androidx.annotation.Nullable;
+import androidx.room.ColumnInfo;
+import androidx.room.Ignore;
+import androidx.room.PrimaryKey;

 import java.util.regex.Pattern;

@@ -108,30 +111,52 @@ public class GalleryInfo implements Parcelable {
            return new GalleryInfo[size];
        }
    };
+    @PrimaryKey
+    @ColumnInfo(name = "GID")
    public long gid;
+    @ColumnInfo(name = "TOKEN")
    public String token;
+    @ColumnInfo(name = "TITLE")
    public String title;
+    @ColumnInfo(name = "TITLE_JPN")
    public String titleJpn;
+    @ColumnInfo(name = "THUMB")
    public String thumb;
+    @ColumnInfo(name = "CATEGORY")
    public int category;
+    @ColumnInfo(name = "POSTED")
    public String posted;
+    @ColumnInfo(name = "UPLOADER")
    public String uploader;
+    @Ignore
    public boolean disowned;
+    @ColumnInfo(name = "RATING")
    public float rating;
+    @Ignore
    public boolean rated;
    @Nullable
+    @Ignore
    public String[] simpleTags;
+    @Ignore
    public int pages;
+    @Ignore
    public int thumbWidth;
+    @Ignore
    public int thumbHeight;
+    @Ignore
    public int spanSize;
+    @Ignore
    public int spanIndex;
+    @Ignore
    public int spanGroupIndex;
    /**
     * language from title
     */
+    @ColumnInfo(name = "SIMPLE_LANGUAGE")
    public String simpleLanguage;
+    @Ignore
    public int favoriteSlot = -2;
+    @Ignore
    public String favoriteName;

    public GalleryInfo() {
@@ -170,6 +195,7 @@ public class GalleryInfo implements Parcelable {
    }

    private void generateSLangFromTags() {
+        assert simpleTags != null;
        for (String tag : simpleTags) {
            for (int i = 0; i < S_LANGS.length; i++) {
                if (S_LANG_TAGS[i].equals(tag)) {
@@ -1,636 +0,0 @@
-/*
- * Copyright (C) 2015 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.data;
-
-import android.os.Parcel;
-import android.os.Parcelable;
-import android.text.TextUtils;
-
-import androidx.annotation.IntDef;
-import androidx.annotation.Nullable;
-
-import com.hippo.ehviewer.client.EhConfig;
-import com.hippo.ehviewer.client.EhUrl;
-import com.hippo.ehviewer.client.EhUtils;
-import com.hippo.ehviewer.dao.QuickSearch;
-import com.hippo.ehviewer.widget.AdvanceSearchTable;
-import com.hippo.network.UrlBuilder;
-import com.hippo.yorozuya.NumberUtils;
-import com.hippo.yorozuya.StringUtils;
-
-import java.io.UnsupportedEncodingException;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.net.URLDecoder;
-import java.net.URLEncoder;
-
-public class ListUrlBuilder implements Cloneable, Parcelable {
-
-    // Mode
-    public static final int MODE_NORMAL = 0x0;
-    public static final int MODE_UPLOADER = 0x1;
-    public static final int MODE_TAG = 0x2;
-    public static final int MODE_WHATS_HOT = 0x3;
-    public static final int MODE_IMAGE_SEARCH = 0x4;
-    public static final int MODE_SUBSCRIPTION = 0x5;
-    public static final int MODE_TOPLIST = 0x6;
-    public static final int DEFAULT_ADVANCE = AdvanceSearchTable.SNAME | AdvanceSearchTable.STAGS;
-    public static final int DEFAULT_MIN_RATING = 2;
-    public static final Creator<ListUrlBuilder> CREATOR = new Creator<ListUrlBuilder>() {
-        @Override
-        public ListUrlBuilder createFromParcel(Parcel source) {
-            return new ListUrlBuilder(source);
-        }
-
-        @Override
-        public ListUrlBuilder[] newArray(int size) {
-            return new ListUrlBuilder[size];
-        }
-    };
-    @Mode
-    private int mMode = MODE_NORMAL;
-
-    private int mPageIndex = 0;
-
-    private int mCategory = EhUtils.NONE;
-    private String mKeyword = null;
-    private String mSHash = null;
-
-    private int mAdvanceSearch = -1;
-    private int mMinRating = -1;
-    private int mPageFrom = -1;
-    private int mPageTo = -1;
-
-    private String mImagePath;
-    private boolean mUseSimilarityScan;
-    private boolean mOnlySearchCovers;
-    private boolean mShowExpunged;
-
-    public ListUrlBuilder() {
-    }
-
-    @SuppressWarnings("WrongConstant")
-    protected ListUrlBuilder(Parcel in) {
-        this.mMode = in.readInt();
-        this.mPageIndex = in.readInt();
-        this.mCategory = in.readInt();
-        this.mKeyword = in.readString();
-        this.mAdvanceSearch = in.readInt();
-        this.mMinRating = in.readInt();
-        this.mPageFrom = in.readInt();
-        this.mPageTo = in.readInt();
-        this.mImagePath = in.readString();
-        this.mUseSimilarityScan = in.readByte() != 0;
-        this.mOnlySearchCovers = in.readByte() != 0;
-        this.mShowExpunged = in.readByte() != 0;
-        this.mSHash = in.readString();
-    }
-
-    /**
-     * Make this ListUrlBuilder point to homepage
-     */
-    public void reset() {
-        mMode = MODE_NORMAL;
-        mPageIndex = 0;
-        mCategory = EhUtils.NONE;
-        mKeyword = null;
-        mAdvanceSearch = -1;
-        mMinRating = -1;
-        mPageFrom = -1;
-        mPageTo = -1;
-        mImagePath = null;
-        mUseSimilarityScan = false;
-        mOnlySearchCovers = false;
-        mShowExpunged = false;
-        mSHash = null;
-    }
-
-    @Override
-    public ListUrlBuilder clone() {
-        try {
-            return (ListUrlBuilder) super.clone();
-        } catch (CloneNotSupportedException e) {
-            throw new IllegalStateException(e);
-        }
-    }
-
-    @Mode
-    public int getMode() {
-        return mMode;
-    }
-
-    public void setMode(@Mode int mode) {
-        mMode = mode;
-    }
-
-    public int getPageIndex() {
-        return mPageIndex;
-    }
-
-    public void setPageIndex(int pageIndex) {
-        mPageIndex = pageIndex;
-    }
-
-    public int getCategory() {
-        return mCategory;
-    }
-
-    public void setCategory(int category) {
-        mCategory = category;
-    }
-
-    public String getKeyword() {
-        return MODE_UPLOADER == mMode ? "uploader:" + mKeyword : mKeyword;
-    }
-
-    public void setKeyword(String keyword) {
-        mKeyword = keyword;
-    }
-
-    public int getAdvanceSearch() {
-        return mAdvanceSearch;
-    }
-
-    public void setAdvanceSearch(int advanceSearch) {
-        mAdvanceSearch = advanceSearch;
-    }
-
-    public int getMinRating() {
-        return mMinRating;
-    }
-
-    public void setMinRating(int minRating) {
-        mMinRating = minRating;
-    }
-
-    public int getPageFrom() {
-        return mPageFrom;
-    }
-
-    public void setPageFrom(int pageFrom) {
-        mPageFrom = pageFrom;
-    }
-
-    public int getPageTo() {
-        return mPageTo;
-    }
-
-    public void setPageTo(int pageTo) {
-        mPageTo = pageTo;
-    }
-
-    @Nullable
-    public String getImagePath() {
-        return mImagePath;
-    }
-
-    public void setImagePath(String imagePath) {
-        mImagePath = imagePath;
-    }
-
-    public boolean isUseSimilarityScan() {
-        return mUseSimilarityScan;
-    }
-
-    public void setUseSimilarityScan(boolean useSimilarityScan) {
-        mUseSimilarityScan = useSimilarityScan;
-    }
-
-    public boolean isOnlySearchCovers() {
-        return mOnlySearchCovers;
-    }
-
-    public void setOnlySearchCovers(boolean onlySearchCovers) {
-        mOnlySearchCovers = onlySearchCovers;
-    }
-
-    public boolean isShowExpunged() {
-        return mShowExpunged;
-    }
-
-    public void setShowExpunged(boolean showExpunged) {
-        mShowExpunged = showExpunged;
-    }
-
-    /**
-     * Make them the same
-     *
-     * @param lub The template
-     */
-    public void set(ListUrlBuilder lub) {
-        mMode = lub.mMode;
-        mPageIndex = lub.mPageIndex;
-        mCategory = lub.mCategory;
-        mKeyword = lub.mKeyword;
-        mAdvanceSearch = lub.mAdvanceSearch;
-        mMinRating = lub.mMinRating;
-        mPageFrom = lub.mPageFrom;
-        mPageTo = lub.mPageTo;
-        mImagePath = lub.mImagePath;
-        mUseSimilarityScan = lub.mUseSimilarityScan;
-        mOnlySearchCovers = lub.mOnlySearchCovers;
-        mShowExpunged = lub.mShowExpunged;
-        mSHash = lub.mSHash;
-    }
-
-    public void set(QuickSearch q) {
-        mMode = q.mode;
-        mCategory = q.category;
-        mKeyword = q.keyword;
-        mAdvanceSearch = q.advanceSearch;
-        mMinRating = q.minRating;
-        mPageFrom = q.pageFrom;
-        mPageTo = q.pageTo;
-        mImagePath = null;
-        mUseSimilarityScan = false;
-        mOnlySearchCovers = false;
-        mShowExpunged = false;
-    }
-
-    public QuickSearch toQuickSearch() {
-        QuickSearch q = new QuickSearch();
-        q.mode = mMode;
-        q.category = mCategory;
-        q.keyword = mKeyword;
-        q.advanceSearch = mAdvanceSearch;
-        q.minRating = mMinRating;
-        q.pageFrom = mPageFrom;
-        q.pageTo = mPageTo;
-        return q;
-    }
-
-    public boolean equalsQuickSearch(QuickSearch q) {
-        if (null == q) {
-            return false;
-        }
-
-        if (q.mode != mMode) {
-            return false;
-        }
-        if (q.category != mCategory) {
-            return false;
-        }
-        if (!StringUtils.equals(q.keyword, mKeyword)) {
-            return false;
-        }
-        if (q.advanceSearch != mAdvanceSearch) {
-            return false;
-        }
-        if (q.minRating != mMinRating) {
-            return false;
-        }
-        if (q.pageFrom != mPageFrom) {
-            return false;
-        }
-        return q.pageTo == mPageTo;
-    }
-
-    /**
-     * @param query xxx=yyy&mmm=nnn
-     */
-    // TODO page
-    public void setQuery(String query) {
-        reset();
-
-        if (TextUtils.isEmpty(query)) {
-            return;
-        }
-        String[] querys = StringUtils.split(query, '&');
-        int category = 0;
-        String keyword = null;
-        boolean enableAdvanceSearch = false;
-        int advanceSearch = 0;
-        boolean enableMinRating = false;
-        int minRating = -1;
-        boolean enablePage = false;
-        int pageFrom = -1;
-        int pageTo = -1;
-        for (String str : querys) {
-            int index = str.indexOf('=');
-            if (index < 0) {
-                continue;
-            }
-            String key = str.substring(0, index);
-            String value = str.substring(index + 1);
-            switch (key) {
-                case "f_cats":
-                    int cats = NumberUtils.parseIntSafely(value, EhConfig.ALL_CATEGORY);
-                    category |= (~cats) & EhConfig.ALL_CATEGORY;
-                    break;
-                case "f_doujinshi":
-                    if ("1".equals(value)) {
-                        category |= EhConfig.DOUJINSHI;
-                    }
-                    break;
-                case "f_manga":
-                    if ("1".equals(value)) {
-                        category |= EhConfig.MANGA;
-                    }
-                    break;
-                case "f_artistcg":
-                    if ("1".equals(value)) {
-                        category |= EhConfig.ARTIST_CG;
-                    }
-                    break;
-                case "f_gamecg":
-                    if ("1".equals(value)) {
-                        category |= EhConfig.GAME_CG;
-                    }
-                    break;
-                case "f_western":
-                    if ("1".equals(value)) {
-                        category |= EhConfig.WESTERN;
-                    }
-                    break;
-                case "f_non-h":
-                    if ("1".equals(value)) {
-                        category |= EhConfig.NON_H;
-                    }
-                    break;
-                case "f_imageset":
-                    if ("1".equals(value)) {
-                        category |= EhConfig.IMAGE_SET;
-                    }
-                    break;
-                case "f_cosplay":
-                    if ("1".equals(value)) {
-                        category |= EhConfig.COSPLAY;
-                    }
-                    break;
-                case "f_asianporn":
-                    if ("1".equals(value)) {
-                        category |= EhConfig.ASIAN_PORN;
-                    }
-                    break;
-                case "f_misc":
-                    if ("1".equals(value)) {
-                        category |= EhConfig.MISC;
-                    }
-                    break;
-                case "f_search":
-                    try {
-                        keyword = URLDecoder.decode(value, "utf-8");
-                    } catch (UnsupportedEncodingException | IllegalArgumentException e) {
-                        // Ignore
-                    }
-                    break;
-                case "advsearch":
-                    if ("1".equals(value)) {
-                        enableAdvanceSearch = true;
-                    }
-                    break;
-                case "f_sname":
-                    if ("on".equals(value)) {
-                        advanceSearch |= AdvanceSearchTable.SNAME;
-                    }
-                    break;
-                case "f_stags":
-                    if ("on".equals(value)) {
-                        advanceSearch |= AdvanceSearchTable.STAGS;
-                    }
-                    break;
-                case "f_sdesc":
-                    if ("on".equals(value)) {
-                        advanceSearch |= AdvanceSearchTable.SDESC;
-                    }
-                    break;
-                case "f_storr":
-                    if ("on".equals(value)) {
-                        advanceSearch |= AdvanceSearchTable.STORR;
-                    }
-                    break;
-                case "f_sto":
-                    if ("on".equals(value)) {
-                        advanceSearch |= AdvanceSearchTable.STO;
-                    }
-                    break;
-                case "f_sdt1":
-                    if ("on".equals(value)) {
-                        advanceSearch |= AdvanceSearchTable.SDT1;
-                    }
-                    break;
-                case "f_sdt2":
-                    if ("on".equals(value)) {
-                        advanceSearch |= AdvanceSearchTable.SDT2;
-                    }
-                    break;
-                case "f_sh":
-                    if ("on".equals(value)) {
-                        advanceSearch |= AdvanceSearchTable.SH;
-                    }
-                    break;
-                case "f_sfl":
-                    if ("on".equals(value)) {
-                        advanceSearch |= AdvanceSearchTable.SFL;
-                    }
-                    break;
-                case "f_sfu":
-                    if ("on".equals(value)) {
-                        advanceSearch |= AdvanceSearchTable.SFU;
-                    }
-                    break;
-                case "f_sft":
-                    if ("on".equals(value)) {
-                        advanceSearch |= AdvanceSearchTable.SFT;
-                    }
-                    break;
-                case "f_sr":
-                    if ("on".equals(value)) {
-                        enableMinRating = true;
-                    }
-                    break;
-                case "f_srdd":
-                    minRating = NumberUtils.parseIntSafely(value, -1);
-                    break;
-                case "f_sp":
-                    if ("on".equals(value)) {
-                        enablePage = true;
-                    }
-                    break;
-                case "f_spf":
-                    pageFrom = NumberUtils.parseIntSafely(value, -1);
-                    break;
-                case "f_spt":
-                    pageTo = NumberUtils.parseIntSafely(value, -1);
-                    break;
-                case "f_shash":
-                    mSHash = value;
-                    break;
-            }
-        }
-
-        mCategory = category;
-        mKeyword = keyword;
-        if (enableAdvanceSearch) {
-            mAdvanceSearch = advanceSearch;
-            if (enableMinRating) {
-                mMinRating = minRating;
-            } else {
-                mMinRating = -1;
-            }
-            if (enablePage) {
-                mPageFrom = pageFrom;
-                mPageTo = pageTo;
-            } else {
-                mPageFrom = -1;
-                mPageTo = -1;
-            }
-        } else {
-            mAdvanceSearch = -1;
-        }
-    }
-
-    public String build() {
-        switch (mMode) {
-            default:
-            case MODE_NORMAL:
-            case MODE_SUBSCRIPTION: {
-                String url;
-                if (mMode == MODE_NORMAL) {
-                    url = EhUrl.getHost();
-                } else {
-                    url = EhUrl.getWatchedUrl();
-                }
-
-                UrlBuilder ub = new UrlBuilder(url);
-                if (mCategory != EhUtils.NONE) {
-                    ub.addQuery("f_cats", (~mCategory) & EhConfig.ALL_CATEGORY);
-                }
-                // Search key
-                if (mKeyword != null) {
-                    String keyword = mKeyword.trim();
-                    if (!keyword.isEmpty()) {
-                        try {
-                            ub.addQuery("f_search", URLEncoder.encode(mKeyword, "UTF-8"));
-                        } catch (UnsupportedEncodingException e) {
-                            // Empty
-                        }
-                    }
-                }
-                if (mSHash != null) {
-                    ub.addQuery("f_shash", mSHash);
-                }
-                // Page index
-                if (mPageIndex != 0) {
-                    ub.addQuery("page", mPageIndex);
-                }
-                // Advance search
-                if (mAdvanceSearch != -1) {
-                    ub.addQuery("advsearch", "1");
-                    if ((mAdvanceSearch & AdvanceSearchTable.SNAME) != 0)
-                        ub.addQuery("f_sname", "on");
-                    if ((mAdvanceSearch & AdvanceSearchTable.STAGS) != 0)
-                        ub.addQuery("f_stags", "on");
-                    if ((mAdvanceSearch & AdvanceSearchTable.SDESC) != 0)
-                        ub.addQuery("f_sdesc", "on");
-                    if ((mAdvanceSearch & AdvanceSearchTable.STORR) != 0)
-                        ub.addQuery("f_storr", "on");
-                    if ((mAdvanceSearch & AdvanceSearchTable.STO) != 0) ub.addQuery("f_sto", "on");
-                    if ((mAdvanceSearch & AdvanceSearchTable.SDT1) != 0)
-                        ub.addQuery("f_sdt1", "on");
-                    if ((mAdvanceSearch & AdvanceSearchTable.SDT2) != 0)
-                        ub.addQuery("f_sdt2", "on");
-                    if ((mAdvanceSearch & AdvanceSearchTable.SH) != 0) ub.addQuery("f_sh", "on");
-                    if ((mAdvanceSearch & AdvanceSearchTable.SFL) != 0) ub.addQuery("f_sfl", "on");
-                    if ((mAdvanceSearch & AdvanceSearchTable.SFU) != 0) ub.addQuery("f_sfu", "on");
-                    if ((mAdvanceSearch & AdvanceSearchTable.SFT) != 0) ub.addQuery("f_sft", "on");
-                    // Set min star
-                    if (mMinRating != -1) {
-                        ub.addQuery("f_sr", "on");
-                        ub.addQuery("f_srdd", mMinRating);
-                    }
-                    // Pages
-                    if (mPageFrom != -1 || mPageTo != -1) {
-                        ub.addQuery("f_sp", "on");
-                        ub.addQuery("f_spf", mPageFrom != -1 ? Integer.toString(mPageFrom) : "");
-                        ub.addQuery("f_spt", mPageTo != -1 ? Integer.toString(mPageTo) : "");
-                    }
-                }
-                return ub.build();
-            }
-            case MODE_UPLOADER: {
-                StringBuilder sb = new StringBuilder(EhUrl.getHost());
-                sb.append("uploader/");
-                try {
-                    sb.append(URLEncoder.encode(mKeyword, "UTF-8"));
-                } catch (UnsupportedEncodingException e) {
-                    // Empty
-                }
-                if (mPageIndex != 0) {
-                    sb.append('/').append(mPageIndex);
-                }
-                return sb.toString();
-            }
-            case MODE_TAG: {
-                StringBuilder sb = new StringBuilder(EhUrl.getHost());
-                sb.append("tag/");
-                try {
-                    sb.append(URLEncoder.encode(mKeyword, "UTF-8"));
-                } catch (UnsupportedEncodingException e) {
-                    // Empty
-                }
-                if (mPageIndex != 0) {
-                    sb.append('/').append(mPageIndex);
-                }
-                return sb.toString();
-            }
-            case MODE_WHATS_HOT:
-                return EhUrl.getPopularUrl();
-            case MODE_IMAGE_SEARCH:
-                return EhUrl.getImageSearchUrl();
-            case MODE_TOPLIST:
-                StringBuilder sb = new StringBuilder(EhUrl.HOST_E);
-                sb.append("toplist.php?tl=");
-                try {
-                    sb.append(URLEncoder.encode(mKeyword, "UTF-8"));
-                } catch (UnsupportedEncodingException e) {
-                    // Empty
-                }
-                if (mPageIndex != 0) {
-                    sb.append("&p=").append(mPageIndex);
-                }
-                return sb.toString();
-        }
-    }
-
-    @Override
-    public int describeContents() {
-        return 0;
-    }
-
-    @Override
-    public void writeToParcel(Parcel dest, int flags) {
-        dest.writeInt(this.mMode);
-        dest.writeInt(this.mPageIndex);
-        dest.writeInt(this.mCategory);
-        dest.writeString(this.mKeyword);
-        dest.writeInt(this.mAdvanceSearch);
-        dest.writeInt(this.mMinRating);
-        dest.writeInt(this.mPageFrom);
-        dest.writeInt(this.mPageTo);
-        dest.writeString(this.mImagePath);
-        dest.writeByte(mUseSimilarityScan ? (byte) 1 : (byte) 0);
-        dest.writeByte(mOnlySearchCovers ? (byte) 1 : (byte) 0);
-        dest.writeByte(mShowExpunged ? (byte) 1 : (byte) 0);
-        dest.writeString(this.mSHash);
-    }
-
-    @IntDef({MODE_NORMAL, MODE_UPLOADER, MODE_TAG, MODE_WHATS_HOT, MODE_IMAGE_SEARCH, MODE_SUBSCRIPTION, MODE_TOPLIST})
-    @Retention(RetentionPolicy.SOURCE)
-    private @interface Mode {
-    }
-}
@@ -0,0 +1,541 @@
+/*
+ * Copyright (C) 2015 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.data
+
+import android.os.Parcel
+import android.os.Parcelable
+import android.os.Parcelable.Creator
+import android.text.TextUtils
+import androidx.annotation.IntDef
+import com.hippo.ehviewer.client.EhConfig
+import com.hippo.ehviewer.client.EhUrl
+import com.hippo.ehviewer.client.EhUtils
+import com.hippo.ehviewer.dao.QuickSearch
+import com.hippo.ehviewer.widget.AdvanceSearchTable
+import com.hippo.network.UrlBuilder
+import com.hippo.yorozuya.NumberUtils
+import com.hippo.yorozuya.StringUtils
+import java.io.UnsupportedEncodingException
+import java.net.URLDecoder
+import java.net.URLEncoder
+
+open class ListUrlBuilder : Cloneable, Parcelable {
+    @get:Mode
+    @Mode
+    var mode = MODE_NORMAL
+    private var mPrevGid = 0
+    private var mNextGid = 0
+    private var mJumpTo: String? = null
+    var category = EhUtils.NONE
+    private var mKeyword: String? = null
+    private var mSHash: String? = null
+    var advanceSearch = -1
+    var minRating = -1
+    var pageFrom = -1
+    var pageTo = -1
+    var imagePath: String? = null
+    var isUseSimilarityScan = false
+    var isOnlySearchCovers = false
+    var isShowExpunged = false
+
+    constructor()
+    protected constructor(parcel: Parcel) {
+        mode = parcel.readInt()
+        mPrevGid = parcel.readInt()
+        mNextGid = parcel.readInt()
+        mJumpTo = parcel.readString()
+        this.category = parcel.readInt()
+        mKeyword = parcel.readString()
+        advanceSearch = parcel.readInt()
+        minRating = parcel.readInt()
+        pageFrom = parcel.readInt()
+        pageTo = parcel.readInt()
+        imagePath = parcel.readString()
+        isUseSimilarityScan = parcel.readByte().toInt() != 0
+        isOnlySearchCovers = parcel.readByte().toInt() != 0
+        isShowExpunged = parcel.readByte().toInt() != 0
+        mSHash = parcel.readString()
+    }
+
+    fun reset() {
+        mode = MODE_NORMAL
+        mPrevGid = 0
+        mNextGid = 0
+        mJumpTo = null
+        this.category = EhUtils.NONE
+        mKeyword = null
+        advanceSearch = -1
+        minRating = -1
+        pageFrom = -1
+        pageTo = -1
+        imagePath = null
+        isUseSimilarityScan = false
+        isOnlySearchCovers = false
+        isShowExpunged = false
+        mSHash = null
+    }
+
+    public override fun clone(): ListUrlBuilder {
+        return try {
+            super.clone() as ListUrlBuilder
+        } catch (e: CloneNotSupportedException) {
+            throw IllegalStateException(e)
+        }
+    }
+
+    fun setPrevGid(prevGid: Int) {
+        mPrevGid = prevGid
+    }
+
+    fun setNextGid(nextGid: Int) {
+        mNextGid = nextGid
+    }
+
+    fun setJumpTo(jumpTo: String?) {
+        mJumpTo = jumpTo
+    }
+
+    var keyword: String?
+        get() = if (MODE_UPLOADER == mode) "uploader:$mKeyword" else mKeyword
+        set(keyword) {
+            mKeyword = keyword
+        }
+
+    /**
+     * Make them the same
+     *
+     * @param lub The template
+     */
+    fun set(lub: ListUrlBuilder) {
+        mode = lub.mode
+        mPrevGid = lub.mPrevGid
+        mNextGid = lub.mNextGid
+        mJumpTo = lub.mJumpTo
+        this.category = lub.category
+        mKeyword = lub.mKeyword
+        advanceSearch = lub.advanceSearch
+        minRating = lub.minRating
+        pageFrom = lub.pageFrom
+        pageTo = lub.pageTo
+        imagePath = lub.imagePath
+        isUseSimilarityScan = lub.isUseSimilarityScan
+        isOnlySearchCovers = lub.isOnlySearchCovers
+        isShowExpunged = lub.isShowExpunged
+        mSHash = lub.mSHash
+    }
+
+    fun set(q: QuickSearch) {
+        mode = q.mode
+        this.category = q.category
+        mKeyword = q.keyword
+        advanceSearch = q.advanceSearch
+        minRating = q.minRating
+        pageFrom = q.pageFrom
+        pageTo = q.pageTo
+        imagePath = null
+        isUseSimilarityScan = false
+        isOnlySearchCovers = false
+        isShowExpunged = false
+    }
+
+    fun toQuickSearch(): QuickSearch {
+        val q = QuickSearch()
+        q.mode = mode
+        q.category = this.category
+        q.keyword = mKeyword
+        q.advanceSearch = advanceSearch
+        q.minRating = minRating
+        q.pageFrom = pageFrom
+        q.pageTo = pageTo
+        return q
+    }
+
+    fun equalsQuickSearch(q: QuickSearch?): Boolean {
+        if (null == q) {
+            return false
+        }
+        if (q.mode != mode) {
+            return false
+        }
+        if (q.category != this.category) {
+            return false
+        }
+        if (!StringUtils.equals(q.keyword, mKeyword)) {
+            return false
+        }
+        if (q.advanceSearch != advanceSearch) {
+            return false
+        }
+        if (q.minRating != minRating) {
+            return false
+        }
+        return if (q.pageFrom != pageFrom) {
+            false
+        } else q.pageTo == pageTo
+    }
+
+    /**
+     * @param query xxx=yyy&mmm=nnn
+     */
+    // TODO page
+    fun setQuery(query: String?) {
+        reset()
+        if (TextUtils.isEmpty(query)) {
+            return
+        }
+        val querys = StringUtils.split(query, '&')
+        var category = 0
+        var keyword: String? = null
+        var enableAdvanceSearch = false
+        var advanceSearch = 0
+        var enableMinRating = false
+        var minRating = -1
+        var enablePage = false
+        var pageFrom = -1
+        var pageTo = -1
+        for (str in querys) {
+            val index = str.indexOf('=')
+            if (index < 0) {
+                continue
+            }
+            val key = str.substring(0, index)
+            val value = str.substring(index + 1)
+            when (key) {
+                "f_cats" -> {
+                    val cats = NumberUtils.parseIntSafely(value, EhConfig.ALL_CATEGORY)
+                    category = category or (cats.inv() and EhConfig.ALL_CATEGORY)
+                }
+
+                "f_doujinshi" -> if ("1" == value) {
+                    category = category or EhConfig.DOUJINSHI
+                }
+
+                "f_manga" -> if ("1" == value) {
+                    category = category or EhConfig.MANGA
+                }
+
+                "f_artistcg" -> if ("1" == value) {
+                    category = category or EhConfig.ARTIST_CG
+                }
+
+                "f_gamecg" -> if ("1" == value) {
+                    category = category or EhConfig.GAME_CG
+                }
+
+                "f_western" -> if ("1" == value) {
+                    category = category or EhConfig.WESTERN
+                }
+
+                "f_non-h" -> if ("1" == value) {
+                    category = category or EhConfig.NON_H
+                }
+
+                "f_imageset" -> if ("1" == value) {
+                    category = category or EhConfig.IMAGE_SET
+                }
+
+                "f_cosplay" -> if ("1" == value) {
+                    category = category or EhConfig.COSPLAY
+                }
+
+                "f_asianporn" -> if ("1" == value) {
+                    category = category or EhConfig.ASIAN_PORN
+                }
+
+                "f_misc" -> if ("1" == value) {
+                    category = category or EhConfig.MISC
+                }
+
+                "f_search" -> try {
+                    keyword = URLDecoder.decode(value, "utf-8")
+                } catch (e: UnsupportedEncodingException) {
+                    // Ignore
+                } catch (_: IllegalArgumentException) {
+                }
+
+                "advsearch" -> if ("1" == value) {
+                    enableAdvanceSearch = true
+                }
+
+                "f_sh" -> if ("on" == value) {
+                    advanceSearch = advanceSearch or AdvanceSearchTable.SH
+                }
+
+                "f_sto" -> if ("on" == value) {
+                    advanceSearch = advanceSearch or AdvanceSearchTable.STO
+                }
+
+                "f_sfl" -> if ("on" == value) {
+                    advanceSearch = advanceSearch or AdvanceSearchTable.SFL
+                }
+
+                "f_sfu" -> if ("on" == value) {
+                    advanceSearch = advanceSearch or AdvanceSearchTable.SFU
+                }
+
+                "f_sft" -> if ("on" == value) {
+                    advanceSearch = advanceSearch or AdvanceSearchTable.SFT
+                }
+
+                "f_sr" -> if ("on" == value) {
+                    enableMinRating = true
+                }
+
+                "f_srdd" -> minRating = NumberUtils.parseIntSafely(value, -1)
+                "f_sp" -> if ("on" == value) {
+                    enablePage = true
+                }
+
+                "f_spf" -> pageFrom = NumberUtils.parseIntSafely(value, -1)
+                "f_spt" -> pageTo = NumberUtils.parseIntSafely(value, -1)
+                "f_shash" -> mSHash = value
+            }
+        }
+        this.category = category
+        mKeyword = keyword
+        if (enableAdvanceSearch) {
+            this.advanceSearch = advanceSearch
+            if (enableMinRating) {
+                this.minRating = minRating
+            } else {
+                this.minRating = -1
+            }
+            if (enablePage) {
+                this.pageFrom = pageFrom
+                this.pageTo = pageTo
+            } else {
+                this.pageFrom = -1
+                this.pageTo = -1
+            }
+        } else {
+            this.advanceSearch = -1
+        }
+    }
+
+    fun build(): String {
+        return when (mode) {
+            MODE_NORMAL, MODE_SUBSCRIPTION -> {
+                val url: String = if (mode == MODE_NORMAL) {
+                    EhUrl.getHost()
+                } else {
+                    EhUrl.getWatchedUrl()
+                }
+                val ub = UrlBuilder(url)
+                if (this.category != EhUtils.NONE) {
+                    ub.addQuery("f_cats", category.inv() and EhConfig.ALL_CATEGORY)
+                }
+                // Search key
+                if (mKeyword != null) {
+                    val keyword = mKeyword!!.trim { it <= ' ' }
+                    if (keyword.isNotEmpty()) {
+                        try {
+                            ub.addQuery("f_search", URLEncoder.encode(mKeyword, "UTF-8"))
+                        } catch (e: UnsupportedEncodingException) {
+                            // Empty
+                        }
+                    }
+                }
+                if (mSHash != null) {
+                    ub.addQuery("f_shash", mSHash!!)
+                }
+                mJumpTo?.let {
+                    ub.addQuery("seek", mJumpTo!!)
+                    mPrevGid = 0
+                    mNextGid = 0
+                }
+                if (mPrevGid != 0) {
+                    ub.addQuery("prev", mPrevGid)
+                }
+                if (mNextGid != 0) {
+                    ub.addQuery("next", mNextGid)
+                }
+                // Advance search
+                if (advanceSearch != -1) {
+                    ub.addQuery("advsearch", "1")
+                    if (advanceSearch and AdvanceSearchTable.SH != 0) ub.addQuery("f_sh", "on")
+                    if (advanceSearch and AdvanceSearchTable.STO != 0) ub.addQuery("f_sto", "on")
+                    if (advanceSearch and AdvanceSearchTable.SFL != 0) ub.addQuery("f_sfl", "on")
+                    if (advanceSearch and AdvanceSearchTable.SFU != 0) ub.addQuery("f_sfu", "on")
+                    if (advanceSearch and AdvanceSearchTable.SFT != 0) ub.addQuery("f_sft", "on")
+                    // Set min star
+                    if (minRating != -1) {
+                        ub.addQuery("f_sr", "on")
+                        ub.addQuery("f_srdd", minRating)
+                    }
+                    // Pages
+                    if (pageFrom != -1 || pageTo != -1) {
+                        ub.addQuery("f_sp", "on")
+                        ub.addQuery("f_spf", if (pageFrom != -1) pageFrom.toString() else "")
+                        ub.addQuery("f_spt", if (pageTo != -1) pageTo.toString() else "")
+                    }
+                }
+                ub.build()
+            }
+
+            MODE_UPLOADER -> {
+                val sb = StringBuilder(EhUrl.getHost())
+                sb.append("uploader/")
+                try {
+                    sb.append(URLEncoder.encode(mKeyword, "UTF-8"))
+                } catch (e: UnsupportedEncodingException) {
+                    // Empty
+                }
+                if (mPrevGid != 0) {
+                    sb.append("?prev=").append(mPrevGid)
+                }
+                if (mNextGid != 0) {
+                    sb.append("?next=").append(mNextGid)
+                }
+                sb.toString()
+            }
+
+            MODE_TAG -> {
+                val sb = StringBuilder(EhUrl.getHost())
+                sb.append("tag/")
+                try {
+                    sb.append(URLEncoder.encode(mKeyword, "UTF-8"))
+                } catch (e: UnsupportedEncodingException) {
+                    // Empty
+                }
+                if (mPrevGid != 0) {
+                    sb.append("?prev=").append(mPrevGid)
+                }
+                if (mNextGid != 0) {
+                    sb.append("?next=").append(mNextGid)
+                }
+                sb.toString()
+            }
+
+            MODE_WHATS_HOT -> EhUrl.getPopularUrl()
+            MODE_IMAGE_SEARCH -> EhUrl.getImageSearchUrl()
+            MODE_TOPLIST -> {
+                val sb = StringBuilder(EhUrl.HOST_E)
+                sb.append("toplist.php?tl=")
+                try {
+                    sb.append(URLEncoder.encode(mKeyword, "UTF-8"))
+                } catch (e: UnsupportedEncodingException) {
+                    // Empty
+                }
+                if (mNextGid != 0) {
+                    sb.append("&p=").append(mNextGid)
+                }
+                sb.toString()
+            }
+
+            else -> {
+                val url: String = if (mode == MODE_NORMAL) {
+                    EhUrl.getHost()
+                } else {
+                    EhUrl.getWatchedUrl()
+                }
+                val ub = UrlBuilder(url)
+                if (this.category != EhUtils.NONE) {
+                    ub.addQuery("f_cats", category.inv() and EhConfig.ALL_CATEGORY)
+                }
+                if (mKeyword != null) {
+                    val keyword = mKeyword!!.trim { it <= ' ' }
+                    if (keyword.isNotEmpty()) {
+                        try {
+                            ub.addQuery("f_search", URLEncoder.encode(mKeyword, "UTF-8"))
+                        } catch (_: UnsupportedEncodingException) {
+                        }
+                    }
+                }
+                if (mSHash != null) {
+                    ub.addQuery("f_shash", mSHash!!)
+                }
+                if (mPrevGid != 0) {
+                    ub.addQuery("prev", mPrevGid)
+                }
+                if (mNextGid != 0) {
+                    ub.addQuery("next", mNextGid)
+                }
+                if (advanceSearch != -1) {
+                    ub.addQuery("advsearch", "1")
+                    if (advanceSearch and AdvanceSearchTable.SH != 0) ub.addQuery("f_sh", "on")
+                    if (advanceSearch and AdvanceSearchTable.STO != 0) ub.addQuery("f_sto", "on")
+                    if (advanceSearch and AdvanceSearchTable.SFL != 0) ub.addQuery("f_sfl", "on")
+                    if (advanceSearch and AdvanceSearchTable.SFU != 0) ub.addQuery("f_sfu", "on")
+                    if (advanceSearch and AdvanceSearchTable.SFT != 0) ub.addQuery("f_sft", "on")
+                    if (minRating != -1) {
+                        ub.addQuery("f_sr", "on")
+                        ub.addQuery("f_srdd", minRating)
+                    }
+                    if (pageFrom != -1 || pageTo != -1) {
+                        ub.addQuery("f_sp", "on")
+                        ub.addQuery("f_spf", if (pageFrom != -1) pageFrom.toString() else "")
+                        ub.addQuery("f_spt", if (pageTo != -1) pageTo.toString() else "")
+                    }
+                }
+                ub.build()
+            }
+        }
+    }
+
+    override fun describeContents(): Int {
+        return 0
+    }
+
+    override fun writeToParcel(dest: Parcel, flags: Int) {
+        dest.writeInt(mode)
+        dest.writeInt(mPrevGid)
+        dest.writeInt(mNextGid)
+        dest.writeString(mJumpTo)
+        dest.writeInt(this.category)
+        dest.writeString(mKeyword)
+        dest.writeInt(advanceSearch)
+        dest.writeInt(minRating)
+        dest.writeInt(pageFrom)
+        dest.writeInt(pageTo)
+        dest.writeString(imagePath)
+        dest.writeByte(if (isUseSimilarityScan) 1.toByte() else 0.toByte())
+        dest.writeByte(if (isOnlySearchCovers) 1.toByte() else 0.toByte())
+        dest.writeByte(if (isShowExpunged) 1.toByte() else 0.toByte())
+        dest.writeString(mSHash)
+    }
+
+    @IntDef(
+        MODE_NORMAL,
+        MODE_UPLOADER,
+        MODE_TAG,
+        MODE_WHATS_HOT,
+        MODE_IMAGE_SEARCH,
+        MODE_SUBSCRIPTION,
+        MODE_TOPLIST
+    )
+    @Retention(AnnotationRetention.SOURCE)
+    private annotation class Mode
+    companion object {
+        const val MODE_NORMAL = 0x0
+        const val MODE_UPLOADER = 0x1
+        const val MODE_TAG = 0x2
+        const val MODE_WHATS_HOT = 0x3
+        const val MODE_IMAGE_SEARCH = 0x4
+        const val MODE_SUBSCRIPTION = 0x5
+        const val MODE_TOPLIST = 0x6
+
+        @JvmField
+        val CREATOR: Creator<ListUrlBuilder> = object : Creator<ListUrlBuilder> {
+            override fun createFromParcel(source: Parcel): ListUrlBuilder {
+                return ListUrlBuilder(source)
+            }
+
+            override fun newArray(size: Int): Array<ListUrlBuilder?> {
+                return arrayOfNulls(size)
+            }
+        }
+    }
+}
@@ -1,3 +1,21 @@
+/*
+ * Copyright 2022 Tarsin Norbin
+ *
+ * This file is part of EhViewer
+ *
+ * EhViewer is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * EhViewer is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with EhViewer.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
 package com.hippo.ehviewer.client.parser;

 import com.hippo.util.ExceptionUtils;
@@ -31,18 +31,22 @@ import org.jsoup.nodes.Element;
 import org.jsoup.select.Elements;

 import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;

 public class FavoritesParser {
+    private static final Pattern PATTERN_PREV_PAGE = Pattern.compile("prev=(\\d+(-\\d+)?)");
+    private static final Pattern PATTERN_NEXT_PAGE = Pattern.compile("next=(\\d+(-\\d+)?)");

    public static Result parse(String body) throws Exception {
        if (body.contains("This page requires you to log on.</p>")) {
            throw new EhException(GetText.getString(R.string.need_sign_in));
        }
+        Document d = Jsoup.parse(body);
+
        String[] catArray = new String[10];
        int[] countArray = new int[10];
-
        try {
-            Document d = Jsoup.parse(body);
            Element ido = JsoupUtils.getElementByClass(d, "ido");
            //noinspection ConstantConditions
            Elements fps = ido.getElementsByClass("fp");
@@ -60,13 +64,24 @@ public class FavoritesParser {
            throw new ParseException("Parse favorites error", body);
        }

+        Result re = new Result();
+        try {
+            Element prev = d.getElementById("uprev");
+            Element next = d.getElementById("unext");
+            assert prev != null;
+            assert next != null;
+            Matcher matcherPrev = PATTERN_PREV_PAGE.matcher(prev.attr("href"));
+            Matcher matcherNext = PATTERN_NEXT_PAGE.matcher(next.attr("href"));
+            if (matcherPrev.find()) re.prevPage = matcherPrev.group(1);
+            if (matcherNext.find()) re.nextPage = matcherNext.group(1);
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+
        GalleryListParser.Result result = GalleryListParser.parse(body);

-        Result re = new Result();
        re.catArray = catArray;
        re.countArray = countArray;
-        re.pages = result.pages;
-        re.nextPage = result.nextPage;
        re.galleryInfoList = result.galleryInfoList;

        return re;
@@ -75,8 +90,8 @@ public class FavoritesParser {
    public static class Result {
        public String[] catArray; // Size 10
        public int[] countArray; // Size 10
-        public int pages;
-        public int nextPage;
+        public String prevPage;
+        public String nextPage;
        public List<GalleryInfo> galleryInfoList;
    }
 }
@@ -19,8 +19,6 @@ package com.hippo.ehviewer.client.parser;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;

-import com.hippo.ehviewer.Settings;
-import com.hippo.ehviewer.client.EhUrl;
 import com.hippo.ehviewer.client.EhUtils;
 import com.hippo.ehviewer.client.data.GalleryComment;
 import com.hippo.ehviewer.client.data.GalleryCommentList;
@@ -646,9 +644,6 @@ public class GalleryDetailParser {
                String pageUrl = element.attr("href");
                element = element.child(0);
                String imageUrl = element.attr("src");
-                if (Settings.getFixThumbUrl()) {
-                    imageUrl = EhUrl.getFixedPreviewThumbUrl(imageUrl);
-                }
                int index = Integer.parseInt(element.attr("alt")) - 1;
                largePreviewSet.addItem(index, imageUrl, pageUrl);
            }
@@ -674,9 +669,6 @@ public class GalleryDetailParser {
            }
            String imageUrl = ParserUtils.trim(m.group(3));
            String pageUrl = ParserUtils.trim(m.group(1));
-            if (Settings.getFixThumbUrl()) {
-                imageUrl = EhUrl.getFixedPreviewThumbUrl(imageUrl);
-            }
            largePreviewSet.addItem(index, imageUrl, pageUrl);
        }

@@ -51,7 +51,8 @@ public class GalleryListParser {
    private static final Pattern PATTERN_THUMB_SIZE = Pattern.compile("height:(\\d+)px;width:(\\d+)px");
    private static final Pattern PATTERN_FAVORITE_SLOT = Pattern.compile("background-color:rgba\\((\\d+),(\\d+),(\\d+),");
    private static final Pattern PATTERN_PAGES = Pattern.compile("(\\d+) page");
-    private static final Pattern PATTERN_NEXT_PAGE = Pattern.compile("page=(\\d+)");
+    private static final Pattern PATTERN_PREV_PAGE = Pattern.compile("prev=(\\d+)");
+    private static final Pattern PATTERN_NEXT_PAGE = Pattern.compile("next=(\\d+)");

    private static final String[][] FAVORITE_SLOT_RGB = new String[][]{
            new String[]{"0", "0", "0"},
@@ -298,37 +299,33 @@ public class GalleryListParser {
    }

    public static Result parse(@NonNull String body) throws Exception {
+
        Result result = new Result();
        Document d = Jsoup.parse(body);
-
        try {
-            Element ptt = d.getElementsByClass("ptt").first();
-            Elements es = ptt.child(0).child(0).children();
-            result.pages = Integer.parseInt(es.get(es.size() - 2).text().trim());
-
-            Element e = es.get(es.size() - 1);
-            if (e != null) {
-                e = e.children().first();
-                if (e != null) {
-                    String href = e.attr("href");
-                    Matcher matcher = PATTERN_NEXT_PAGE.matcher(href);
-                    if (matcher.find()) {
-                        result.nextPage = NumberUtils.parseIntSafely(matcher.group(1), 0);
-                    }
-                }
-            }
+            Element prev = d.getElementById("uprev");
+            Element next = d.getElementById("unext");
+            assert prev != null;
+            assert next != null;
+            Matcher matcherPrev = PATTERN_PREV_PAGE.matcher(prev.attr("href"));
+            Matcher matcherNext = PATTERN_NEXT_PAGE.matcher(next.attr("href"));
+            if (matcherPrev.find())
+                result.prevGid = NumberUtils.parseIntSafely(matcherPrev.group(1), 0);
+            if (matcherNext.find())
+                result.nextGid = NumberUtils.parseIntSafely(matcherNext.group(1), 0);
+            result.founds = Integer.MAX_VALUE;
        } catch (Throwable e) {
            ExceptionUtils.throwIfFatal(e);
            result.noWatchedTags = body.contains("<p>You do not have any watched tags");
            if (body.contains("No hits found</p>")) {
-                result.pages = 0;
+                result.founds = 0;
                //noinspection unchecked
                result.galleryInfoList = Collections.EMPTY_LIST;
                return result;
            } else if (d.getElementsByClass("ptt").isEmpty()) {
-                result.pages = 1;
+                result.founds = 1;
            } else {
-                result.pages = Integer.MAX_VALUE;
+                result.founds = Integer.MAX_VALUE;
            }
        }

@@ -350,7 +347,7 @@ public class GalleryListParser {
            }
            if (list.isEmpty()) {
                if (es.size() < 2 || !NO_UNFILTERED_TEXT.equals(es.get(1).text())) {
-                    throw new ParseException("No gallery", body);
+                    Log.d(TAG, "No gallery found");
                }
            }
            result.galleryInfoList = list;
@@ -364,8 +361,9 @@ public class GalleryListParser {
    }

    public static class Result {
-        public int pages;
-        public int nextPage;
+        public int founds;
+        public int prevGid;
+        public int nextGid;
        public boolean noWatchedTags;
        public List<GalleryInfo> galleryInfoList;
    }
@@ -17,6 +17,7 @@
 package com.hippo.ehviewer.client.parser;

 import android.net.Uri;
+import android.os.Build;
 import android.text.TextUtils;

 import com.hippo.ehviewer.client.EhUrl;
@@ -27,6 +28,7 @@ import java.io.UnsupportedEncodingException;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;

 public final class GalleryListUrlParser {

@@ -91,10 +93,15 @@ public final class GalleryListUrlParser {
            uploader = path.substring(prefixLength, index);
        }

-        try {
-            uploader = URLDecoder.decode(uploader, "utf-8");
-        } catch (UnsupportedEncodingException e) {
-            return null;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            uploader = URLDecoder.decode(uploader, StandardCharsets.UTF_8);
+        } else {
+            try {
+                uploader = URLDecoder.decode(uploader, StandardCharsets.UTF_8.displayName());
+            } catch (UnsupportedEncodingException e) {
+                e.printStackTrace();
+                return null;
+            }
        }

        if (TextUtils.isEmpty(uploader)) {
@@ -120,10 +127,15 @@ public final class GalleryListUrlParser {
            tag = path.substring(prefixLength, index);
        }

-        try {
-            tag = URLDecoder.decode(tag, "utf-8");
-        } catch (UnsupportedEncodingException e) {
-            return null;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            tag = URLDecoder.decode(tag, StandardCharsets.UTF_8);
+        } else {
+            try {
+                tag = URLDecoder.decode(tag, StandardCharsets.UTF_8.displayName());
+            } catch (UnsupportedEncodingException e) {
+                e.printStackTrace();
+                return null;
+            }
        }

        if (TextUtils.isEmpty(tag)) {
@@ -1,3 +1,21 @@
+/*
+ * Copyright 2022 Tarsin Norbin
+ *
+ * This file is part of EhViewer
+ *
+ * EhViewer is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * EhViewer is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with EhViewer.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
 package com.hippo.ehviewer.client.parser;

 import com.hippo.ehviewer.client.exception.EhException;
@@ -1,3 +1,21 @@
+/*
+ * Copyright 2022 Tarsin Norbin
+ *
+ * This file is part of EhViewer
+ *
+ * EhViewer is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * EhViewer is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with EhViewer.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
 package com.hippo.ehviewer.client.parser;

 import com.hippo.util.ExceptionUtils;
@@ -1,3 +1,21 @@
+/*
+ * Copyright 2022 Tarsin Norbin
+ *
+ * This file is part of EhViewer
+ *
+ * EhViewer is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * EhViewer is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with EhViewer.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
 package com.hippo.ehviewer.client.parser;

 import org.json.JSONException;
@@ -0,0 +1,9 @@
+package com.hippo.ehviewer.dao;
+
+import java.util.List;
+
+public interface BasicDao<T> {
+    List<T> list();
+
+    long insert(T t);
+}
@@ -0,0 +1,160 @@
+package com.hippo.ehviewer.dao;
+
+import android.os.Parcel;
+
+import androidx.room.ColumnInfo;
+import androidx.room.Entity;
+
+import com.hippo.ehviewer.client.data.GalleryInfo;
+
+@Entity(tableName = "BOOKMARKS")
+public class BookmarkInfo extends GalleryInfo {
+    public static final Creator<BookmarkInfo> CREATOR = new Creator<>() {
+        @Override
+        public BookmarkInfo createFromParcel(Parcel source) {
+            return new BookmarkInfo(source);
+        }
+
+        @Override
+        public BookmarkInfo[] newArray(int size) {
+            return new BookmarkInfo[size];
+        }
+    };
+    @ColumnInfo(name = "PAGE")
+    public int page;
+    @ColumnInfo(name = "TIME")
+    public long time;
+
+    protected BookmarkInfo(Parcel in) {
+        super(in);
+        this.page = in.readInt();
+        this.time = in.readLong();
+    }
+
+    public BookmarkInfo(GalleryInfo galleryInfo) {
+        this.gid = galleryInfo.gid;
+        this.token = galleryInfo.token;
+        this.title = galleryInfo.title;
+        this.titleJpn = galleryInfo.titleJpn;
+        this.thumb = galleryInfo.thumb;
+        this.category = galleryInfo.category;
+        this.posted = galleryInfo.posted;
+        this.uploader = galleryInfo.uploader;
+        this.rating = galleryInfo.rating;
+        this.simpleTags = galleryInfo.simpleTags;
+        this.simpleLanguage = galleryInfo.simpleLanguage;
+    }
+
+    public BookmarkInfo(int page, long time) {
+        this.page = page;
+        this.time = time;
+    }
+
+    public long getGid() {
+        return gid;
+    }
+
+    public void setGid(long gid) {
+        this.gid = gid;
+    }
+
+    public String getToken() {
+        return token;
+    }
+
+    public void setToken(String token) {
+        this.token = token;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public String getTitleJpn() {
+        return titleJpn;
+    }
+
+    public void setTitleJpn(String titleJpn) {
+        this.titleJpn = titleJpn;
+    }
+
+    public String getThumb() {
+        return thumb;
+    }
+
+    public void setThumb(String thumb) {
+        this.thumb = thumb;
+    }
+
+    public int getCategory() {
+        return category;
+    }
+
+    public void setCategory(int category) {
+        this.category = category;
+    }
+
+    public String getPosted() {
+        return posted;
+    }
+
+    public void setPosted(String posted) {
+        this.posted = posted;
+    }
+
+    public String getUploader() {
+        return uploader;
+    }
+
+    public void setUploader(String uploader) {
+        this.uploader = uploader;
+    }
+
+    public float getRating() {
+        return rating;
+    }
+
+    public void setRating(float rating) {
+        this.rating = rating;
+    }
+
+    public String getSimpleLanguage() {
+        return simpleLanguage;
+    }
+
+    public void setSimpleLanguage(String simpleLanguage) {
+        this.simpleLanguage = simpleLanguage;
+    }
+
+    public int getPage() {
+        return page;
+    }
+
+    public void setPage(int page) {
+        this.page = page;
+    }
+
+    public long getTime() {
+        return time;
+    }
+
+    public void setTime(long time) {
+        this.time = time;
+    }
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
+        dest.writeInt(this.page);
+        dest.writeLong(this.time);
+    }
+}
@@ -0,0 +1,20 @@
+package com.hippo.ehviewer.dao;
+
+import androidx.room.Dao;
+import androidx.room.Delete;
+import androidx.room.Insert;
+import androidx.room.Query;
+
+import java.util.List;
+
+@Dao
+public interface BookmarksDao extends BasicDao<BookmarkInfo> {
+    @Insert
+    long insert(BookmarkInfo bookmark);
+
+    @Delete
+    void delete(BookmarkInfo bookmark);
+
+    @Query("SELECT * FROM BOOKMARKS ORDER BY TIME DESC")
+    List<BookmarkInfo> list();
+}
@@ -0,0 +1,30 @@
+package com.hippo.ehviewer.dao;
+
+import androidx.room.ColumnInfo;
+import androidx.room.Entity;
+import androidx.room.PrimaryKey;
+
+@Entity(tableName = "DOWNLOAD_DIRNAME")
+public class DownloadDirname {
+    @PrimaryKey
+    @ColumnInfo(name = "GID")
+    private long gid;
+    @ColumnInfo(name = "DIRNAME")
+    private String dirname;
+
+    public long getGid() {
+        return gid;
+    }
+
+    public void setGid(long gid) {
+        this.gid = gid;
+    }
+
+    public String getDirname() {
+        return dirname;
+    }
+
+    public void setDirname(String dirname) {
+        this.dirname = dirname;
+    }
+}
@@ -0,0 +1,29 @@
+package com.hippo.ehviewer.dao;
+
+import androidx.room.Dao;
+import androidx.room.Insert;
+import androidx.room.Query;
+import androidx.room.Update;
+
+import java.util.List;
+
+@Dao
+public interface DownloadDirnameDao extends BasicDao<DownloadDirname> {
+    @Query("SELECT * FROM DOWNLOAD_DIRNAME WHERE GID = :gid")
+    DownloadDirname load(long gid);
+
+    @Update
+    void update(DownloadDirname downloadDirname);
+
+    @Insert
+    long insert(DownloadDirname downloadDirname);
+
+    @Query("DELETE FROM DOWNLOAD_DIRNAME WHERE GID = :gid")
+    void deleteByKey(long gid);
+
+    @Query("DELETE FROM DOWNLOAD_DIRNAME")
+    void deleteAll();
+
+    @Query("SELECT * FROM DOWNLOAD_DIRNAME")
+    List<DownloadDirname> list();
+}
@@ -0,0 +1,252 @@
+package com.hippo.ehviewer.dao;
+
+import android.os.Parcel;
+
+import androidx.room.ColumnInfo;
+import androidx.room.Entity;
+import androidx.room.Ignore;
+
+import com.hippo.ehviewer.client.data.GalleryInfo;
+
+@Entity(tableName = "DOWNLOADS")
+public class DownloadInfo extends GalleryInfo {
+    public static final Creator<DownloadInfo> CREATOR = new Creator<>() {
+        @Override
+        public DownloadInfo createFromParcel(Parcel source) {
+            return new DownloadInfo(source);
+        }
+
+        @Override
+        public DownloadInfo[] newArray(int size) {
+            return new DownloadInfo[size];
+        }
+    };
+    public static final int STATE_INVALID = -1;
+    public static final int STATE_NONE = 0;
+    public static final int STATE_WAIT = 1;
+    public static final int STATE_DOWNLOAD = 2;
+    public static final int STATE_FINISH = 3;
+    public static final int STATE_FAILED = 4;
+    @ColumnInfo(name = "STATE")
+    public int state;
+    @ColumnInfo(name = "LEGACY")
+    public int legacy;
+    @ColumnInfo(name = "TIME")
+    public long time;
+    @ColumnInfo(name = "LABEL")
+    public String label;
+    @Ignore
+    public long speed;
+    @Ignore
+    public long remaining;
+    @Ignore
+    public int finished;
+    @Ignore
+    public int downloaded;
+    @Ignore
+    public int total;
+
+    DownloadInfo() {
+    }
+
+    protected DownloadInfo(Parcel in) {
+        super(in);
+        this.state = in.readInt();
+        this.legacy = in.readInt();
+        this.time = in.readLong();
+        this.label = in.readString();
+    }
+
+    public DownloadInfo(GalleryInfo galleryInfo) {
+        this.gid = galleryInfo.gid;
+        this.token = galleryInfo.token;
+        this.title = galleryInfo.title;
+        this.titleJpn = galleryInfo.titleJpn;
+        this.thumb = galleryInfo.thumb;
+        this.category = galleryInfo.category;
+        this.posted = galleryInfo.posted;
+        this.uploader = galleryInfo.uploader;
+        this.rating = galleryInfo.rating;
+        this.simpleTags = galleryInfo.simpleTags;
+        this.simpleLanguage = galleryInfo.simpleLanguage;
+    }
+
+    public DownloadInfo(int state, int legacy, long time, String label, long speed, long remaining,
+                        int finished, int downloaded, int total) {
+        this.state = state;
+        this.legacy = legacy;
+        this.time = time;
+        this.label = label;
+        this.speed = speed;
+        this.remaining = remaining;
+        this.finished = finished;
+        this.downloaded = downloaded;
+        this.total = total;
+    }
+
+    public long getGid() {
+        return gid;
+    }
+
+    public void setGid(long gid) {
+        this.gid = gid;
+    }
+
+    public String getToken() {
+        return token;
+    }
+
+    public void setToken(String token) {
+        this.token = token;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public String getTitleJpn() {
+        return titleJpn;
+    }
+
+    public void setTitleJpn(String titleJpn) {
+        this.titleJpn = titleJpn;
+    }
+
+    public String getThumb() {
+        return thumb;
+    }
+
+    public void setThumb(String thumb) {
+        this.thumb = thumb;
+    }
+
+    public int getCategory() {
+        return category;
+    }
+
+    public void setCategory(int category) {
+        this.category = category;
+    }
+
+    public String getPosted() {
+        return posted;
+    }
+
+    public void setPosted(String posted) {
+        this.posted = posted;
+    }
+
+    public String getUploader() {
+        return uploader;
+    }
+
+    public void setUploader(String uploader) {
+        this.uploader = uploader;
+    }
+
+    public float getRating() {
+        return rating;
+    }
+
+    public void setRating(float rating) {
+        this.rating = rating;
+    }
+
+    public String getSimpleLanguage() {
+        return simpleLanguage;
+    }
+
+    public void setSimpleLanguage(String simpleLanguage) {
+        this.simpleLanguage = simpleLanguage;
+    }
+
+    public int getState() {
+        return state;
+    }
+
+    public void setState(int state) {
+        this.state = state;
+    }
+
+    public int getLegacy() {
+        return legacy;
+    }
+
+    public void setLegacy(int legacy) {
+        this.legacy = legacy;
+    }
+
+    public long getTime() {
+        return time;
+    }
+
+    public void setTime(long time) {
+        this.time = time;
+    }
+
+    public String getLabel() {
+        return label;
+    }
+
+    public void setLabel(String label) {
+        this.label = label;
+    }
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
+        dest.writeInt(this.state);
+        dest.writeInt(this.legacy);
+        dest.writeLong(this.time);
+        dest.writeString(this.label);
+    }
+
+    public long getSpeed() {
+        return this.speed;
+    }
+
+    public void setSpeed(long speed) {
+        this.speed = speed;
+    }
+
+    public long getRemaining() {
+        return this.remaining;
+    }
+
+    public void setRemaining(long remaining) {
+        this.remaining = remaining;
+    }
+
+    public int getFinished() {
+        return this.finished;
+    }
+
+    public void setFinished(int finished) {
+        this.finished = finished;
+    }
+
+    public int getDownloaded() {
+        return this.downloaded;
+    }
+
+    public void setDownloaded(int downloaded) {
+        this.downloaded = downloaded;
+    }
+
+    public int getTotal() {
+        return this.total;
+    }
+
+    public void setTotal(int total) {
+        this.total = total;
+    }
+}
@@ -0,0 +1,40 @@
+package com.hippo.ehviewer.dao;
+
+import androidx.room.ColumnInfo;
+import androidx.room.Entity;
+import androidx.room.PrimaryKey;
+
+@Entity(tableName = "DOWNLOAD_LABELS")
+public class DownloadLabel {
+    @PrimaryKey
+    @ColumnInfo(name = "_id")
+    private Long id;
+    @ColumnInfo(name = "LABEL")
+    private String label;
+    @ColumnInfo(name = "TIME")
+    private long time;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getLabel() {
+        return label;
+    }
+
+    public void setLabel(String label) {
+        this.label = label;
+    }
+
+    public long getTime() {
+        return time;
+    }
+
+    public void setTime(long time) {
+        this.time = time;
+    }
+}
@@ -0,0 +1,30 @@
+package com.hippo.ehviewer.dao;
+
+import androidx.room.Dao;
+import androidx.room.Delete;
+import androidx.room.Insert;
+import androidx.room.Query;
+import androidx.room.Update;
+
+import java.util.List;
+
+@Dao
+public interface DownloadLabelDao extends BasicDao<DownloadLabel> {
+    @Query("SELECT * FROM DOWNLOAD_LABELS ORDER BY TIME ASC")
+    List<DownloadLabel> list();
+
+    @Query("SELECT * FROM DOWNLOAD_LABELS ORDER BY TIME ASC LIMIT :limit OFFSET :offset")
+    List<DownloadLabel> list(int offset, int limit);
+
+    @Update
+    void update(List<DownloadLabel> downloadLabels);
+
+    @Update
+    void update(DownloadLabel downloadLabel);
+
+    @Insert
+    long insert(DownloadLabel downloadLabel);
+
+    @Delete
+    void delete(DownloadLabel downloadLabel);
+}
@@ -0,0 +1,27 @@
+package com.hippo.ehviewer.dao;
+
+import androidx.room.Dao;
+import androidx.room.Delete;
+import androidx.room.Insert;
+import androidx.room.Query;
+import androidx.room.Update;
+
+import java.util.List;
+
+@Dao
+public interface DownloadsDao extends BasicDao<DownloadInfo> {
+    @Query("SELECT * FROM DOWNLOADS ORDER BY TIME DESC")
+    List<DownloadInfo> list();
+
+    @Query("SELECT * FROM DOWNLOADS WHERE GID = :gid")
+    DownloadInfo load(long gid);
+
+    @Update
+    void update(DownloadInfo downloadInfo);
+
+    @Insert
+    long insert(DownloadInfo downloadInfo);
+
+    @Delete
+    void delete(DownloadInfo downloadInfo);
+}
@@ -0,0 +1,23 @@
+package com.hippo.ehviewer.dao;
+
+import androidx.room.Database;
+import androidx.room.RoomDatabase;
+
+@Database(entities = {BookmarkInfo.class, DownloadInfo.class, DownloadLabel.class, DownloadDirname.class, Filter.class, HistoryInfo.class, LocalFavoriteInfo.class, QuickSearch.class}, version = 4, exportSchema = false)
+public abstract class EhDatabase extends RoomDatabase {
+    public abstract BookmarksDao bookmarksBao();
+
+    public abstract DownloadDirnameDao downloadDirnameDao();
+
+    public abstract DownloadLabelDao downloadLabelDao();
+
+    public abstract DownloadsDao downloadsDao();
+
+    public abstract FilterDao filterDao();
+
+    public abstract HistoryDao historyDao();
+
+    public abstract LocalFavoritesDao localFavoritesDao();
+
+    public abstract QuickSearchDao quickSearchDao();
+}
@@ -0,0 +1,66 @@
+package com.hippo.ehviewer.dao;
+
+import androidx.room.ColumnInfo;
+import androidx.room.Entity;
+import androidx.room.PrimaryKey;
+
+import com.hippo.util.HashCodeUtils;
+import com.hippo.yorozuya.ObjectUtils;
+
+@Entity(tableName = "FILTER")
+public class Filter {
+    @ColumnInfo(name = "MODE")
+    public int mode;
+    @ColumnInfo(name = "TEXT")
+    public String text;
+    @ColumnInfo(name = "ENABLE")
+    public Boolean enable;
+    @PrimaryKey
+    @ColumnInfo(name = "_id")
+    private Long id;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public int getMode() {
+        return mode;
+    }
+
+    public void setMode(int mode) {
+        this.mode = mode;
+    }
+
+    public String getText() {
+        return text;
+    }
+
+    public void setText(String text) {
+        this.text = text;
+    }
+
+    public Boolean getEnable() {
+        return enable;
+    }
+
+    public void setEnable(Boolean enable) {
+        this.enable = enable;
+    }
+
+    @Override
+    public int hashCode() {
+        return HashCodeUtils.hashCode(mode, text);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof Filter filter)) {
+            return false;
+        }
+        return filter.mode == mode && ObjectUtils.equal(filter.text, text);
+    }
+}
@@ -0,0 +1,27 @@
+package com.hippo.ehviewer.dao;
+
+import androidx.room.Dao;
+import androidx.room.Delete;
+import androidx.room.Insert;
+import androidx.room.Query;
+import androidx.room.Update;
+
+import java.util.List;
+
+@Dao
+public interface FilterDao extends BasicDao<Filter> {
+    @Query("SELECT * FROM FILTER")
+    List<Filter> list();
+
+    @Update
+    void update(Filter filter);
+
+    @Insert
+    long insert(Filter filter);
+
+    @Delete
+    void delete(Filter filter);
+
+    @Query("SELECT * FROM FILTER WHERE TEXT = :text AND MODE = :mode")
+    Filter load(String text, int mode);
+}
@@ -0,0 +1,40 @@
+package com.hippo.ehviewer.dao;
+
+import androidx.paging.PagingSource;
+import androidx.room.Dao;
+import androidx.room.Delete;
+import androidx.room.Insert;
+import androidx.room.Query;
+import androidx.room.Update;
+
+import java.util.List;
+
+@Dao
+public interface HistoryDao extends BasicDao<HistoryInfo> {
+    @Query("SELECT * FROM HISTORY WHERE GID = :gid")
+    HistoryInfo load(long gid);
+
+    @Query("SELECT * FROM HISTORY ORDER BY TIME DESC")
+    List<HistoryInfo> list();
+
+    @Query("SELECT * FROM HISTORY ORDER BY TIME DESC LIMIT :limit OFFSET :offset")
+    List<HistoryInfo> list(int offset, int limit);
+
+    @Query("SELECT * FROM HISTORY ORDER BY TIME DESC")
+    PagingSource<Integer, HistoryInfo> listLazy();
+
+    @Update
+    void update(HistoryInfo historyInfo);
+
+    @Insert
+    long insert(HistoryInfo historyInfo);
+
+    @Delete
+    void delete(HistoryInfo historyInfos);
+
+    @Delete
+    void delete(List<HistoryInfo> historyInfos);
+
+    @Query("DELETE FROM HISTORY")
+    void deleteAll();
+}
@@ -0,0 +1,160 @@
+package com.hippo.ehviewer.dao;
+
+import android.os.Parcel;
+
+import androidx.room.ColumnInfo;
+import androidx.room.Entity;
+
+import com.hippo.ehviewer.client.data.GalleryInfo;
+
+@Entity(tableName = "HISTORY")
+public class HistoryInfo extends GalleryInfo {
+    public static final Creator<HistoryInfo> CREATOR = new Creator<>() {
+        @Override
+        public HistoryInfo createFromParcel(Parcel source) {
+            return new HistoryInfo(source);
+        }
+
+        @Override
+        public HistoryInfo[] newArray(int size) {
+            return new HistoryInfo[size];
+        }
+    };
+    @ColumnInfo(name = "MODE")
+    public int mode;
+    @ColumnInfo(name = "TIME")
+    public long time;
+
+    protected HistoryInfo(Parcel in) {
+        super(in);
+        this.mode = in.readInt();
+        this.time = in.readLong();
+    }
+
+    public HistoryInfo(GalleryInfo galleryInfo) {
+        this.gid = galleryInfo.gid;
+        this.token = galleryInfo.token;
+        this.title = galleryInfo.title;
+        this.titleJpn = galleryInfo.titleJpn;
+        this.thumb = galleryInfo.thumb;
+        this.category = galleryInfo.category;
+        this.posted = galleryInfo.posted;
+        this.uploader = galleryInfo.uploader;
+        this.rating = galleryInfo.rating;
+        this.simpleTags = galleryInfo.simpleTags;
+        this.simpleLanguage = galleryInfo.simpleLanguage;
+    }
+
+    public HistoryInfo(int mode, long time) {
+        this.mode = mode;
+        this.time = time;
+    }
+
+    public long getGid() {
+        return gid;
+    }
+
+    public void setGid(long gid) {
+        this.gid = gid;
+    }
+
+    public String getToken() {
+        return token;
+    }
+
+    public void setToken(String token) {
+        this.token = token;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public String getTitleJpn() {
+        return titleJpn;
+    }
+
+    public void setTitleJpn(String titleJpn) {
+        this.titleJpn = titleJpn;
+    }
+
+    public String getThumb() {
+        return thumb;
+    }
+
+    public void setThumb(String thumb) {
+        this.thumb = thumb;
+    }
+
+    public int getCategory() {
+        return category;
+    }
+
+    public void setCategory(int category) {
+        this.category = category;
+    }
+
+    public String getPosted() {
+        return posted;
+    }
+
+    public void setPosted(String posted) {
+        this.posted = posted;
+    }
+
+    public String getUploader() {
+        return uploader;
+    }
+
+    public void setUploader(String uploader) {
+        this.uploader = uploader;
+    }
+
+    public float getRating() {
+        return rating;
+    }
+
+    public void setRating(float rating) {
+        this.rating = rating;
+    }
+
+    public String getSimpleLanguage() {
+        return simpleLanguage;
+    }
+
+    public void setSimpleLanguage(String simpleLanguage) {
+        this.simpleLanguage = simpleLanguage;
+    }
+
+    public int getMode() {
+        return mode;
+    }
+
+    public void setMode(int mode) {
+        this.mode = mode;
+    }
+
+    public long getTime() {
+        return time;
+    }
+
+    public void setTime(long time) {
+        this.time = time;
+    }
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
+        dest.writeInt(this.mode);
+        dest.writeLong(this.time);
+    }
+}
@@ -0,0 +1,147 @@
+package com.hippo.ehviewer.dao;
+
+import android.os.Parcel;
+
+import androidx.room.ColumnInfo;
+import androidx.room.Entity;
+
+import com.hippo.ehviewer.client.data.GalleryInfo;
+
+@Entity(tableName = "LOCAL_FAVORITES")
+public class LocalFavoriteInfo extends GalleryInfo {
+
+    public static final Creator<LocalFavoriteInfo> CREATOR = new Creator<>() {
+        @Override
+        public LocalFavoriteInfo createFromParcel(Parcel source) {
+            return new LocalFavoriteInfo(source);
+        }
+
+        @Override
+        public LocalFavoriteInfo[] newArray(int size) {
+            return new LocalFavoriteInfo[size];
+        }
+    };
+    @ColumnInfo(name = "TIME")
+    public long time;
+
+    protected LocalFavoriteInfo(Parcel in) {
+        super(in);
+        this.time = in.readLong();
+    }
+
+    public LocalFavoriteInfo(GalleryInfo galleryInfo) {
+        this.gid = galleryInfo.gid;
+        this.token = galleryInfo.token;
+        this.title = galleryInfo.title;
+        this.titleJpn = galleryInfo.titleJpn;
+        this.thumb = galleryInfo.thumb;
+        this.category = galleryInfo.category;
+        this.posted = galleryInfo.posted;
+        this.uploader = galleryInfo.uploader;
+        this.rating = galleryInfo.rating;
+        this.simpleTags = galleryInfo.simpleTags;
+        this.simpleLanguage = galleryInfo.simpleLanguage;
+    }
+
+    public LocalFavoriteInfo() {
+    }
+
+    public long getGid() {
+        return gid;
+    }
+
+    public void setGid(long gid) {
+        this.gid = gid;
+    }
+
+    public String getToken() {
+        return token;
+    }
+
+    public void setToken(String token) {
+        this.token = token;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public String getTitleJpn() {
+        return titleJpn;
+    }
+
+    public void setTitleJpn(String titleJpn) {
+        this.titleJpn = titleJpn;
+    }
+
+    public String getThumb() {
+        return thumb;
+    }
+
+    public void setThumb(String thumb) {
+        this.thumb = thumb;
+    }
+
+    public int getCategory() {
+        return category;
+    }
+
+    public void setCategory(int category) {
+        this.category = category;
+    }
+
+    public String getPosted() {
+        return posted;
+    }
+
+    public void setPosted(String posted) {
+        this.posted = posted;
+    }
+
+    public String getUploader() {
+        return uploader;
+    }
+
+    public void setUploader(String uploader) {
+        this.uploader = uploader;
+    }
+
+    public float getRating() {
+        return rating;
+    }
+
+    public void setRating(float rating) {
+        this.rating = rating;
+    }
+
+    public String getSimpleLanguage() {
+        return simpleLanguage;
+    }
+
+    public void setSimpleLanguage(String simpleLanguage) {
+        this.simpleLanguage = simpleLanguage;
+    }
+
+    public long getTime() {
+        return time;
+    }
+
+    public void setTime(long time) {
+        this.time = time;
+    }
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
+        dest.writeLong(this.time);
+    }
+}
@@ -0,0 +1,29 @@
+package com.hippo.ehviewer.dao;
+
+import androidx.room.Dao;
+import androidx.room.Delete;
+import androidx.room.Insert;
+import androidx.room.Query;
+
+import java.util.List;
+
+@Dao
+public interface LocalFavoritesDao extends BasicDao<LocalFavoriteInfo> {
+    @Query("SELECT * FROM LOCAL_FAVORITES ORDER BY TIME DESC")
+    List<LocalFavoriteInfo> list();
+
+    @Query("SELECT * FROM LOCAL_FAVORITES WHERE TITLE LIKE :title ORDER BY TIME DESC")
+    List<LocalFavoriteInfo> list(String title);
+
+    @Query("SELECT * FROM LOCAL_FAVORITES WHERE GID = :gid")
+    LocalFavoriteInfo load(long gid);
+
+    @Insert
+    long insert(LocalFavoriteInfo localFavoriteInfo);
+
+    @Delete
+    void delete(LocalFavoriteInfo localFavoriteInfo);
+
+    @Query("DELETE FROM LOCAL_FAVORITES WHERE GID = :gid")
+    void deleteByKey(long gid);
+}
@@ -0,0 +1,117 @@
+package com.hippo.ehviewer.dao;
+
+import androidx.annotation.NonNull;
+import androidx.room.ColumnInfo;
+import androidx.room.Entity;
+import androidx.room.PrimaryKey;
+
+@Entity(tableName = "QUICK_SEARCH")
+public class QuickSearch {
+    @PrimaryKey
+    @ColumnInfo(name = "_id")
+    public Long id;
+    @ColumnInfo(name = "NAME")
+    public String name;
+    @ColumnInfo(name = "MODE")
+    public int mode;
+    @ColumnInfo(name = "CATEGORY")
+    public int category;
+    @ColumnInfo(name = "KEYWORD")
+    public String keyword;
+    @ColumnInfo(name = "ADVANCE_SEARCH")
+    public int advanceSearch;
+    @ColumnInfo(name = "MIN_RATING")
+    public int minRating;
+    @ColumnInfo(name = "PAGE_FROM")
+    public int pageFrom;
+    @ColumnInfo(name = "PAGE_TO")
+    public int pageTo;
+    @ColumnInfo(name = "TIME")
+    public long time;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getMode() {
+        return mode;
+    }
+
+    public void setMode(int mode) {
+        this.mode = mode;
+    }
+
+    public int getCategory() {
+        return category;
+    }
+
+    public void setCategory(int category) {
+        this.category = category;
+    }
+
+    public String getKeyword() {
+        return keyword;
+    }
+
+    public void setKeyword(String keyword) {
+        this.keyword = keyword;
+    }
+
+    public int getAdvanceSearch() {
+        return advanceSearch;
+    }
+
+    public void setAdvanceSearch(int advanceSearch) {
+        this.advanceSearch = advanceSearch;
+    }
+
+    public int getMinRating() {
+        return minRating;
+    }
+
+    public void setMinRating(int minRating) {
+        this.minRating = minRating;
+    }
+
+    public int getPageFrom() {
+        return pageFrom;
+    }
+
+    public void setPageFrom(int pageFrom) {
+        this.pageFrom = pageFrom;
+    }
+
+    public int getPageTo() {
+        return pageTo;
+    }
+
+    public void setPageTo(int pageTo) {
+        this.pageTo = pageTo;
+    }
+
+    public long getTime() {
+        return time;
+    }
+
+    public void setTime(long time) {
+        this.time = time;
+    }
+
+    @NonNull
+    @Override
+    public String toString() {
+        return name;
+    }
+}
@@ -0,0 +1,30 @@
+package com.hippo.ehviewer.dao;
+
+import androidx.room.Dao;
+import androidx.room.Delete;
+import androidx.room.Insert;
+import androidx.room.Query;
+import androidx.room.Update;
+
+import java.util.List;
+
+@Dao
+public interface QuickSearchDao extends BasicDao<QuickSearch> {
+    @Query("SELECT * FROM QUICK_SEARCH ORDER BY TIME ASC")
+    List<QuickSearch> list();
+
+    @Query("SELECT * FROM QUICK_SEARCH ORDER BY TIME ASC LIMIT :limit OFFSET :offset")
+    List<QuickSearch> list(int offset, int limit);
+
+    @Update
+    void update(List<QuickSearch> downloadLabels);
+
+    @Update
+    void update(QuickSearch quickSearch);
+
+    @Insert
+    long insert(QuickSearch quickSearch);
+
+    @Delete
+    void delete(QuickSearch quickSearch);
+}