Bump Version

Avoid unnecessary overhead
Rewrite the GIF frame delay if it's below a threshold (coil-kt/coil#783) (#672 )
2023-01-15 09:57:00 +08:00 · 2023-01-14 19:56:55 +08:00 · 2023-01-14 17:19:48 +08:00 · 2023-01-14 12:19:58 +08:00 · 2023-01-14 12:11:27 +08:00 · 2023-01-14 12:03:55 +08:00
748 changed files with 47208 additions and 49719 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,137 @@
+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 with fresh installation, with screen recording if possible.
+      placeholder: |
+        0. 重新安装应用 / Fresh install
+        1.
+        2.
+        3.
+        [录屏] / [Screen recording]
+    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: 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,42 +0,0 @@
-name: EhViewer
-
-on: push
-
-jobs:
-  linux:
-    name: Build
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Setup Java 11
-        uses: actions/setup-java@v3
-        with:
-            distribution: temurin
-            java-version: 11
-
-      - name: Setup Android SDK Tools
-        uses: android-actions/setup-android@v2
-
-      - name: Install NDK
-        run: |
-          echo "y" | sudo ${ANDROID_HOME}/tools/bin/sdkmanager --install "ndk;24.0.8215888" --sdk_root=${ANDROID_SDK_ROOT} &> /dev/null
-
-      - name: Gradle Build
-        uses: gradle/gradle-build-action@v2
-      - run: |
-          git submodule update --init --recursive
-          gradle assembleRelease
-
-      - name: Update ARM64
-        uses: actions/upload-artifact@v3
-        with:
-            name: arm64-${{ 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
@@ -0,0 +1,65 @@
+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
+
+      - name: Update mapping
+        uses: actions/upload-artifact@v3
+        with:
+          name: mapping-${{ github.sha }}
+          path: app/build/outputs/mapping/release/mapping.txt
+          retention-days: 5
@@ -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
@@ -12,30 +12,61 @@ jobs:
    steps:
      - name: Checkout
        uses: actions/checkout@v3
+        with:
+          submodules: 'recursive'

-      - name: Setup Java 11
+      - name: Setup Java 19
        uses: actions/setup-java@v3
        with:
-            distribution: temurin
-            java-version: 11
-
-      - name: Setup Android SDK Tools
-        uses: android-actions/setup-android@v2
+          distribution: temurin
+          java-version: 19

      - name: Install NDK
        run: |
-          echo "y" | sudo ${ANDROID_HOME}/tools/bin/sdkmanager --install "ndk;24.0.8215888" --sdk_root=${ANDROID_SDK_ROOT} &> /dev/null
+          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
-      - run: |
-          git submodule update --init --recursive
-          gradle assembleRelease
+        with:
+          arguments: assembleRelease
+
+      - name: Rename Apks
+        run: |
+          cp app/build/outputs/apk/release/app-universal-release.apk app/build/outputs/apk/release/EhViewer-universal.apk
+          cp app/build/outputs/apk/release/app-arm64-v8a-release.apk app/build/outputs/apk/release/EhViewer-arm64-v8a.apk
+          cp app/build/outputs/apk/release/app-x86_64-release.apk app/build/outputs/apk/release/EhViewer-x86_64.apk
+          cp app/build/outputs/apk/release/app-x86-release.apk app/build/outputs/apk/release/EhViewer-x86.apk
+          cp app/build/outputs/apk/release/app-armeabi-v7a-release.apk app/build/outputs/apk/release/EhViewer-armeabi-v7a.apk

      - name: Releases
-        uses: softprops/action-gh-release@v0.1.14
+        uses: softprops/action-gh-release@v1
        with:
          body: Bump Version
+          discussion_category_name: Announcements
          files: |
-            app/build/outputs/apk/release/app-arm64-v8a-release.apk
-            app/build/outputs/apk/release/app-x86_64-release.apk
+            app/build/outputs/apk/release/EhViewer-universal.apk
+            app/build/outputs/apk/release/EhViewer-arm64-v8a.apk
+            app/build/outputs/apk/release/EhViewer-x86_64.apk
+            app/build/outputs/apk/release/EhViewer-x86.apk
+            app/build/outputs/apk/release/EhViewer-armeabi-v7a.apk
+            app/build/outputs/mapping/release/mapping.txt
+
+      - 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,15 +1,9 @@
-[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 "native/src/main/jni/libarchive"]
-	path = native/src/main/jni/libarchive
-	url = https://github.com/asuka-mio/libarchive
-[submodule "native/src/main/jni/liblzma"]
-	path = native/src/main/jni/liblzma
-	url = https://git.tukaani.org/xz.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,95 +1,103 @@
+<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>
+
 <h1 align="center">
-  <img src="art/launcher_icon-web.png" width="200">
+  <img src="https://github.com/Ehviewer-Overhauled/Art/blob/master/launcher_icon-web.svg" width="200">
  <br>EhViewer<br>
 </h1>

 <p align="center">
-  <a href="https://github.com/asuka-mio/Ehviewer/actions">
-    <img src="https://img.shields.io/github/workflow/status/asuka-mio/Ehviewer/EhViewer" alt="Github Actions">
+  <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/asuka-mio/Ehviewer/blob/master/LICENSE">
-    <img src="https://img.shields.io/github/license/asuka-mio/Ehviewer" alt="LICENSE">
+  <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/asuka-mio/ehviewer">
-    <img src="https://www.codefactor.io/repository/github/asuka-mio/ehviewer/badge" alt="CodeFactor">
+  <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/asuka-mio/Ehviewer/releases">
-    <img src="https://img.shields.io/github/v/release/asuka-mio/ehviewer?include_prereleases" alt="Release">
+  <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/asuka-mio/Ehviewer/issues">
-    <img src="https://img.shields.io/github/issues/asuka-mio/ehviewer" alt="Issues">
+  <a href="https://github.com/Ehviewer-Overhauled/Ehviewer/issues">
+    <img src="https://img.shields.io/github/issues/Ehviewer-Overhauled/ehviewer" alt="Issues">
  </a>
 </p>

+<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>
+
+
 # Description
-这是一个 E-Hentai Android 平台的浏览器

-已针对性适配 Material Design 3 及其动态取色系统
+EhViewer fork dedicated to lightweight and high-performance

-仅供 Android 12 及以上平台使用！
-
-
-An E-Hentai Application for Android.
-
-with Material Design 3 and Dynamic Color Support.
-
-Only Support Android S and above!
+with Material Design 3 and Dynamic Color Support

 # Download

-[Github 下载](https://github.com/asuka-mio/Ehviewer/releases)
+<a href="https://github.com/Ehviewer-Overhauled/Ehviewer/releases"><img alt="Get it on GitHub" src="https://github.com/Ehviewer-Overhauled/Art/blob/master/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="https://github.com/Ehviewer-Overhauled/Art/blob/master/get-it-on-fdroid.svg" width="200px"/></a>

 # Screenshot

-![screenshot-01](art/screenshot-01.png)
-
-
-# Build
-
-本项目使用了 CMake 3.23.1 作为构建工具链之一，而当前版本的 Android Studio SDK Tool 无法满足本项目需求。
-
-因此，在构建本项目前需要提前配置好 CMake >=3.23.1。
-
-This Project use CMake 3.23.1, with is highter than Android Studio bundle CMake.
-
-So you need to pre-install CMake>=3.23.1 before build.
+![screenshot-01](https://github.com/Ehviewer-Overhauled/Art/blob/master/screenshot-01.png)
+![screenshot-02](https://github.com/Ehviewer-Overhauled/Art/blob/master/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/)
+- [Coil](https://coil-kt.github.io/coil/)
+- [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-2023 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,55 +1,59 @@
 plugins {
    id 'com.android.application'
-    id 'org.jetbrains.kotlin.android'
-    id 'kotlin-kapt'
+    id 'kotlin-android'
+    id 'kotlin-parcelize'
+    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.1"
+    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 {
-            sign {
-                storeFile file(signStoreFile)
-                storePassword signStorePassword
-                keyAlias signkeyAlias
-                keyPassword signkeyPassword
-            }
-    }
-
-    buildFeatures {
-        compose true
+        sign {
+            storeFile file(signStoreFile)
+            storePassword signStorePassword
+            keyAlias signkeyAlias
+            keyPassword signkeyPassword
+        }
    }

    defaultConfig {
-        applicationId "io.github.nekoinverter.ehviewer"
-        minSdkVersion 31
-        targetSdkVersion 32
-        versionCode 114521
-        versionName "1.7.27.1"
+        applicationId "moe.tarsin.ehviewer"
+        minSdkVersion 28
+        targetSdkVersion 33
+        versionCode 180030
+        versionName "1.8.5.3-alpha05"
        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 += [
+                // https://kotlinlang.org/docs/compiler-reference.html#progressive
+                "-progressive"
+        ]
    }

    lint {
@@ -82,80 +86,80 @@ android {
        }
    }

-    sourceSets {
-        main {
-            java.srcDirs += 'src/main/java-gen'
-        }
+    buildFeatures {
+        buildConfig true
+        compose true
+        viewBinding true
    }

    composeOptions {
-        kotlinCompilerExtensionVersion compose
+        kotlinCompilerExtensionVersion = "1.4.0-dev-k1.8.0-33c0ad36f83"
    }
+
    namespace 'com.hippo.ehviewer'
 }

-tasks.withType(JavaCompile) {
-    task -> task.dependsOn ":daogenerator:executeDaoGenerator"
-}
-
 dependencies {
-    implementation 'androidx.activity:activity:1.4.0'
-    implementation "androidx.activity:activity-compose: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'
-    implementation 'androidx.preference:preference:1.2.0'
-    implementation 'androidx.recyclerview:recyclerview:1.2.1'
+    // https://developer.android.com/jetpack/androidx/releases/activity
+    implementation "androidx.activity:activity-compose:1.6.1"
+    implementation "androidx.appcompat:appcompat:1.6.0"
+    implementation "androidx.biometric:biometric-ktx:1.2.0-alpha05"
+    implementation "androidx.browser:browser:1.4.0"
+
+    // https://developer.android.com/jetpack/androidx/releases/compose-material3
+    implementation platform("androidx.compose:compose-bom:2023.01.00")
+    implementation "androidx.compose.material:material-icons-extended"
+    implementation "androidx.compose.material3:material3"
+
+    implementation "androidx.constraintlayout:constraintlayout:2.2.0-alpha05"
+    implementation "androidx.coordinatorlayout:coordinatorlayout:1.2.0"
+    // https://developer.android.com/jetpack/androidx/releases/lifecycle
+    implementation "androidx.lifecycle:lifecycle-process:2.5.1"
+
+    // https://developer.android.com/jetpack/androidx/releases/navigation
+    def nav_version = "2.5.3"
+    implementation "androidx.navigation:navigation-fragment-ktx:$nav_version"
+    implementation "androidx.navigation:navigation-ui-ktx:$nav_version"
+    implementation "androidx.navigation:navigation-compose:$nav_version"
+
+    // https://developer.android.com/jetpack/androidx/releases/paging
+    implementation "androidx.paging:paging-runtime-ktx:3.2.0-alpha03"
+    implementation 'androidx.preference:preference-ktx:1.2.0'
+    implementation 'androidx.recyclerview:recyclerview:1.3.0-rc01'
+
+    // https://developer.android.com/jetpack/androidx/releases/room
+    def room_version = "2.5.0"
+    ksp "androidx.room:room-compiler:$room_version"
+    implementation "androidx.room:room-paging:$room_version"
+
    implementation 'androidx.swiperefreshlayout:swiperefreshlayout:1.2.0-alpha01'
-    implementation 'androidx.webkit:webkit:1.4.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.3'
-    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.3'
-    implementation 'com.squareup.okhttp3:okhttp-dnsoverhttps:4.9.3'
-    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.4.0'
-    implementation 'dev.rikka.rikkax.insets:insets:1.2.0'
+    implementation 'com.github.chrisbanes:PhotoView:2.3.0' // Dead Dependency
+    implementation 'com.github.tachiyomiorg:DirectionalViewPager:1.0.0' // Dead Dependency
+    // https://github.com/google/accompanist/releases
+    implementation "com.google.accompanist:accompanist-themeadapter-material3:0.28.0"
+    implementation 'com.google.android.material:material:1.8.0-rc01'
+
+    // https://square.github.io/okhttp/changelogs/changelog/
+    implementation 'com.squareup.okhttp3:okhttp-bom:5.0.0-alpha.11'
+    implementation 'com.squareup.okhttp3:okhttp-coroutines'
+
+    implementation 'dev.chrisbanes.insetter:insetter:0.6.1' // Dead Dependency
+    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:2.4.0'
-    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.15.1'
-    implementation projects.native
-
-    implementation "androidx.compose.material3:material3:1.0.0-alpha12"
-
-    implementation "androidx.compose.ui:ui:$compose"
-    implementation "androidx.compose.ui:ui-util:$compose"
-    implementation "androidx.compose.animation:animation-graphics:$compose"
+    implementation 'dev.rikka.rikkax.material:material-preference:2.0.0'
+    // https://coil-kt.github.io/coil/changelog/
+    implementation 'io.coil-kt:coil:2.2.2'
+    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: 'org.jetbrains.kotlin', module: 'kotlin-android-extensions-runtime'
+    exclude group: 'org.jetbrains.kotlin', module: 'kotlin-stdlib-jdk7'
+    exclude group: 'org.jetbrains.kotlin', module: 'kotlin-stdlib-jdk8'
 }
@@ -2,33 +2,15 @@
    public static final ** CREATOR;
 }

-assumenosideeffects class kotlin.jvm.internal.Intrinsics {
-    public static void check*(...);
-    public static void throw*(...);
+-keepclasseswithmembernames,includedescriptorclasses class * {
+    native <methods>;
 }

-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 { }
+-keep class androidx.viewpager.widget.ViewPager$LayoutParams { int position; }

-keepnames class com.hippo.ehviewer.ui.scene.* { }
+-keepattributes LineNumberTable,SourceFile
+-renamesourcefileattribute SourceFile

-keep class com.hippo.ehviewer.dao.* { *; }
-
-keepattributes SourceFile,LineNumberTable
-renamesourcefileattribute
 -repackageclasses
 -allowaccessmodification
 -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
@@ -1,60 +1,60 @@
-<?xml version="1.0" encoding="utf-8"?><!--
-  ~ 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.
-->
-
+<?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

+    <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" />
-
-    <uses-feature
-        android:glEsVersion="0x00020000"
-        android:required="true" />
+        android:maxSdkVersion="28" />

    <application
-        android:name="com.hippo.ehviewer.EhApplication"
+        android:name=".EhApplication"
        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:supportsRtl="true"
        android:theme="@style/AppTheme"
-        tools:ignore="UnusedAttribute">
-
+        tools:targetApi="tiramisu">
        <activity
-            android:name="com.hippo.ehviewer.ui.MainActivity"
+            android:name=".ui.LoginActivity"
+            android:exported="false"
+            android:theme="@style/AppTheme"
+            android:windowSoftInputMode="adjustResize"/>
+        <activity
+            android:name=".ui.MainActivity"
+            android:banner="@mipmap/ic_leanback_banner"
            android:configChanges="screenSize"
            android:exported="true"
            android:launchMode="singleTask"
            android:windowSoftInputMode="adjustResize|stateAlwaysHidden">
-
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
+
                <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"
@@ -73,26 +73,26 @@
                <data android:host="g.e-hentai.org" />
                <data android:host="lofi.e-hentai.org" />
            </intent-filter>
-
            <intent-filter android:label="@string/keyword_search">
                <action android:name="android.intent.action.SEND" />
+
                <category android:name="android.intent.category.DEFAULT" />
+
                <data android:mimeType="text/plain" />
            </intent-filter>
-
            <intent-filter android:label="@string/image_search">
                <action android:name="android.intent.action.SEND" />
+
                <category android:name="android.intent.category.DEFAULT" />
+
                <data android:mimeType="image/*" />
            </intent-filter>
        </activity>
-
        <activity
-            android:name="com.hippo.ehviewer.ui.GalleryActivity"
+            android:name="eu.kanade.tachiyomi.ui.reader.ReaderActivity"
            android:configChanges="screenSize"
            android:exported="true"
            android:launchMode="singleTask">
-
            <intent-filter>
                <action android:name="android.intent.action.VIEW" />

@@ -109,53 +109,50 @@
                <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>
-
        <activity
-            android:name="com.hippo.ehviewer.ui.SettingsActivity"
+            android:name=".ui.SettingsActivity"
            android:configChanges="screenSize"
            android:label="@string/settings"
            android:theme="@style/AppTheme" />
-
        <activity
-            android:name="com.hippo.ehviewer.shortcuts.ShortcutsActivity"
+            android:name=".ui.SecurityActivity"
+            android:configChanges="screenSize"
+            android:label="@string/settings"
+            android:theme="@style/AppTheme" />
+        <activity
+            android:name=".shortcuts.ShortcutsActivity"
            android:excludeFromRecents="true"
            android:launchMode="singleTask"
            android:taskAffinity=""
            android:theme="@android:style/Theme.Translucent.NoTitleBar" />

        <service
-            android:name="com.hippo.ehviewer.download.DownloadService"
+            android:name="androidx.appcompat.app.AppLocalesMetadataHolderService"
+            android:enabled="false"
+            android:exported="false">
+            <meta-data
+                android:name="autoStoreLocales"
+                android:value="true" />
+        </service>
+        <service
+            android:name=".download.DownloadService"
            android:foregroundServiceType="dataSync"
            android:label="@string/download_service_label" />

@@ -164,11 +161,10 @@
            android:authorities="${applicationId}.fileprovider"
            android:exported="false"
            android:grantUriPermissions="true">
-
            <meta-data
                android:name="android.support.FILE_PROVIDER_PATHS"
                android:resource="@xml/filepaths" />
-
        </provider>
    </application>
-</manifest>
+
+</manifest>
@@ -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 fdutils.c gifUtils.c)
+target_include_directories(${PROJECT_NAME} PUBLIC libarchive/libarchive)
+target_link_libraries(${PROJECT_NAME} archive_static log -Wl,--gc-sections)
@@ -0,0 +1,419 @@
+/*
+ * 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;
+
+typedef struct {
+    const char *filename;
+    int index;
+} entry;
+
+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;
+static entry *entries = NULL;
+static size_t entryCount = 0;
+
+#define POPULATE_THRESHOLD (512 * 1024 * 1024) // 512 MiB
+
+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 inline int compare_entries(const void *a, const void *b) {
+    const char *fa = ((entry *) a)->filename;
+    const char *fb = ((entry *) b)->filename;
+    int a_len = (int) strlen(fa);
+    int b_len = (int) strlen(fb);
+    return a_len == b_len ? strcmp(fa, fb) : a_len - b_len;
+}
+
+static long archive_map_entries_index(archive_ctx *ctx) {
+    long count = 0;
+    while (archive_read_next_header(ctx->arc, &ctx->entry) == ARCHIVE_OK) {
+        const char *name = archive_entry_pathname(ctx->entry);
+        if (filename_is_playable_file(name)) {
+            entries[count].filename = strdup(name);
+            entries[count].index = count;
+            count++;
+        }
+    }
+    if (!count)
+        LOGE("%s", archive_error_string(ctx->arc));
+    qsort(entries, entryCount, sizeof(entry), compare_entries);
+    return count;
+}
+
+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;
+    int mmap_flags = MAP_PRIVATE;
+    if (size <= POPULATE_THRESHOLD)
+        mmap_flags |= MAP_POPULATE;
+    archiveAddr = mmap64(0, size, PROT_READ, mmap_flags, 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");
+        LOGE("%s%s", "Archive open failed:", archive_error_string(ctx->arc));
+    } else {
+        entryCount = 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);
+
+    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 {
+        entries = calloc(entryCount, sizeof(entry));
+        r = archive_map_entries_index(ctx);
+    }
+
+    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);
+    index = entries[index].index;
+    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);
+    for (int i = 0; i < entryCount; ++i) {
+        free((void *) entries[i].filename);
+    }
+    free(entries);
+}
+
+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);
+    index = entries[index].index;
+    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);
+    index = entries[index].index;
+    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) {
+    EH_UNUSED(thiz);
+    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,11 @@
+#include <string.h>
+#include <jni.h>
+
+#define GIF_HEADER_87A "GIF87a"
+#define GIF_HEADER_89A "GIF89a"
+
+JNIEXPORT jboolean JNICALL
+Java_com_hippo_Native_isGif(JNIEnv *env, jobject thiz, jobject buffer) {
+    void *addr = (*env)->GetDirectBufferAddress(env, buffer);
+    return !memcmp(addr, GIF_HEADER_87A, 6) || !memcmp(addr, GIF_HEADER_89A, 6);
+}
@@ -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 */
@@ -0,0 +1,49 @@
+package androidx.navigation.ui
+
+import android.view.Menu
+import android.view.MenuItem
+import androidx.annotation.IdRes
+import androidx.navigation.ActivityNavigator
+import androidx.navigation.NavController
+import androidx.navigation.NavDestination
+import androidx.navigation.NavDestination.Companion.hierarchy
+import androidx.navigation.NavGraph.Companion.findStartDestination
+import androidx.navigation.NavOptions
+
+fun onNavDestinationSelected2(item: MenuItem, navController: NavController): Boolean {
+    if (navController.currentDestination?.matchDestination(item.itemId) == true) return false
+    val builder = NavOptions.Builder().setLaunchSingleTop(true)
+    if (
+        navController.currentDestination!!.parent!!.findNode(item.itemId)
+                is ActivityNavigator.Destination
+    ) {
+        builder.setEnterAnim(R.anim.nav_default_enter_anim)
+            .setExitAnim(R.anim.nav_default_exit_anim)
+            .setPopEnterAnim(R.anim.nav_default_pop_enter_anim)
+            .setPopExitAnim(R.anim.nav_default_pop_exit_anim)
+    } else {
+        builder.setEnterAnim(com.hippo.ehviewer.R.anim.scene_open_enter)
+            .setExitAnim(com.hippo.ehviewer.R.anim.scene_open_exit)
+            .setPopEnterAnim(com.hippo.ehviewer.R.anim.scene_close_enter)
+            .setPopExitAnim(com.hippo.ehviewer.R.anim.scene_close_exit)
+    }
+    if (item.order and Menu.CATEGORY_SECONDARY == 0) {
+        builder.setPopUpTo(
+            navController.graph.findStartDestination().id,
+            inclusive = false,
+            saveState = false
+        )
+    }
+    val options = builder.build()
+    return try {
+        // TODO provide proper API instead of using Exceptions as Control-Flow.
+        navController.navigate(item.itemId, null, options)
+        // Return true only if the destination we've navigated to matches the MenuItem
+        navController.currentDestination?.matchDestination(item.itemId) == true
+    } catch (e: IllegalArgumentException) {
+        false
+    }
+}
+
+fun NavDestination.matchDestination(@IdRes destId: Int): Boolean =
+    hierarchy.any { it.id == destId }
@@ -0,0 +1,25 @@
+package androidx.swiperefreshlayout.widget
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.graphics.drawable.ShapeDrawable
+import android.util.AttributeSet
+import androidx.core.graphics.ColorUtils
+import rikka.core.res.resolveColor
+
+
+@SuppressLint("PrivateResource")
+class ThemedSwipeRefreshLayout @JvmOverloads constructor(
+    context: Context, attrs: AttributeSet? = null
+) : SwipeRefreshLayout(context, attrs) {
+
+    init {
+        val surfaceColor =
+            context.theme.resolveColor(com.google.android.material.R.attr.colorSurface)
+        val overlayColor =
+            context.getColor(com.google.android.material.R.color.m3_popupmenu_overlay_color)
+        val backgroundColor = ColorUtils.compositeColors(overlayColor, surfaceColor)
+        (mCircleView.background as ShapeDrawable).paint.color = backgroundColor
+        setColorSchemeColors(context.theme.resolveColor(com.google.android.material.R.attr.colorAccent))
+    }
+}
@@ -0,0 +1,88 @@
+@file:Suppress("SameParameterValue")
+
+package coil.decode
+
+import okio.Buffer
+import okio.ByteString
+import okio.ByteString.Companion.decodeHex
+import okio.ForwardingSource
+import okio.Source
+
+/**
+ * A [ForwardingSource] that rewrites the GIF frame delay in every graphics control block if it's
+ * below a threshold.
+ */
+internal class FrameDelayRewritingSource(delegate: Source) : ForwardingSource(delegate) {
+
+    // An intermediary buffer so we can read and alter the data before it's written to the destination.
+    private val buffer = Buffer()
+
+    override fun read(sink: Buffer, byteCount: Long): Long {
+        // Ensure our buffer has enough bytes to satisfy this read.
+        request(byteCount)
+
+        // Short circuit if there are no bytes in the buffer.
+        if (buffer.size == 0L) {
+            return if (byteCount == 0L) 0L else -1L
+        }
+
+        // Search through the buffer and rewrite any frame delays below the threshold.
+        var bytesWritten = 0L
+        while (true) {
+            val index = indexOf(FRAME_DELAY_START_MARKER)
+            if (index == -1L) break
+
+            // Write up until the end of the frame delay start marker.
+            bytesWritten += write(sink, index + FRAME_DELAY_START_MARKER_SIZE_BYTES)
+
+            // Check for the end of the graphics control extension block.
+            if (!request(5) || buffer[4] != 0.toByte()) continue
+
+            // Rewrite the frame delay if it is below the threshold.
+            // The frame delay is stored as two unsigned bytes in reverse order
+            // (i.e. the most significant bits are in the byte that's read second).
+            val frameDelay = (buffer[2].toUByte().toInt() shl 8) or buffer[1].toUByte().toInt()
+            if (frameDelay < MINIMUM_FRAME_DELAY) {
+                sink.writeByte(buffer[0].toInt())
+                sink.writeByte(DEFAULT_FRAME_DELAY)
+                sink.writeByte(0)
+                buffer.skip(3)
+            }
+        }
+
+        // Write anything left in the source.
+        if (bytesWritten < byteCount) {
+            bytesWritten += write(sink, byteCount - bytesWritten)
+        }
+        return if (bytesWritten == 0L) -1 else bytesWritten
+    }
+
+    private fun indexOf(bytes: ByteString): Long {
+        var index = -1L
+        while (true) {
+            index = buffer.indexOf(bytes[0], index + 1)
+            if (index == -1L) break
+            if (request(bytes.size.toLong()) && buffer.rangeEquals(index, bytes)) break
+        }
+        return index
+    }
+
+    private fun write(sink: Buffer, byteCount: Long): Long {
+        return buffer.read(sink, byteCount).coerceAtLeast(0)
+    }
+
+    private fun request(byteCount: Long): Boolean {
+        if (buffer.size >= byteCount) return true
+        val toRead = byteCount - buffer.size
+        return super.read(buffer, toRead) == toRead
+    }
+
+    private companion object {
+        // https://www.matthewflickinger.com/lab/whatsinagif/bits_and_bytes.asp
+        // See: "Graphics Control Extension"
+        private val FRAME_DELAY_START_MARKER = "0021F904".decodeHex()
+        private const val FRAME_DELAY_START_MARKER_SIZE_BYTES = 4
+        private const val MINIMUM_FRAME_DELAY = 2
+        private const val DEFAULT_FRAME_DELAY = 10
+    }
+}
@@ -0,0 +1,160 @@
+package com.davemorrissey.labs.subscaleview
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Rect
+import android.net.Uri
+import com.davemorrissey.labs.subscaleview.provider.AssetInputProvider
+import com.davemorrissey.labs.subscaleview.provider.InputProvider
+import com.davemorrissey.labs.subscaleview.provider.OpenStreamProvider
+import com.davemorrissey.labs.subscaleview.provider.ResourceInputProvider
+import com.davemorrissey.labs.subscaleview.provider.UriInputProvider
+import java.io.InputStream
+
+/**
+ * Helper class used to set the source and additional attributes from a variety of sources. Supports
+ * use of a bitmap, asset, resource, external file or any other URI.
+ *
+ *
+ * When you are using a preview image, you must set the dimensions of the full size image on the
+ * ImageSource object for the full size image using the [.dimensions] method.
+ */
+class ImageSource {
+    val bitmap: Bitmap?
+    val provider: InputProvider?
+
+    private var sWidth = 0
+    private var sHeight = 0
+
+    var sRegion = Rect(0, 0, 0, 0)
+        private set
+    var isCached = false
+        private set
+
+    private constructor(bitmap: Bitmap, cached: Boolean) {
+        this.bitmap = bitmap
+        provider = null
+        sWidth = bitmap.width
+        sHeight = bitmap.height
+        isCached = cached
+    }
+
+    private constructor(provider: InputProvider) {
+        bitmap = null
+        this.provider = provider
+    }
+
+    /**
+     * Use a region of the source image. Region must be set independently for the full size image and the preview if
+     * you are using one.
+     *
+     * @param sRegion the region of the source image to be displayed.
+     * @return this instance for chaining.
+     */
+    fun region(sRegion: Rect): ImageSource {
+        this.sRegion = sRegion
+        setInvariants()
+        return this
+    }
+
+    /**
+     * Declare the dimensions of the image. This is only required for a full size image, when you are specifying a URI
+     * and also a preview image. When displaying a bitmap object, or not using a preview, you do not need to declare
+     * the image dimensions. Note if the declared dimensions are found to be incorrect, the view will reset.
+     *
+     * @param sWidth  width of the source image.
+     * @param sHeight height of the source image.
+     * @return this instance for chaining.
+     */
+    fun dimensions(sWidth: Int, sHeight: Int): ImageSource {
+        if (bitmap == null) {
+            this.sWidth = sWidth
+            this.sHeight = sHeight
+        }
+        setInvariants()
+        return this
+    }
+
+    private fun setInvariants() {
+        if (!sRegion.isEmpty) {
+            sWidth = sRegion.width()
+            sHeight = sRegion.height()
+        }
+    }
+
+    companion object {
+        /**
+         * Create an instance from a resource. The correct resource for the device screen resolution will be used.
+         *
+         * @param resId resource ID.
+         * @return an [ImageSource] instance.
+         */
+        @JvmStatic
+        fun resource(context: Context, resId: Int): ImageSource {
+            return ImageSource(ResourceInputProvider(context, resId))
+        }
+
+        /**
+         * Create an instance from an asset name.
+         *
+         * @param assetName asset name.
+         * @return an [ImageSource] instance.
+         */
+        @JvmStatic
+        fun asset(context: Context, assetName: String): ImageSource {
+            return ImageSource(AssetInputProvider(context, assetName))
+        }
+
+        /**
+         * Create an instance from a URI.
+         *
+         * @param uri image URI.
+         * @return an [ImageSource] instance.
+         */
+        fun uri(context: Context, uri: Uri): ImageSource {
+            return ImageSource(UriInputProvider(context, uri))
+        }
+
+        /**
+         * Create an instance from an input provider.
+         *
+         * @param provider input stream provider.
+         * @return an [ImageSource] instance.
+         */
+        fun provider(provider: InputProvider): ImageSource {
+            return ImageSource(provider)
+        }
+
+        /**
+         * Create an instance from an input stream.
+         *
+         * @param stream open input stream.
+         * @return an [ImageSource] instance.
+         */
+        fun inputStream(stream: InputStream): ImageSource {
+            return ImageSource(OpenStreamProvider(stream))
+        }
+
+        /**
+         * Provide a loaded bitmap for display.
+         *
+         * @param bitmap bitmap to be displayed.
+         * @return an [ImageSource] instance.
+         */
+        fun bitmap(bitmap: Bitmap): ImageSource {
+            return ImageSource(bitmap, false)
+        }
+
+        /**
+         * Provide a loaded and cached bitmap for display. This bitmap will not be recycled when it is no
+         * longer needed. Use this method if you loaded the bitmap with an image loader such as Picasso
+         * or Volley.
+         *
+         * @param bitmap bitmap to be displayed.
+         * @return an [ImageSource] instance.
+         */
+        fun cachedBitmap(bitmap: Bitmap): ImageSource {
+            return ImageSource(bitmap, true)
+        }
+    }
+}
@@ -0,0 +1,15 @@
+package com.davemorrissey.labs.subscaleview
+
+import android.graphics.PointF
+import java.io.Serializable
+
+/**
+ * Wraps the scale, center and orientation of a displayed image for easy restoration on screen rotate.
+ */
+class ImageViewState(val scale: Float, center: PointF) : Serializable {
+    private val centerX: Float = center.x
+    private val centerY: Float = center.y
+
+    val center: PointF
+        get() = PointF(centerX, centerY)
+}
@@ -0,0 +1,53 @@
+package com.davemorrissey.labs.subscaleview.decoder
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Point
+import android.graphics.Rect
+import kotlin.Throws
+import com.davemorrissey.labs.subscaleview.provider.InputProvider
+import java.lang.Exception
+
+/**
+ * Interface for image decoding classes.
+ */
+interface Decoder {
+    /**
+     * Initialise the decoder. When possible, perform initial setup work once in this method. The
+     * dimensions of the image must be returned.
+     *
+     * @param context  Application context. A reference may be held, but must be cleared on recycle.
+     * @param provider Provider of the image.
+     * @return Dimensions of the image.
+     * @throws Exception if initialisation fails.
+     */
+    @Throws(Exception::class)
+    fun init(context: Context, provider: InputProvider): Point
+
+    /**
+     * Decode a region of the image with the given sample size. This method is called off the UI
+     * thread so it can safely load the image on the current thread. It is called from
+     * [android.os.AsyncTask]s running in an executor that may have multiple threads, so
+     * implementations must be thread safe. Adding `synchronized` to the method signature
+     * is the simplest way to achieve this, but bear in mind the [.recycle] method can be
+     * called concurrently.
+     *
+     * @param sRect      Source image rectangle to decode.
+     * @param sampleSize Sample size.
+     * @return The decoded region. It is safe to return null if decoding fails.
+     */
+    fun decodeRegion(sRect: Rect, sampleSize: Int): Bitmap
+
+    /**
+     * Status check. Should return false before initialisation and after recycle.
+     *
+     * @return true if the decoder is ready to be used.
+     */
+    val isReady: Boolean
+
+    /**
+     * This method will be called when the decoder is no longer required. It should clean up any
+     * resources still in use.
+     */
+    fun recycle()
+}
@@ -0,0 +1,64 @@
+package com.davemorrissey.labs.subscaleview.decoder
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Point
+import android.graphics.Rect
+import kotlin.Throws
+import com.davemorrissey.labs.subscaleview.provider.InputProvider
+import com.davemorrissey.labs.subscaleview.SubsamplingScaleImageView
+import java.lang.Exception
+
+class ImageDecoder @JvmOverloads constructor(
+    private val cropBorders: Boolean,
+    bitmapConfig: Bitmap.Config? = null
+) : Decoder {
+    init {
+        val globalBitmapConfig = SubsamplingScaleImageView.preferredBitmapConfig
+    }
+
+    /**
+     * Initialise the decoder. When possible, perform initial setup work once in this method. The
+     * dimensions of the image must be returned.
+     *
+     * @param context  Application context. A reference may be held, but must be cleared on recycle.
+     * @param provider Provider of the image.
+     * @return Dimensions of the image.
+     * @throws Exception if initialisation fails.
+     */
+    @Throws(Exception::class)
+    override fun init(context: Context, provider: InputProvider): Point {
+        TODO()
+    }
+
+    /**
+     * Decode a region of the image with the given sample size. This method is called off the UI
+     * thread so it can safely load the image on the current thread. It is called from
+     * [android.os.AsyncTask]s running in an executor that may have multiple threads, so
+     * implementations must be thread safe. Adding `synchronized` to the method signature
+     * is the simplest way to achieve this, but bear in mind the [.recycle] method can be
+     * called concurrently.
+     *
+     * @param sRect      Source image rectangle to decode.
+     * @param sampleSize Sample size.
+     * @return The decoded region. It is safe to return null if decoding fails.
+     */
+    override fun decodeRegion(sRect: Rect, sampleSize: Int): Bitmap {
+        TODO()
+    }
+
+    /**
+     * Status check. Should return false before initialisation and after recycle.
+     *
+     * @return true if the decoder is ready to be used.
+     */
+    override val isReady: Boolean = TODO()
+
+    /**
+     * This method will be called when the decoder is no longer required. It should clean up any
+     * resources still in use.
+     */
+    override fun recycle() {
+        TODO()
+    }
+}
@@ -0,0 +1,11 @@
+package com.davemorrissey.labs.subscaleview.provider
+
+import android.content.Context
+import java.io.IOException
+
+class AssetInputProvider(context: Context, val assetName: String) : InputProvider {
+    private val assets = context.assets
+
+    @Throws(IOException::class)
+    override fun openStream() = assets.open(assetName)
+}
@@ -0,0 +1,10 @@
+package com.davemorrissey.labs.subscaleview.provider
+
+import java.io.IOException
+import java.io.InputStream
+import kotlin.Throws
+
+interface InputProvider {
+    @Throws(IOException::class)
+    fun openStream(): InputStream?
+}
@@ -0,0 +1,16 @@
+package com.davemorrissey.labs.subscaleview.provider
+
+import java.io.IOException
+import java.io.InputStream
+import kotlin.Throws
+
+/**
+ * Provider from an already open input stream.
+ *
+ *
+ * Please keep in mind this provider is not reusable.
+ */
+class OpenStreamProvider(private val stream: InputStream) : InputProvider {
+    @Throws(IOException::class)
+    override fun openStream() = stream
+}
@@ -0,0 +1,11 @@
+package com.davemorrissey.labs.subscaleview.provider
+
+import android.content.Context
+import java.io.IOException
+
+class ResourceInputProvider(context: Context, val resource: Int) : InputProvider {
+    private val resources = context.resources
+
+    @Throws(IOException::class)
+    override fun openStream() = resources.openRawResource(resource)
+}
@@ -0,0 +1,13 @@
+package com.davemorrissey.labs.subscaleview.provider
+
+import android.content.Context
+import android.net.Uri
+import java.io.IOException
+import kotlin.Throws
+
+class UriInputProvider(context: Context, val uri: Uri) : InputProvider {
+    private val resolver = context.contentResolver
+
+    @Throws(IOException::class)
+    override fun openStream() = resolver.openInputStream(uri)
+}
@@ -0,0 +1,32 @@
+/*
+ * 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
+import java.nio.ByteBuffer
+
+object Native {
+    fun initialize() {
+        System.loadLibrary("ehviewer")
+    }
+
+    @JvmStatic
+    external fun getFd(fd: FileDescriptor?): Int
+
+    external fun isGif(buffer: ByteBuffer): Boolean
+}
@@ -0,0 +1,46 @@
+/*
+ * 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 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()
+    }
+
+    companion object {
+        @JvmStatic
+        external fun releaseByteBuffer(buffer: ByteBuffer)
+    }
+}
@@ -0,0 +1,8 @@
+package com.hippo.app
+
+import android.content.Context
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+
+open class BaseDialogBuilder constructor(
+    context: Context
+) : MaterialAlertDialogBuilder(context)
@@ -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,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 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));
+    }    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;
+        }
+    };
+
+    /**
+     * 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,504 @@
+/*
+ * 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 com.hippo.util.HashCodeUtils;
+
+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 = HashCodeUtils.bytesToHexString(digest.digest());
+        } catch (final NoSuchAlgorithmException e) {
+            cacheKey = String.valueOf(key.hashCode());
+        }
+        return cacheKey;
+    }
+
+    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;
+    }
+}
@@ -1,223 +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 android.os.Process;
-import android.util.Log;
-
-import androidx.annotation.IntDef;
-import androidx.annotation.UiThread;
-
-import com.hippo.beerbelly.BeerBelly;
-import com.hippo.yorozuya.thread.PriorityThreadFactory;
-import com.hippo.yorozuya.thread.SerialThreadExecutor;
-
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.util.LinkedList;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import okhttp3.OkHttpClient;
-
-@SuppressWarnings("rawtypes")
-public final class Conaco<V> {
-
-    public static final int SOURCE_MEMORY = 0;
-    public static final int SOURCE_DISK = 1;
-    public static final int SOURCE_NETWORK = 2;
-    private static final String TAG = Conaco.class.getSimpleName();
-    private final ValueHelper<V> mHelper;
-    private final ValueCache<V> mCache;
-    private final OkHttpClient mOkHttpClient;
-    private final Register<V> mRegister;
-    private final SerialThreadExecutor mDiskExecutor;
-    private final ThreadPoolExecutor mNetworkExecutor;
-    private final AtomicInteger mIdGenerator;
-    private final boolean mDebug;
-
-    private Conaco(Builder<V> builder) {
-        mHelper = builder.objectHelper;
-
-        BeerBelly.BeerBellyParams beerBellyParams = new BeerBelly.BeerBellyParams();
-        beerBellyParams.hasMemoryCache = builder.hasMemoryCache;
-        beerBellyParams.memoryCacheMaxSize = builder.memoryCacheMaxSize;
-        beerBellyParams.hasDiskCache = builder.hasDiskCache;
-        beerBellyParams.diskCacheDir = builder.diskCacheDir;
-        beerBellyParams.diskCacheMaxSize = builder.diskCacheMaxSize;
-
-        mCache = new ValueCache<>(beerBellyParams, mHelper);
-        mOkHttpClient = builder.okHttpClient;
-
-        mRegister = new Register<>();
-
-        mDiskExecutor = new SerialThreadExecutor(3000L, new LinkedList<>(),
-                new PriorityThreadFactory("Conaco-Disk", Process.THREAD_PRIORITY_BACKGROUND));
-        mNetworkExecutor = new ThreadPoolExecutor(3, 3, 5L, TimeUnit.SECONDS,
-                new LinkedBlockingQueue<>(),
-                new PriorityThreadFactory("Conaco-Network", Process.THREAD_PRIORITY_BACKGROUND));
-
-        mIdGenerator = new AtomicInteger();
-
-        mDebug = builder.debug;
-    }
-
-    public BeerBelly getBeerBelly() {
-        return mCache;
-    }
-
-    private void onUnregisterConacoTask(ConacoTask<V> task) {
-        ConacoTask<V> next = mRegister.getByKey(task.getKey());
-        if (next != null) {
-            startConacoTask(next);
-        }
-    }
-
-    private void startConacoTask(ConacoTask<V> task) {
-        Unikery<V> unikery = task.getUnikery();
-
-        // Can't unikery is gone, finish the task now
-        if (unikery == null) {
-            finishConacoTask(task);
-            return;
-        }
-
-        String key = task.getKey();
-        V value = null;
-
-        // Get from memory
-        if (key != null && task.useMemoryCache() && mHelper.useMemoryCache(key, null)) {
-            value = mCache.getFromMemory(key);
-        }
-
-        if (value == null || !unikery.onGetValue(value, SOURCE_MEMORY)) {
-            unikery.onMiss(SOURCE_MEMORY);
-            task.start();
-        } else {
-            // Get the object, finish the task
-            finishConacoTask(task);
-        }
-    }
-
-    @UiThread
-    public void load(ConacoTask.Builder<V> builder) {
-        builder.isValid();
-
-        if (mDebug) {
-            Log.d(TAG, "Key " + builder.getKey());
-            Log.d(TAG, "Url " + builder.getUrl());
-        }
-
-        Unikery<V> unikery = builder.getUnikery();
-
-        // Cancel first
-        cancel(unikery);
-
-        // Build conaco task
-        int id;
-        //noinspection StatementWithEmptyBody
-        while ((id = mIdGenerator.getAndIncrement()) == Unikery.INVALID_ID) ;
-        unikery.setTaskId(id);
-        builder.setId(id)
-                .setHelper(mHelper)
-                .setCache(mCache)
-                .setOkHttpClient(mOkHttpClient)
-                .setDiskExecutor(mDiskExecutor)
-                .setNetworkExecutor(mNetworkExecutor)
-                .setConaco(this);
-        ConacoTask<V> task = builder.build();
-
-        if (!mRegister.register(id, task)) {
-            startConacoTask(task);
-        } else {
-            // The key is repeated, wait
-            unikery.onWait();
-        }
-    }
-
-    @UiThread
-    public void cancel(Unikery<V> unikery) {
-        int id = unikery.getTaskId();
-        if (id != Unikery.INVALID_ID) {
-            unikery.setTaskId(Unikery.INVALID_ID);
-            ConacoTask<V> task = mRegister.unregister(id);
-            if (task != null) {
-                task.stop();
-                // Don't need unikery anymore
-                task.clearUnikery();
-                // Callback
-                onUnregisterConacoTask(task);
-            } else {
-                Log.e(TAG, "Can't find conaco task by id " + id);
-            }
-        }
-    }
-
-    public boolean isLoading(Unikery<V> unikery) {
-        int id = unikery.getTaskId();
-        return id != Unikery.INVALID_ID && mRegister.contain(id);
-    }
-
-    /**
-     * Unregister task, reset unikery id, clear unikery in task, call next
-     */
-    void finishConacoTask(ConacoTask<V> task) {
-        mRegister.unregister(task.getId());
-        Unikery unikery = task.getUnikery();
-        if (unikery != null) {
-            unikery.setTaskId(Unikery.INVALID_ID);
-        }
-        task.clearUnikery();
-
-        onUnregisterConacoTask(task);
-    }
-
-    @IntDef({SOURCE_MEMORY, SOURCE_DISK, SOURCE_NETWORK})
-    @Retention(RetentionPolicy.SOURCE)
-    public @interface Source {
-    }
-
-    public static class Builder<T> extends BeerBelly.BeerBellyParams {
-        /**
-         * The client to get image from internet
-         */
-        public OkHttpClient okHttpClient = null;
-
-        /**
-         * Decode, get size and others
-         */
-        public ValueHelper<T> objectHelper = null;
-
-        public boolean debug = false;
-
-        @Override
-        public void isValid() throws IllegalStateException {
-            super.isValid();
-
-            if (okHttpClient == null) {
-                throw new IllegalStateException("No http client? How can I load image via url?");
-            }
-        }
-
-        public Conaco<T> build() {
-            isValid();
-            return new Conaco<>(this);
-        }
-    }
-}
@@ -1,588 +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 android.annotation.SuppressLint;
-import android.os.AsyncTask;
-import android.util.Log;
-
-import androidx.annotation.Nullable;
-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;
-import java.io.InputStream;
-import java.io.OutputStream;
-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;
-import okhttp3.ResponseBody;
-
-@SuppressWarnings({"rawtypes", "deprecation"})
-public final class ConacoTask<V> {
-
-    private static final String TAG = ConacoTask.class.getSimpleName();
-
-    private final int mId;
-    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;
-    private final ValueHelper<V> mHelper;
-    private final ValueCache<V> mCache;
-    private final OkHttpClient mOkHttpClient;
-    private final Executor mDiskExecutor;
-    private final Executor mNetworkExecutor;
-    private final Conaco<V> mConaco;
-
-    private DiskLoadTask mDiskLoadTask;
-    private NetworkLoadTask mNetworkLoadTask;
-    private Call mCall;
-    private boolean mStart;
-    private volatile boolean mStop;
-
-    private ConacoTask(Builder<V> builder) {
-        mId = builder.mId;
-        mUnikeryWeakReference = new WeakReference<>(builder.mUnikery);
-        mKey = builder.mKey;
-        mUrl = builder.mUrl;
-        mDataContainer = builder.mDataContainer;
-        mUseMemoryCache = builder.mUseMemoryCache;
-        mUseDiskCache = builder.mUseDiskCache;
-        mUseNetwork = builder.mUseNetwork;
-        mHelper = builder.mHelper;
-        mCache = builder.mCache;
-        mOkHttpClient = builder.mOkHttpClient;
-        mDiskExecutor = builder.mDiskExecutor;
-        mNetworkExecutor = builder.mNetworkExecutor;
-        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;
-    }
-
-    String getKey() {
-        return mKey;
-    }
-
-    boolean useMemoryCache() {
-        return mUseMemoryCache;
-    }
-
-    @Nullable
-    Unikery<V> getUnikery() {
-        return mUnikeryWeakReference.get();
-    }
-
-    void clearUnikery() {
-        mUnikeryWeakReference.clear();
-    }
-
-    private void onFinish() {
-        if (!mStop) {
-            mConaco.finishConacoTask(this);
-        }/* else  {
-            // It is done by Conaco
-        }*/
-    }
-
-    @UiThread
-    void start() {
-        if (mStop || mStart) {
-            return;
-        }
-
-        mStart = true;
-
-        Unikery unikery = mUnikeryWeakReference.get();
-        if (unikery != null && unikery.getTaskId() == mId) {
-            if (mUseDiskCache) {
-                mDiskLoadTask = new DiskLoadTask();
-                mDiskLoadTask.executeOnExecutor(mDiskExecutor);
-                return;
-            } else if (mUseNetwork) {
-                unikery.onMiss(Conaco.SOURCE_DISK);
-                unikery.onRequest();
-                mNetworkLoadTask = new NetworkLoadTask();
-                mNetworkLoadTask.executeOnExecutor(mNetworkExecutor);
-                return;
-            } else {
-                unikery.onMiss(Conaco.SOURCE_DISK);
-                unikery.onMiss(Conaco.SOURCE_NETWORK);
-                unikery.onFailure();
-            }
-        }
-
-        onFinish();
-    }
-
-    @UiThread
-    void stop() {
-        if (mStop) {
-            return;
-        }
-
-        mStop = true;
-
-        // Stop jobs
-        if (mDiskLoadTask != null) { // Getting from disk
-            mDiskLoadTask.cancel(false);
-        } else if (mNetworkLoadTask != null) { // Getting from network
-            mNetworkLoadTask.cancel(false);
-            if (mCall != null) {
-                mCall.cancel();
-                mCall = null;
-            }
-        }
-
-        Unikery unikery = mUnikeryWeakReference.get();
-        if (unikery != null) {
-            unikery.onCancel();
-        }
-
-        // Conaco handle the clean up
-    }
-
-    private boolean isNotNecessary(AsyncTask asyncTask) {
-        Unikery unikery = mUnikeryWeakReference.get();
-        return mStop || asyncTask.isCancelled() || unikery == null || unikery.getTaskId() != mId;
-    }
-
-    @SuppressWarnings({"unused", "UnusedReturnValue", "RedundantSuppression"})
-    public static class Builder<T> {
-
-        private int mId;
-        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;
-        private ValueHelper<T> mHelper;
-        private ValueCache<T> mCache;
-        private OkHttpClient mOkHttpClient;
-        private Executor mDiskExecutor;
-        private Executor mNetworkExecutor;
-        private Conaco<T> mConaco;
-
-        public Builder<T> setId(int id) {
-            mId = id;
-            return this;
-        }
-
-        public Unikery<T> getUnikery() {
-            return mUnikery;
-        }
-
-        public Builder<T> setUnikery(Unikery<T> unikery) {
-            mUnikery = unikery;
-            return this;
-        }
-
-        public String getKey() {
-            return mKey;
-        }
-
-        public Builder<T> setKey(String key) {
-            mKey = key;
-            return this;
-        }
-
-        public String getUrl() {
-            return mUrl;
-        }
-
-        public Builder<T> setUrl(String url) {
-            mUrl = url;
-            return this;
-        }
-
-        public Builder<T> setDataContainer(DataContainer dataContainer) {
-            mDataContainer = dataContainer;
-            return this;
-        }
-
-        boolean isUseMemoryCache() {
-            return mUseMemoryCache;
-        }
-
-        public Builder<T> setUseMemoryCache(boolean useMemoryCache) {
-            mUseMemoryCache = useMemoryCache;
-            return this;
-        }
-
-        boolean isUseDiskCache() {
-            return mUseDiskCache;
-        }
-
-        public Builder<T> setUseDiskCache(boolean useDiskCache) {
-            mUseDiskCache = useDiskCache;
-            return this;
-        }
-
-        boolean isUseNetwork() {
-            return mUseNetwork;
-        }
-
-        public Builder<T> setUseNetwork(boolean useNetwork) {
-            mUseNetwork = useNetwork;
-            return this;
-        }
-
-        ValueHelper<T> getHelper() {
-            return mHelper;
-        }
-
-        Builder<T> setHelper(ValueHelper<T> helper) {
-            mHelper = helper;
-            return this;
-        }
-
-        Builder<T> setCache(ValueCache<T> cache) {
-            mCache = cache;
-            return this;
-        }
-
-        Builder<T> setOkHttpClient(OkHttpClient okHttpClient) {
-            mOkHttpClient = okHttpClient;
-            return this;
-        }
-
-        Builder<T> setDiskExecutor(Executor diskExecutor) {
-            mDiskExecutor = diskExecutor;
-            return this;
-        }
-
-        Builder<T> setNetworkExecutor(Executor networkExecutor) {
-            mNetworkExecutor = networkExecutor;
-            return this;
-        }
-
-        Builder<T> setConaco(Conaco<T> conaco) {
-            mConaco = conaco;
-            return this;
-        }
-
-        public void isValid() {
-            if (mUnikery == null) {
-                throw new IllegalStateException("Must set unikery");
-            }
-            if (mKey == null && mUrl == null && mDataContainer == null) {
-                throw new IllegalStateException("At least one of mKey and mUrl and mDataContainer have to not be null");
-            }
-        }
-
-        public ConacoTask<T> build() {
-            return new ConacoTask<>(this);
-        }
-    }
-
-    @SuppressLint("StaticFieldLeak")
-    private class DiskLoadTask extends AsyncTask<Void, Void, V> {
-
-        @Override
-        protected V doInBackground(Void... params) {
-            if (isNotNecessary(this)) {
-                return null;
-            } 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);
-                    }
-                }
-
-                return value;
-            }
-        }
-
-        @Override
-        protected void onPostExecute(V value) {
-            mDiskLoadTask = null;
-
-            if (isCancelled() || mStop) {
-                onCancelled(value);
-            } else {
-                Unikery<V> unikery = mUnikeryWeakReference.get();
-                if (unikery != null && unikery.getTaskId() == mId) {
-                    boolean getValue = false;
-                    if ((value == null || !(getValue = unikery.onGetValue(value, Conaco.SOURCE_DISK))) && mUseNetwork) {
-                        unikery.onMiss(Conaco.SOURCE_DISK);
-                        unikery.onRequest();
-                        mNetworkLoadTask = new NetworkLoadTask();
-                        mNetworkLoadTask.executeOnExecutor(mNetworkExecutor);
-                        return;
-                    } else if (!getValue) {
-                        unikery.onMiss(Conaco.SOURCE_DISK);
-                        unikery.onFailure();
-                    }
-                }
-                onFinish();
-            }
-        }
-
-        @Override
-        protected void onCancelled(V holder) {
-            onFinish();
-        }
-    }
-
-    @SuppressLint("StaticFieldLeak")
-    private class NetworkLoadTask extends AsyncTask<Void, Long, V> implements ProgressNotifier {
-
-        @Override
-        public void notifyProgress(long singleReceivedSize, long receivedSize, long totalSize) {
-            if (!isNotNecessary(this)) {
-                publishProgress(singleReceivedSize, receivedSize, totalSize);
-            }
-        }
-
-        private boolean putToDiskCache(InputStream is, long length) {
-            SimpleDiskCache diskCache = mCache.getDiskCache();
-            if (diskCache == null) {
-                return false;
-            }
-
-            OutputStreamPipe pipe = diskCache.getOutputStreamPipe(mKey);
-            try {
-                pipe.obtain();
-                OutputStream os = pipe.open();
-
-                final byte[] buffer = new byte[1024 * 4];
-                long receivedSize = 0;
-                int bytesRead;
-
-                while ((bytesRead = is.read(buffer)) != -1) {
-                    os.write(buffer, 0, bytesRead);
-                    receivedSize += bytesRead;
-                    notifyProgress(bytesRead, receivedSize, length);
-                }
-
-                return true;
-            } catch (IOException e) {
-                return false;
-            } finally {
-                pipe.close();
-                pipe.release();
-            }
-        }
-
-        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)) {
-                return null;
-            }
-
-            V value;
-            InputStream is = null;
-            try {
-                Log.d("TAG", "Conaco " + mUrl);
-
-                // Load it from internet
-                Request request = new ChromeRequestBuilder(mUrl).build();
-                mCall = mOkHttpClient.newCall(request);
-
-                Response response = mCall.execute();
-                ResponseBody body = response.body();
-                if (body == null) {
-                    return null;
-                }
-                is = body.byteStream();
-
-                if (isNotNecessary(this)) {
-                    return null;
-                }
-
-                if ((mDataContainer == null || !mDataContainer.isEnabled()) && mKey != null) {
-                    if (putToDiskCache(is, body.contentLength())) {
-                        // Get object from disk cache
-                        value = mCache.getFromDisk(mKey);
-                        if (value == null) {
-                            // Maybe bad download, remove it from disk cache
-                            mCache.removeFromDisk(mKey);
-                        } else if (mUseMemoryCache && mHelper.useMemoryCache(mKey, value)) {
-                            // Put it to memory
-                            mCache.putToMemory(mKey, value);
-                        }
-                        return value;
-                    } else {
-                        // Maybe bad download, remove it from disk cache
-                        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;
-                }
-            } catch (Exception e) {
-                e.printStackTrace();
-                return null;
-            } finally {
-                mCall = null;
-                try {
-                    if (is != null) {
-                        is.close();
-                    }
-                } catch (IOException e) {
-                    // Ignore
-                }
-            }
-        }
-
-        @Override
-        protected void onPostExecute(V holder) {
-            mNetworkLoadTask = null;
-
-            if (isCancelled() || mStop) {
-                onCancelled(holder);
-            } else {
-                Unikery<V> unikery = mUnikeryWeakReference.get();
-                if (unikery != null && unikery.getTaskId() == mId) {
-                    if (holder == null || !unikery.onGetValue(holder, Conaco.SOURCE_NETWORK)) {
-                        unikery.onFailure();
-                    }
-                }
-                onFinish();
-            }
-        }
-
-        @Override
-        protected void onCancelled(V value) {
-            onFinish();
-        }
-
-        @Override
-        protected void onProgressUpdate(Long... values) {
-            Unikery unikery = mUnikeryWeakReference.get();
-            if (!mStop && !isCancelled() && unikery != null && unikery.getTaskId() == mId) {
-                unikery.onProgress(values[0], values[1], values[2]);
-            }
-        }
-    }
-}
@@ -1,72 +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.conaco;
-
-import com.hippo.yorozuya.collect.Multimap;
-import com.hippo.yorozuya.collect.SparseILArray;
-
-import java.util.List;
-
-class Register<V> {
-
-    private final SparseILArray<ConacoTask<V>> mIdMap = new SparseILArray<>();
-    private final Multimap<String, ConacoTask<V>> mKeyMap = Multimap.create();
-
-    /**
-     * @return true for the key is already registered
-     */
-    public synchronized boolean register(int id, ConacoTask<V> task) {
-        boolean repeatedKey = false;
-        String taskKey = task.getKey();
-
-        // For no-key task, there no need to check
-        if (taskKey != null) {
-            repeatedKey = mKeyMap.countElements(taskKey) != 0;
-        }
-
-        // Append task
-        mKeyMap.putElement(taskKey, task);
-        mIdMap.append(id, task);
-
-        return repeatedKey;
-    }
-
-    public synchronized ConacoTask<V> unregister(int id) {
-        ConacoTask<V> task = mIdMap.remove(id);
-        if (task != null) {
-            mKeyMap.removeElement(task.getKey(), task);
-        }
-        return task;
-    }
-
-    public synchronized boolean contain(int id) {
-        return mIdMap.indexOfKey(id) >= 0;
-    }
-
-    public synchronized ConacoTask<V> getByKey(String key) {
-        if (key == null) {
-            return null;
-        }
-
-        List<ConacoTask<V>> list = mKeyMap.get(key);
-        if (list != null && list.size() > 0) {
-            return list.get(0);
-        } else {
-            return null;
-        }
-    }
-}
@@ -1,77 +0,0 @@
-/*
- * Copyright 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.conaco;
-
-import androidx.annotation.NonNull;
-
-public interface Unikery<V> {
-
-    int INVALID_ID = -1;
-
-    /**
-     * Get the conaco task id
-     *
-     * @return the conaco task id
-     */
-    int getTaskId();
-
-    /**
-     * Store the conaco task id
-     *
-     * @param id the conaco task id
-     */
-    void setTaskId(int id);
-
-    /**
-     * On miss in the source
-     */
-    void onMiss(@Conaco.Source int source);
-
-    /**
-     * On start http request
-     */
-    void onRequest();
-
-    /**
-     * On http request progress
-     */
-    void onProgress(long singleReceivedSize, long receivedSize, long totalSize);
-
-    /**
-     * On start to wait because repeated key
-     */
-    void onWait();
-
-    /**
-     * On get the value
-     *
-     * @return {@code true} for the {@code Unikery} accepts the value
-     * and the task ends. {@code false} for the {@code Unikery}
-     * reject the value and the task goes on or failed
-     */
-    boolean onGetValue(@NonNull V value, @Conaco.Source int source);
-
-    /**
-     * On failed to get value
-     */
-    void onFailure();
-
-    /**
-     * On user cancel the conaco task
-     */
-    void onCancel();
-}
@@ -1,61 +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.conaco;
-
-import androidx.annotation.NonNull;
-
-import com.hippo.beerbelly.BeerBelly;
-import com.hippo.streampipe.InputStreamPipe;
-
-import java.io.OutputStream;
-
-class ValueCache<V> extends BeerBelly<V> {
-
-    private final ValueHelper<V> mHelper;
-
-    public ValueCache(BeerBelly.BeerBellyParams params, ValueHelper<V> helper) {
-        super(params);
-        mHelper = helper;
-    }
-
-    @Override
-    protected int sizeOf(String key, V value) {
-        return mHelper.sizeOf(key, value);
-    }
-
-    @Override
-    protected void memoryEntryAdded(V value) {
-        mHelper.onAddToMemoryCache(value);
-    }
-
-    @Override
-    protected void memoryEntryRemoved(boolean evicted, String key, V oldValue, V newValue) {
-        if (oldValue != null) {
-            mHelper.onRemoveFromMemoryCache(key, oldValue);
-        }
-    }
-
-    @Override
-    protected V read(@NonNull InputStreamPipe isPipe) {
-        return mHelper.decode(isPipe);
-    }
-
-    @Override
-    protected boolean write(OutputStream os, V value) {
-        throw new UnsupportedOperationException("Not support write object");
-    }
-}
@@ -1,55 +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.conaco;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-
-import com.hippo.streampipe.InputStreamPipe;
-
-public interface ValueHelper<V> {
-
-    /**
-     * Decode object for the {@code InputStreamPipe}
-     *
-     * @param isPipe the {@code InputStreamPipe}
-     * @return the decoded object
-     */
-    @Nullable
-    V decode(@NonNull InputStreamPipe isPipe);
-
-    /**
-     * Get the size of the object
-     */
-    int sizeOf(@NonNull String key, @NonNull V value);
-
-    /**
-     * Called when the object added to memory cache
-     */
-    void onAddToMemoryCache(@NonNull V oldValue);
-
-    /**
-     * Called when the object removed from memory cache
-     */
-    void onRemoveFromMemoryCache(@NonNull String key, @NonNull V oldValue);
-
-    /**
-     * Use cache memory or not. Sometimes large object
-     * should not be stored in memory cache.
-     */
-    boolean useMemoryCache(@NonNull String key, V holder);
-}
@@ -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)
+    }
+}
@@ -1,176 +0,0 @@
-/*
- * Copyright (C) 2014 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.drawable;
-
-import android.graphics.Canvas;
-import android.graphics.Color;
-import android.graphics.ColorFilter;
-import android.graphics.Paint;
-import android.graphics.PixelFormat;
-import android.graphics.Rect;
-import android.graphics.drawable.Drawable;
-
-import com.hippo.yorozuya.MathUtils;
-
-public class BatteryDrawable extends Drawable {
-
-    public static final int WARN_LIMIT = 15;
-    @SuppressWarnings("unused")
-    private static final String TAG = BatteryDrawable.class.getSimpleName();
-    private final Paint mPaint;
-    private final Rect mTopRect;
-    private final Rect mBottomRect;
-    private final Rect mRightRect;
-    private final Rect mHeadRect;
-    private final Rect mElectRect;
-    private int mColor = Color.WHITE;
-    private int mWarningColor = Color.RED;
-    private int mElect = -1;
-    private int mStart;
-    private int mStop;
-
-    public BatteryDrawable() {
-        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG);
-        mPaint.setStyle(Paint.Style.FILL);
-
-        mTopRect = new Rect();
-        mBottomRect = new Rect();
-        mRightRect = new Rect();
-        mHeadRect = new Rect();
-        mElectRect = new Rect();
-        updatePaint();
-    }
-
-    @Override
-    @SuppressWarnings("SuspiciousNameCombination")
-    protected void onBoundsChange(Rect bounds) {
-        int width = bounds.width();
-        int height = bounds.height();
-        int strokeWidth = (int) (Math.sqrt(width * width + height * height) * 0.06f);
-        int turn1 = width * 6 / 7;
-        int turn2 = height / 3;
-        int secBottom = height - strokeWidth;
-        mStart = strokeWidth;
-        mStop = turn1 - strokeWidth;
-
-        mTopRect.set(0, 0, turn1, strokeWidth);
-        mBottomRect.set(0, secBottom, turn1, height);
-        mRightRect.set(turn1 - strokeWidth, strokeWidth, turn1, secBottom);
-        mHeadRect.set(turn1, turn2, width, height - turn2);
-        mElectRect.set(0, strokeWidth, mStop, secBottom);
-    }
-
-    /**
-     * How to draw:<br>
-     * |------------------------------|<br>
-     * |\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\|<br>
-     * |------------------------------|---|<br>
-     * |/////////////////|         |//|\\\|<br>
-     * |/////////////////|         |//|\\\|<br>
-     * |------------------------------|---|<br>
-     * |\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\|<br>
-     * |------------------------------|
-     */
-    @Override
-    public void draw(Canvas canvas) {
-        if (mElect == -1) {
-            return;
-        }
-
-        mElectRect.right = MathUtils.lerp(mStart, mStop, mElect / 100.0f);
-
-        canvas.drawRect(mTopRect, mPaint);
-        canvas.drawRect(mBottomRect, mPaint);
-        canvas.drawRect(mRightRect, mPaint);
-        canvas.drawRect(mHeadRect, mPaint);
-        canvas.drawRect(mElectRect, mPaint);
-    }
-
-    private boolean isWarn() {
-        return mElect <= WARN_LIMIT;
-    }
-
-    public void setColor(int color) {
-        if (mColor == color) {
-            return;
-        }
-
-        mColor = color;
-        if (!isWarn()) {
-            mPaint.setColor(mColor);
-            invalidateSelf();
-        }
-    }
-
-    public void setWarningColor(int color) {
-        if (mWarningColor == color) {
-            return;
-        }
-
-        mWarningColor = color;
-        if (isWarn()) {
-            mPaint.setColor(mWarningColor);
-            invalidateSelf();
-        }
-    }
-
-    public void setElect(int elect) {
-        if (mElect == elect) {
-            return;
-        }
-
-        mElect = elect;
-        updatePaint();
-    }
-
-    public void setElect(int elect, boolean warn) {
-        if (mElect == elect) {
-            return;
-        }
-
-        mElect = elect;
-        updatePaint(warn);
-    }
-
-    private void updatePaint() {
-        updatePaint(isWarn());
-    }
-
-    private void updatePaint(boolean warn) {
-        if (warn) {
-            mPaint.setColor(mWarningColor);
-        } else {
-            mPaint.setColor(mColor);
-        }
-        invalidateSelf();
-    }
-
-    @Override
-    public void setAlpha(int alpha) {
-        mPaint.setAlpha(alpha);
-    }
-
-    @Override
-    public void setColorFilter(ColorFilter cf) {
-        mPaint.setColorFilter(cf);
-    }
-
-    @Override
-    public int getOpacity() {
-        return PixelFormat.TRANSLUCENT;
-    }
-}
@@ -22,6 +22,7 @@ import android.graphics.ColorFilter;
 import android.graphics.PorterDuff;
 import android.graphics.Rect;
 import android.graphics.Region;
+import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;

 import androidx.annotation.NonNull;
@@ -29,17 +30,25 @@ import androidx.core.graphics.drawable.DrawableCompat;

 public class DrawableWrapper extends Drawable implements Drawable.Callback {
    private Drawable mDrawable;
+    private Rect mBounds;

    public DrawableWrapper(Drawable drawable) {
        this.setWrappedDrawable(drawable);
    }

    public void draw(@NonNull Canvas canvas) {
-        this.mDrawable.draw(canvas);
+        if (mDrawable instanceof BitmapDrawable bitmapDrawable) {
+            canvas.drawBitmap(bitmapDrawable.getBitmap(), null, mBounds, bitmapDrawable.getPaint());
+        } else {
+            synchronized (mDrawable) {
+                mDrawable.setBounds(mBounds);
+                mDrawable.draw(canvas);
+            }
+        }
    }

    protected void onBoundsChange(Rect bounds) {
-        this.mDrawable.setBounds(bounds);
+        mBounds = bounds;
    }

    public int getChangingConfigurations() {
@@ -1,215 +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.drawable;
-
-import android.animation.ObjectAnimator;
-import android.content.Context;
-import android.content.res.Resources;
-import android.graphics.Canvas;
-import android.graphics.ColorFilter;
-import android.graphics.Paint;
-import android.graphics.Path;
-import android.graphics.PixelFormat;
-import android.graphics.Rect;
-import android.graphics.drawable.Drawable;
-
-import androidx.annotation.ColorInt;
-import androidx.annotation.Keep;
-
-import com.hippo.ehviewer.R;
-import com.hippo.yorozuya.MathUtils;
-
-/**
- * A drawable that can draw a "Drawer hamburger" menu or an Arrow and animate between them.
- */
-public class DrawerArrowDrawable extends Drawable {
-
-    // The angle in degrees that the arrow head is inclined at.
-    private static final float ARROW_HEAD_ANGLE = (float) Math.toRadians(45);
-    private final Paint mPaint = new Paint();
-    private final float mBarThickness;
-    // The length of top and bottom bars when they merge into an arrow
-    private final float mTopBottomArrowSize;
-    // The length of middle bar
-    private final float mBarSize;
-    // The length of the middle bar when arrow is shaped
-    private final float mMiddleArrowSize;
-    // The space between bars when they are parallel
-    private final float mBarGap;
-    // Whether bars should spin or not during progress
-    private final boolean mSpin;
-    // Use Path instead of canvas operations so that if color has transparency, overlapping sections
-    // wont look different
-    private final Path mPath = new Path();
-    // The reported intrinsic size of the drawable.
-    private final int mSize;
-    // the amount that overlaps w/ bar size when rotation is max
-    private final float mMaxCutForBarSize;
-    // Whether we should mirror animation when animation is reversed.
-    private boolean mVerticalMirror = false;
-    // The interpolated version of the original progress
-    private float mProgress;
-
-    /**
-     * @param context used to get the configuration for the drawable from
-     */
-    public DrawerArrowDrawable(Context context, int color) {
-        Resources resources = context.getResources();
-
-        mPaint.setAntiAlias(true);
-        mPaint.setColor(color);
-        mSize = resources.getDimensionPixelSize(R.dimen.dad_drawable_size);
-        // round this because having this floating may cause bad measurements
-        mBarSize = Math.round(resources.getDimension(R.dimen.dad_bar_size));
-        // round this because having this floating may cause bad measurements
-        mTopBottomArrowSize = Math.round(resources.getDimension(R.dimen.dad_top_bottom_bar_arrow_size));
-        mBarThickness = resources.getDimension(R.dimen.dad_thickness);
-        // round this because having this floating may cause bad measurements
-        mBarGap = Math.round(resources.getDimension(R.dimen.dad_gap_between_bars));
-        mSpin = resources.getBoolean(R.bool.dad_spin_bars);
-        mMiddleArrowSize = resources.getDimension(R.dimen.dad_middle_bar_arrow_size);
-
-        mPaint.setStyle(Paint.Style.STROKE);
-        mPaint.setStrokeJoin(Paint.Join.MITER);
-        mPaint.setStrokeCap(Paint.Cap.BUTT);
-        mPaint.setStrokeWidth(mBarThickness);
-
-        mMaxCutForBarSize = (float) (mBarThickness / 2 * Math.cos(ARROW_HEAD_ANGLE));
-    }
-
-    /**
-     * If set, canvas is flipped when progress reached to end and going back to start.
-     */
-    protected void setVerticalMirror(boolean verticalMirror) {
-        mVerticalMirror = verticalMirror;
-    }
-
-    @Override
-    public void draw(Canvas canvas) {
-        Rect bounds = getBounds();
-        // Interpolated widths of arrow bars
-        final float arrowSize = MathUtils.lerp(mBarSize, mTopBottomArrowSize, mProgress);
-        final float middleBarSize = MathUtils.lerp(mBarSize, mMiddleArrowSize, mProgress);
-        // Interpolated size of middle bar
-        final float middleBarCut = Math.round(MathUtils.lerp(0, mMaxCutForBarSize, mProgress));
-        // The rotation of the top and bottom bars (that make the arrow head)
-        final float rotation = MathUtils.lerp(0, ARROW_HEAD_ANGLE, mProgress);
-
-        // The whole canvas rotates as the transition happens
-        final float canvasRotate = MathUtils.lerp(-180, 0, mProgress);
-        final float arrowWidth = Math.round(arrowSize * Math.cos(rotation));
-        final float arrowHeight = Math.round(arrowSize * Math.sin(rotation));
-
-        mPath.rewind();
-        final float topBottomBarOffset = MathUtils.lerp(mBarGap + mBarThickness, -mMaxCutForBarSize,
-                mProgress);
-
-        final float arrowEdge = -middleBarSize / 2;
-        // draw middle bar
-        mPath.moveTo(arrowEdge + middleBarCut, 0);
-        mPath.rLineTo(middleBarSize - middleBarCut * 2, 0);
-
-        // bottom bar
-        mPath.moveTo(arrowEdge, topBottomBarOffset);
-        mPath.rLineTo(arrowWidth, arrowHeight);
-
-        // top bar
-        mPath.moveTo(arrowEdge, -topBottomBarOffset);
-        mPath.rLineTo(arrowWidth, -arrowHeight);
-
-        mPath.close();
-
-        canvas.save();
-        // Rotate the whole canvas if spinning, if not, rotate it 180 to get
-        // the arrow pointing the other way for RTL.
-        canvas.translate(bounds.centerX(), bounds.centerY());
-        if (mSpin) {
-            canvas.rotate(canvasRotate * (mVerticalMirror ? -1 : 1));
-        }
-        canvas.drawPath(mPath, mPaint);
-
-        canvas.restore();
-    }
-
-    public void setColor(@ColorInt int color) {
-        mPaint.setColor(color);
-        invalidateSelf();
-    }
-
-    @Override
-    public void setAlpha(int i) {
-        mPaint.setAlpha(i);
-    }
-
-    @Override
-    public void setColorFilter(ColorFilter colorFilter) {
-        mPaint.setColorFilter(colorFilter);
-    }
-
-    @Override
-    public int getIntrinsicHeight() {
-        return mSize;
-    }
-
-    @Override
-    public int getIntrinsicWidth() {
-        return mSize;
-    }
-
-    @Override
-    public int getOpacity() {
-        return PixelFormat.TRANSLUCENT;
-    }
-
-    @Keep
-    public float getProgress() {
-        return mProgress;
-    }
-
-    @Keep
-    public void setProgress(float progress) {
-        if (progress == 1f) {
-            setVerticalMirror(true);
-        } else if (progress == 0f) {
-            setVerticalMirror(false);
-        }
-        mProgress = progress;
-        invalidateSelf();
-    }
-
-    public void setMenu(long duration) {
-        setShape(false, duration);
-    }
-
-    public void setArrow(long duration) {
-        setShape(true, duration);
-    }
-
-    public void setShape(boolean arrow, long duration) {
-        if (!((!arrow && mProgress == 0f) || (arrow && mProgress == 1f))) {
-            float endProgress = arrow ? 1f : 0f;
-            if (duration <= 0) {
-                setProgress(endProgress);
-            } else {
-                ObjectAnimator oa = ObjectAnimator.ofFloat(this, "progress", endProgress);
-                oa.setDuration(duration);
-                oa.setAutoCancel(true);
-                oa.start();
-            }
-        }
-    }
-}
@@ -16,31 +16,25 @@

 package com.hippo.drawable;

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

-import androidx.annotation.NonNull;
-
-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.widget.ObservedTextView;

-public class UnikeryDrawable extends WrapDrawable implements Unikery<ImageBitmap>,
-        ObservedTextView.OnWindowAttachListener {
+import coil.Coil;
+import coil.request.Disposable;
+import coil.request.ImageRequest;
+
+public class UnikeryDrawable extends WrapDrawable implements ObservedTextView.OnWindowAttachListener {

    private static final String TAG = UnikeryDrawable.class.getSimpleName();
    private final ObservedTextView mTextView;
-    private final Conaco<ImageBitmap> mConaco;
-    private int mTaskId = Unikery.INVALID_ID;
    private String mUrl;
+    private Disposable task;

-    public UnikeryDrawable(ObservedTextView textView, Conaco<ImageBitmap> conaco) {
+    public UnikeryDrawable(ObservedTextView textView) {
        mTextView = textView;
        mTextView.setOnWindowAttachListener(this);
-        mConaco = conaco;
    }

    @Override
@@ -50,22 +44,28 @@ public class UnikeryDrawable extends WrapDrawable implements Unikery<ImageBitmap

    @Override
    public void onDetachedFromWindow() {
-        mConaco.cancel(this);
+        if (task != null && !task.isDisposed())
+            task.dispose();
        clearDrawable();
    }

    public void load(String url) {
        if (url != null) {
            mUrl = url;
-            mConaco.load(new ConacoTask.Builder<ImageBitmap>().setUnikery(this).setUrl(url).setKey(url));
+            var imageLoader = Coil.imageLoader(mTextView.getContext());
+            var request = new ImageRequest.Builder(mTextView.getContext()).data(url).memoryCacheKey(url).diskCacheKey(url).target(
+                    drawable -> null,
+                    drawable -> null,
+                    drawable -> {
+                        onGetValue(drawable);
+                        return null;
+                    }
+            ).build();
+            task = imageLoader.enqueue(request);
        }
    }

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

@@ -89,63 +89,16 @@ public class UnikeryDrawable extends WrapDrawable implements Unikery<ImageBitmap
        }
    }

-    @Override
-    public int getTaskId() {
-        return mTaskId;
-    }
-
-    @Override
-    public void setTaskId(int id) {
-        mTaskId = id;
-    }
-
    @Override
    public void invalidateSelf() {
        CharSequence cs = mTextView.getText();
        mTextView.setText(cs);
    }

-    @Override
-    public void onMiss(int source) {
-    }
-
-    @Override
-    public void onRequest() {
-    }
-
-    @Override
-    public void onProgress(long singleReceivedSize, long receivedSize, long totalSize) {
-    }
-
-    @Override
-    public void onWait() {
-    }
-
-    @Override
-    public boolean onGetValue(@NonNull ImageBitmap value, int source) {
-        ImageDrawable drawable;
-        try {
-            drawable = new ImageDrawable(value);
-        } catch (Exception e) {
-            Log.d(TAG, "The ImageBitmap is recycled", e);
-            return false;
-        }
-
+    public void onGetValue(Drawable drawable) {
        clearDrawable();
-
        setDrawable(drawable);
-        drawable.start();
-
-        return true;
-    }
-
-    @Override
-    public void onFailure() {
-        // Empty
-    }
-
-    @Override
-    public void onCancel() {
-        // Empty
+        if (drawable instanceof AnimatedImageDrawable animatedImageDrawable)
+            animatedImageDrawable.start();
    }
 }
@@ -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);
-    }
-}
@@ -16,7 +16,6 @@

 package com.hippo.ehviewer;

-import android.app.Activity;
 import android.content.Context;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
@@ -25,7 +24,6 @@ import android.os.Debug;

 import androidx.annotation.NonNull;

-import com.hippo.scene.StageActivity;
 import com.hippo.util.PackageUtils;
 import com.hippo.util.ReadableTime;
 import com.hippo.yorozuya.FileUtils;
@@ -78,27 +76,10 @@ public final class Crash {

        // Runtime
        String topActivityClazzName = "null";
-        String topSceneClazzName = "null";
-        try {
-            Activity topActivity = ((EhApplication) context.getApplicationContext()).getTopActivity();
-            if (null != topActivity) {
-                topActivityClazzName = topActivity.getClass().getName();
-                if (topActivity instanceof StageActivity) {
-                    Class<?> clazz = ((StageActivity) topActivity).getTopSceneClass();
-                    if (clazz != null) {
-                        topSceneClazzName = clazz.getName();
-                    }
-                }
-            }
-        } catch (Throwable e) {
-            // Ignore
-        }
        fw.write("======== Runtime ========\r\n");
        fw.write("TopActivity=");
        fw.write(avoidNull(topActivityClazzName));
        fw.write("\r\n");
-        fw.write("TopScene=");
-        fw.write(avoidNull(topSceneClazzName));
        fw.write("\r\n");
        fw.write("\r\n");

@@ -1,585 +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.ehviewer;
-
-import android.annotation.SuppressLint;
-import android.app.Activity;
-import android.content.ComponentCallbacks2;
-import android.content.ComponentName;
-import android.content.Context;
-import android.content.Intent;
-import android.content.ServiceConnection;
-import android.content.pm.PackageInfo;
-import android.content.pm.PackageManager;
-import android.os.AsyncTask;
-import android.os.Debug;
-import android.text.method.LinkMovementMethod;
-import android.util.Log;
-import android.view.View;
-import android.widget.TextView;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-import androidx.appcompat.app.AlertDialog;
-import androidx.collection.LruCache;
-
-import com.google.android.material.dialog.MaterialAlertDialogBuilder;
-import com.hippo.Native;
-import com.hippo.beerbelly.SimpleDiskCache;
-import com.hippo.conaco.Conaco;
-import com.hippo.ehviewer.client.EhClient;
-import com.hippo.ehviewer.client.EhCookieStore;
-import com.hippo.ehviewer.client.EhDns;
-import com.hippo.ehviewer.client.EhEngine;
-import com.hippo.ehviewer.client.EhRequestBuilder;
-import com.hippo.ehviewer.client.EhSSLSocketFactory;
-import com.hippo.ehviewer.client.EhUrl;
-import com.hippo.ehviewer.client.EhX509TrustManager;
-import com.hippo.ehviewer.client.data.GalleryDetail;
-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.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;
-import com.hippo.yorozuya.FileUtils;
-import com.hippo.yorozuya.IntIdGenerator;
-import com.hippo.yorozuya.OSUtils;
-import com.hippo.yorozuya.SimpleHandler;
-
-import java.io.File;
-import java.io.IOException;
-import java.security.KeyStore;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.concurrent.TimeUnit;
-
-import javax.net.ssl.TrustManager;
-import javax.net.ssl.TrustManagerFactory;
-import javax.net.ssl.X509TrustManager;
-
-import okhttp3.Cache;
-import okhttp3.Call;
-import okhttp3.HttpUrl;
-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 {
-
-    public static final boolean BETA = false;
-    private static final String TAG = EhApplication.class.getSimpleName();
-    private static final String KEY_GLOBAL_STUFF_NEXT_ID = "global_stuff_next_id";
-    private static final boolean DEBUG_CONACO = false;
-    private static final boolean DEBUG_PRINT_NATIVE_MEMORY = false;
-    private static final boolean DEBUG_PRINT_IMAGE_COUNT = false;
-    private static final long DEBUG_PRINT_INTERVAL = 3000L;
-
-    private static EhApplication instance;
-
-    private final IntIdGenerator mIdGenerator = new IntIdGenerator();
-    private final HashMap<Integer, Object> mGlobalStuffMap = new HashMap<>();
-    private final List<Activity> mActivityList = new ArrayList<>();
-    private EhCookieStore mEhCookieStore;
-    private EhClient mEhClient;
-    private EhProxySelector mEhProxySelector;
-    private OkHttpClient mOkHttpClient;
-    private Cache mOkHttpCache;
-    private ImageBitmapHelper mImageBitmapHelper;
-    private Conaco<ImageBitmap> mConaco;
-    private LruCache<Long, GalleryDetail> mGalleryDetailCache;
-    private SimpleDiskCache mSpiderInfoCache;
-    private DownloadManager mDownloadManager;
-    private Hosts mHosts;
-    private FavouriteStatusRouter mFavouriteStatusRouter;
-    private boolean initialized = false;
-
-    public static EhApplication getInstance() {
-        return instance;
-    }
-
-    public static EhCookieStore getEhCookieStore(@NonNull Context context) {
-        EhApplication application = ((EhApplication) context.getApplicationContext());
-        if (application.mEhCookieStore == null) {
-            application.mEhCookieStore = new EhCookieStore(context);
-        }
-        return application.mEhCookieStore;
-    }
-
-    @NonNull
-    public static EhClient getEhClient(@NonNull Context context) {
-        EhApplication application = ((EhApplication) context.getApplicationContext());
-        if (application.mEhClient == null) {
-            application.mEhClient = new EhClient(application);
-        }
-        return application.mEhClient;
-    }
-
-    @NonNull
-    public static EhProxySelector getEhProxySelector(@NonNull Context context) {
-        EhApplication application = ((EhApplication) context.getApplicationContext());
-        if (application.mEhProxySelector == null) {
-            application.mEhProxySelector = new EhProxySelector();
-        }
-        return application.mEhProxySelector;
-    }
-
-    @NonNull
-    public static OkHttpClient getOkHttpClient(@NonNull Context context) {
-        EhApplication application = ((EhApplication) context.getApplicationContext());
-        if (application.mOkHttpClient == null) {
-            OkHttpClient.Builder builder = new OkHttpClient.Builder()
-                    .connectTimeout(5, TimeUnit.SECONDS)
-                    .readTimeout(5, TimeUnit.SECONDS)
-                    .writeTimeout(5, TimeUnit.SECONDS)
-                    .callTimeout(10, TimeUnit.SECONDS)
-                    .cookieJar(getEhCookieStore(application))
-                    .cache(getOkHttpCache(application))
-                    .dns(new EhDns(application))
-                    .addNetworkInterceptor(chain -> {
-                        try {
-                            return chain.proceed(chain.request());
-                        } catch (NullPointerException e) {
-                            // crash on meizu devices due to old Android version
-                            // https://github.com/square/okhttp/issues/3301#issuecomment-348415095
-                            throw new IOException(e.getMessage());
-                        }
-                    })
-                    .proxySelector(getEhProxySelector(application));
-            try {
-                TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(
-                        TrustManagerFactory.getDefaultAlgorithm());
-                trustManagerFactory.init((KeyStore) null);
-                TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();
-                if (trustManagers.length != 1 || !(trustManagers[0] instanceof X509TrustManager)) {
-                    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();
-                builder.sslSocketFactory(new EhSSLSocketFactory(), new EhX509TrustManager());
-            }
-            application.mOkHttpClient = builder.build();
-        }
-        return application.mOkHttpClient;
-    }
-
-    @NonNull
-    public static Cache getOkHttpCache(@NonNull Context context) {
-        EhApplication application = ((EhApplication) context.getApplicationContext());
-        if (application.mOkHttpCache == null) {
-            application.mOkHttpCache = new Cache(new File(application.getCacheDir(), "http_cache"), 50L * 1024L * 1024L);
-        }
-        return application.mOkHttpCache;
-    }
-
-    @NonNull
-    public static ImageBitmapHelper getImageBitmapHelper(@NonNull Context context) {
-        EhApplication application = ((EhApplication) context.getApplicationContext());
-        if (application.mImageBitmapHelper == null) {
-            application.mImageBitmapHelper = new ImageBitmapHelper();
-        }
-        return application.mImageBitmapHelper;
-    }
-
-    private static int getMemoryCacheMaxSize() {
-        return Math.min(20 * 1024 * 1024, (int) OSUtils.getAppMaxMemory());
-    }
-
-    @NonNull
-    public static Conaco<ImageBitmap> getConaco(@NonNull Context context) {
-        EhApplication application = ((EhApplication) context.getApplicationContext());
-        if (application.mConaco == null) {
-            Conaco.Builder<ImageBitmap> builder = new Conaco.Builder<>();
-            builder.hasMemoryCache = true;
-            builder.memoryCacheMaxSize = getMemoryCacheMaxSize();
-            builder.hasDiskCache = true;
-            builder.diskCacheDir = new File(context.getCacheDir(), "thumb");
-            builder.diskCacheMaxSize = 320 * 1024 * 1024; // 320MB
-            builder.okHttpClient = getOkHttpClient(context);
-            builder.objectHelper = getImageBitmapHelper(context);
-            builder.debug = DEBUG_CONACO;
-            application.mConaco = builder.build();
-        }
-        return application.mConaco;
-    }
-
-    @NonNull
-    public static LruCache<Long, GalleryDetail> getGalleryDetailCache(@NonNull Context context) {
-        EhApplication application = ((EhApplication) context.getApplicationContext());
-        if (application.mGalleryDetailCache == null) {
-            // Max size 25, 3 min timeout
-            application.mGalleryDetailCache = new LruCache<>(25);
-            getFavouriteStatusRouter().addListener((gid, slot) -> {
-                GalleryDetail gd = application.mGalleryDetailCache.get(gid);
-                if (gd != null) {
-                    gd.favoriteSlot = slot;
-                }
-            });
-        }
-        return application.mGalleryDetailCache;
-    }
-
-    @NonNull
-    public static SimpleDiskCache getSpiderInfoCache(@NonNull Context context) {
-        EhApplication application = ((EhApplication) context.getApplicationContext());
-        if (null == application.mSpiderInfoCache) {
-            application.mSpiderInfoCache = new SimpleDiskCache(
-                    new File(context.getCacheDir(), "spider_info"), 20 * 1024 * 1024); // 20M
-        }
-        return application.mSpiderInfoCache;
-    }
-
-    @NonNull
-    public static DownloadManager getDownloadManager() {
-        return getDownloadManager(instance);
-    }
-
-    @NonNull
-    public static DownloadManager getDownloadManager(@NonNull Context context) {
-        EhApplication application = ((EhApplication) context.getApplicationContext());
-        if (application.mDownloadManager == null) {
-            application.mDownloadManager = new DownloadManager(application);
-        }
-        return application.mDownloadManager;
-    }
-
-    @NonNull
-    public static Hosts getHosts(@NonNull Context context) {
-        EhApplication application = ((EhApplication) context.getApplicationContext());
-        if (application.mHosts == null) {
-            application.mHosts = new Hosts(application, "hosts.db");
-        }
-        return application.mHosts;
-    }
-
-    @NonNull
-    public static FavouriteStatusRouter getFavouriteStatusRouter() {
-        return getFavouriteStatusRouter(getInstance());
-    }
-
-    @NonNull
-    public static FavouriteStatusRouter getFavouriteStatusRouter(@NonNull Context context) {
-        EhApplication application = ((EhApplication) context.getApplicationContext());
-        if (application.mFavouriteStatusRouter == null) {
-            application.mFavouriteStatusRouter = new FavouriteStatusRouter();
-        }
-        return application.mFavouriteStatusRouter;
-    }
-
-    @SuppressLint("StaticFieldLeak")
-    @Override
-    public void onCreate() {
-        instance = this;
-
-        Thread.UncaughtExceptionHandler handler = Thread.getDefaultUncaughtExceptionHandler();
-        Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
-            try {
-                // Always save crash file if onCreate() is not done
-                if (!initialized || Settings.getSaveCrashLog()) {
-                    Crash.saveCrashLog(instance, e);
-                }
-            } catch (Throwable ignored) {
-            }
-
-            if (handler != null) {
-                handler.uncaughtException(t, e);
-            }
-        });
-
-        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);
-        }
-
-        LocaleDelegate.setDefaultLocale(Settings.getLocale());
-        DayNightDelegate.setApplicationContext(this);
-        DayNightDelegate.setDefaultNightMode(Settings.getTheme());
-
-        // Do io tasks in new thread
-        //noinspection deprecation
-        new AsyncTask<Void, Void, Void>() {
-            @Override
-            protected Void doInBackground(Void... voids) {
-                // Check no media file
-                try {
-                    UniFile downloadLocation = Settings.getDownloadLocation();
-                    if (Settings.getMediaScan()) {
-                        CommonOperations.removeNoMediaFile(downloadLocation);
-                    } else {
-                        CommonOperations.ensureNoMediaFile(downloadLocation);
-                    }
-                } catch (Throwable t) {
-                    t.printStackTrace();
-                    ExceptionUtils.throwIfFatal(t);
-                }
-
-                // Clear temp files
-                try {
-                    clearTempDir();
-                } catch (Throwable t) {
-                    t.printStackTrace();
-                    ExceptionUtils.throwIfFatal(t);
-                }
-
-                return null;
-            }
-        }.executeOnExecutor(IoThreadPoolExecutor.getInstance());
-
-        // Check app update
-        update();
-
-        // Update version code
-        try {
-            PackageInfo pi = getPackageManager().getPackageInfo(getPackageName(), 0);
-            Settings.putVersionCode(pi.versionCode);
-        } catch (PackageManager.NameNotFoundException e) {
-            // Ignore
-        }
-
-        mIdGenerator.setNextId(Settings.getInt(KEY_GLOBAL_STUFF_NEXT_ID, 0));
-
-        if (DEBUG_PRINT_NATIVE_MEMORY || DEBUG_PRINT_IMAGE_COUNT) {
-            debugPrint();
-        }
-
-        initialized = true;
-        theDawnOfNewDay();
-    }
-
-    private void theDawnOfNewDay() {
-        if (!Settings.getRequestNews()) {
-            return;
-        }
-        EhCookieStore store = getEhCookieStore(this);
-        HttpUrl eh = HttpUrl.get(EhUrl.HOST_E);
-
-        if (store.contains(eh, EhCookieStore.KEY_IPD_MEMBER_ID) || store.contains(eh, EhCookieStore.KEY_IPD_PASS_HASH)) {
-            IoThreadPoolExecutor.getInstance().execute(() -> {
-                String referer = EhUrl.REFERER_E;
-                Request request = new EhRequestBuilder(EhUrl.HOST_E + "news.php", referer).build();
-                Call call = getOkHttpClient(this).newCall(request);
-                try {
-                    Response response = call.execute();
-                    ResponseBody responseBody = response.body();
-                    if (responseBody == null) {
-                        return;
-                    }
-                    String body = responseBody.string();
-                    String html = EventPaneParser.parse(body);
-                    if (html != null) {
-                        showEventPane(html);
-                    }
-                } catch (Throwable e) {
-                    e.printStackTrace();
-                }
-            });
-        }
-    }
-
-    public void showEventPane(String html) {
-        Activity activity = getTopActivity();
-        if (activity != null) {
-            activity.runOnUiThread(() -> {
-                AlertDialog dialog = new MaterialAlertDialogBuilder(activity)
-                        .setMessage(Html.fromHtml(html))
-                        .setPositiveButton(android.R.string.ok, null)
-                        .create();
-                dialog.setOnShowListener(d -> {
-                    final View messageView = dialog.findViewById(android.R.id.message);
-                    if (messageView instanceof TextView) {
-                        ((TextView) messageView).setMovementMethod(LinkMovementMethod.getInstance());
-                    }
-                });
-                try {
-                    dialog.show();
-                } catch (Throwable t) {
-                    // ignore
-                }
-            });
-        }
-    }
-
-    private void clearTempDir() {
-        File dir = AppConfig.getTempDir();
-        if (null != dir) {
-            FileUtils.deleteContent(dir);
-        }
-        dir = AppConfig.getExternalTempDir();
-        if (null != dir) {
-            FileUtils.deleteContent(dir);
-        }
-    }
-
-    private void update() {
-        int version = Settings.getVersionCode();
-        if (version < 52) {
-            Settings.putGuideGallery(true);
-        }
-    }
-
-    public void clearMemoryCache() {
-        if (null != mConaco) {
-            mConaco.getBeerBelly().clearMemory();
-        }
-        if (null != mGalleryDetailCache) {
-            mGalleryDetailCache.evictAll();
-        }
-    }
-
-    @Override
-    public void onTrimMemory(int level) {
-        super.onTrimMemory(level);
-
-        if (level >= ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW) {
-            clearMemoryCache();
-        }
-    }
-
-    private void debugPrint() {
-        new Runnable() {
-            @Override
-            public void run() {
-                if (DEBUG_PRINT_NATIVE_MEMORY) {
-                    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();
-    }
-
-    public int putGlobalStuff(@NonNull Object o) {
-        int id = mIdGenerator.nextId();
-        mGlobalStuffMap.put(id, o);
-        Settings.putInt(KEY_GLOBAL_STUFF_NEXT_ID, mIdGenerator.nextId());
-        return id;
-    }
-
-    public boolean containGlobalStuff(int id) {
-        return mGlobalStuffMap.containsKey(id);
-    }
-
-    public Object getGlobalStuff(int id) {
-        return mGlobalStuffMap.get(id);
-    }
-
-    public Object removeGlobalStuff(int id) {
-        return mGlobalStuffMap.remove(id);
-    }
-
-    public void removeGlobalStuff(Object o) {
-        mGlobalStuffMap.values().removeAll(Collections.singleton(o));
-    }
-
-    public void registerActivity(Activity activity) {
-        mActivityList.add(activity);
-    }
-
-    public void unregisterActivity(Activity activity) {
-        mActivityList.remove(activity);
-    }
-
-    @Nullable
-    public Activity getTopActivity() {
-        if (!mActivityList.isEmpty()) {
-            return mActivityList.get(mActivityList.size() - 1);
-        } else {
-            return null;
-        }
-    }
-
-    // Avoid crash on some "energy saving" devices
-    @Override
-    public ComponentName startService(Intent service) {
-        try {
-            return super.startService(service);
-        } catch (Throwable t) {
-            t.printStackTrace();
-            ExceptionUtils.throwIfFatal(t);
-            return null;
-        }
-    }
-
-    // Avoid crash on some "energy saving" devices
-    @Override
-    public boolean bindService(Intent service, ServiceConnection conn, int flags) {
-        try {
-            return super.bindService(service, conn, flags);
-        } catch (Throwable t) {
-            t.printStackTrace();
-            ExceptionUtils.throwIfFatal(t);
-            return false;
-        }
-    }
-
-    // Avoid crash on some "energy saving" devices
-    @Override
-    public void unbindService(ServiceConnection conn) {
-        try {
-            super.unbindService(conn);
-        } catch (Throwable t) {
-            t.printStackTrace();
-            ExceptionUtils.throwIfFatal(t);
-        }
-    }
-
-    // Avoid crash on some "energy saving" devices
-    @Override
-    public ComponentName startForegroundService(Intent service) {
-        try {
-            return super.startForegroundService(service);
-        } catch (Throwable t) {
-            t.printStackTrace();
-            ExceptionUtils.throwIfFatal(t);
-            return null;
-        }
-    }
-}
@@ -0,0 +1,352 @@
+/*
+ * Copyright 2016 Hippo Seven
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.hippo.ehviewer
+
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.app.ActivityManager
+import android.app.Application
+import android.content.ComponentCallbacks2
+import android.text.Html
+import android.text.method.LinkMovementMethod
+import android.view.View
+import android.widget.TextView
+import androidx.appcompat.app.AppCompatDelegate
+import androidx.collection.LruCache
+import androidx.core.content.getSystemService
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.ProcessLifecycleOwner
+import coil.ImageLoader
+import coil.ImageLoaderFactory
+import coil.disk.DiskCache
+import com.hippo.Native
+import com.hippo.app.BaseDialogBuilder
+import com.hippo.ehviewer.client.EhCookieStore
+import com.hippo.ehviewer.client.EhDns
+import com.hippo.ehviewer.client.EhRequestBuilder
+import com.hippo.ehviewer.client.EhSSLSocketFactory
+import com.hippo.ehviewer.client.EhTagDatabase
+import com.hippo.ehviewer.client.EhUrl
+import com.hippo.ehviewer.client.EhX509TrustManager
+import com.hippo.ehviewer.client.data.GalleryDetail
+import com.hippo.ehviewer.client.parser.EventPaneParser
+import com.hippo.ehviewer.dao.buildMainDB
+import com.hippo.ehviewer.download.DownloadManager
+import com.hippo.ehviewer.spider.SpiderDen
+import com.hippo.ehviewer.ui.CommonOperations
+import com.hippo.ehviewer.ui.EhActivity
+import com.hippo.util.BitmapUtils
+import com.hippo.util.ExceptionUtils
+import com.hippo.util.ReadableTime
+import com.hippo.yorozuya.FileUtils
+import com.hippo.yorozuya.IntIdGenerator
+import eu.kanade.tachiyomi.core.preference.AndroidPreferenceStore
+import eu.kanade.tachiyomi.ui.reader.setting.ReaderPreferences
+import eu.kanade.tachiyomi.util.lang.launchIO
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import okhttp3.Cache
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.OkHttpClient
+import java.io.File
+import java.net.Proxy
+import java.security.KeyStore
+import java.util.Arrays
+import javax.net.ssl.TrustManagerFactory
+import javax.net.ssl.X509TrustManager
+
+class EhApplication : Application(), DefaultLifecycleObserver, ImageLoaderFactory {
+    private val mIdGenerator = IntIdGenerator()
+    private val mGlobalStuffMap = HashMap<Int, Any>()
+    private val mActivityList = ArrayList<Activity>()
+    val topActivity: EhActivity?
+        get() = if (mActivityList.isNotEmpty()) {
+            mActivityList[mActivityList.size - 1] as EhActivity
+        } else {
+            null
+        }
+
+    fun recreateAllActivity() {
+        mActivityList.forEach { it.recreate() }
+    }
+
+    @OptIn(DelicateCoroutinesApi::class)
+    @SuppressLint("StaticFieldLeak")
+    override fun onCreate() {
+        ProcessLifecycleOwner.get().lifecycle.addObserver(this)
+        application = this
+        val handler = Thread.getDefaultUncaughtExceptionHandler()
+        Thread.setDefaultUncaughtExceptionHandler { t, e ->
+            try {
+                if (Settings.getSaveCrashLog()) {
+                    Crash.saveCrashLog(application, e)
+                }
+            } catch (ignored: Throwable) {
+            }
+            handler?.uncaughtException(t, e)
+        }
+        super<Application>.onCreate()
+        Native.initialize()
+        GetText.initialize(this)
+        Settings.initialize()
+        ReadableTime.initialize(this)
+        AppConfig.initialize(this)
+        SpiderDen.initialize(this)
+        BitmapUtils.initialize(this)
+        EhTagDatabase.update()
+        AppCompatDelegate.setDefaultNightMode(Settings.getTheme())
+        launchIO {
+            launchIO {
+                ehDatabase
+            }
+            launchIO {
+                downloadManager
+            }
+            launchIO {
+                cleanupDownload()
+            }
+            launchIO {
+                theDawnOfNewDay()
+            }
+        }
+        mIdGenerator.setNextId(Settings.getInt(KEY_GLOBAL_STUFF_NEXT_ID, 0))
+    }
+
+    private fun cleanupDownload() {
+        try {
+            val downloadLocation = Settings.getDownloadLocation()
+            if (Settings.getMediaScan()) {
+                CommonOperations.removeNoMediaFile(downloadLocation)
+            } else {
+                CommonOperations.ensureNoMediaFile(downloadLocation)
+            }
+        } catch (t: Throwable) {
+            t.printStackTrace()
+            ExceptionUtils.throwIfFatal(t)
+        }
+
+        // Clear temp files
+        try {
+            clearTempDir()
+        } catch (t: Throwable) {
+            t.printStackTrace()
+            ExceptionUtils.throwIfFatal(t)
+        }
+    }
+
+    private fun theDawnOfNewDay() {
+        if (!Settings.getRequestNews()) {
+            return
+        }
+        val store = ehCookieStore
+        val eh = EhUrl.HOST_E.toHttpUrl()
+
+        if (store.contains(eh, EhCookieStore.KEY_IPD_MEMBER_ID) || store.contains(
+                eh,
+                EhCookieStore.KEY_IPD_PASS_HASH
+            )
+        ) {
+            val referer = EhUrl.REFERER_E
+            val request = EhRequestBuilder(EhUrl.HOST_E + "news.php", referer).build()
+            val call = okHttpClient.newCall(request)
+            try {
+                call.execute().use { response ->
+                    val responseBody = response.body
+                    val body = responseBody.string()
+                    val html = EventPaneParser.parse(body)
+                    if (html != null) {
+                        showEventPane(html)
+                    }
+                }
+            } catch (e: Throwable) {
+                e.printStackTrace()
+            }
+        }
+    }
+
+    fun showEventPane(html: String) {
+        if (Settings.getHideHvEvents() && html.contains("You have encountered a monster!")) {
+            return
+        }
+        val activity = topActivity
+        activity?.runOnUiThread {
+            val dialog = BaseDialogBuilder(activity)
+                .setMessage(Html.fromHtml(html, Html.FROM_HTML_MODE_LEGACY))
+                .setPositiveButton(android.R.string.ok, null)
+                .create()
+            dialog.setOnShowListener {
+                val messageView = dialog.findViewById<View>(android.R.id.message)
+                if (messageView is TextView) {
+                    messageView.movementMethod = LinkMovementMethod.getInstance()
+                }
+            }
+            try {
+                dialog.show()
+            } catch (t: Throwable) {
+                // ignore
+            }
+        }
+    }
+
+    private fun clearTempDir() {
+        var dir = AppConfig.getTempDir()
+        if (null != dir) {
+            FileUtils.deleteContent(dir)
+        }
+        dir = AppConfig.getExternalTempDir()
+        if (null != dir) {
+            FileUtils.deleteContent(dir)
+        }
+    }
+
+    override fun onTrimMemory(level: Int) {
+        super.onTrimMemory(level)
+        if (level >= ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW) {
+            galleryDetailCache.evictAll()
+        }
+    }
+
+    fun putGlobalStuff(o: Any): Int {
+        val id = mIdGenerator.nextId()
+        mGlobalStuffMap[id] = o
+        Settings.putInt(KEY_GLOBAL_STUFF_NEXT_ID, mIdGenerator.nextId())
+        return id
+    }
+
+    fun containGlobalStuff(id: Int): Boolean {
+        return mGlobalStuffMap.containsKey(id)
+    }
+
+    fun getGlobalStuff(id: Int): Any? {
+        return mGlobalStuffMap[id]
+    }
+
+    fun removeGlobalStuff(id: Int): Any? {
+        return mGlobalStuffMap.remove(id)
+    }
+
+    fun removeGlobalStuff(o: Any) {
+        mGlobalStuffMap.values.removeAll(setOf(o))
+    }
+
+    fun registerActivity(activity: Activity) {
+        mActivityList.add(activity)
+    }
+
+    fun unregisterActivity(activity: Activity) {
+        mActivityList.remove(activity)
+    }
+
+    override fun onPause(owner: LifecycleOwner) {
+        if (!locked)
+            locked_last_leave_time = System.currentTimeMillis() / 1000
+        locked = true
+    }
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    override fun newImageLoader(): ImageLoader {
+        return ImageLoader.Builder(this).apply {
+            okHttpClient(okHttpClient)
+            allowRgb565(getSystemService<ActivityManager>()!!.isLowRamDevice)
+            // Coil spawns a new thread for every image load by default
+            fetcherDispatcher(Dispatchers.IO.limitedParallelism(8))
+            decoderDispatcher(Dispatchers.IO.limitedParallelism(2))
+            transformationDispatcher(Dispatchers.IO.limitedParallelism(2))
+        }.build()
+    }
+
+    companion object {
+        private const val KEY_GLOBAL_STUFF_NEXT_ID = "global_stuff_next_id"
+        var locked = true
+        var locked_last_leave_time: Long = 0
+
+        @JvmStatic
+        lateinit var application: EhApplication
+            private set
+
+        @JvmStatic
+        val ehCookieStore by lazy { EhCookieStore }
+
+        @JvmStatic
+        val ehProxySelector by lazy { EhProxySelector() }
+
+        @JvmStatic
+        val okHttpClient by lazy {
+            val builder = OkHttpClient.Builder()
+                .cookieJar(ehCookieStore)
+                .cache(Cache(File(application.cacheDir, "http_cache"), 50L * 1024L * 1024L))
+                .dns(EhDns)
+                .proxySelector(ehProxySelector)
+
+            if (Settings.getDF()) {
+                var trustManager: X509TrustManager
+                try {
+                    val trustManagerFactory = TrustManagerFactory.getInstance(
+                        TrustManagerFactory.getDefaultAlgorithm()
+                    )
+                    trustManagerFactory.init(null as KeyStore?)
+                    val trustManagers = trustManagerFactory.trustManagers
+                    check(!(trustManagers.size != 1 || trustManagers[0] !is X509TrustManager)) {
+                        "Unexpected default trust managers:" + Arrays.toString(
+                            trustManagers
+                        )
+                    }
+                    trustManager = trustManagers[0] as X509TrustManager
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                    trustManager = EhX509TrustManager
+                }
+
+                builder.sslSocketFactory(EhSSLSocketFactory, trustManager)
+                builder.proxy(Proxy.NO_PROXY)
+            }
+            builder.build()
+        }
+
+        @JvmStatic
+        val galleryDetailCache by lazy {
+            LruCache<Long, GalleryDetail>(25).also {
+                favouriteStatusRouter.addListener { gid, slot ->
+                    it[gid]?.favoriteSlot = slot
+                }
+            }
+        }
+
+        @JvmStatic
+        val spiderInfoCache by lazy {
+            DiskCache.Builder().directory(File(application.cacheDir, "spider_info"))
+                .maxSizeBytes(20 * 1024 * 1024).build()
+        }
+
+        @JvmStatic
+        val downloadManager by lazy { DownloadManager() }
+
+        @JvmStatic
+        val hosts by lazy { Hosts(application, "hosts.db") }
+
+        @JvmStatic
+        val favouriteStatusRouter by lazy { FavouriteStatusRouter() }
+
+        @JvmStatic
+        val readerPreferences by lazy { ReaderPreferences(AndroidPreferenceStore(application)) }
+
+        @JvmStatic
+        val ehDatabase by lazy { buildMainDB(application) }
+    }
+}
@@ -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 final EhDatabase db = EhApplication.getEhDatabase();

    private static void upgradeDB(SQLiteDatabase db, int oldVersion) {
        switch (oldVersion) {
@@ -114,220 +99,9 @@ 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
-        }
-    }
-
    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) {
@@ -337,10 +111,34 @@ public class EhDB {
        return list;
    }

+    public static synchronized void moveDownloadInfo(int fromPosition, int toPosition) {
+        if (fromPosition == toPosition) {
+            return;
+        }
+
+        boolean reverse = fromPosition > toPosition;
+        int offset = reverse ? toPosition : fromPosition;
+        int limit = reverse ? fromPosition - toPosition + 1 : toPosition - fromPosition + 1;
+
+        DownloadsDao dao = db.downloadsDao();
+        List<DownloadInfo> list = dao.list(offset, limit);
+
+        int step = reverse ? 1 : -1;
+        int start = reverse ? limit - 1 : 0;
+        int end = reverse ? 0 : limit - 1;
+        long toTime = list.get(end).time;
+        for (int i = end; reverse ? i < start : i > start; i += step) {
+            list.get(i).time = list.get(i + step).time;
+        }
+        list.get(start).time = toTime;
+
+        dao.update(list);
+    }
+
    // Insert or update
    public static synchronized void putDownloadInfo(DownloadInfo downloadInfo) {
-        DownloadsDao dao = sDaoSession.getDownloadsDao();
-        if (null != dao.load(downloadInfo.gid)) {
+        DownloadsDao dao = db.downloadsDao();
+        if (null != dao.load(downloadInfo.getGid())) {
            // Update
            dao.update(downloadInfo);
        } else {
@@ -349,13 +147,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 +166,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 +180,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 +207,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 +226,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,51 +238,45 @@ 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("%" + query + "%");
+        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();
-        if (null == dao.load(galleryInfo.gid)) {
+        LocalFavoritesDao dao = db.localFavoritesDao();
+        if (null == dao.load(galleryInfo.getGid())) {
            LocalFavoriteInfo info;
            if (galleryInfo instanceof LocalFavoriteInfo) {
                info = (LocalFavoriteInfo) galleryInfo;
@@ -504,31 +295,26 @@ 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();
-        quickSearch.id = null;
-        quickSearch.time = System.currentTimeMillis();
-        quickSearch.id = dao.insert(quickSearch);
+        QuickSearchDao dao = db.quickSearchDao();
+        quickSearch.setId(null);
+        quickSearch.setTime(System.currentTimeMillis());
+        quickSearch.setId(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();
-        dao.update(quickSearch);
-    }
-
    public static synchronized void deleteQuickSearch(QuickSearch quickSearch) {
-        QuickSearchDao dao = sDaoSession.getQuickSearchDao();
+        QuickSearchDao dao = db.quickSearchDao();
        dao.delete(quickSearch);
    }

@@ -541,9 +327,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,68 +339,62 @@ 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 PagingSource<Integer, HistoryInfo> getHistoryLazyList() {
+        return db.historyDao().listLazy();
    }

    public static synchronized void putHistoryInfo(GalleryInfo galleryInfo) {
-        HistoryDao dao = sDaoSession.getHistoryDao();
-        HistoryInfo info = dao.load(galleryInfo.gid);
-        if (null != info) {
-            // Update time
-            info.time = System.currentTimeMillis();
+        HistoryDao dao = db.historyDao();
+        HistoryInfo info;
+        if (galleryInfo instanceof HistoryInfo) {
+            info = (HistoryInfo) galleryInfo;
+        } else {
+            info = new HistoryInfo(galleryInfo);
+        }
+        info.time = System.currentTimeMillis();
+        if (null != dao.load(info.getGid())) {
            dao.update(info);
        } else {
-            // New history
-            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)) {
+            if (null == dao.load(info.getGid())) {
                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 +402,18 @@ 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);
+        filter.enable = !filter.enable;
+        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> void copyDao(BasicDao<T> from, BasicDao<T> to) {
+        List<T> list = from.list();
+        for (T item : list)
+            to.insert(item);
    }

    public static synchronized boolean exportDB(Context context, Uri uri) {
@@ -647,30 +421,21 @@ 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;
+            copyDao(db.downloadsDao(), newDb.downloadsDao());
+            copyDao(db.downloadLabelDao(), newDb.downloadLabelDao());
+            copyDao(db.downloadDirnameDao(), newDb.downloadDirnameDao());
+            copyDao(db.historyDao(), newDb.historyDao());
+            copyDao(db.quickSearchDao(), newDb.quickSearchDao());
+            copyDao(db.localFavoritesDao(), newDb.localFavoritesDao());
+            copyDao(db.filterDao(), newDb.filterDao());
+
+            // Close export db so we can copy it
+            if (newDb.isOpen()) {
+                newDb.close();
            }

            // Copy export db to data dir
@@ -691,6 +456,7 @@ public class EhDB {
                IOUtils.closeQuietly(is);
                IOUtils.closeQuietly(os);
            }
+
            // Delete failed file
            return false;
        } finally {
@@ -704,6 +470,8 @@ public class EhDB {
    public static synchronized String importDB(Context context, Uri uri) {
        try {
            InputStream inputStream = context.getContentResolver().openInputStream(uri);
+
+            // Copy file to cache dir
            File file = File.createTempFile("importDatabase", "");
            FileOutputStream outputStream = new FileOutputStream(file);
            byte[] buff = new byte[1024];
@@ -718,77 +486,105 @@ public class EhDB {
            inputStream.close();
            outputStream.close();

-            SQLiteDatabase db = SQLiteDatabase.openDatabase(
+            // Check database version
+            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);
+                return context.getString(R.string.db_version_too_high);
            }

-            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);
+            // Crete temp room database from cache file
+            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();
+            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.getName();
+                    for (QuickSearch q : currentQuickSearchList) {
+                        if (ObjectUtils.equal(q.getName(), 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) {
            }

+            // Delete temp database
+            if (oldRoomDatabase.isOpen()) {
+                oldRoomDatabase.close();
+            }
+            context.deleteDatabase(tmpDBName);
+
            return null;
        } catch (Throwable e) {
            ExceptionUtils.throwIfFatal(e);
@@ -796,46 +592,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) {
-        }
-    }
 }
@@ -51,7 +51,7 @@ public class FavouriteStatusRouter {
        for (Map<Long, GalleryInfo> map : maps.values()) {
            GalleryInfo info = map.get(gid);
            if (info != null) {
-                info.favoriteSlot = slot;
+                info.setFavoriteSlot(slot);
            }
        }

@@ -1,70 +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.ehviewer;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-
-import com.hippo.conaco.ValueHelper;
-import com.hippo.image.ImageBitmap;
-import com.hippo.streampipe.InputStreamPipe;
-
-import java.io.IOException;
-
-public class ImageBitmapHelper implements ValueHelper<ImageBitmap> {
-
-    private static final int MAX_CACHE_SIZE = 512 * 512;
-
-    @Nullable
-    @Override
-    public ImageBitmap decode(@NonNull InputStreamPipe isPipe) {
-        try {
-            isPipe.obtain();
-            return ImageBitmap.decode(isPipe.open());
-        } catch (OutOfMemoryError | IOException e) {
-            return null;
-        } finally {
-            isPipe.close();
-            isPipe.release();
-        }
-    }
-
-    @Override
-    public int sizeOf(@NonNull String key, @NonNull ImageBitmap value) {
-        return value.getWidth() * value.getHeight() * 4 /* value.getByteCount() TODO Update Image */;
-    }
-
-    @Override
-    public void onAddToMemoryCache(@NonNull ImageBitmap oldValue) {
-        oldValue.obtain();
-    }
-
-    @Override
-    public void onRemoveFromMemoryCache(@NonNull String key, @NonNull ImageBitmap oldValue) {
-        oldValue.release();
-    }
-
-    @Override
-    public boolean useMemoryCache(@NonNull String key, ImageBitmap value) {
-        if (value != null) {
-            return value.getWidth() * value.getHeight() <= MAX_CACHE_SIZE
-                    /* value.getByteCount() <= MAX_CACHE_BYTE_COUNT TODO Update Image */;
-        } else {
-            return true;
-        }
-    }
-}
@@ -16,7 +16,6 @@

 package com.hippo.ehviewer;

-import android.content.Context;
 import android.content.SharedPreferences;
 import android.net.Uri;
 import android.util.Log;
@@ -27,20 +26,15 @@ import androidx.annotation.Nullable;
 import androidx.preference.PreferenceManager;

 import com.hippo.ehviewer.client.EhConfig;
-import com.hippo.ehviewer.client.EhUtils;
 import com.hippo.ehviewer.client.data.FavListUrlBuilder;
 import com.hippo.ehviewer.ui.CommonOperations;
 import com.hippo.ehviewer.ui.scene.GalleryListScene;
-import com.hippo.glgallery.GalleryView;
 import com.hippo.unifile.UniFile;
-import com.hippo.util.ExceptionUtils;
 import com.hippo.yorozuya.AssertUtils;
-import com.hippo.yorozuya.FileUtils;
-import com.hippo.yorozuya.MathUtils;
 import com.hippo.yorozuya.NumberUtils;

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

 public class Settings {

@@ -49,19 +43,18 @@ 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;
-    public static final int THEME_BLACK = 2;
-    public static final String KEY_APPLY_NAV_BAR_THEME_COLOR = "apply_nav_bar_theme_color";
    public static final String KEY_GALLERY_SITE = "gallery_site";
    public static final String KEY_LIST_MODE = "list_mode";
    public static final String KEY_DETAIL_SIZE = "detail_size";
-    public static final String KEY_THUMB_SIZE = "thumb_size";
+    public static final String KEY_THUMB_SIZE = "thumb_size_";
    public static final String KEY_THUMB_RESOLUTION = "thumb_resolution";
    public static final String KEY_SHOW_TAG_TRANSLATIONS = "show_tag_translations";
    public static final String KEY_DEFAULT_CATEGORIES = "default_categories";
-    public static final int DEFAULT_DEFAULT_CATEGORIES = EhUtils.ALL_CATEGORY;
+    public static final int DEFAULT_DEFAULT_CATEGORIES = EhConfig.ALL_CATEGORY;
    public static final String KEY_EXCLUDED_TAG_NAMESPACES = "excluded_tag_namespaces";
    public static final String KEY_EXCLUDED_LANGUAGES = "excluded_languages";
    /********************
@@ -75,53 +68,49 @@ 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";
    public static final String KEY_IMAGE_RESOLUTION = "image_size";
    public static final String DEFAULT_IMAGE_RESOLUTION = EhConfig.IMAGE_SIZE_AUTO;
    public static final int INVALID_DEFAULT_FAV_SLOT = -2;
-    public static final String KEY_ENABLE_ANALYTICS = "enable_analytics";
    /********************
     ****** 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 DEFAULT_SECURITY = "";
-    public static final String KEY_ENABLE_FINGERPRINT = "enable_fingerprint";
+    public static final String KEY_SECURITY = "require_unlock";
+    public static final String KEY_SECURITY_DELAY = "require_unlock_delay";
    public static final String KEY_READ_CACHE_SIZE = "read_cache_size";
    public static final int DEFAULT_READ_CACHE_SIZE = 320;
    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 KEY_HIDE_HV_EVENTS = "hide_hv_events";
+    private static final boolean DEFAULT_HIDE_HV_EVENTS = true;
+    private static final String KEY_SHOW_COMMENTS = "show_gallery_comments";
+    private static final boolean DEFAULT_SHOW_COMMENTS = true;
+    private static final String KEY_PREVIEW_NUM = "preview_num";
+    private static final int DEFAULT_PREVIEW_NUM = 60;
    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";
-    private static final boolean DEFAULT_SHOW_WARNING = true;
    private static final String KEY_REMOVE_IMAGE_FILES = "include_pic";
    private static final boolean DEFAULT_REMOVE_IMAGE_FILES = true;
    private static final String KEY_NEED_SIGN_IN = "need_sign_in";
    private static final boolean DEFAULT_NEED_SIGN_IN = true;
    private static final String KEY_SELECT_SITE = "select_site";
    private static final boolean DEFAULT_SELECT_SITE = true;
-    private static final String KEY_QUICK_SEARCH_TIP = "quick_search_tip";
-    private static final boolean DEFAULT_QUICK_SEARCH_TIP = true;
    private static final int DEFAULT_THEME = THEME_SYSTEM;
-    private static final boolean DEFAULT_APPLY_NAV_BAR_THEME_COLOR = true;
    private static final int DEFAULT_GALLERY_SITE = 1;
    private static final String KEY_LAUNCH_PAGE = "launch_page";
    private static final int DEFAULT_LAUNCH_PAGE = 0;
    private static final int DEFAULT_LIST_MODE = 0;
    private static final int DEFAULT_DETAIL_SIZE = 0;
-    private static final int DEFAULT_THUMB_SIZE = 1;
+    private static final int DEFAULT_THUMB_SIZE = 120;
    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";
@@ -133,41 +122,6 @@ public class Settings {
    private static final boolean DEFAULT_METERED_NETWORK_WARNING = false;
    private static final String KEY_APP_LINK_VERIFY_TIP = "app_link_verify_tip";
    private static final boolean DEFAULT_APP_LINK_VERIFY_TIP = false;
-    private static final String KEY_NIGHT_MODE = "night_mode";
-    private static final String DEFAULT_NIGHT_MODE = "-1";
-    private static final String KEY_E_INK_MODE = "e_ink_mode_2";
-    private static final boolean DEFAULT_E_INK_MODE = false;
-    /********************
-     ****** Read
-     ********************/
-    private static final String KEY_SCREEN_ROTATION = "screen_rotation";
-    private static final int DEFAULT_SCREEN_ROTATION = 0;
-    private static final String KEY_READING_DIRECTION = "reading_direction";
-    private static final int DEFAULT_READING_DIRECTION = GalleryView.LAYOUT_RIGHT_TO_LEFT;
-    private static final String KEY_PAGE_SCALING = "page_scaling";
-    private static final int DEFAULT_PAGE_SCALING = GalleryView.SCALE_FIT;
-    private static final String KEY_START_POSITION = "start_position";
-    private static final int DEFAULT_START_POSITION = GalleryView.START_POSITION_TOP_RIGHT;
-    private static final String KEY_KEEP_SCREEN_ON = "keep_screen_on";
-    private static final boolean DEFAULT_KEEP_SCREEN_ON = false;
-    private static final String KEY_SHOW_CLOCK = "gallery_show_clock";
-    private static final boolean DEFAULT_SHOW_CLOCK = true;
-    private static final String KEY_SHOW_PROGRESS = "gallery_show_progress";
-    private static final boolean DEFAULT_SHOW_PROGRESS = true;
-    private static final String KEY_SHOW_BATTERY = "gallery_show_battery";
-    private static final boolean DEFAULT_SHOW_BATTERY = true;
-    private static final String KEY_SHOW_PAGE_INTERVAL = "gallery_show_page_interval";
-    private static final boolean DEFAULT_SHOW_PAGE_INTERVAL = true;
-    private static final String KEY_VOLUME_PAGE = "volume_page";
-    private static final boolean DEFAULT_VOLUME_PAGE = false;
-    private static final String KEY_REVERSE_VOLUME_PAGE = "reserve_volume_page";
-    private static final boolean DEFAULT_REVERSE_VOLUME_PAGE = false;
-    private static final String KEY_READING_FULLSCREEN = "reading_fullscreen";
-    private static final boolean VALUE_READING_FULLSCREEN = true;
-    private static final String KEY_CUSTOM_SCREEN_LIGHTNESS = "custom_screen_lightness";
-    private static final boolean DEFAULT_CUSTOM_SCREEN_LIGHTNESS = false;
-    private static final String KEY_SCREEN_LIGHTNESS = "screen_lightness";
-    private static final int DEFAULT_SCREEN_LIGHTNESS = 50;
    private static final boolean DEFAULT_MEDIA_SCAN = false;
    private static final String KEY_RECENT_DOWNLOAD_LABEL = "recent_download_label";
    private static final String DEFAULT_RECENT_DOWNLOAD_LABEL = null;
@@ -181,8 +135,6 @@ public class Settings {
    private static final int DEFAULT_PRELOAD_IMAGE = 5;
    private static final String KEY_DOWNLOAD_ORIGIN_IMAGE = "download_origin_image";
    private static final boolean DEFAULT_DOWNLOAD_ORIGIN_IMAGE = false;
-    private static final String KEY_READ_THEME = "read_theme";
-    private static final int DEFAULT_READ_THEME = 1;
    /********************
     ****** Favorites
     ********************/
@@ -224,65 +176,38 @@ public class Settings {
    // -1 for local, 0 - 9 for cloud favorite, other for no default fav slot
    private static final String KEY_DEFAULT_FAV_SLOT = "default_favorite_2";
    private static final int DEFAULT_DEFAULT_FAV_SLOT = INVALID_DEFAULT_FAV_SLOT;
-    /********************
-     ****** Analytics
-     ********************/
-    private static final String KEY_ASK_ANALYTICS = "ask_analytics";
-    private static final boolean DEFAULT_ASK_ANALYTICS = true;
-    private static final boolean DEFAULT_ENABLE_ANALYTICS = false;
-    private static final String KEY_USER_ID = "user_id";
-    private static final String FILENAME_USER_ID = ".user_id";
-    private static final int LENGTH_USER_ID = 32;
-    /********************
-     ****** Update
-     ********************/
-    private static final String KEY_BETA_UPDATE_CHANNEL = "beta_update_channel";
-    private static final boolean DEFAULT_BETA_UPDATE_CHANNEL = EhApplication.BETA;
-    private static final String KEY_SKIP_UPDATE_VERSION = "skip_update_version";
-    private static final int DEFAULT_SKIP_UPDATE_VERSION = 0;
    private static final boolean DEFAULT_SAVE_PARSE_ERROR_BODY = true;
    private static final String KEY_SAVE_CRASH_LOG = "save_crash_log";
    private static final boolean DEFAULT_SAVE_CRASH_LOG = true;
    private static final boolean DEFAULT_BUILT_IN_HOSTS = false;
    private static final boolean DEFAULT_FRONTING = false;
-    private static final String DEFAULT_APP_LANGUAGE = "system";
    private static final String KEY_PROXY_TYPE = "proxy_type";
    private static final int DEFAULT_PROXY_TYPE = EhProxySelector.TYPE_SYSTEM;
    private static final String KEY_PROXY_IP = "proxy_ip";
    private static final String DEFAULT_PROXY_IP = null;
    private static final String KEY_PROXY_PORT = "proxy_port";
    private static final int DEFAULT_PROXY_PORT = -1;
-    /********************
-     ****** Guide
-     ********************/
-    private static final String KEY_GUIDE_QUICK_SEARCH = "guide_quick_search";
-    private static final boolean DEFAULT_GUIDE_QUICK_SEARCH = true;
-    private static final String KEY_GUIDE_COLLECTIONS = "guide_collections";
-    private static final boolean DEFAULT_GUIDE_COLLECTIONS = true;
-    private static final String KEY_GUIDE_DOWNLOAD_THUMB = "guide_download_thumb";
-    private static final boolean DEFAULT_GUIDE_DOWNLOAD_THUMB = true;
-    private static final String KEY_GUIDE_DOWNLOAD_LABELS = "guide_download_labels";
-    private static final boolean DEFAULT_GUIDE_DOWNLOAD_LABELS = true;
-    private static final String KEY_GUIDE_GALLERY = "guide_gallery";
-    private static final boolean DEFAULT_GUIDE_GALLERY = true;
    private static final String KEY_CLIPBOARD_TEXT_HASH_CODE = "clipboard_text_hash_code";
    private static final int DEFAULT_CLIPBOARD_TEXT_HASH_CODE = 0;
    private static final String KEY_DOWNLOAD_DELAY = "download_delay";
    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 Context sContext;
-    private static SharedPreferences sSettingsPre;
+    private static final String KEY_ARCHIVE_PASSWDS = "archive_passwds";
+    private static final String KEY_QS_SAVE_PROGRESS = "qs_save_progress";
+    private static final boolean DEFAULT_QS_SAVE_PROGRESS = true;
+    public static boolean LIST_THUMB_SIZE_INITED = false;
+    public static SharedPreferences sSettingsPre;
+    private static int LIST_THUMB_SIZE = 40;
    private static EhConfig sEhConfig;

-    public static void initialize(Context context) {
-        sContext = context.getApplicationContext();
-        sSettingsPre = PreferenceManager.getDefaultSharedPreferences(sContext);
+    public static void initialize() {
+        sSettingsPre = PreferenceManager.getDefaultSharedPreferences(EhApplication.getApplication());
        sEhConfig = loadEhConfig();
-        fixDefaultValue(context);
+        fixDefaultValue();
    }

-    private static void fixDefaultValue(Context context) {
+    private static void fixDefaultValue() {
        if ("CN".equals(Locale.getDefault().getCountry())) {
            // Enable domain fronting if the country is CN
            if (!sSettingsPre.contains(KEY_BUILT_IN_HOSTS)) {
@@ -299,16 +224,6 @@ public class Settings {
        }
    }

-    public static Locale getLocale() {
-        Locale locale = null;
-        String language = Settings.getAppLanguage();
-        if (language != null && !language.equals("system")) {
-            return Locale.forLanguageTag(language);
-        } else {
-            return Locale.getDefault();
-        }
-    }
-
    private static EhConfig loadEhConfig() {
        EhConfig ehConfig = new EhConfig();
        ehConfig.imageSize = getImageResolution();
@@ -345,32 +260,6 @@ public class Settings {
        sSettingsPre.edit().putInt(key, value).apply();
    }

-    public static long getLong(String key, long defValue) {
-        try {
-            return sSettingsPre.getLong(key, defValue);
-        } catch (ClassCastException e) {
-            Log.d(TAG, "Get ClassCastException when get " + key + " value", e);
-            return defValue;
-        }
-    }
-
-    public static void putLong(String key, long value) {
-        sSettingsPre.edit().putLong(key, value).apply();
-    }
-
-    public static float getFloat(String key, float defValue) {
-        try {
-            return sSettingsPre.getFloat(key, defValue);
-        } catch (ClassCastException e) {
-            Log.d(TAG, "Get ClassCastException when get " + key + " value", e);
-            return defValue;
-        }
-    }
-
-    public static void putFloat(String key, float value) {
-        sSettingsPre.edit().putFloat(key, value).apply();
-    }
-
    public static String getString(String key, String defValue) {
        try {
            return sSettingsPre.getString(key, defValue);
@@ -384,6 +273,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);
@@ -397,14 +301,7 @@ public class Settings {
        sSettingsPre.edit().putString(key, Integer.toString(value)).apply();
    }

-    public static int getVersionCode() {
-        return getInt(KEY_VERSION_CODE, DEFAULT_VERSION_CODE);
-    }
-
-    public static void putVersionCode(int value) {
-        putInt(KEY_VERSION_CODE, value);
-    }
-
+    @Nullable
    public static String getDisplayName() {
        return getString(KEY_DISPLAY_NAME, DEFAULT_DISPLAY_NAME);
    }
@@ -413,22 +310,10 @@ public class Settings {
        putString(KEY_DISPLAY_NAME, value);
    }

-    public static String getAvatar() {
-        return getString(KEY_AVATAR, DEFAULT_AVATAR);
-    }
-
    public static void putAvatar(String value) {
        putString(KEY_AVATAR, value);
    }

-    public static boolean getShowWarning() {
-        return getBoolean(KEY_SHOW_WARNING, DEFAULT_SHOW_WARNING);
-    }
-
-    public static void putShowWarning(boolean value) {
-        putBoolean(KEY_SHOW_WARNING, value);
-    }
-
    public static boolean getRemoveImageFiles() {
        return getBoolean(KEY_REMOVE_IMAGE_FILES, DEFAULT_REMOVE_IMAGE_FILES);
    }
@@ -461,14 +346,6 @@ public class Settings {
        return getIntFromStr(KEY_THEME, DEFAULT_THEME);
    }

-    public static void putTheme(int theme) {
-        putIntToStr(KEY_THEME, theme);
-    }
-
-    public static boolean getApplyNavBarThemeColor() {
-        return getBoolean(KEY_APPLY_NAV_BAR_THEME_COLOR, DEFAULT_APPLY_NAV_BAR_THEME_COLOR);
-    }
-
    public static int getGallerySite() {
        return getIntFromStr(KEY_GALLERY_SITE, DEFAULT_GALLERY_SITE);
    }
@@ -479,17 +356,13 @@ public class Settings {

    public static String getLaunchPageGalleryListSceneAction() {
        int value = getIntFromStr(KEY_LAUNCH_PAGE, DEFAULT_LAUNCH_PAGE);
-        switch (value) {
-            default:
-            case 0:
-                return GalleryListScene.ACTION_HOMEPAGE;
-            case 1:
-                return GalleryListScene.ACTION_SUBSCRIPTION;
-            case 2:
-                return GalleryListScene.ACTION_WHATS_HOT;
-            case 3:
-                return GalleryListScene.ACTION_TOP_LIST;
-        }
+        return switch (value) {
+            case 0 -> GalleryListScene.ACTION_HOMEPAGE;
+            case 1 -> GalleryListScene.ACTION_SUBSCRIPTION;
+            case 2 -> GalleryListScene.ACTION_WHATS_HOT;
+            case 3 -> GalleryListScene.ACTION_TOP_LIST;
+            default -> throw new IllegalStateException("Unexpected value: " + value);
+        };
    }

    public static int getListMode() {
@@ -502,44 +375,38 @@ public class Settings {

    @DimenRes
    public static int getDetailSizeResId() {
-        switch (getDetailSize()) {
-            default:
-            case 0:
-                return R.dimen.gallery_list_column_width_long;
-            case 1:
-                return R.dimen.gallery_list_column_width_short;
-        }
+        return switch (getDetailSize()) {
+            case 0 -> R.dimen.gallery_list_column_width_long;
+            case 1 -> R.dimen.gallery_list_column_width_short;
+            default -> throw new IllegalStateException("Unexpected value: " + getDetailSize());
+        };
    }

    public static int getThumbSize() {
-        return getIntFromStr(KEY_THUMB_SIZE, DEFAULT_THUMB_SIZE);
+        return dip2px(getInt(KEY_THUMB_SIZE, DEFAULT_THUMB_SIZE));
    }

-    @DimenRes
-    public static int getThumbSizeResId() {
-        switch (getThumbSize()) {
-            case 0:
-                return R.dimen.gallery_grid_column_width_large;
-            default:
-            case 1:
-                return R.dimen.gallery_grid_column_width_middle;
-            case 2:
-                return R.dimen.gallery_grid_column_width_small;
-        }
+    public static int dip2px(int dpValue) {
+        final float scale = EhApplication.getApplication().getResources().getDisplayMetrics().density;
+        return (int) (dpValue * scale + 0.5f);
    }

    public static int getThumbResolution() {
        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 getShowComments() {
+        return getBoolean(KEY_SHOW_COMMENTS, DEFAULT_SHOW_COMMENTS);
    }

    public static boolean getRequestNews() {
        return getBoolean(KEY_REQUEST_NEWS, DEFAULT_REQUEST_NEWS);
    }

+    public static boolean getHideHvEvents() {
+        return getBoolean(KEY_HIDE_HV_EVENTS, DEFAULT_HIDE_HV_EVENTS);
+    }
+
    public static boolean getShowJpnTitle() {
        return getBoolean(KEY_SHOW_JPN_TITLE, DEFAULT_SHOW_JPN_TITLE);
    }
@@ -556,36 +423,22 @@ public class Settings {
        putBoolean(KEY_SHOW_TAG_TRANSLATIONS, value);
    }

-    public static int getDefaultCategories() {
-        return getInt(KEY_DEFAULT_CATEGORIES, DEFAULT_DEFAULT_CATEGORIES);
+    public static int getPreviewNum() {
+        return getInt(KEY_PREVIEW_NUM, DEFAULT_PREVIEW_NUM);
    }

-    public static void putDefaultCategories(int value) {
-        sEhConfig.defaultCategories = value;
-        sEhConfig.setDirty();
-        putInt(KEY_DEFAULT_CATEGORIES, value);
+    public static int getDefaultCategories() {
+        return getInt(KEY_DEFAULT_CATEGORIES, DEFAULT_DEFAULT_CATEGORIES);
    }

    public static int getExcludedTagNamespaces() {
        return getInt(KEY_EXCLUDED_TAG_NAMESPACES, DEFAULT_EXCLUDED_TAG_NAMESPACES);
    }

-    public static void putExcludedTagNamespaces(int value) {
-        sEhConfig.excludedNamespaces = value;
-        sEhConfig.setDirty();
-        putInt(KEY_EXCLUDED_TAG_NAMESPACES, value);
-    }
-
    public static String getExcludedLanguages() {
        return getString(KEY_EXCLUDED_LANGUAGES, DEFAULT_EXCLUDED_LANGUAGES);
    }

-    public static void putExcludedLanguages(String value) {
-        sEhConfig.excludedLanguages = value;
-        sEhConfig.setDirty();
-        putString(KEY_EXCLUDED_LANGUAGES, value);
-    }
-
    public static boolean getMeteredNetworkWarning() {
        return getBoolean(KEY_METERED_NETWORK_WARNING, DEFAULT_METERED_NETWORK_WARNING);
    }
@@ -598,152 +451,20 @@ public class Settings {
        putBoolean(KEY_APP_LINK_VERIFY_TIP, value);
    }

-    public static int getScreenRotation() {
-        return getIntFromStr(KEY_SCREEN_ROTATION, DEFAULT_SCREEN_ROTATION);
-    }
-
-    public static void putScreenRotation(int value) {
-        putIntToStr(KEY_SCREEN_ROTATION, value);
-    }
-
-    @GalleryView.LayoutMode
-    public static int getReadingDirection() {
-        return GalleryView.sanitizeLayoutMode(getIntFromStr(KEY_READING_DIRECTION, DEFAULT_READING_DIRECTION));
-    }
-
-    public static void putReadingDirection(int value) {
-        putIntToStr(KEY_READING_DIRECTION, value);
-    }
-
-    @GalleryView.ScaleMode
-    public static int getPageScaling() {
-        return GalleryView.sanitizeScaleMode(getIntFromStr(KEY_PAGE_SCALING, DEFAULT_PAGE_SCALING));
-    }
-
-    public static void putPageScaling(int value) {
-        putIntToStr(KEY_PAGE_SCALING, value);
-    }
-
-    @GalleryView.StartPosition
-    public static int getStartPosition() {
-        return GalleryView.sanitizeStartPosition(getIntFromStr(KEY_START_POSITION, DEFAULT_START_POSITION));
-    }
-
-    public static void putStartPosition(int value) {
-        putIntToStr(KEY_START_POSITION, value);
-    }
-
-    public static boolean getKeepScreenOn() {
-        return getBoolean(KEY_KEEP_SCREEN_ON, DEFAULT_KEEP_SCREEN_ON);
-    }
-
-    public static void putKeepScreenOn(boolean value) {
-        putBoolean(KEY_KEEP_SCREEN_ON, value);
-    }
-
-    public static boolean getShowClock() {
-        return getBoolean(KEY_SHOW_CLOCK, DEFAULT_SHOW_CLOCK);
-    }
-
-    public static void putShowClock(boolean value) {
-        putBoolean(KEY_SHOW_CLOCK, value);
-    }
-
-    public static boolean getShowProgress() {
-        return getBoolean(KEY_SHOW_PROGRESS, DEFAULT_SHOW_PROGRESS);
-    }
-
-    public static void putShowProgress(boolean value) {
-        putBoolean(KEY_SHOW_PROGRESS, value);
-    }
-
-    public static boolean getShowBattery() {
-        return getBoolean(KEY_SHOW_BATTERY, DEFAULT_SHOW_BATTERY);
-    }
-
-    public static void putShowBattery(boolean value) {
-        putBoolean(KEY_SHOW_BATTERY, value);
-    }
-
-    public static boolean getShowPageInterval() {
-        return getBoolean(KEY_SHOW_PAGE_INTERVAL, DEFAULT_SHOW_PAGE_INTERVAL);
-    }
-
-    public static void putShowPageInterval(boolean value) {
-        putBoolean(KEY_SHOW_PAGE_INTERVAL, value);
-    }
-
-    public static boolean getVolumePage() {
-        return getBoolean(KEY_VOLUME_PAGE, DEFAULT_VOLUME_PAGE);
-    }
-
-    public static void putVolumePage(boolean value) {
-        putBoolean(KEY_VOLUME_PAGE, value);
-    }
-
-    public static boolean getReverseVolumePage() {
-        return getBoolean(KEY_REVERSE_VOLUME_PAGE, DEFAULT_REVERSE_VOLUME_PAGE);
-    }
-
-    public static void putReverseVolumePage(boolean value) {
-        putBoolean(KEY_REVERSE_VOLUME_PAGE, value);
-    }
-
-    public static boolean getReadingFullscreen() {
-        return getBoolean(KEY_READING_FULLSCREEN, VALUE_READING_FULLSCREEN);
-    }
-
-    public static void putReadingFullscreen(boolean value) {
-        putBoolean(KEY_READING_FULLSCREEN, value);
-    }
-
-    public static boolean getCustomScreenLightness() {
-        return getBoolean(KEY_CUSTOM_SCREEN_LIGHTNESS, DEFAULT_CUSTOM_SCREEN_LIGHTNESS);
-    }
-
-    public static void putCustomScreenLightness(boolean value) {
-        putBoolean(KEY_CUSTOM_SCREEN_LIGHTNESS, value);
-    }
-
-    public static int getScreenLightness() {
-        return getInt(KEY_SCREEN_LIGHTNESS, DEFAULT_SCREEN_LIGHTNESS);
-    }
-
-    public static void putScreenLightness(int value) {
-        putInt(KEY_SCREEN_LIGHTNESS, value);
-    }
-
-    public static int getReadTheme() {
-        return getIntFromStr(KEY_READ_THEME, DEFAULT_READ_THEME);
-    }
-
-    public static void putReadTheme(int value) {
-        putIntToStr(KEY_READ_THEME, value);
-    }
-
    public static boolean getEnabledSecurity() {
        return getBoolean(KEY_SEC_SECURITY, VALUE_SEC_SECURITY);
    }

-    public static void putEnabledSecurity(boolean value) {
-        putBoolean(KEY_READING_FULLSCREEN, value);
-    }
-
    @Nullable
    public static UniFile getDownloadLocation() {
-        UniFile dir = null;
-        try {
-            Uri.Builder builder = new Uri.Builder();
-            builder.scheme(getString(KEY_DOWNLOAD_SAVE_SCHEME, null));
-            builder.encodedAuthority(getString(KEY_DOWNLOAD_SAVE_AUTHORITY, null));
-            builder.encodedPath(getString(KEY_DOWNLOAD_SAVE_PATH, null));
-            builder.encodedQuery(getString(KEY_DOWNLOAD_SAVE_QUERY, null));
-            builder.encodedFragment(getString(KEY_DOWNLOAD_SAVE_FRAGMENT, null));
-            dir = UniFile.fromUri(sContext, builder.build());
-        } catch (Throwable e) {
-            ExceptionUtils.throwIfFatal(e);
-            // Ignore
-        }
+        UniFile dir;
+        Uri.Builder builder = new Uri.Builder();
+        builder.scheme(getString(KEY_DOWNLOAD_SAVE_SCHEME, null));
+        builder.encodedAuthority(getString(KEY_DOWNLOAD_SAVE_AUTHORITY, null));
+        builder.encodedPath(getString(KEY_DOWNLOAD_SAVE_PATH, null));
+        builder.encodedQuery(getString(KEY_DOWNLOAD_SAVE_QUERY, null));
+        builder.encodedFragment(getString(KEY_DOWNLOAD_SAVE_FRAGMENT, null));
+        dir = UniFile.fromUri(EhApplication.getApplication(), builder.build());
        return dir != null ? dir : UniFile.fromFile(AppConfig.getDefaultDownloadDir());
    }

@@ -794,26 +515,14 @@ public class Settings {
        return getIntFromStr(KEY_MULTI_THREAD_DOWNLOAD, DEFAULT_MULTI_THREAD_DOWNLOAD);
    }

-    public static void putMultiThreadDownload(int value) {
-        putIntToStr(KEY_MULTI_THREAD_DOWNLOAD, value);
-    }
-
    public static int getDownloadDelay() {
        return getIntFromStr(KEY_DOWNLOAD_DELAY, DEFAULT_DOWNLOAD_DELAY);
    }

-    public static void putDownloadDelay(int value) {
-        putIntToStr(KEY_DOWNLOAD_DELAY, value);
-    }
-
    public static int getPreloadImage() {
        return getIntFromStr(KEY_PRELOAD_IMAGE, DEFAULT_PRELOAD_IMAGE);
    }

-    public static void putPreloadImage(int value) {
-        putIntToStr(KEY_PRELOAD_IMAGE, value);
-    }
-
    public static String getImageResolution() {
        return getString(KEY_IMAGE_RESOLUTION, DEFAULT_IMAGE_RESOLUTION);
    }
@@ -828,10 +537,6 @@ public class Settings {
        return getBoolean(KEY_DOWNLOAD_ORIGIN_IMAGE, DEFAULT_DOWNLOAD_ORIGIN_IMAGE);
    }

-    public static void putDownloadOriginImage(boolean value) {
-        putBoolean(KEY_DOWNLOAD_ORIGIN_IMAGE, value);
-    }
-
    public static String[] getFavCat() {
        String[] favCat = new String[10];
        favCat[0] = sSettingsPre.getString(KEY_FAV_CAT_0, DEFAULT_FAV_CAT_0);
@@ -926,122 +631,32 @@ public class Settings {
        putInt(KEY_DEFAULT_FAV_SLOT, value);
    }

-    public static boolean getAskAnalytics() {
-        return getBoolean(KEY_ASK_ANALYTICS, DEFAULT_ASK_ANALYTICS);
+    public static boolean getQSSaveProgress() {
+        return getBoolean(KEY_QS_SAVE_PROGRESS, DEFAULT_QS_SAVE_PROGRESS);
    }

-    public static void putAskAnalytics(boolean value) {
-        putBoolean(KEY_ASK_ANALYTICS, value);
-    }
-
-    public static boolean getEnableAnalytics() {
-        return getBoolean(KEY_ENABLE_ANALYTICS, DEFAULT_ENABLE_ANALYTICS);
-    }
-
-    public static void putEnableAnalytics(boolean value) {
-        putBoolean(KEY_ENABLE_ANALYTICS, value);
-    }
-
-    public static String getUserID() {
-        boolean writeXml = false;
-        boolean writeFile = false;
-        String userID = getString(KEY_USER_ID, null);
-        File file = AppConfig.getFileInExternalAppDir(FILENAME_USER_ID);
-        if (null == userID || !isValidUserID(userID)) {
-            writeXml = true;
-            // Get use ID from out sd card file
-            userID = FileUtils.read(file);
-            if (null == userID || !isValidUserID(userID)) {
-                writeFile = true;
-                userID = generateUserID();
-            }
-        } else {
-            writeFile = true;
-        }
-
-        if (writeXml) {
-            putString(KEY_USER_ID, userID);
-        }
-        if (writeFile) {
-            FileUtils.write(file, userID);
-        }
-
-        return userID;
-    }
-
-    @NonNull
-    private static String generateUserID() {
-        int length = LENGTH_USER_ID;
-        StringBuilder sb = new StringBuilder(length);
-
-        for (int i = 0; i < length; i++) {
-            if (MathUtils.random(0, ('9' - '0' + 1) + ('z' - 'a' + 1)) <= '9' - '0') {
-                sb.append((char) MathUtils.random('0', '9' + 1));
-            } else {
-                sb.append((char) MathUtils.random('a', 'z' + 1));
-            }
-        }
-
-        return sb.toString();
-    }
-
-    private static boolean isValidUserID(@Nullable String userID) {
-        if (null == userID || LENGTH_USER_ID != userID.length()) {
-            return false;
-        }
-
-        for (int i = 0; i < LENGTH_USER_ID; i++) {
-            char ch = userID.charAt(i);
-            if (!(ch >= '0' && ch <= '9') && !(ch >= 'a' && ch <= 'z')) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    public static boolean getBetaUpdateChannel() {
-        return getBoolean(KEY_BETA_UPDATE_CHANNEL, DEFAULT_BETA_UPDATE_CHANNEL);
-    }
-
-    public static void putBetaUpdateChannel(boolean value) {
-        putBoolean(KEY_BETA_UPDATE_CHANNEL, value);
-    }
-
-    public static int getSkipUpdateVersion() {
-        return getInt(KEY_SKIP_UPDATE_VERSION, DEFAULT_SKIP_UPDATE_VERSION);
-    }
-
-    public static void putSkipUpdateVersion(int value) {
-        putInt(KEY_SKIP_UPDATE_VERSION, value);
+    public static void putQSSaveProgress(boolean value) {
+        putBoolean(KEY_QS_SAVE_PROGRESS, value);
    }

    public static boolean getSaveParseErrorBody() {
        return getBoolean(KEY_SAVE_PARSE_ERROR_BODY, DEFAULT_SAVE_PARSE_ERROR_BODY);
    }

-    public static void putSaveParseErrorBody(boolean value) {
-        putBoolean(KEY_SAVE_PARSE_ERROR_BODY, value);
-    }
-
    public static boolean getSaveCrashLog() {
        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 boolean getEnableFingerprint() {
-        return getBoolean(KEY_ENABLE_FINGERPRINT, true);
-    }
-
-    public static void putEnableFingerprint(boolean value) {
-        putBoolean(KEY_ENABLE_FINGERPRINT, value);
+    public static int getSecurityDelay() {
+        return getInt(KEY_SECURITY_DELAY, 0);
    }

    public static int getReadCacheSize() {
@@ -1064,14 +679,6 @@ public class Settings {
        putBoolean(KEY_DOMAIN_FRONTING, value);
    }

-    public static String getAppLanguage() {
-        return getString(KEY_APP_LANGUAGE, DEFAULT_APP_LANGUAGE);
-    }
-
-    public static void putAppLanguage(String value) {
-        putString(KEY_APP_LANGUAGE, value);
-    }
-
    public static int getProxyType() {
        return getInt(KEY_PROXY_TYPE, DEFAULT_PROXY_TYPE);
    }
@@ -1096,46 +703,6 @@ public class Settings {
        putInt(KEY_PROXY_PORT, value);
    }

-    public static boolean getGuideQuickSearch() {
-        return getBoolean(KEY_GUIDE_QUICK_SEARCH, DEFAULT_GUIDE_QUICK_SEARCH);
-    }
-
-    public static void putGuideQuickSearch(boolean value) {
-        putBoolean(KEY_GUIDE_QUICK_SEARCH, value);
-    }
-
-    public static boolean getGuideCollections() {
-        return getBoolean(KEY_GUIDE_COLLECTIONS, DEFAULT_GUIDE_COLLECTIONS);
-    }
-
-    public static void putGuideCollections(boolean value) {
-        putBoolean(KEY_GUIDE_COLLECTIONS, value);
-    }
-
-    public static boolean getGuideDownloadThumb() {
-        return getBoolean(KEY_GUIDE_DOWNLOAD_THUMB, DEFAULT_GUIDE_DOWNLOAD_THUMB);
-    }
-
-    public static void putGuideDownloadThumb(boolean value) {
-        putBoolean(KEY_GUIDE_DOWNLOAD_THUMB, value);
-    }
-
-    public static boolean getGuideDownloadLabels() {
-        return getBoolean(KEY_GUIDE_DOWNLOAD_LABELS, DEFAULT_GUIDE_DOWNLOAD_LABELS);
-    }
-
-    public static void puttGuideDownloadLabels(boolean value) {
-        putBoolean(KEY_GUIDE_DOWNLOAD_LABELS, value);
-    }
-
-    public static boolean getGuideGallery() {
-        return getBoolean(KEY_GUIDE_GALLERY, DEFAULT_GUIDE_GALLERY);
-    }
-
-    public static void putGuideGallery(boolean value) {
-        putBoolean(KEY_GUIDE_GALLERY, value);
-    }
-
    public static int getClipboardTextHashCode() {
        return getInt(KEY_CLIPBOARD_TEXT_HASH_CODE, DEFAULT_CLIPBOARD_TEXT_HASH_CODE);
    }
@@ -1143,4 +710,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);
+    }
 }
@@ -26,13 +26,10 @@ import android.widget.Toast;
 import androidx.annotation.NonNull;
 import androidx.browser.customtabs.CustomTabsIntent;

-import com.hippo.ehviewer.client.EhUrlOpener;
 import com.hippo.ehviewer.client.data.GalleryDetail;
 import com.hippo.ehviewer.client.parser.GalleryPageUrlParser;
-import com.hippo.ehviewer.ui.GalleryActivity;
-import com.hippo.ehviewer.ui.MainActivity;
-import com.hippo.scene.Announcer;
-import com.hippo.scene.StageActivity;
+
+import eu.kanade.tachiyomi.ui.reader.ReaderActivity;

 public final class UrlOpener {

@@ -55,20 +52,20 @@ public final class UrlOpener {
            if (galleryDetail != null) {
                GalleryPageUrlParser.Result result = GalleryPageUrlParser.parse(url);
                if (result != null) {
-                    if (result.gid == galleryDetail.gid) {
-                        intent = new Intent(context, GalleryActivity.class);
-                        intent.setAction(GalleryActivity.ACTION_EH);
-                        intent.putExtra(GalleryActivity.KEY_GALLERY_INFO, galleryDetail);
-                        intent.putExtra(GalleryActivity.KEY_PAGE, result.page);
+                    if (result.gid == galleryDetail.getGid()) {
+                        intent = new Intent(context, ReaderActivity.class);
+                        intent.setAction(ReaderActivity.ACTION_EH);
+                        intent.putExtra(ReaderActivity.KEY_GALLERY_INFO, galleryDetail);
+                        intent.putExtra(ReaderActivity.KEY_PAGE, result.page);
                        context.startActivity(intent);
                        return;
                    }
                } else if (url.startsWith("#c")) {
                    try {
-                        intent = new Intent(context, GalleryActivity.class);
-                        intent.setAction(GalleryActivity.ACTION_EH);
-                        intent.putExtra(GalleryActivity.KEY_GALLERY_INFO, galleryDetail);
-                        intent.putExtra(GalleryActivity.KEY_PAGE, Integer.parseInt(url.replace("#c", "")) - 1);
+                        intent = new Intent(context, ReaderActivity.class);
+                        intent.setAction(ReaderActivity.ACTION_EH);
+                        intent.putExtra(ReaderActivity.KEY_GALLERY_INFO, galleryDetail);
+                        intent.putExtra(ReaderActivity.KEY_PAGE, Integer.parseInt(url.replace("#c", "")) - 1);
                        context.startActivity(intent);
                        return;
                    } catch (NumberFormatException e) {
@@ -76,16 +73,6 @@ public final class UrlOpener {
                    }
                }
            }
-            Announcer announcer = EhUrlOpener.parseUrl(url);
-            if (null != announcer) {
-                intent = new Intent(context, MainActivity.class);
-                intent.setAction(StageActivity.ACTION_START_SCENE);
-                intent.putExtra(StageActivity.KEY_SCENE_NAME, announcer.getClazz().getName());
-                intent.putExtra(StageActivity.KEY_SCENE_ARGS, announcer.getArgs());
-                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
-                context.startActivity(intent);
-                return;
-            }
        }

        CustomTabsIntent.Builder customTabsIntent = new CustomTabsIntent.Builder();
@@ -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;
@@ -1,212 +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.ehviewer.client;
-
-import android.content.Context;
-import android.os.AsyncTask;
-
-import com.hippo.ehviewer.EhApplication;
-import com.hippo.ehviewer.client.exception.CancelledException;
-import com.hippo.util.ExceptionUtils;
-import com.hippo.util.IoThreadPoolExecutor;
-import com.hippo.yorozuya.SimpleHandler;
-
-import java.io.File;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicReference;
-
-import okhttp3.Call;
-import okhttp3.OkHttpClient;
-
-public class EhClient {
-
-    public static final String TAG = EhClient.class.getSimpleName();
-
-    public static final int METHOD_SIGN_IN = 0;
-    public static final int METHOD_GET_GALLERY_LIST = 1;
-    public static final int METHOD_GET_GALLERY_DETAIL = 3;
-    public static final int METHOD_GET_PREVIEW_SET = 4;
-    public static final int METHOD_GET_RATE_GALLERY = 5;
-    public static final int METHOD_GET_COMMENT_GALLERY = 6;
-    public static final int METHOD_GET_GALLERY_TOKEN = 7;
-    public static final int METHOD_GET_FAVORITES = 8;
-    public static final int METHOD_ADD_FAVORITES = 9;
-    public static final int METHOD_ADD_FAVORITES_RANGE = 10;
-    public static final int METHOD_MODIFY_FAVORITES = 11;
-    public static final int METHOD_GET_TORRENT_LIST = 12;
-    public static final int METHOD_GET_PROFILE = 14;
-    public static final int METHOD_VOTE_COMMENT = 15;
-    public static final int METHOD_IMAGE_SEARCH = 16;
-    public static final int METHOD_ARCHIVE_LIST = 17;
-    public static final int METHOD_DOWNLOAD_ARCHIVE = 18;
-    public static final int METHOD_VOTE_TAG = 19;
-
-    private final ThreadPoolExecutor mRequestThreadPool;
-    private final OkHttpClient mOkHttpClient;
-
-    public EhClient(Context context) {
-        mRequestThreadPool = IoThreadPoolExecutor.getInstance();
-        mOkHttpClient = EhApplication.getOkHttpClient(context);
-    }
-
-    public void execute(EhRequest request) {
-        if (!request.isCancelled()) {
-            Task task = new Task(request.getMethod(), request.getCallback(), request.getEhConfig());
-            task.executeOnExecutor(mRequestThreadPool, request.getArgs());
-            request.task = task;
-        } else {
-            request.getCallback().onCancel();
-        }
-    }
-
-    public interface Callback<E> {
-
-        void onSuccess(E result);
-
-        void onFailure(Exception e);
-
-        void onCancel();
-    }
-
-    public class Task extends AsyncTask<Object, Void, Object> {
-
-        private final int mMethod;
-        private final AtomicReference<Call> mCall = new AtomicReference<>();
-        private final AtomicBoolean mStop = new AtomicBoolean();
-        private Callback mCallback;
-        private EhConfig mEhConfig;
-
-        public Task(int method, Callback callback, EhConfig ehConfig) {
-            mMethod = method;
-            mCallback = callback;
-            mEhConfig = ehConfig;
-        }
-
-        // Called in Job thread
-        public void setCall(Call call) throws CancelledException {
-            if (mStop.get()) {
-                // Stopped Job thread
-                throw new CancelledException();
-            } else {
-                mCall.lazySet(call);
-            }
-        }
-
-        public EhConfig getEhConfig() {
-            return mEhConfig;
-        }
-
-        public void stop() {
-            if (!mStop.get()) {
-                mStop.lazySet(true);
-
-                if (mCallback != null) {
-                    // TODO Avoid new runnable
-                    SimpleHandler.getInstance().post(mCallback::onCancel);
-                }
-
-                Status status = getStatus();
-                if (status == Status.PENDING) {
-                    cancel(false);
-                } else if (status == Status.RUNNING) {
-                    // It is running, cancel call if it is created
-                    Call call = mCall.get();
-                    if (call != null) {
-                        call.cancel();
-                    }
-                }
-
-                // Clear
-                mCallback = null;
-                mEhConfig = null;
-                mCall.lazySet(null);
-            }
-        }
-
-        @Override
-        protected Object doInBackground(Object... params) {
-            try {
-                switch (mMethod) {
-                    case METHOD_SIGN_IN:
-                        return EhEngine.signIn(this, mOkHttpClient, (String) params[0], (String) params[1]);
-                    case METHOD_GET_GALLERY_LIST:
-                        return EhEngine.getGalleryList(this, mOkHttpClient, (String) params[0]);
-                    case METHOD_GET_GALLERY_DETAIL:
-                        return EhEngine.getGalleryDetail(this, mOkHttpClient, (String) params[0]);
-                    case METHOD_GET_PREVIEW_SET:
-                        return EhEngine.getPreviewSet(this, mOkHttpClient, (String) params[0]);
-                    case METHOD_GET_RATE_GALLERY:
-                        return EhEngine.rateGallery(this, mOkHttpClient, (Long) params[0], (String) params[1], (Long) params[2], (String) params[3], (Float) params[4]);
-                    case METHOD_GET_COMMENT_GALLERY:
-                        return EhEngine.commentGallery(this, mOkHttpClient, (String) params[0], (String) params[1], (String) params[2]);
-                    case METHOD_GET_GALLERY_TOKEN:
-                        return EhEngine.getGalleryToken(this, mOkHttpClient, (Long) params[0], (String) params[1], (Integer) params[2]);
-                    case METHOD_GET_FAVORITES:
-                        return EhEngine.getFavorites(this, mOkHttpClient, (String) params[0], (Boolean) params[1]);
-                    case METHOD_ADD_FAVORITES:
-                        return EhEngine.addFavorites(this, mOkHttpClient, (Long) params[0], (String) params[1], (Integer) params[2], (String) params[3]);
-                    case METHOD_ADD_FAVORITES_RANGE:
-                        return EhEngine.addFavoritesRange(this, mOkHttpClient, (long[]) params[0], (String[]) params[1], (Integer) params[2]);
-                    case METHOD_MODIFY_FAVORITES:
-                        return EhEngine.modifyFavorites(this, mOkHttpClient, (String) params[0], (long[]) params[1], (Integer) params[2], (Boolean) params[3]);
-                    case METHOD_GET_TORRENT_LIST:
-                        return EhEngine.getTorrentList(this, mOkHttpClient, (String) params[0], (Long) params[1], (String) params[2]);
-                    case METHOD_GET_PROFILE:
-                        return EhEngine.getProfile(this, mOkHttpClient);
-                    case METHOD_VOTE_COMMENT:
-                        return EhEngine.voteComment(this, mOkHttpClient, (Long) params[0], (String) params[1], (Long) params[2], (String) params[3], (Long) params[4], (Integer) params[5]);
-                    case METHOD_IMAGE_SEARCH:
-                        return EhEngine.imageSearch(this, mOkHttpClient, (File) params[0], (Boolean) params[1], (Boolean) params[2], (Boolean) params[3]);
-                    case METHOD_ARCHIVE_LIST:
-                        return EhEngine.getArchiveList(this, mOkHttpClient, (String) params[0], (Long) params[1], (String) params[2]);
-                    case METHOD_DOWNLOAD_ARCHIVE:
-                        return EhEngine.downloadArchive(this, mOkHttpClient, (Long) params[0], (String) params[1], (String) params[2], (String) params[3]);
-                    case METHOD_VOTE_TAG:
-                        return EhEngine.voteTag(this, mOkHttpClient, (Long) params[0], (String) params[1], (Long) params[2], (String) params[3], (String) params[4], (Integer) params[5]);
-                    default:
-                        return new IllegalStateException("Can't detect method " + mMethod);
-                }
-            } catch (Throwable e) {
-                ExceptionUtils.throwIfFatal(e);
-                return e;
-            }
-        }
-
-        @SuppressWarnings("unchecked")
-        @Override
-        protected void onPostExecute(Object result) {
-            if (mCallback != null) {
-                //noinspection StatementWithEmptyBody
-                if (!(result instanceof CancelledException)) {
-                    if (result instanceof Exception) {
-                        mCallback.onFailure((Exception) result);
-                    } else {
-                        mCallback.onSuccess(result);
-                    }
-                } else {
-                    // onCancel is called in stop
-                }
-            }
-
-            // Clear
-            mCallback = null;
-            mEhConfig = null;
-            mCall.lazySet(null);
-        }
-    }
-}
@@ -0,0 +1,184 @@
+/*
+ * Copyright 2016 Hippo Seven
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hippo.ehviewer.client
+
+import eu.kanade.tachiyomi.util.lang.launchIO
+import eu.kanade.tachiyomi.util.lang.withUIContext
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import java.io.File
+
+object EhClient {
+    internal fun enqueue(request: EhRequest, scope: CoroutineScope) {
+        check(!request.isActive) // Abort if attempt to execute an active request
+        request.job = scope.launchIO {
+            val callback: Callback<Any?>? = request.callback
+            try {
+                val result: Any? = request.run {
+                    if (args == null)
+                        execute(method)
+                    else
+                        execute(method, *args!!)
+                }
+                withUIContext { callback?.onSuccess(result) }
+            } catch (e: Exception) {
+                if (e is CancellationException)
+                    throw e // Don't catch coroutine CancellationException
+                e.printStackTrace()
+                withUIContext { callback?.onFailure(e) }
+            }
+        }
+    }
+
+    suspend fun execute(method: Int, vararg params: Any?): Any? {
+        return when (method) {
+            METHOD_SIGN_IN -> EhEngine.signIn(
+                params[0] as String,
+                params[1] as String
+            )
+
+            METHOD_GET_GALLERY_LIST -> EhEngine.getGalleryList(
+                params[0] as String
+            )
+
+            METHOD_GET_GALLERY_DETAIL -> EhEngine.getGalleryDetail(
+                params[0] as String?
+            )
+
+            METHOD_GET_PREVIEW_SET -> EhEngine.getPreviewSet(
+                params[0] as String?
+            )
+
+            METHOD_GET_RATE_GALLERY -> EhEngine.rateGallery(
+                params[0] as Long,
+                params[1] as String?,
+                params[2] as Long,
+                params[3] as String?,
+                params[4] as Float
+            )
+
+            METHOD_GET_COMMENT_GALLERY -> EhEngine.commentGallery(
+                params[0] as String?,
+                params[1] as String,
+                params[2] as String?
+            )
+
+            METHOD_GET_GALLERY_TOKEN -> EhEngine.getGalleryToken(
+                params[0] as Long,
+                params[1] as String?,
+                params[2] as Int
+            )
+
+            METHOD_GET_FAVORITES -> EhEngine.getFavorites(
+                params[0] as String
+            )
+
+            METHOD_ADD_FAVORITES -> EhEngine.addFavorites(
+                params[0] as Long,
+                params[1] as String?,
+                params[2] as Int,
+                params[3] as String?
+            )
+
+            METHOD_ADD_FAVORITES_RANGE -> @Suppress("UNCHECKED_CAST") EhEngine.addFavoritesRange(
+                params[0] as LongArray,
+                params[1] as Array<String?>,
+                params[2] as Int
+            )
+
+            METHOD_MODIFY_FAVORITES -> EhEngine.modifyFavorites(
+                params[0] as String,
+                params[1] as LongArray,
+                params[2] as Int
+            )
+
+            METHOD_GET_TORRENT_LIST -> EhEngine.getTorrentList(
+                params[0] as String?,
+                params[1] as Long,
+                params[2] as String?
+            )
+
+            METHOD_GET_PROFILE -> EhEngine.getProfile()
+            METHOD_VOTE_COMMENT -> EhEngine.voteComment(
+                params[0] as Long,
+                params[1] as String?,
+                params[2] as Long,
+                params[3] as String?,
+                params[4] as Long,
+                params[5] as Int
+            )
+
+            METHOD_IMAGE_SEARCH -> EhEngine.imageSearch(
+                params[0] as File,
+                params[1] as Boolean,
+                params[2] as Boolean,
+                params[3] as Boolean
+            )
+
+            METHOD_ARCHIVE_LIST -> EhEngine.getArchiveList(
+                params[0] as String?,
+                params[1] as Long,
+                params[2] as String?
+            )
+
+            METHOD_DOWNLOAD_ARCHIVE -> EhEngine.downloadArchive(
+                params[0] as Long,
+                params[1] as String?,
+                params[2] as String?,
+                params[3] as String?,
+                params[4] as Boolean
+            )
+
+            METHOD_VOTE_TAG -> EhEngine.voteTag(
+                params[0] as Long,
+                params[1] as String?,
+                params[2] as Long,
+                params[3] as String?,
+                params[4] as String?,
+                params[5] as Int
+            )
+
+            METHOD_GET_UCONFIG -> EhEngine.getUConfig()
+            else -> throw IllegalStateException("Can't detect method $method")
+        }
+    }
+
+    interface Callback<E> {
+        fun onSuccess(result: E)
+        fun onFailure(e: Exception)
+        fun onCancel()
+    }
+
+    const val METHOD_SIGN_IN = 0
+    const val METHOD_GET_GALLERY_LIST = 1
+    const val METHOD_GET_GALLERY_DETAIL = 3
+    const val METHOD_GET_PREVIEW_SET = 4
+    const val METHOD_GET_RATE_GALLERY = 5
+    const val METHOD_GET_COMMENT_GALLERY = 6
+    const val METHOD_GET_GALLERY_TOKEN = 7
+    const val METHOD_GET_FAVORITES = 8
+    const val METHOD_ADD_FAVORITES = 9
+    const val METHOD_ADD_FAVORITES_RANGE = 10
+    const val METHOD_MODIFY_FAVORITES = 11
+    const val METHOD_GET_TORRENT_LIST = 12
+    const val METHOD_GET_PROFILE = 14
+    const val METHOD_VOTE_COMMENT = 15
+    const val METHOD_IMAGE_SEARCH = 16
+    const val METHOD_ARCHIVE_LIST = 17
+    const val METHOD_DOWNLOAD_ARCHIVE = 18
+    const val METHOD_VOTE_TAG = 19
+    const val METHOD_GET_UCONFIG = 20
+}
@@ -1,116 +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.ehviewer.client;
-
-import android.content.Context;
-
-import androidx.annotation.NonNull;
-
-import com.hippo.network.CookieRepository;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-import okhttp3.Cookie;
-import okhttp3.HttpUrl;
-
-public class EhCookieStore extends CookieRepository {
-
-    public static final String KEY_IPD_MEMBER_ID = "ipb_member_id";
-    public static final String KEY_IPD_PASS_HASH = "ipb_pass_hash";
-    public static final String KEY_IGNEOUS = "igneous";
-
-    public static final Cookie sTipsCookie =
-            new Cookie.Builder()
-                    .name(EhConfig.KEY_CONTENT_WARNING)
-                    .value(EhConfig.CONTENT_WARNING_NOT_SHOW)
-                    .domain(EhUrl.DOMAIN_E)
-                    .path("/")
-                    .expiresAt(Long.MAX_VALUE)
-                    .build();
-
-    public EhCookieStore(Context context) {
-        super(context, "okhttp3-cookie.db");
-    }
-
-    public static Cookie newCookie(Cookie cookie, String newDomain, boolean forcePersistent,
-                                   boolean forceLongLive, boolean forceNotHostOnly) {
-        Cookie.Builder builder = new Cookie.Builder();
-        builder.name(cookie.name());
-        builder.value(cookie.value());
-
-        if (forceLongLive) {
-            builder.expiresAt(Long.MAX_VALUE);
-        } else if (cookie.persistent()) {
-            builder.expiresAt(cookie.expiresAt());
-        } else if (forcePersistent) {
-            builder.expiresAt(Long.MAX_VALUE);
-        }
-        if (cookie.hostOnly() && !forceNotHostOnly) {
-            builder.hostOnlyDomain(newDomain);
-        } else {
-            builder.domain(newDomain);
-        }
-        builder.path(cookie.path());
-        if (cookie.secure()) {
-            builder.secure();
-        }
-        if (cookie.httpOnly()) {
-            builder.httpOnly();
-        }
-        return builder.build();
-    }
-
-    public void signOut() {
-        clear();
-    }
-
-    public boolean hasSignedIn() {
-        HttpUrl url = HttpUrl.parse(EhUrl.HOST_E);
-        return contains(url, KEY_IPD_MEMBER_ID) &&
-                contains(url, KEY_IPD_PASS_HASH);
-    }
-
-    @NonNull
-    @Override
-    public List<Cookie> loadForRequest(@NonNull HttpUrl url) {
-        List<Cookie> cookies = super.loadForRequest(url);
-
-        boolean checkTips = domainMatch(url, EhUrl.DOMAIN_E);
-
-        if (checkTips) {
-            List<Cookie> result = new ArrayList<>(cookies.size() + 1);
-            // Add all but skip some
-            for (Cookie cookie : cookies) {
-                String name = cookie.name();
-                if (EhConfig.KEY_CONTENT_WARNING.equals(name)) {
-                    continue;
-                }
-                if (EhConfig.KEY_UCONFIG.equals(name)) {
-                    continue;
-                }
-                result.add(cookie);
-            }
-            // Add some
-            result.add(sTipsCookie);
-            return Collections.unmodifiableList(result);
-        } else {
-            return cookies;
-        }
-    }
-}
@@ -0,0 +1,247 @@
+/*
+ * Copyright 2016 Hippo Seven
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hippo.ehviewer.client
+
+import com.hippo.ehviewer.EhApplication
+import com.hippo.network.CookieDatabase
+import com.hippo.network.CookieSet
+import okhttp3.Cookie
+import okhttp3.CookieJar
+import okhttp3.HttpUrl
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import java.util.Collections
+import java.util.regex.Pattern
+
+object EhCookieStore : CookieJar {
+    private val db: CookieDatabase = CookieDatabase(EhApplication.application, "okhttp3-cookie.db")
+    private val map: MutableMap<String, CookieSet> = db.allCookies
+
+    fun signOut() {
+        clear()
+    }
+
+    fun hasSignedIn(): Boolean {
+        val url = EhUrl.HOST_E.toHttpUrl()
+        return contains(url, KEY_IPD_MEMBER_ID) &&
+                contains(url, KEY_IPD_PASS_HASH)
+    }
+
+    const val KEY_IPD_MEMBER_ID = "ipb_member_id"
+    const val KEY_IPD_PASS_HASH = "ipb_pass_hash"
+    const val KEY_IGNEOUS = "igneous"
+    private val sTipsCookie: Cookie = Cookie.Builder()
+        .name(EhConfig.KEY_CONTENT_WARNING)
+        .value(EhConfig.CONTENT_WARNING_NOT_SHOW)
+        .domain(EhUrl.DOMAIN_E)
+        .path("/")
+        .expiresAt(Long.MAX_VALUE)
+        .build()
+
+    fun newCookie(
+        cookie: Cookie, newDomain: String, forcePersistent: Boolean,
+        forceLongLive: Boolean, forceNotHostOnly: Boolean
+    ): Cookie {
+        val builder = Cookie.Builder()
+        builder.name(cookie.name)
+        builder.value(cookie.value)
+        if (forceLongLive) {
+            builder.expiresAt(Long.MAX_VALUE)
+        } else if (cookie.persistent) {
+            builder.expiresAt(cookie.expiresAt)
+        } else if (forcePersistent) {
+            builder.expiresAt(Long.MAX_VALUE)
+        }
+        if (cookie.hostOnly && !forceNotHostOnly) {
+            builder.hostOnlyDomain(newDomain)
+        } else {
+            builder.domain(newDomain)
+        }
+        builder.path(cookie.path)
+        if (cookie.secure) {
+            builder.secure()
+        }
+        if (cookie.httpOnly) {
+            builder.httpOnly()
+        }
+        return builder.build()
+    }
+
+    @Synchronized
+    fun addCookie(cookie: Cookie) {
+        // For cookie database
+        var toAdd: Cookie? = null
+        var toUpdate: Cookie? = null
+        var toRemove: Cookie? = null
+        var set = map[cookie.domain]
+        if (set == null) {
+            set = CookieSet()
+            map[cookie.domain] = set
+        }
+        if (cookie.expiresAt <= System.currentTimeMillis()) {
+            toRemove = set.remove(cookie)
+            // If the cookie is not persistent, it's not in database
+            if (toRemove != null && !toRemove.persistent) {
+                toRemove = null
+            }
+        } else {
+            toAdd = cookie
+            toUpdate = set.add(cookie)
+            // If the cookie is not persistent, it's not in database
+            if (!toAdd.persistent) toAdd = null
+            if (toUpdate != null && !toUpdate.persistent) toUpdate = null
+            // Remove the cookie if it updates to null
+            if (toAdd == null && toUpdate != null) {
+                toRemove = toUpdate
+                toUpdate = null
+            }
+        }
+        if (toRemove != null) {
+            db.remove(toRemove)
+        }
+        if (toAdd != null) {
+            if (toUpdate != null) {
+                db.update(toUpdate, toAdd)
+            } else {
+                db.add(toAdd)
+            }
+        }
+    }
+
+    fun getCookieHeader(url: HttpUrl): String {
+        val cookies = getCookies(url)
+        val cookieHeader = StringBuilder()
+        var i = 0
+        val size = cookies.size
+        while (i < size) {
+            if (i > 0) {
+                cookieHeader.append("; ")
+            }
+            val cookie = cookies[i]
+            cookieHeader.append(cookie.name).append('=').append(cookie.value)
+            i++
+        }
+        return cookieHeader.toString()
+    }
+
+    @Synchronized
+    fun getCookies(url: HttpUrl): List<Cookie> {
+        val accepted: MutableList<Cookie> = ArrayList()
+        val expired: MutableList<Cookie> = ArrayList()
+        for ((domain, cookieSet) in map) {
+            if (domainMatch(url, domain)) {
+                cookieSet[url, accepted, expired]
+            }
+        }
+        for (cookie in expired) {
+            if (cookie.persistent) {
+                db.remove(cookie)
+            }
+        }
+
+        // RFC 6265 Section-5.4 step 2, sort the cookie-list
+        // Cookies with longer paths are listed before cookies with shorter paths.
+        // Ignore creation-time, we don't store them.
+        accepted.sortWith { o1: Cookie, o2: Cookie -> o2.path.length - o1.path.length }
+        return accepted
+    }
+
+    fun contains(url: HttpUrl, name: String?): Boolean {
+        for (cookie in getCookies(url)) {
+            if (cookie.name == name) {
+                return true
+            }
+        }
+        return false
+    }
+
+    /**
+     * Remove all cookies in this `CookieRepository`.
+     */
+    @Synchronized
+    fun clear() {
+        map.clear()
+        db.clear()
+    }
+
+    @Synchronized
+    fun close() {
+        db.close()
+    }
+
+    override fun saveFromResponse(url: HttpUrl, cookies: List<Cookie>) {
+        for (cookie in cookies) {
+            addCookie(cookie)
+        }
+    }
+
+    /**
+     * Quick and dirty pattern to differentiate IP addresses from hostnames. This is an approximation
+     * of Android's private InetAddress#isNumeric API.
+     *
+     *
+     * This matches IPv6 addresses as a hex string containing at least one colon, and possibly
+     * including dots after the first colon. It matches IPv4 addresses as strings containing only
+     * decimal digits and dots. This pattern matches strings like "a:.23" and "54" that are neither IP
+     * addresses nor hostnames; they will be verified as IP addresses (which is a more strict
+     * verification).
+     */
+    private val VERIFY_AS_IP_ADDRESS =
+        Pattern.compile("([0-9a-fA-F]*:[0-9a-fA-F:.]*)|([\\d.]+)")
+
+    /**
+     * Returns true if `host` is not a host name and might be an IP address.
+     */
+    private fun verifyAsIpAddress(host: String): Boolean {
+        return VERIFY_AS_IP_ADDRESS.matcher(host).matches()
+    }
+
+    // okhttp3.Cookie.domainMatch(HttpUrl, String)
+    @JvmStatic
+    fun domainMatch(url: HttpUrl, domain: String?): Boolean {
+        val urlHost = url.host
+        return if (urlHost == domain) {
+            true // As in 'example.com' matching 'example.com'.
+        } else urlHost.endsWith(domain!!)
+                && urlHost[urlHost.length - domain.length - 1] == '.' && !verifyAsIpAddress(
+            urlHost
+        )
+        // As in 'example.com' matching 'www.example.com'.
+    }
+
+    override fun loadForRequest(url: HttpUrl): List<Cookie> {
+        val cookies = getCookies(url)
+        val checkTips = domainMatch(url, EhUrl.DOMAIN_E)
+        return if (checkTips) {
+            val result: MutableList<Cookie> = ArrayList(cookies.size + 1)
+            // Add all but skip some
+            for (cookie in cookies) {
+                val name = cookie.name
+                if (EhConfig.KEY_CONTENT_WARNING == name) {
+                    continue
+                }
+                if (EhConfig.KEY_UCONFIG == name) {
+                    continue
+                }
+                result.add(cookie)
+            }
+            // Add some
+            result.add(sTipsCookie)
+            Collections.unmodifiableList(result)
+        } else {
+            cookies
+        }
+    }
+}
@@ -1,95 +0,0 @@
-/*
- * Copyright 2018 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;
-
-/*
- * Created by Hippo on 2018/3/23.
- */
-
-import android.content.Context;
-
-import androidx.annotation.NonNull;
-
-import com.hippo.ehviewer.EhApplication;
-import com.hippo.ehviewer.Hosts;
-import com.hippo.ehviewer.Settings;
-
-import java.net.InetAddress;
-import java.net.UnknownHostException;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import okhttp3.Dns;
-
-public class EhDns implements Dns {
-
-    private static final Map<String, List<InetAddress>> builtInHosts;
-
-    static {
-        Map<String, List<InetAddress>> map = new HashMap<>();
-        put(map, "e-hentai.org", "104.20.134.21", "104.20.135.21", "172.67.0.127");
-        put(map, "exhentai.org", "178.175.128.252", "178.175.129.252", "178.175.129.254", "178.175.128.254",
-                "178.175.132.20", "178.175.132.22");
-        put(map, "repo.e-hentai.org", "94.100.28.57", "94.100.29.73");
-        put(map, "forums.e-hentai.org", "94.100.18.243");
-        put(map, "ehgt.org", "37.48.89.44", "81.171.10.48", "178.162.139.24", "178.162.140.212"
-                , "2001:1af8:4700:a062:8::47de", "2001:1af8:4700:a062:9::47de", "2001:1af8:4700:a0c9:4::47de", "2001:1af8:4700:a0c9:3::47de");
-        put(map, "gt0.ehgt.org", "37.48.89.44", "81.171.10.48", "178.162.139.24", "178.162.140.212"
-                , "2001:1af8:4700:a062:8::47de", "2001:1af8:4700:a062:9::47de", "2001:1af8:4700:a0c9:4::47de", "2001:1af8:4700:a0c9:3::47de");
-        put(map, "gt1.ehgt.org", "37.48.89.44", "81.171.10.48", "178.162.139.24", "178.162.140.212"
-                , "2001:1af8:4700:a062:8::47de", "2001:1af8:4700:a062:9::47de", "2001:1af8:4700:a0c9:4::47de", "2001:1af8:4700:a0c9:3::47de");
-        put(map, "gt2.ehgt.org", "37.48.89.44", "81.171.10.48", "178.162.139.24", "178.162.140.212"
-                , "2001:1af8:4700:a062:8::47de", "2001:1af8:4700:a062:9::47de", "2001:1af8:4700:a0c9:4::47de", "2001:1af8:4700:a0c9:3::47de");
-        put(map, "gt3.ehgt.org", "37.48.89.44", "81.171.10.48", "178.162.139.24", "178.162.140.212"
-                , "2001:1af8:4700:a062:8::47de", "2001:1af8:4700:a062:9::47de", "2001:1af8:4700:a0c9:4::47de", "2001:1af8:4700:a0c9:3::47de");
-        put(map, "ul.ehgt.org", "94.100.24.82", "94.100.24.72");
-        put(map, "raw.githubusercontent.com", "151.101.0.133", "151.101.64.133", "151.101.128.133", "151.101.192.133");
-        builtInHosts = map;
-    }
-
-    private final Hosts hosts;
-
-    public EhDns(Context context) {
-        hosts = EhApplication.getHosts(context);
-    }
-
-    private static void put(Map<String, List<InetAddress>> map, String host, String... ips) {
-        List<InetAddress> addresses = new ArrayList<>();
-        for (String ip : ips) {
-            addresses.add(Hosts.toInetAddress(host, ip));
-        }
-        map.put(host, addresses);
-    }
-
-    @NonNull
-    @Override
-    public List<InetAddress> lookup(@NonNull String hostname) throws UnknownHostException {
-        List<InetAddress> inetAddresses = hosts.get(hostname);
-        if (inetAddresses != null) {
-            return inetAddresses;
-        }
-        if (Settings.getBuiltInHosts()) {
-            inetAddresses = builtInHosts.get(hostname);
-            if (inetAddresses != null) {
-                return inetAddresses;
-            }
-        }
-        return SYSTEM.lookup(hostname);
-    }
-}
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2018 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
+
+import com.hippo.ehviewer.EhApplication
+import com.hippo.ehviewer.Hosts
+import com.hippo.ehviewer.Settings
+import okhttp3.Dns
+import java.net.InetAddress
+import java.net.UnknownHostException
+
+object EhDns : Dns {
+    private val hosts = EhApplication.hosts
+    private val builtInHosts: MutableMap<String, List<InetAddress>> = mutableMapOf()
+
+    init {
+        /* Pair(ip: String!, blockedByCCP: Boolean!) */
+        val ehgtHosts = arrayOf(
+            Pair("37.48.89.44", false),
+            Pair("81.171.10.48", false),
+            Pair("178.162.139.24", false),
+            Pair("178.162.140.212", false),
+            Pair("2001:1af8:4700:a062:8::47de", false),
+            Pair("2001:1af8:4700:a062:9::47de", true),
+            Pair("2001:1af8:4700:a0c9:4::47de", false),
+            Pair("2001:1af8:4700:a0c9:3::47de", true),
+        )
+
+        put(
+            builtInHosts,
+            "e-hentai.org",
+            Pair("104.20.134.21", false),
+            Pair("104.20.135.21", false),
+            Pair("172.67.0.127", false),
+        )
+        put(
+            builtInHosts,
+            "exhentai.org",
+            Pair("178.175.128.252", false),
+            Pair("178.175.129.252", false),
+            Pair("178.175.129.254", false),
+            Pair("178.175.128.254", false),
+            Pair("178.175.132.20", false),
+            Pair("178.175.132.22", false),
+        )
+        put(
+            builtInHosts,
+            "repo.e-hentai.org",
+            Pair("94.100.28.57", true),
+            Pair("94.100.29.73", true),
+        )
+        put(
+            builtInHosts,
+            "forums.e-hentai.org",
+            Pair("94.100.18.243", false),
+        )
+        put(
+            builtInHosts,
+            "ehgt.org",
+            *ehgtHosts
+        )
+        put(
+            builtInHosts,
+            "gt0.ehgt.org",
+            *ehgtHosts
+        )
+        put(
+            builtInHosts,
+            "gt1.ehgt.org",
+            *ehgtHosts
+        )
+        put(
+            builtInHosts,
+            "gt2.ehgt.org",
+            *ehgtHosts
+        )
+        put(
+            builtInHosts,
+            "gt3.ehgt.org",
+            *ehgtHosts
+        )
+        put(
+            builtInHosts,
+            "ul.ehgt.org",
+            Pair("94.100.24.82", true),
+            Pair("94.100.24.72", true),
+        )
+        put(
+            builtInHosts,
+            "raw.githubusercontent.com",
+            Pair("151.101.0.133", false),
+            Pair("151.101.64.133", false),
+            Pair("151.101.128.133", false),
+            Pair("151.101.192.133", false),
+        )
+    }
+
+    private fun put(
+        map: MutableMap<String, List<InetAddress>>,
+        host: String,
+        vararg ips: Pair<String, Boolean>
+    ) {
+        map[host] = ips.mapNotNull { pair ->
+            Hosts.toInetAddress(host, pair.first).takeUnless { Settings.getDF() && pair.second }
+        }
+    }
+
+    @Throws(UnknownHostException::class)
+    override fun lookup(hostname: String): List<InetAddress> {
+        return hosts[hostname] ?: builtInHosts[hostname].takeIf { Settings.getBuiltInHosts() }
+        ?: Dns.SYSTEM.lookup(hostname)
+    }
+}
@@ -1,275 +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.ehviewer.client;
-
-import android.util.Log;
-
-import com.hippo.ehviewer.EhDB;
-import com.hippo.ehviewer.client.data.GalleryInfo;
-import com.hippo.ehviewer.dao.Filter;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public final class EhFilter {
-
-    public static final int MODE_TITLE = 0;
-    public static final int MODE_UPLOADER = 1;
-    public static final int MODE_TAG = 2;
-    public static final int MODE_TAG_NAMESPACE = 3;
-    private static final String TAG = EhFilter.class.getSimpleName();
-    private static EhFilter sInstance;
-    private final List<Filter> mTitleFilterList = new ArrayList<>();
-    private final List<Filter> mUploaderFilterList = new ArrayList<>();
-    private final List<Filter> mTagFilterList = new ArrayList<>();
-    private final List<Filter> mTagNamespaceFilterList = new ArrayList<>();
-
-    private EhFilter() {
-        List<Filter> list = EhDB.getAllFilter();
-        for (int i = 0, n = list.size(); i < n; i++) {
-            Filter filter = list.get(i);
-            switch (filter.mode) {
-                case MODE_TITLE:
-                    filter.text = filter.text.toLowerCase();
-                    mTitleFilterList.add(filter);
-                    break;
-                case MODE_UPLOADER:
-                    mUploaderFilterList.add(filter);
-                    break;
-                case MODE_TAG:
-                    filter.text = filter.text.toLowerCase();
-                    mTagFilterList.add(filter);
-                    break;
-                case MODE_TAG_NAMESPACE:
-                    filter.text = filter.text.toLowerCase();
-                    mTagNamespaceFilterList.add(filter);
-                    break;
-                default:
-                    Log.d(TAG, "Unknown mode: " + filter.mode);
-                    break;
-            }
-        }
-    }
-
-    public static EhFilter getInstance() {
-        if (sInstance == null) {
-            sInstance = new EhFilter();
-        }
-        return sInstance;
-    }
-
-    public List<Filter> getTitleFilterList() {
-        return mTitleFilterList;
-    }
-
-    public List<Filter> getUploaderFilterList() {
-        return mUploaderFilterList;
-    }
-
-    public List<Filter> getTagFilterList() {
-        return mTagFilterList;
-    }
-
-    public List<Filter> getTagNamespaceFilterList() {
-        return mTagNamespaceFilterList;
-    }
-
-    public synchronized boolean addFilter(Filter filter) {
-        // enable filter by default before it is added to database
-        filter.enable = true;
-        if (!EhDB.addFilter(filter)) return false;
-
-        switch (filter.mode) {
-            case MODE_TITLE:
-                filter.text = filter.text.toLowerCase();
-                mTitleFilterList.add(filter);
-                break;
-            case MODE_UPLOADER:
-                mUploaderFilterList.add(filter);
-                break;
-            case MODE_TAG:
-                filter.text = filter.text.toLowerCase();
-                mTagFilterList.add(filter);
-                break;
-            case MODE_TAG_NAMESPACE:
-                filter.text = filter.text.toLowerCase();
-                mTagNamespaceFilterList.add(filter);
-                break;
-            default:
-                Log.d(TAG, "Unknown mode: " + filter.mode);
-                break;
-        }
-        return true;
-    }
-
-    public synchronized void triggerFilter(Filter filter) {
-        EhDB.triggerFilter(filter);
-    }
-
-    public synchronized void deleteFilter(Filter filter) {
-        EhDB.deleteFilter(filter);
-
-        switch (filter.mode) {
-            case MODE_TITLE:
-                mTitleFilterList.remove(filter);
-                break;
-            case MODE_UPLOADER:
-                mUploaderFilterList.remove(filter);
-                break;
-            case MODE_TAG:
-                mTagFilterList.remove(filter);
-                break;
-            case MODE_TAG_NAMESPACE:
-                mTagNamespaceFilterList.remove(filter);
-                break;
-            default:
-                Log.d(TAG, "Unknown mode: " + filter.mode);
-                break;
-        }
-    }
-
-    public synchronized boolean needTags() {
-        return 0 != mTagFilterList.size() || 0 != mTagNamespaceFilterList.size();
-    }
-
-    public synchronized boolean filterTitle(GalleryInfo info) {
-        if (null == info) {
-            return false;
-        }
-
-        // Title
-        String title = info.title;
-        List<Filter> filters = mTitleFilterList;
-        if (null != title && filters.size() > 0) {
-            for (int i = 0, n = filters.size(); i < n; i++) {
-                if (filters.get(i).enable && title.toLowerCase().contains(filters.get(i).text)) {
-                    return false;
-                }
-            }
-        }
-
-        return true;
-    }
-
-    public synchronized boolean filterUploader(GalleryInfo info) {
-        if (null == info) {
-            return false;
-        }
-
-        // Uploader
-        String uploader = info.uploader;
-        List<Filter> filters = mUploaderFilterList;
-        if (null != uploader && filters.size() > 0) {
-            for (int i = 0, n = filters.size(); i < n; i++) {
-                if (filters.get(i).enable && uploader.equals(filters.get(i).text)) {
-                    return false;
-                }
-            }
-        }
-
-        return true;
-    }
-
-    private boolean matchTag(String tag, String filter) {
-        if (null == tag || null == filter) {
-            return false;
-        }
-
-        String tagNamespace;
-        String tagName;
-        String filterNamespace;
-        String filterName;
-        int index = tag.indexOf(':');
-        if (index < 0) {
-            tagNamespace = null;
-            tagName = tag;
-        } else {
-            tagNamespace = tag.substring(0, index);
-            tagName = tag.substring(index + 1);
-        }
-        index = filter.indexOf(':');
-        if (index < 0) {
-            filterNamespace = null;
-            filterName = filter;
-        } else {
-            filterNamespace = filter.substring(0, index);
-            filterName = filter.substring(index + 1);
-        }
-
-        if (null != tagNamespace && null != filterNamespace &&
-                !tagNamespace.equals(filterNamespace)) {
-            return false;
-        }
-        return tagName.equals(filterName);
-    }
-
-    public synchronized boolean filterTag(GalleryInfo info) {
-        if (null == info) {
-            return false;
-        }
-
-        // Tag
-        String[] tags = info.simpleTags;
-        List<Filter> filters = mTagFilterList;
-        if (null != tags && filters.size() > 0) {
-            for (String tag : tags) {
-                for (int i = 0, n = filters.size(); i < n; i++) {
-                    if (filters.get(i).enable && matchTag(tag, filters.get(i).text)) {
-                        return false;
-                    }
-                }
-            }
-        }
-
-        return true;
-    }
-
-    private boolean matchTagNamespace(String tag, String filter) {
-        if (null == tag || null == filter) {
-            return false;
-        }
-
-        String tagNamespace;
-        int index = tag.indexOf(':');
-        if (index >= 0) {
-            tagNamespace = tag.substring(0, index);
-            return tagNamespace.equals(filter);
-        } else {
-            return false;
-        }
-    }
-
-    public synchronized boolean filterTagNamespace(GalleryInfo info) {
-        if (null == info) {
-            return false;
-        }
-
-        String[] tags = info.simpleTags;
-        List<Filter> filters = mTagNamespaceFilterList;
-        if (null != tags && filters.size() > 0) {
-            for (String tag : tags) {
-                for (int i = 0, n = filters.size(); i < n; i++) {
-                    if (filters.get(i).enable && matchTagNamespace(tag, filters.get(i).text)) {
-                        return false;
-                    }
-                }
-            }
-        }
-
-        return true;
-    }
-}
@@ -0,0 +1,315 @@
+/*
+ * Copyright 2016 Hippo Seven
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hippo.ehviewer.client
+
+import android.util.Log
+import com.hippo.ehviewer.EhDB
+import com.hippo.ehviewer.client.data.GalleryInfo
+import com.hippo.ehviewer.dao.Filter
+import java.util.Locale
+import java.util.regex.Pattern
+
+object EhFilter {
+    private val mTitleFilterList: MutableList<Filter> = ArrayList()
+    private val mUploaderFilterList: MutableList<Filter> = ArrayList()
+    private val mTagFilterList: MutableList<Filter> = ArrayList()
+    private val mTagNamespaceFilterList: MutableList<Filter> = ArrayList()
+    private val mCommenterFilterList: MutableList<Filter> = ArrayList()
+    private val mCommentFilterList: MutableList<Filter> = ArrayList()
+
+    const val MODE_TITLE = 0
+    const val MODE_UPLOADER = 1
+    const val MODE_TAG = 2
+    const val MODE_TAG_NAMESPACE = 3
+    const val MODE_COMMENTER = 4
+    const val MODE_COMMENT = 5
+    private val TAG = EhFilter::class.java.simpleName
+
+    init {
+        val list = EhDB.getAllFilter()
+        var i = 0
+        val n = list.size
+        while (i < n) {
+            val filter = list[i]
+            when (filter.mode) {
+                MODE_TITLE -> {
+                    filter.text = filter.text!!.lowercase(Locale.getDefault())
+                    mTitleFilterList.add(filter)
+                }
+
+                MODE_TAG -> {
+                    filter.text = filter.text!!.lowercase(Locale.getDefault())
+                    mTagFilterList.add(filter)
+                }
+
+                MODE_TAG_NAMESPACE -> {
+                    filter.text = filter.text!!.lowercase(Locale.getDefault())
+                    mTagNamespaceFilterList.add(filter)
+                }
+
+                MODE_UPLOADER -> mUploaderFilterList.add(filter)
+                MODE_COMMENTER -> mCommenterFilterList.add(filter)
+                MODE_COMMENT -> mCommentFilterList.add(filter)
+                else -> Log.d(TAG, "Unknown mode: " + filter.mode)
+            }
+            i++
+        }
+    }
+
+    val titleFilterList: List<Filter>
+        get() = mTitleFilterList
+    val uploaderFilterList: List<Filter>
+        get() = mUploaderFilterList
+    val tagFilterList: List<Filter>
+        get() = mTagFilterList
+    val tagNamespaceFilterList: List<Filter>
+        get() = mTagNamespaceFilterList
+    val commenterFilterList: List<Filter>
+        get() = mCommenterFilterList
+    val commentFilterList: List<Filter>
+        get() = mCommentFilterList
+
+    @Synchronized
+    fun addFilter(filter: Filter): Boolean {
+        // enable filter by default before it is added to database
+        filter.enable = true
+        if (!EhDB.addFilter(filter)) return false
+        when (filter.mode) {
+            MODE_TITLE -> {
+                filter.text = filter.text!!.lowercase(Locale.getDefault())
+                mTitleFilterList.add(filter)
+            }
+
+            MODE_TAG -> {
+                filter.text = filter.text!!.lowercase(Locale.getDefault())
+                mTagFilterList.add(filter)
+            }
+
+            MODE_TAG_NAMESPACE -> {
+                filter.text = filter.text!!.lowercase(Locale.getDefault())
+                mTagNamespaceFilterList.add(filter)
+            }
+
+            MODE_UPLOADER -> mUploaderFilterList.add(filter)
+            MODE_COMMENTER -> mCommenterFilterList.add(filter)
+            MODE_COMMENT -> mCommentFilterList.add(filter)
+            else -> Log.d(TAG, "Unknown mode: " + filter.mode)
+        }
+        return true
+    }
+
+    @Synchronized
+    fun triggerFilter(filter: Filter?) {
+        EhDB.triggerFilter(filter)
+    }
+
+    @Synchronized
+    fun deleteFilter(filter: Filter) {
+        EhDB.deleteFilter(filter)
+        when (filter.mode) {
+            MODE_TITLE -> mTitleFilterList.remove(filter)
+            MODE_TAG -> mTagFilterList.remove(filter)
+            MODE_TAG_NAMESPACE -> mTagNamespaceFilterList.remove(filter)
+            MODE_UPLOADER -> mUploaderFilterList.remove(filter)
+            MODE_COMMENTER -> mCommenterFilterList.remove(filter)
+            MODE_COMMENT -> mCommentFilterList.remove(filter)
+            else -> Log.d(TAG, "Unknown mode: " + filter.mode)
+        }
+    }
+
+    @Synchronized
+    fun needTags(): Boolean {
+        return 0 != mTagFilterList.size || 0 != mTagNamespaceFilterList.size
+    }
+
+    @Synchronized
+    fun filterTitle(info: GalleryInfo?): Boolean {
+        if (null == info) {
+            return false
+        }
+
+        // Title
+        val title = info.title
+        val filters: List<Filter> = mTitleFilterList
+        if (null != title && filters.isNotEmpty()) {
+            var i = 0
+            val n = filters.size
+            while (i < n) {
+                if (filters[i].enable!! && title.lowercase(Locale.getDefault()).contains(
+                        filters[i].text!!
+                    )
+                ) {
+                    return false
+                }
+                i++
+            }
+        }
+        return true
+    }
+
+    @Synchronized
+    fun filterUploader(info: GalleryInfo?): Boolean {
+        if (null == info) {
+            return false
+        }
+
+        // Uploader
+        val uploader = info.uploader
+        val filters: List<Filter> = mUploaderFilterList
+        if (null != uploader && filters.isNotEmpty()) {
+            var i = 0
+            val n = filters.size
+            while (i < n) {
+                if (filters[i].enable!! && uploader == filters[i].text) {
+                    return false
+                }
+                i++
+            }
+        }
+        return true
+    }
+
+    private fun matchTag(tag: String?, filter: String?): Boolean {
+        if (null == tag || null == filter) {
+            return false
+        }
+        val tagNamespace: String?
+        val tagName: String
+        val filterNamespace: String?
+        val filterName: String
+        var index = tag.indexOf(':')
+        if (index < 0) {
+            tagNamespace = null
+            tagName = tag
+        } else {
+            tagNamespace = tag.substring(0, index)
+            tagName = tag.substring(index + 1)
+        }
+        index = filter.indexOf(':')
+        if (index < 0) {
+            filterNamespace = null
+            filterName = filter
+        } else {
+            filterNamespace = filter.substring(0, index)
+            filterName = filter.substring(index + 1)
+        }
+        return if (null != tagNamespace && null != filterNamespace &&
+            tagNamespace != filterNamespace
+        ) {
+            false
+        } else tagName == filterName
+    }
+
+    @Synchronized
+    fun filterTag(info: GalleryInfo?): Boolean {
+        if (null == info) {
+            return false
+        }
+
+        // Tag
+        val tags = info.simpleTags
+        val filters: List<Filter> = mTagFilterList
+        if (null != tags && filters.isNotEmpty()) {
+            for (tag in tags) {
+                var i = 0
+                val n = filters.size
+                while (i < n) {
+                    if (filters[i].enable!! && matchTag(tag, filters[i].text)) {
+                        return false
+                    }
+                    i++
+                }
+            }
+        }
+        return true
+    }
+
+    private fun matchTagNamespace(tag: String?, filter: String?): Boolean {
+        if (null == tag || null == filter) {
+            return false
+        }
+        val tagNamespace: String
+        val index = tag.indexOf(':')
+        return if (index >= 0) {
+            tagNamespace = tag.substring(0, index)
+            tagNamespace == filter
+        } else {
+            false
+        }
+    }
+
+    @Synchronized
+    fun filterTagNamespace(info: GalleryInfo?): Boolean {
+        if (null == info) {
+            return false
+        }
+        val tags = info.simpleTags
+        val filters: List<Filter> = mTagNamespaceFilterList
+        if (null != tags && filters.isNotEmpty()) {
+            for (tag in tags) {
+                var i = 0
+                val n = filters.size
+                while (i < n) {
+                    if (filters[i].enable!! && matchTagNamespace(tag, filters[i].text)) {
+                        return false
+                    }
+                    i++
+                }
+            }
+        }
+        return true
+    }
+
+    @Synchronized
+    fun filterCommenter(commenter: String?): Boolean {
+        if (null == commenter) {
+            return false
+        }
+        val filters: List<Filter> = mCommenterFilterList
+        if (filters.isNotEmpty()) {
+            var i = 0
+            val n = filters.size
+            while (i < n) {
+                if (filters[i].enable!! && commenter == filters[i].text) {
+                    return false
+                }
+                i++
+            }
+        }
+        return true
+    }
+
+    @Synchronized
+    fun filterComment(comment: String?): Boolean {
+        if (null == comment) {
+            return false
+        }
+        val filters: List<Filter> = mCommentFilterList
+        if (filters.isNotEmpty()) {
+            var i = 0
+            val n = filters.size
+            while (i < n) {
+                if (filters[i].enable!!) {
+                    val p = Pattern.compile(filters[i].text!!)
+                    val m = p.matcher(comment)
+                    if (m.find()) return false
+                }
+                i++
+            }
+        }
+        return true
+    }
+}
@@ -1,79 +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.ehviewer.client;
-
-import com.hippo.ehviewer.Settings;
-
-public class EhRequest {
-
-    EhClient.Task task;
-    private int mMethod;
-    private Object[] mArgs;
-    private EhClient.Callback mCallback;
-    private EhConfig mEhConfig;
-    private boolean mCancel = false;
-
-    public int getMethod() {
-        return mMethod;
-    }
-
-    public EhRequest setMethod(int method) {
-        mMethod = method;
-        return this;
-    }
-
-    public Object[] getArgs() {
-        return mArgs;
-    }
-
-    public EhRequest setArgs(Object... args) {
-        mArgs = args;
-        return this;
-    }
-
-    public EhClient.Callback getCallback() {
-        return mCallback;
-    }
-
-    public EhRequest setCallback(EhClient.Callback callback) {
-        mCallback = callback;
-        return this;
-    }
-
-    public EhConfig getEhConfig() {
-        return mEhConfig != null ? mEhConfig : Settings.getEhConfig();
-    }
-
-    public EhRequest setEhConfig(EhConfig ehConfig) {
-        mEhConfig = ehConfig;
-        return this;
-    }
-
-    public void cancel() {
-        if (!mCancel) {
-            mCancel = true;
-            if (task != null) {
-                task.stop();
-                task = null;
-            }
-        }
-    }
-
-    public boolean isCancelled() {
-        return mCancel;
-    }
-}
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2016 Hippo Seven
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.hippo.ehviewer.client
+
+import android.app.Activity
+import androidx.annotation.MainThread
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import androidx.lifecycle.lifecycleScope
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.Job
+
+class EhRequest {
+    internal var job: Job? = null
+    val isActive
+        get() = job?.isActive ?: false
+    var method = 0
+        private set
+    var args: Array<out Any?>? = null
+        private set
+    var callback: EhClient.Callback<Any?>? = null
+        private set
+
+    fun setMethod(method: Int): EhRequest {
+        this.method = method
+        return this
+    }
+
+    fun setArgs(vararg args: Any?): EhRequest {
+        this.args = args
+        return this
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    fun setCallback(callback: EhClient.Callback<*>?): EhRequest {
+        this.callback = callback as EhClient.Callback<Any?>?
+        return this
+    }
+
+    fun enqueue(scope: CoroutineScope) {
+        EhClient.enqueue(this, scope)
+    }
+
+    @DelicateCoroutinesApi
+    fun enqueue() {
+        EhClient.enqueue(this, GlobalScope)
+    }
+
+    fun enqueue(fragment: Fragment) {
+        enqueue(fragment.viewLifecycleOwner.lifecycleScope)
+    }
+
+    fun enqueue(activity: Activity) {
+        check(activity is FragmentActivity)
+        enqueue(activity.lifecycleScope)
+    }
+
+    @MainThread
+    fun cancel() {
+        if (isActive) {
+            job?.cancel()
+            callback?.onCancel()
+        }
+    }
+}
@@ -1,61 +0,0 @@
-package com.hippo.ehviewer.client;
-
-import android.util.Log;
-
-import com.hippo.ehviewer.Settings;
-
-import java.io.IOException;
-import java.net.InetAddress;
-import java.net.Socket;
-
-import javax.net.ssl.SSLSession;
-import javax.net.ssl.SSLSocket;
-import javax.net.ssl.SSLSocketFactory;
-
-public class EhSSLSocketFactory extends SSLSocketFactory {
-    @Override
-    public String[] getDefaultCipherSuites() {
-        return ((SSLSocketFactory) getDefault()).getDefaultCipherSuites();
-    }
-
-    @Override
-    public String[] getSupportedCipherSuites() {
-        return ((SSLSocketFactory) getDefault()).getSupportedCipherSuites();
-    }
-
-    @Override
-    public Socket createSocket(Socket s, String host, int port, boolean autoClose) throws IOException {
-        SSLSocketFactory defaultFactory = (SSLSocketFactory) getDefault();
-        if (!Settings.getDF()) {
-            return defaultFactory.createSocket(s, host, port, autoClose);
-        }
-        String address = s.getInetAddress().getHostAddress();
-        SSLSocket socket = (SSLSocket) defaultFactory.createSocket(s, address, port, autoClose);
-        SSLSession sslSession = socket.getSession();
-        Log.d("EhSSLSocketFactory", "Host: " + host + " Address: " + address + " Protocol:" + sslSession.getProtocol() + " CipherSuite:" + sslSession.getCipherSuite());
-        socket.setEnabledProtocols(socket.getSupportedProtocols());
-        return socket;
-    }
-
-    @Override
-    public Socket createSocket(String host, int port) throws IOException {
-        return getDefault().createSocket(host, port);
-    }
-
-    @Override
-    public Socket createSocket(String host, int port, InetAddress localHost, int localPort) throws IOException {
-        return getDefault().createSocket(host, port, localHost, localPort);
-    }
-
-    @Override
-    public Socket createSocket(InetAddress host, int port) throws IOException {
-        return getDefault().createSocket(host, port);
-    }
-
-    @Override
-    public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException {
-        return getDefault().createSocket(address, port, localAddress, localPort);
-    }
-
-
-}
@@ -0,0 +1,72 @@
+/*
+ * 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
+import java.net.InetAddress
+import java.net.Socket
+import javax.net.ssl.SSLSocket
+import javax.net.ssl.SSLSocketFactory
+
+object EhSSLSocketFactory : SSLSocketFactory() {
+    private val sslSocketFactory = getDefault() as SSLSocketFactory
+    override fun getDefaultCipherSuites(): Array<String> {
+        return sslSocketFactory.defaultCipherSuites
+    }
+
+    override fun getSupportedCipherSuites(): Array<String> {
+        return sslSocketFactory.supportedCipherSuites
+    }
+
+    override fun createSocket(s: Socket, host: String, port: Int, autoClose: Boolean): Socket {
+        val address = s.inetAddress.hostAddress
+        val socket = sslSocketFactory.createSocket(s, address, port, autoClose) as SSLSocket
+        val sslSession = socket.session
+        Log.d(
+            "EhSSLSocketFactory",
+            "Host: " + host + " Address: " + address + " Protocol:" + sslSession.protocol + " CipherSuite:" + sslSession.cipherSuite
+        )
+        return socket
+    }
+
+    override fun createSocket(host: String, port: Int): Socket {
+        return sslSocketFactory.createSocket(host, port)
+    }
+
+    override fun createSocket(
+        host: String,
+        port: Int,
+        localHost: InetAddress,
+        localPort: Int
+    ): Socket {
+        return sslSocketFactory.createSocket(host, port, localHost, localPort)
+    }
+
+    override fun createSocket(host: InetAddress, port: Int): Socket {
+        return sslSocketFactory.createSocket(host, port)
+    }
+
+    override fun createSocket(
+        address: InetAddress,
+        port: Int,
+        localAddress: InetAddress,
+        localPort: Int
+    ): Socket {
+        return sslSocketFactory.createSocket(address, port, localAddress, localPort)
+    }
+}
@@ -1,436 +0,0 @@
-/*
- * Copyright 2019 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;
-
-import android.content.Context;
-import android.util.Base64;
-
-import androidx.annotation.Nullable;
-import androidx.core.util.Pair;
-
-import com.hippo.ehviewer.AppConfig;
-import com.hippo.ehviewer.EhApplication;
-import com.hippo.ehviewer.R;
-import com.hippo.util.ExceptionUtils;
-import com.hippo.util.IoThreadPoolExecutor;
-import com.hippo.yorozuya.FileUtils;
-import com.hippo.yorozuya.IOUtils;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.nio.charset.StandardCharsets;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
-
-import okhttp3.Call;
-import okhttp3.OkHttpClient;
-import okhttp3.Request;
-import okhttp3.Response;
-import okhttp3.ResponseBody;
-import okio.BufferedSource;
-import okio.Okio;
-
-public class EhTagDatabase {
-
-    private static final Map<String, String> NAMESPACE_TO_PREFIX = new HashMap<>();
-    // TODO more lock for different language
-    private static final Lock lock = new ReentrantLock();
-    private static volatile EhTagDatabase instance;
-
-    static {
-        NAMESPACE_TO_PREFIX.put("artist", "a:");
-        NAMESPACE_TO_PREFIX.put("cosplayer", "cos:");
-        NAMESPACE_TO_PREFIX.put("character", "c:");
-        NAMESPACE_TO_PREFIX.put("female", "f:");
-        NAMESPACE_TO_PREFIX.put("group", "g:");
-        NAMESPACE_TO_PREFIX.put("language", "l:");
-        NAMESPACE_TO_PREFIX.put("male", "m:");
-        NAMESPACE_TO_PREFIX.put("mixed", "x:");
-        NAMESPACE_TO_PREFIX.put("other", "o:");
-        NAMESPACE_TO_PREFIX.put("parody", "p:");
-        NAMESPACE_TO_PREFIX.put("reclass", "r:");
-    }
-
-    private final String name;
-    private final byte[] tags;
-
-    public EhTagDatabase(String name, BufferedSource source) throws IOException {
-        this.name = name;
-        String[] tmp;
-        StringBuilder buffer = new StringBuilder();
-        source.readInt();
-        for (String i : source.readUtf8().split("\n")) {
-            tmp = i.split("\r", 2);
-            buffer.append(tmp[0]);
-            buffer.append("\r");
-            try {
-                buffer.append(new String(Base64.decode(tmp[1], Base64.DEFAULT), StandardCharsets.UTF_8));
-            } catch (Exception e) {
-                buffer.append(tmp[1]);
-            }
-            buffer.append("\n");
-        }
-        byte[] b = buffer.toString().getBytes(StandardCharsets.UTF_8);
-        int totalBytes = b.length;
-        tags = new byte[totalBytes];
-        System.arraycopy(b, 0, tags, 0, totalBytes);
-    }
-
-    @Nullable
-    public static EhTagDatabase getInstance(Context context) {
-        if (isPossible(context)) {
-            return instance;
-        } else {
-            instance = null;
-            return null;
-        }
-    }
-
-    @Nullable
-    public static String namespaceToPrefix(String namespace) {
-        return NAMESPACE_TO_PREFIX.get(namespace);
-    }
-
-    private static String[] getMetadata(Context context) {
-        String[] metadata = context.getResources().getStringArray(R.array.tag_translation_metadata);
-        if (metadata.length == 4) {
-            return metadata;
-        } else {
-            return null;
-        }
-    }
-
-    public static boolean isPossible(Context context) {
-        return getMetadata(context) != null;
-    }
-
-    @Nullable
-    private static byte[] getFileContent(File file, int length) {
-        try (BufferedSource source = Okio.buffer(Okio.source(file))) {
-            byte[] content = new byte[length];
-            source.readFully(content);
-            return content;
-        } catch (IOException e) {
-            return null;
-        }
-    }
-
-    @Nullable
-    private static byte[] getFileSha1(File file) {
-        try (InputStream is = new FileInputStream(file)) {
-            MessageDigest digest = MessageDigest.getInstance("SHA-1");
-            int n;
-            byte[] buffer = new byte[4 * 1024];
-            while ((n = is.read(buffer)) != -1) {
-                digest.update(buffer, 0, n);
-            }
-            return digest.digest();
-        } catch (IOException | NoSuchAlgorithmException e) {
-            return null;
-        }
-    }
-
-    private static boolean equals(byte[] b1, byte[] b2) {
-        if (b1 == null && b2 == null) {
-            return true;
-        }
-        if (b1 == null || b2 == null) {
-            return false;
-        }
-
-        if (b1.length != b2.length) {
-            return false;
-        }
-
-        for (int i = 0; i < b1.length; i++) {
-            if (b1[i] != b2[i]) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    private static boolean checkData(File sha1File, File dataFile) {
-        byte[] s1 = getFileContent(sha1File, 20);
-        if (s1 == null) {
-            return false;
-        }
-
-        byte[] s2 = getFileSha1(dataFile);
-        if (s2 == null) {
-            return false;
-        }
-
-        return equals(s1, s2);
-    }
-
-    private static boolean save(OkHttpClient client, String url, File file) {
-        Request request = new Request.Builder().url(url).build();
-        Call call = client.newCall(request);
-        try (Response response = call.execute()) {
-            if (!response.isSuccessful()) {
-                return false;
-            }
-            ResponseBody body = response.body();
-            if (body == null) {
-                return false;
-            }
-
-            try (InputStream is = body.byteStream(); OutputStream os = new FileOutputStream(file)) {
-                IOUtils.copy(is, os);
-            }
-
-            return true;
-        } catch (Throwable t) {
-            t.printStackTrace();
-            ExceptionUtils.throwIfFatal(t);
-            return false;
-        }
-    }
-
-    public static void update(Context context) {
-        String[] urls = getMetadata(context);
-        if (urls == null || urls.length != 4) {
-            // Clear tags if it's not possible
-            instance = null;
-            return;
-        }
-
-        String sha1Name = urls[0];
-        String sha1Url = urls[1];
-        String dataName = urls[2];
-        String dataUrl = urls[3];
-
-        // Clear tags if name if different
-        EhTagDatabase tmp = instance;
-        if (tmp != null && !tmp.name.equals(dataName)) {
-            instance = null;
-        }
-
-        IoThreadPoolExecutor.getInstance().execute(() -> {
-            if (!lock.tryLock()) {
-                return;
-            }
-
-            try {
-                File dir = AppConfig.getFilesDir("tag-translations");
-                if (dir == null) {
-                    return;
-                }
-
-                // Check current sha1 and current data
-                File sha1File = new File(dir, sha1Name);
-                File dataFile = new File(dir, dataName);
-                if (!checkData(sha1File, dataFile)) {
-                    FileUtils.delete(sha1File);
-                    FileUtils.delete(dataFile);
-                }
-
-                // Read current EhTagDatabase
-                if (instance == null && dataFile.exists()) {
-                    try (BufferedSource source = Okio.buffer(Okio.source(dataFile))) {
-                        instance = new EhTagDatabase(dataName, source);
-                    } catch (IOException e) {
-                        FileUtils.delete(sha1File);
-                        FileUtils.delete(dataFile);
-                    }
-                }
-
-                OkHttpClient client = EhApplication.getOkHttpClient(context);
-
-                // Save new sha1
-                File tempSha1File = new File(dir, sha1Name + ".tmp");
-                if (!save(client, sha1Url, tempSha1File)) {
-                    FileUtils.delete(tempSha1File);
-                    return;
-                }
-
-                // Check new sha1 and current data
-                if (checkData(tempSha1File, dataFile)) {
-                    // The data is the same
-                    FileUtils.delete(tempSha1File);
-                    return;
-                }
-
-                // Save new data
-                File tempDataFile = new File(dir, dataName + ".tmp");
-                if (!save(client, dataUrl, tempDataFile)) {
-                    FileUtils.delete(tempDataFile);
-                    return;
-                }
-
-                // Check new sha1 and new data
-                if (!checkData(tempSha1File, tempDataFile)) {
-                    FileUtils.delete(tempSha1File);
-                    FileUtils.delete(tempDataFile);
-                    return;
-                }
-
-                // Replace current sha1 and current data with new sha1 and new data
-                FileUtils.delete(sha1File);
-                FileUtils.delete(dataFile);
-                tempSha1File.renameTo(sha1File);
-                tempDataFile.renameTo(dataFile);
-
-                // Read new EhTagDatabase
-                try (BufferedSource source = Okio.buffer(Okio.source(dataFile))) {
-                    instance = new EhTagDatabase(dataName, source);
-                } catch (IOException e) {
-                    // Ignore
-                }
-            } finally {
-                lock.unlock();
-            }
-        });
-    }
-
-    public String getTranslation(String tag) {
-        return search(tags, tag.getBytes(StandardCharsets.UTF_8));
-    }
-
-    @Nullable
-    private String search(byte[] tags, byte[] tag) {
-        int low = 0;
-        int high = tags.length;
-        while (low < high) {
-            int start = (low + high) / 2;
-            // Look for the starting '\n'
-            while (start > -1 && tags[start] != '\n') {
-                start--;
-            }
-            start++;
-
-            // Look for the middle '\r'.
-            int middle = 1;
-            while (tags[start + middle] != '\r') {
-                middle++;
-            }
-
-            // Look for the ending '\n'
-            int end = middle + 1;
-            while (tags[start + end] != '\n') {
-                end++;
-            }
-
-            int compare;
-            int tagIndex = 0;
-            int curIndex = start;
-
-            for (; ; ) {
-                int tagByte = tag[tagIndex] & 0xff;
-                int curByte = tags[curIndex] & 0xff;
-                compare = tagByte - curByte;
-                if (compare != 0) {
-                    break;
-                }
-
-                tagIndex++;
-                curIndex++;
-                if (tagIndex == tag.length && curIndex == start + middle) {
-                    break;
-                }
-                if (tagIndex == tag.length) {
-                    compare = -1;
-                    break;
-                }
-                if (curIndex == start + middle) {
-                    compare = 1;
-                    break;
-                }
-            }
-
-            if (compare < 0) {
-                high = start - 1;
-            } else if (compare > 0) {
-                low = start + end + 1;
-            } else {
-                return new String(tags, start + middle + 1, end - middle - 1, StandardCharsets.UTF_8);
-            }
-        }
-        return null;
-    }
-
-    public ArrayList<Pair<String, String>> suggest(String keyword) {
-        return searchTag(tags, keyword);
-    }
-
-    private ArrayList<Pair<String, String>> searchTag(byte[] tags, String keyword) {
-        ArrayList<Pair<String, String>> searchHints = new ArrayList<>();
-        int begin = 0;
-        while (begin < tags.length - 1) {
-            int start = begin;
-            // Look for the starting '\n'
-            while (tags[start] != '\n') {
-                start++;
-            }
-
-            // Look for the middle '\r'.
-            int middle = 1;
-            while (tags[start + middle] != '\r') {
-                middle++;
-            }
-
-            // Look for the ending '\n'
-            int end = middle + 1;
-            while (tags[start + end] != '\n') {
-                end++;
-            }
-
-            begin = start + end;
-
-            byte[] hintBytes = new byte[end - middle - 1];
-            System.arraycopy(tags, start + middle + 1, hintBytes, 0, end - middle - 1);
-            String hint = new String(hintBytes, StandardCharsets.UTF_8);
-            byte[] tagBytes = new byte[middle];
-            System.arraycopy(tags, start + 1, tagBytes, 0, middle);
-            String tag = new String(tagBytes, StandardCharsets.UTF_8);
-            int index = tag.indexOf(':');
-            boolean keywordMatches;
-            if (index == -1 || index >= tag.length() - 1 || keyword.length() > 2) {
-                keywordMatches = containsIgnoreSpace(tag, keyword);
-            } else {
-                keywordMatches = containsIgnoreSpace(tag.substring(index + 1), keyword);
-            }
-
-            if (keywordMatches || containsIgnoreSpace(hint, keyword)) {
-                Pair<String, String> pair = new Pair<>(hint, tag);
-                if (!searchHints.contains(pair)) {
-                    searchHints.add(pair);
-                }
-            }
-            if (searchHints.size() > 20) {
-                break;
-            }
-
-        }
-        return searchHints;
-    }
-
-    private boolean containsIgnoreSpace(String text, String key) {
-        return text.replace(" ", "").contains(key.replace(" ", ""));
-    }
-}