Release v2.1.1867

Update electron (#1556 )
Fix handling of too long page image urls migration (#1552 )
2025-07-31 13:56:03 -04:00 · 2025-07-31 12:01:33 -04:00 · 2025-07-29 18:00:10 -04:00 · 2025-07-25 19:42:06 -04:00 · 2025-07-25 19:42:00 -04:00 · 2025-07-21 22:20:58 -04:00
612 changed files with 67020 additions and 6925 deletions
@@ -0,0 +1,11 @@
+[*.{kt,kts}]
+indent_size=4
+insert_final_newline=true
+ij_kotlin_allow_trailing_comma=true
+ij_kotlin_allow_trailing_comma_on_call_site=true
+ij_kotlin_name_count_to_use_star_import=2147483647
+ij_kotlin_name_count_to_use_star_import_for_members=2147483647
+
+ktlint_standard_discouraged-comment-location=disabled
+ktlint_standard_if-else-wrapping=disabled
+ktlint_standard_no-consecutive-comments=disabled
@@ -25,4 +25,7 @@
 *.pyc binary
 *.swp binary
 *.pdf binary
-*.exe binary
+*.exe binary
+*.avif binary
+*.heif binary
+*.jxl binary
@@ -1,44 +0,0 @@
---
-name: "🐞 Bug report"
-title: "[Bug] <short description>"
-about: "Report a bug"
-labels: "bug"
---
-
-**PLEASE READ THIS**
-
-I acknowledge that:
-
- I have updated to the latest version of the app.
- I have tried the troubleshooting guide described in `README.md`
- If this is a request for adding/changing an extension it should be brought up to Tachiyomi: https://github.com/tachiyomiorg/tachiyomi-extensions/issues/new/choose
- If this is an issue with some extension not working properly, It does work inside Tachiyomi as intended.
- I have searched the existing issues and this is a new ticket **NOT** a duplicate or related to another open issue
- I will fill out the title and the information in this template
-
-Note that the issue will be automatically closed if you do not fill out the title or requested information.
-
-**DELETE THIS SECTION IF YOU HAVE READ AND ACKNOWLEDGED IT**
-
---
-
-## Device information
- Tachidesk version: (Example: v0.2.3-r255-win32)
- Server Operating System: (Example: Ubuntu 20.04)
- Server Desktop Environment: N/A or (Example: Gnome 40)
- Server JVM version: bundled with win32 or (Example: Java 8 Update 281 or OpenJDK 8u281)
- Client Operating System: <usually the same as above Server Operating System>
- Client Web Browser: (Example: Google Chrome 89.0.4389.82) 
-
-## Steps to reproduce
-1. First Step
-2. Second Step
-
-### Expected behavior
-Describe what should have happened. Remove this line after you are done.
-
-### Actual behavior
-Describe what happens instead. Remove this line after you are done.
-
-## Other details
-Describe additional details If necessary. Remove this line after you are done.
@@ -0,0 +1,144 @@
+name: 🐞 Bug report
+description: Report a bug in Suwayomi-Server
+labels: [bug]
+body:
+
+  - type: textarea
+    id: reproduce-steps
+    attributes:
+      label: Steps to reproduce
+      description: Provide an example of the issue.
+      placeholder: |
+        Example:
+          1. First step
+          2. Second step
+          3. Issue here
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected-behavior
+    attributes:
+      label: Expected behavior
+      description: Explain what you should expect to happen.
+      placeholder: |
+        Example: "This should happen..."
+    validations:
+      required: true
+
+  - type: textarea
+    id: actual-behavior
+    attributes:
+      label: Actual behavior
+      description: Explain what actually happens.
+      placeholder: |
+        Example: "This happened instead..."
+    validations:
+      required: true
+
+  - type: input
+    id: suwayomi-server-version
+    attributes:
+      label: Suwayomi-Server version
+      description: You can find your Suwayomi-Server version in **More → About**.
+      placeholder: |
+        Example: "v2.1.1867"
+    validations:
+      required: true
+
+  - type: input
+    id: server-os
+    attributes:
+      label: Server operating system
+      description: The operating system on which Suwayomi-Server is running on
+      placeholder: |
+        Example: "Windows 11 Pro 24H2 | Ubuntu 24.04.2 LTS"
+    validations:
+      required: true
+
+  - type: input
+    id: server-desktop-environment
+    attributes:
+      label: Server Desktop Environment
+      description:
+      placeholder: |
+        Example: "Gnome 40"
+    validations:
+      required: false
+
+  - type: input
+    id: server-jvm-version
+    attributes:
+      label: Server JVM version
+      description: The java version used to run Suwayomi-Server
+      placeholder: |
+        Example: "openjdk 21.0.5 2024-10-15 LTS"
+    validations:
+      required: true
+
+  - type: input
+    id: client-name
+    attributes:
+      label: Used client name
+      description:
+      placeholder: |
+        Example: "Suwayomi-WebUI"
+    validations:
+      required: true
+
+  - type: input
+    id: client-version
+    attributes:
+      label: Client version
+      description:
+      placeholder: |
+        Example: "v1.2.3"
+    validations:
+      required: true
+
+  - type: input
+    id: client-browser
+    attributes:
+      label: Used web browser
+      description: The browser which is used to open Suwayomi-WebUI
+      placeholder: |
+        Example: "Chrome 134.0.6998.118 (64-Bit) | FireFox 136.0.2 (64-Bit) | Electron v35.0.2"
+    validations:
+      required: true
+
+  - type: input
+    id: client-os
+    attributes:
+      label: Client operating system
+      description: The system on which the Suwayomi-WebUI is running on
+      placeholder: |
+        Example: "Windows 11 Pro 24H2 | Ubuntu 24.04.2 LTS"
+    validations:
+      required: true
+
+  - type: textarea
+    id: other-details
+    attributes:
+      label: Other details
+      description: The more information that gets provided the better, especially via videos and images
+      placeholder: |
+        Additional details and attachments.
+
+  - type: checkboxes
+    id: acknowledgements
+    attributes:
+      label: Acknowledgements
+      description: Read this carefully, we will close and ignore your issue if you skimmed through this.
+      options:
+        - label: I have searched the existing issues and this is a new ticket, **NOT** a duplicate or related to another open or closed issue.
+          required: true
+        - label: I have written a short but informative title (ideally less than ~100 characters).
+          required: true
+        - label: I have tried the troubleshooting guide described in [README.md](https://github.com/Suwayomi/Suwayomi-Server?tab=readme-ov-file#troubleshooting-and-support)
+          required: true
+        - label: I have updated to the **[latest version](https://github.com/suwayomi/suwayomi-server/releases/latest)**.
+          required: true
+        - label: I have filled out all of the requested information in this form, including specific version numbers.
+          required: true
+        - label: I understand that **Suwayomi does not have or fix any extensions**, and I **will not receive help** for any issues related to sources or extensions.
+          required: true
@@ -1 +1,5 @@
 blank_issues_enabled: false
+contact_links:
+  - name: ☎️ Support
+    url: https://discord.gg/DDZdqZWaHA
+    about: Join our discord to get help for anything that is not a bug or a feature request
@@ -1,29 +0,0 @@
---
-name: "🌟 Feature request"
-title: "[Feature Request] <short description>"
-about: "Suggest a feature to improve the project"
-labels: "enhancement"
---
-
-**PLEASE READ THIS**
-
-I acknowledge that:
-
- I have updated to the latest version of the app.
- I have tried the troubleshooting guide described in `README.md`
- If this is a request for adding/changing an extension it should be brought up to Tachiyomi: https://github.com/tachiyomiorg/tachiyomi-extensions/issues/new/choose
- If this is an issue with some extension not working properly, It does work in Tachiyomi application as intended.
- I have searched the existing issues and this is a new ticket **NOT** a duplicate or related to another open issue
- I will fill out the title and the information in this template
-
-Note that the issue will be automatically closed if you do not fill out the title or requested information.
-
-**DELETE THIS SECTION IF YOU HAVE READ AND ACKNOWLEDGED IT**
-
---
-
-## What feature should be added to Tachidesk?
-Explain What the feature is and how it should work in detail. Remove this line after you are done.
-
-##  Why/Project's Benefit/Existing Problem
-Explain why this should be added. Remove this line after you are done.
@@ -0,0 +1,37 @@
+name: 🌟 Feature request
+description: Suggest a feature to improve Suwayomi-Server
+labels: [enhancement]
+body:
+
+  - type: textarea
+    id: feature-description
+    attributes:
+      label: Describe your suggested feature
+      description: How can Suwayomi-Server be improved?
+      placeholder: |
+        Example:
+          "It should work like this..."
+    validations:
+      required: true
+
+  - type: textarea
+    id: other-details
+    attributes:
+      label: Other details
+      placeholder: |
+        Additional details and attachments.
+
+  - type: checkboxes
+    id: acknowledgements
+    attributes:
+      label: Acknowledgements
+      description: Read this carefully, we will close and ignore your issue if you skimmed through this.
+      options:
+        - label: I have searched the existing issues and this is a new ticket, **NOT** a duplicate or related to another open or closed issue.
+          required: true
+        - label: I have written a short but informative title (ideally less than ~100 characters).
+          required: true
+        - label: I have updated to the **[latest version](https://github.com/suwayomi/suwayomi-server/releases/latest)**.
+          required: true
+        - label: I have filled out all of the requested information in this form, including specific version numbers.
+          required: true
@@ -3,6 +3,10 @@ name: CI Pull Request
 on:
  pull_request:

+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
  check_wrapper:
    name: Validate Gradle Wrapper
@@ -10,34 +14,32 @@ jobs:

    steps:
      - name: Clone repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4

      - name: Validate Gradle Wrapper
-        uses: gradle/wrapper-validation-action@v1
+        uses: gradle/actions/wrapper-validation@v4

  build:
    name: Build pull request
    needs: check_wrapper
-    if: "!startsWith(github.event.head_commit.message, '[SKIP CI]')"
    runs-on: ubuntu-latest

    steps:
-      - name: Cancel previous runs
-        uses: styfle/cancel-workflow-action@0.9.0
-        with:
-          access_token: ${{ github.token }}
-
      - name: Checkout pull request
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
        with:
          ref: ${{ github.event.pull_request.head.sha }}
          path: master
          fetch-depth: 0

-      - name: Set up JDK 1.8
-        uses: actions/setup-java@v1
+      - name: Set up JDK
+        uses: actions/setup-java@v4
        with:
-          java-version: 1.8
+          java-version: 21
+          distribution: 'temurin'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4

      - name: Copy CI gradle.properties
        run: |
@@ -45,13 +47,7 @@ jobs:
          mkdir -p ~/.gradle
          cp .github/runner-files/ci-gradle.properties ~/.gradle/gradle.properties

-
      - name: Build Jar
-        uses: eskatos/gradle-command-action@v1
-        with:
-          build-root-directory: master
-          wrapper-directory: master
-          arguments: :server:shadowJar --stacktrace
-          wrapper-cache-enabled: true
-          dependencies-cache-enabled: true
-          configuration-cache-enabled: true
+        working-directory: master
+        run: ./gradlew ktlintCheck :server:shadowJar --stacktrace
+
@@ -5,41 +5,41 @@ on:
    branches:
      - master

+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
  check_wrapper:
    name: Validate Gradle Wrapper
    runs-on: ubuntu-latest
-
    steps:
      - name: Clone repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4

      - name: Validate Gradle Wrapper
-        uses: gradle/wrapper-validation-action@v1
+        uses: gradle/actions/wrapper-validation@v4

  build:
-    name: Build artifacts and deploy preview
+    name: Build Jar
    needs: check_wrapper
-    if: "!startsWith(github.event.head_commit.message, '[SKIP CI]')"
    runs-on: ubuntu-latest
-
    steps:
-      - name: Cancel previous runs
-        uses: styfle/cancel-workflow-action@0.9.0
-        with:
-          access_token: ${{ github.token }}
-
      - name: Checkout master branch
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
        with:
          ref: master
          path: master
          fetch-depth: 0

-      - name: Set up JDK 1.8
-        uses: actions/setup-java@v1
+      - name: Set up JDK
+        uses: actions/setup-java@v4
        with:
-          java-version: 1.8
+          java-version: 21
+          distribution: 'temurin'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4

      - name: Copy CI gradle.properties
        run: |
@@ -48,42 +48,180 @@ jobs:
          cp .github/runner-files/ci-gradle.properties ~/.gradle/gradle.properties

      - name: Build Jar
-        uses: eskatos/gradle-command-action@v1
        env:
          ProductBuildType: "Preview"
+        working-directory: master
+        run: ./gradlew :server:shadowJar --stacktrace
+
+      - name: Upload Jar
+        uses: actions/upload-artifact@v4
        with:
-          build-root-directory: master
-          wrapper-directory: master
-          arguments: :server:shadowJar --stacktrace
-          wrapper-cache-enabled: true
-          dependencies-cache-enabled: true
-          configuration-cache-enabled: true
+          name: jar
+          path: master/server/build/*.jar
+          if-no-files-found: error
+
+      - name: Upload icons
+        uses: actions/upload-artifact@v4
+        with:
+          name: icon
+          path: master/server/src/main/resources/icon
+          if-no-files-found: error
+
+      - name: Tar scripts dir to maintain file permissions
+        run: tar -cvzf scripts.tar.gz -C master/ scripts/
+
+      - name: Upload scripts.tar.gz
+        uses: actions/upload-artifact@v4
+        with:
+          name: scripts
+          path: scripts.tar.gz
+          if-no-files-found: error
+
+  jlink:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            name: linux-x64
+          - os: windows-latest
+            name: windows-x64
+          - os: macos-14
+            name: macOS-arm64
+          - os: macos-13
+            name: macOS-x64
+        os: [ubuntu-latest, windows-latest, macos-14, macos-13]
+
+    steps:
+      - name: Set up JDK
+        uses: actions/setup-java@v4
+        with:
+          java-version: 21
+          distribution: 'temurin'
+
+      - name: Package JDK
+        run: jlink --add-modules java.base,java.compiler,java.datatransfer,java.desktop,java.instrument,java.logging,java.management,java.naming,java.prefs,java.scripting,java.se,java.security.jgss,java.security.sasl,java.sql,java.transaction.xa,java.xml,jdk.attach,jdk.crypto.ec,jdk.jdi,jdk.management,jdk.net,jdk.random,jdk.unsupported,jdk.unsupported.desktop,jdk.zipfs --output suwa --strip-debug --no-man-pages --no-header-files --compress=2
+
+      - name: Upload JRE package
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.name }}-jre
+          path: suwa
+
+  bundle:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: debian-all
+            jre: linux-x64
+          - name: appimage
+            jre: linux-x64
+          - name: linux-assets
+            jre: linux-assets
+          - name: linux-x64
+            jre: linux-x64
+          - name: macOS-x64
+            jre: macOS-x64
+          - name: macOS-arm64
+            jre: macOS-arm64
+          - name: windows-x64
+            jre: windows-x64
+        name: [debian-all, appimage, linux-assets, linux-x64, macOS-x64, macOS-arm64, windows-x64]
+
+    name: Make ${{ matrix.name }} release
+    needs: [build, jlink]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download Jar
+        uses: actions/download-artifact@v4
+        with:
+          name: jar
+          path: server/build
+
+      - name: Download JRE
+        uses: actions/download-artifact@v4
+        if: matrix.name != 'linux-assets' && matrix.name != 'debian-all'
+        with:
+          name: ${{ matrix.jre }}-jre
+          path: jre
+
+      - name: Download icons
+        uses: actions/download-artifact@v4
+        with:
+          name: icon
+          path: server/src/main/resources/icon
+
+      - name: Download scripts.tar.gz
+        uses: actions/download-artifact@v4
+        with:
+          name: scripts
+
+      - name: Make ${{ matrix.name }} release
+        run: |
+          mkdir upload
+          tar -xvpf scripts.tar.gz
+          scripts/bundler.sh -o upload/ ${{ matrix.name }}
+
+      - name: Upload ${{ matrix.name }} release
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.name }}
+          path: upload/*
+          if-no-files-found: error
+
+  release:
+    needs: bundle
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: jar
+          path: release
+      - uses: actions/download-artifact@v4
+        with:
+          name: debian-all
+          path: release
+      - uses: actions/download-artifact@v4
+        with:
+          name: appimage
+          path: release
+      - uses: actions/download-artifact@v4
+        with:
+          name: linux-assets
+          path: release
+      - uses: actions/download-artifact@v4
+        with:
+          name: linux-x64
+          path: release
+      - uses: actions/download-artifact@v4
+        with:
+          name: macOS-x64
+          path: release
+      - uses: actions/download-artifact@v4
+        with:
+          name: macOS-arm64
+          path: release
+      - uses: actions/download-artifact@v4
+        with:
+          name: windows-x64
+          path: release
+
+      - name: Checkout Preview branch
+        uses: actions/checkout@v4
+        with:
+          repository: "Suwayomi/Suwayomi-Server-preview"
+          ref: main
+          path: preview
+          token: ${{ secrets.DEPLOY_PREVIEW_TOKEN }}

      - name: Generate Tag Name
        id: GenTagName
        run: |
-          cd master/server/build
-          genTag=$(ls *.jar | sed -e's/Tachidesk-Server-\|.jar//g')
+          cd release
+          genTag=$(ls *.jar | sed -e's/Suwayomi-Server-\|.jar//g')
          echo "$genTag"
-          echo "::set-output name=value::$genTag"
-
-      - name: make bundle packages
-        run: |
-          cd master/scripts
-          ./windows-bundler.sh win32
-          ./windows-bundler.sh win64
-          ./unix-bundler.sh linux-x64
-          ./debian-packager.sh
-          ./unix-bundler.sh macOS-x64
-          ./unix-bundler.sh macOS-arm64
-
-      - name: Checkout preview branch
-        uses: actions/checkout@v2
-        with:
-          repository: 'Suwayomi/Tachidesk-Server-preview'
-          ref: main
-          path: preview
-          token: ${{ secrets.DEPLOY_PREVIEW_TOKEN }}
+          echo "value=$genTag" >> $GITHUB_OUTPUT

      - name: Create Tag
        run: |
@@ -92,7 +230,8 @@ jobs:
          cd preview
          echo "{ \"latest\": \"$TAG\" }" > index.json
          git add index.json
-          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+          git config --global user.email \
+            "github-actions[bot]@users.noreply.github.com"
          git config --global user.name "github-actions[bot]"
          git commit -m "Updated to $TAG"
          git push origin main
@@ -101,10 +240,10 @@ jobs:
          git push origin $TAG

      - name: Upload Preview Release
-        uses: ncipollo/release-action@v1
+        uses: softprops/action-gh-release@v2
        with:
          token: ${{ secrets.DEPLOY_PREVIEW_TOKEN }}
-          artifacts: "master/server/build/*.jar,master/server/build/*.msi,master/server/build/*.zip,master/server/build/*.tar.gz,master/server/build/*.deb"
-          owner: "Suwayomi"
-          repo: "Tachidesk-Server-preview"
-          tag: ${{ steps.GenTagName.outputs.value }}
+          repository: "Suwayomi/Suwayomi-Server-preview"
+          tag_name:  ${{ steps.GenTagName.outputs.value }}
+          files: release/*
+
@@ -1,37 +0,0 @@
-name: Issue closer
-
-on:
-  issues:
-    types: [opened, edited, reopened]
-
-jobs:
-  autoclose:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Autoclose issues
-        uses: arkon/issue-closer-action@v3.0
-        with:
-          repo-token: ${{ github.token }}
-          rules: |
-            [
-              {
-                "type": "title",
-                "regex": ".*<short description>*",
-                "message": "You did not fill out the description in the title"
-              },
-              {
-                "type": "body",
-                "regex": ".*DELETE THIS SECTION IF YOU HAVE READ AND ACKNOWLEDGED IT.*",
-                "message": "The acknowledgment section was not removed"
-              },
-              {
-                "type": "body",
-                "regex": "(Tachidesk version|Server Operating System|Server Desktop Environment|Server JVM version|Client Operating System|Client Web Browser):.*(\\(Example:|<usually).*",
-                "message": "The requested information was not filled out"
-              },
-              {
-                "type": "body",
-                "regex": ".*Remove this line after you are done.*",
-                "message": "The lines requesting to be removed were not removed."
-              }
-            ]
@@ -1,79 +1,221 @@
 name: CI Publish

 on:
+  workflow_dispatch:
  push:
    tags:
      - "v*"

+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
  check_wrapper:
    name: Validate Gradle Wrapper
    runs-on: ubuntu-latest
-
    steps:
      - name: Clone repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4

      - name: Validate Gradle Wrapper
-        uses: gradle/wrapper-validation-action@v1
+        uses: gradle/actions/wrapper-validation@v4

  build:
-    name: Build artifacts and release
+    name: Build Jar
    needs: check_wrapper
    runs-on: ubuntu-latest
-
    steps:
-      - name: Cancel previous runs
-        uses: styfle/cancel-workflow-action@0.9.0
-        with:
-          access_token: ${{ github.token }}
-
      - name: Checkout ${{ github.ref }}
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
        with:
          ref: ${{ github.ref }}
          path: master
          fetch-depth: 0

-      - name: Set up JDK 1.8
-        uses: actions/setup-java@v1
+      - name: Set up JDK
+        uses: actions/setup-java@v4
        with:
-          java-version: 1.8
+          java-version: 21
+          distribution: 'temurin'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4

      - name: Copy CI gradle.properties
        run: |
          cd master
          mkdir -p ~/.gradle
-          cp .github/runner-files/ci-gradle.properties ~/.gradle/gradle.properties
+          cp .github/runner-files/ci-gradle.properties \
+            ~/.gradle/gradle.properties

      - name: Build and copy webUI, Build Jar
-        uses: eskatos/gradle-command-action@v1
        env:
          ProductBuildType: "Stable"
-        with:
-          build-root-directory: master
-          wrapper-directory: master
-          arguments: :server:downloadWebUI :server:shadowJar --stacktrace
-          wrapper-cache-enabled: true
-          dependencies-cache-enabled: true
-          configuration-cache-enabled: true
+        working-directory: master
+        run: ./gradlew :server:downloadWebUI :server:shadowJar --stacktrace

-      - name: Make bundle packages
+      - name: Upload Jar
+        uses: actions/upload-artifact@v4
+        with:
+          name: jar
+          path: master/server/build/*.jar
+          if-no-files-found: error
+
+      - name: Upload icons
+        uses: actions/upload-artifact@v4
+        with:
+          name: icon
+          path: master/server/src/main/resources/icon
+          if-no-files-found: error
+
+      - name: Tar scripts dir to maintain file permissions
+        run: tar -cvzf scripts.tar.gz -C master/ scripts/
+
+      - name: Upload scripts.tar.gz
+        uses: actions/upload-artifact@v4
+        with:
+          name: scripts
+          path: scripts.tar.gz
+          if-no-files-found: error
+
+  jlink:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            name: linux-x64
+          - os: windows-latest
+            name: windows-x64
+          - os: macos-14
+            name: macOS-arm64
+          - os: macos-13
+            name: macOS-x64
+        os: [ubuntu-latest, windows-latest, macos-14, macos-13]
+
+    steps:
+      - name: Set up JDK
+        uses: actions/setup-java@v4
+        with:
+          java-version: 21
+          distribution: 'temurin'
+
+      - name: Package JDK
+        run: jlink --add-modules java.base,java.compiler,java.datatransfer,java.desktop,java.instrument,java.logging,java.management,java.naming,java.prefs,java.scripting,java.se,java.security.jgss,java.security.sasl,java.sql,java.transaction.xa,java.xml,jdk.attach,jdk.crypto.ec,jdk.jdi,jdk.management,jdk.net,jdk.random,jdk.unsupported,jdk.unsupported.desktop,jdk.zipfs --output suwa --strip-debug --no-man-pages --no-header-files --compress=2
+
+      - name: Upload JDK package
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.name }}-jre
+          path: suwa
+
+  bundle:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: debian-all
+            jre: linux-x64
+          - name: appimage
+            jre: linux-x64
+          - name: linux-assets
+            jre: linux-assets
+          - name: linux-x64
+            jre: linux-x64
+          - name: macOS-x64
+            jre: macOS-x64
+          - name: macOS-arm64
+            jre: macOS-arm64
+          - name: windows-x64
+            jre: windows-x64
+        name: [debian-all, appimage, linux-assets, linux-x64, macOS-x64, macOS-arm64, windows-x64]
+
+    name: Make ${{ matrix.name }} release
+    needs: [build, jlink]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download Jar
+        uses: actions/download-artifact@v4
+        with:
+          name: jar
+          path: server/build
+
+      - name: Download JRE
+        uses: actions/download-artifact@v4
+        if: matrix.name != 'linux-assets' && matrix.name != 'debian-all'
+        with:
+          name: ${{ matrix.jre }}-jre
+          path: jre
+
+      - name: Download icons
+        uses: actions/download-artifact@v4
+        with:
+          name: icon
+          path: server/src/main/resources/icon
+
+      - name: Download scripts.tar.gz
+        uses: actions/download-artifact@v4
+        with:
+          name: scripts
+
+      - name: Make ${{ matrix.name }} release
        run: |
-          cd master/scripts
-          ./windows-bundler.sh win32
-          ./windows-bundler.sh win64
-          ./unix-bundler.sh linux-x64
-          ./debian-packager.sh
-          ./unix-bundler.sh macOS-x64
-          ./unix-bundler.sh macOS-arm64
+          mkdir upload/
+          tar -xvpf scripts.tar.gz
+          scripts/bundler.sh -o upload/ ${{ matrix.name }}

-      - name: Upload Release
-        uses: xresloader/upload-to-github-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Upload ${{ matrix.name }} files
+        uses: actions/upload-artifact@v4
        with:
-          file: "master/server/build/*.jar;master/server/build/*.msi;master/server/build/*.zip;master/server/build/*.tar.gz;master/server/build/*.deb"
-          tags: true
+          name: ${{ matrix.name }}
+          path: upload/*
+          if-no-files-found: error
+
+  release:
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: bundle
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: jar
+          path: release
+      - uses: actions/download-artifact@v4
+        with:
+          name: debian-all
+          path: release
+      - uses: actions/download-artifact@v4
+        with:
+          name: appimage
+          path: release
+      - uses: actions/download-artifact@v4
+        with:
+          name: linux-assets
+          path: release
+      - uses: actions/download-artifact@v4
+        with:
+          name: linux-x64
+          path: release
+      - uses: actions/download-artifact@v4
+        with:
+          name: macOS-x64
+          path: release
+      - uses: actions/download-artifact@v4
+        with:
+          name: macOS-arm64
+          path: release
+      - uses: actions/download-artifact@v4
+        with:
+          name: windows-x64
+          path: release
+
+      - name: Generate checksums
+        run: cd release && sha256sum * > Checksums.sha256
+
+      - name: Release
+        uses: softprops/action-gh-release@v2
+        with:
+          token: ${{ secrets.DEPLOY_RELEASE_TOKEN }}
          draft: true
-          verbose: true
+          files: release/*
@@ -0,0 +1,19 @@
+name: Publish to WinGet
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: Version
+        required: false
+
+jobs:
+  publish:
+    runs-on: windows-latest # action can only be run on windows
+    steps:
+      - uses: vedantmgoyal2009/winget-releaser@v2
+        with:
+          identifier: Suwayomi.Suwayomi-Server
+          installers-regex: '.*x64.msi$'
+          token: ${{ secrets.WINGET_PUBLISH_PAT }}
+          version: ${{ inputs.version || github.ref_name }}
+          release-tag: ${{ inputs.version || github.ref_name  }}
@@ -2,9 +2,10 @@
 .gradle
 .idea
 gradle.properties
-
+.fleet
 # But we need these
 !.idea/runConfigurations
+.kotlin

 # Ignore Gradle build output directory
 build
@@ -19,3 +20,4 @@ scripts/OpenJDK*
 scripts/zulu*
 scripts/electron-*
 scripts/rcedit-*
+scripts/resources/*.so
@@ -0,0 +1,23 @@
+plugins {
+    id(
+        libs.plugins.kotlin.jvm
+            .get()
+            .pluginId,
+    )
+    id(
+        libs.plugins.kotlin.serialization
+            .get()
+            .pluginId,
+    )
+    id(
+        libs.plugins.ktlint
+            .get()
+            .pluginId,
+    )
+}
+
+dependencies {
+    // Shared
+    implementation(libs.bundles.shared)
+    testImplementation(libs.bundles.sharedTest)
+}
@@ -7,7 +7,7 @@ package xyz.nulldev.ts.config
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */

-import net.harawata.appdirs.AppDirsFactory
+import ca.gosyer.appdirs.AppDirs

 const val CONFIG_PREFIX = "suwayomi.tachidesk.config"

@@ -15,6 +15,6 @@ val ApplicationRootDir: String
    get(): String {
        return System.getProperty(
            "$CONFIG_PREFIX.server.rootDir",
-            AppDirsFactory.getInstance().getUserDataDir("Tachidesk", null, null)
+            AppDirs { appName = "Tachidesk" }.getUserDataDir(),
        )
    }
@@ -1,12 +0,0 @@
-package xyz.nulldev.ts.config
-
-import org.kodein.di.DI
-import org.kodein.di.bind
-import org.kodein.di.singleton
-
-class ConfigKodeinModule {
-    fun create() = DI.Module("ConfigManager") {
-        // Config module
-        bind<ConfigManager>() with singleton { GlobalConfigManager }
-    }
-}
@@ -10,22 +10,32 @@ package xyz.nulldev.ts.config
 import ch.qos.logback.classic.Level
 import com.typesafe.config.Config
 import com.typesafe.config.ConfigFactory
-import com.typesafe.config.ConfigRenderOptions
-import mu.KotlinLogging
+import com.typesafe.config.ConfigObject
+import com.typesafe.config.ConfigValue
+import com.typesafe.config.parser.ConfigDocument
+import com.typesafe.config.parser.ConfigDocumentFactory
+import io.github.config4k.toConfig
+import io.github.oshai.kotlinlogging.KotlinLogging
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import java.io.File

 /**
 * Manages app config.
 */
 open class ConfigManager {
+    val logger = KotlinLogging.logger {}
    private val generatedModules = mutableMapOf<Class<out ConfigModule>, ConfigModule>()
-    val config by lazy { loadConfigs() }
+    private val userConfigFile = File(ApplicationRootDir, "server.conf")
+    private var internalConfig = loadConfigs()
+    val config: Config
+        get() = internalConfig

    // Public read-only view of modules
    val loadedModules: Map<Class<out ConfigModule>, ConfigModule>
        get() = generatedModules

-    val logger = KotlinLogging.logger {}
+    private val mutex = Mutex()

    /**
     * Get a config module
@@ -38,6 +48,11 @@ open class ConfigManager {
    @Suppress("UNCHECKED_CAST")
    fun <T : ConfigModule> module(type: Class<T>): T = loadedModules[type] as T

+    private fun getUserConfig(): Config =
+        userConfigFile.let {
+            ConfigFactory.parseFile(it)
+        }
+
    /**
     * Load configs
     */
@@ -48,30 +63,26 @@ open class ConfigManager {
        val baseConfig =
            ConfigFactory.parseMap(
                mapOf(
-                    "androidcompat.rootDir" to "$ApplicationRootDir/android-compat" // override AndroidCompat's rootDir
-                )
+                    // override AndroidCompat's rootDir
+                    "androidcompat.rootDir" to "$ApplicationRootDir/android-compat",
+                ),
            )

        // Load user config
-        val userConfig =
-            File(ApplicationRootDir, "server.conf").let {
-                ConfigFactory.parseFile(it)
-            }
+        val userConfig = getUserConfig()

-        val config = ConfigFactory.empty()
-            .withFallback(baseConfig)
-            .withFallback(userConfig)
-            .withFallback(compatConfig)
-            .withFallback(serverConfig)
-            .resolve()
+        val config =
+            ConfigFactory
+                .empty()
+                .withFallback(baseConfig)
+                .withFallback(userConfig)
+                .withFallback(compatConfig)
+                .withFallback(serverConfig)
+                .resolve()

        // set log level early
        if (debugLogsEnabled(config)) {
-            setLogLevel(Level.DEBUG)
-        }
-
-        logger.debug {
-            "Loaded config:\n" + config.root().render(ConfigRenderOptions.concise().setFormatted(true))
+            setLogLevelFor(BASE_LOGGER_NAME, Level.DEBUG)
        }

        return config
@@ -86,6 +97,84 @@ open class ConfigManager {
            registerModule(it)
        }
    }
+
+    private fun updateUserConfigFile(
+        path: String,
+        value: ConfigValue,
+    ) {
+        val userConfigDoc = ConfigDocumentFactory.parseFile(userConfigFile)
+        val updatedConfigDoc = userConfigDoc.withValue(path, value)
+        val newFileContent = updatedConfigDoc.render()
+        userConfigFile.writeText(newFileContent)
+    }
+
+    suspend fun updateValue(
+        path: String,
+        value: Any,
+    ) {
+        mutex.withLock {
+            val actualValue = if (value is Enum<*>) value.name else value
+            val configValue = actualValue.toConfig("internal").getValue("internal")
+
+            updateUserConfigFile(path, configValue)
+            internalConfig = internalConfig.withValue(path, configValue)
+        }
+    }
+
+    fun resetUserConfig(updateInternalConfig: Boolean = true): ConfigDocument {
+        val serverConfigFileContent = this::class.java.getResource("/server-reference.conf")?.readText()
+        val serverConfigDoc = ConfigDocumentFactory.parseString(serverConfigFileContent)
+        userConfigFile.writeText(serverConfigDoc.render())
+
+        if (updateInternalConfig) {
+            getUserConfig().entrySet().forEach { internalConfig = internalConfig.withValue(it.key, it.value) }
+        }
+
+        return serverConfigDoc
+    }
+
+    /**
+     * Makes sure the "UserConfig" is up-to-date.
+     *
+     *  - adds missing settings
+     *  - removes outdated settings
+     */
+    fun updateUserConfig(migrate: ConfigDocument.(Config) -> ConfigDocument) {
+        val serverConfig = ConfigFactory.parseResources("server-reference.conf")
+        val userConfig = getUserConfig()
+
+        // NOTE: if more than 1 dot is included, that's a nested setting, which we need to filter out here
+        val refKeys =
+            serverConfig.root().entries.flatMap {
+                (it.value as? ConfigObject)?.entries?.map { e -> "${it.key}.${e.key}" }.orEmpty()
+            }
+        val hasMissingSettings = refKeys.any { !userConfig.hasPath(it) }
+        val hasOutdatedSettings = userConfig.entrySet().any { !refKeys.contains(it.key) && it.key.count { c -> c == '.' } <= 1 }
+        val isUserConfigOutdated = hasMissingSettings || hasOutdatedSettings
+        if (!isUserConfigOutdated) {
+            return
+        }
+
+        logger.debug {
+            "user config is out of date, updating... (missingSettings= $hasMissingSettings, outdatedSettings= $hasOutdatedSettings"
+        }
+
+        var newUserConfigDoc: ConfigDocument = resetUserConfig(false)
+        userConfig
+            .entrySet()
+            .filter {
+                serverConfig.hasPath(
+                    it.key,
+                ) ||
+                    it.key.count { c -> c == '.' } > 1
+            }.forEach { newUserConfigDoc = newUserConfigDoc.withValue(it.key, it.value) }
+
+        newUserConfigDoc =
+            migrate(newUserConfigDoc, internalConfig)
+
+        userConfigFile.writeText(newUserConfigDoc.render())
+        getUserConfig().entrySet().forEach { internalConfig = internalConfig.withValue(it.key, it.value) }
+    }
 }

 object GlobalConfigManager : ConfigManager()
@@ -0,0 +1,9 @@
+package xyz.nulldev.ts.config
+
+import org.koin.core.module.Module
+import org.koin.dsl.module
+
+fun configManagerModule(): Module =
+    module {
+        single<ConfigManager> { GlobalConfigManager }
+    }
@@ -8,37 +8,69 @@ package xyz.nulldev.ts.config
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */

 import com.typesafe.config.Config
+import com.typesafe.config.ConfigException
+import com.typesafe.config.ConfigFactory
+import io.github.config4k.ClassContainer
+import io.github.config4k.TypeReference
 import io.github.config4k.getValue
+import io.github.config4k.readers.SelectReader
 import kotlin.reflect.KProperty

 /**
 * Abstract config module.
 */
@Suppress("UNUSED_PARAMETER")
-abstract class ConfigModule(config: Config)
+abstract class ConfigModule(
+    getConfig: () -> Config,
+)

 /**
 * Abstract jvm-commandline-argument-overridable config module.
 */
-abstract class SystemPropertyOverridableConfigModule(config: Config, moduleName: String) : ConfigModule(config) {
-    val overridableConfig = SystemPropertyOverrideDelegate(config, moduleName)
+abstract class SystemPropertyOverridableConfigModule(
+    getConfig: () -> Config,
+    val moduleName: String,
+) : ConfigModule(getConfig) {
+    val overridableConfig = SystemPropertyOverrideDelegate(getConfig, moduleName)
 }

 /** Defines a config property that is overridable with jvm `-D` commandline arguments prefixed with [CONFIG_PREFIX] */
-class SystemPropertyOverrideDelegate(val config: Config, val moduleName: String) {
-    inline operator fun <R, reified T> getValue(thisRef: R, property: KProperty<*>): T {
-        val configValue: T = config.getValue(thisRef, property)
+class SystemPropertyOverrideDelegate(
+    val getConfig: () -> Config,
+    val moduleName: String,
+) {
+    inline operator fun <R, reified T> getValue(
+        thisRef: R,
+        property: KProperty<*>,
+    ): T {
+        val config = getConfig()

-        val combined = System.getProperty(
-            "$CONFIG_PREFIX.$moduleName.${property.name}",
-            configValue.toString()
-        )
+        val systemProperty =
+            System.getProperty("$CONFIG_PREFIX.$moduleName.${property.name}")
+        if (systemProperty == null) {
+            val configValue: T = config.getValue(thisRef, property)
+            return configValue
+        }

-        return when (T::class.simpleName) {
-            "Int" -> combined.toInt()
-            "Boolean" -> combined.toBoolean()
-            // add more types as needed
-            else -> combined // covers String
-        } as T
+        val systemPropertyConfig =
+            try {
+                ConfigFactory.parseString("internal=$systemProperty")
+            } catch (_: ConfigException) {
+                ConfigFactory.parseMap(mapOf("internal" to systemProperty))
+            }
+
+        val genericType = object : TypeReference<T>() {}.genericType()
+        val clazz = ClassContainer(T::class, genericType)
+        val reader = SelectReader.getReader(clazz)
+        val path = property.name
+
+        val result = reader(systemPropertyConfig, "internal")
+        return try {
+            result as T
+        } catch (e: Exception) {
+            throw result
+                ?.let { e }
+                ?: ConfigException.BadPath(path, "take a look at your config")
+        }
    }
 }
@@ -8,12 +8,131 @@ package xyz.nulldev.ts.config
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */

 import ch.qos.logback.classic.Level
+import ch.qos.logback.classic.LoggerContext
+import ch.qos.logback.classic.encoder.PatternLayoutEncoder
+import ch.qos.logback.classic.spi.ILoggingEvent
+import ch.qos.logback.core.rolling.RollingFileAppender
+import ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy
+import ch.qos.logback.core.util.FileSize
 import com.typesafe.config.Config
-import mu.KotlinLogging
+import io.github.oshai.kotlinlogging.DelegatingKLogger
+import io.github.oshai.kotlinlogging.KotlinLogging
 import org.slf4j.Logger
+import org.slf4j.LoggerFactory

-fun setLogLevel(level: Level) {
-    (KotlinLogging.logger(Logger.ROOT_LOGGER_NAME).underlyingLogger as ch.qos.logback.classic.Logger).level = level
+private fun fileSizeValueOfOrDefault(
+    fileSizeStr: String,
+    default: String,
+): FileSize =
+    try {
+        FileSize.valueOf(fileSizeStr)
+    } catch (e: IllegalArgumentException) {
+        FileSize.valueOf(default)
+    }
+
+private const val FILE_APPENDER_NAME = "SuwayomiDefaultAppender"
+
+private fun createRollingFileAppender(
+    logContext: LoggerContext,
+    logDirPath: String,
+    maxFiles: Int,
+    maxFileSize: String,
+    maxTotalSize: String,
+): RollingFileAppender<ILoggingEvent> {
+    val logFilename = "application"
+
+    val logEncoder =
+        PatternLayoutEncoder().apply {
+            pattern = "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n"
+            context = logContext
+            start()
+        }
+
+    val appender =
+        RollingFileAppender<ILoggingEvent>().apply {
+            name = FILE_APPENDER_NAME
+            context = logContext
+            encoder = logEncoder
+            file = "$logDirPath/$logFilename.log"
+        }
+
+    val rollingPolicy =
+        SizeAndTimeBasedRollingPolicy<ILoggingEvent>().apply {
+            context = logContext
+            setParent(appender)
+            fileNamePattern = "$logDirPath/${logFilename}_%d{yyyy-MM-dd}_%i.log.gz"
+            maxHistory = maxFiles.coerceAtLeast(0)
+            setMaxFileSize(fileSizeValueOfOrDefault(maxFileSize, "10mb"))
+            setTotalSizeCap(fileSizeValueOfOrDefault(maxTotalSize, "100mb"))
+            start()
+        }
+
+    appender.rollingPolicy = rollingPolicy
+    appender.start()
+
+    return appender
+}
+
+private fun getBaseLogger(): ch.qos.logback.classic.Logger =
+    ((KotlinLogging.logger(Logger.ROOT_LOGGER_NAME) as DelegatingKLogger<*>).underlyingLogger as ch.qos.logback.classic.Logger)
+
+private fun getLogger(name: String): ch.qos.logback.classic.Logger {
+    val context = LoggerFactory.getILoggerFactory() as LoggerContext
+    return context.getLogger(name)
+}
+
+fun initLoggerConfig(
+    appRootPath: String,
+    maxFiles: Int,
+    maxFileSize: String,
+    maxTotalSize: String,
+) {
+    val context = LoggerFactory.getILoggerFactory() as LoggerContext
+    val logger = getBaseLogger()
+
+    // logback logs to the console by default (at least when adding a console appender logs in the console are duplicated)
+    logger.addAppender(createRollingFileAppender(context, "$appRootPath/logs", maxFiles, maxFileSize, maxTotalSize))
+
+    // set "kotlin exposed" log level
+    setLogLevelFor("Exposed", Level.ERROR)
+}
+
+fun updateFileAppender(
+    maxFiles: Int,
+    maxFileSize: String,
+    maxTotalSize: String,
+) {
+    val logger = getBaseLogger()
+
+    val appender = logger.getAppender(FILE_APPENDER_NAME) as RollingFileAppender<*>? ?: return
+    val rollingPolicy = appender.rollingPolicy as SizeAndTimeBasedRollingPolicy<*>
+    rollingPolicy.apply {
+        maxHistory = maxFiles
+        setMaxFileSize(FileSize.valueOf(maxFileSize))
+        setTotalSizeCap(FileSize.valueOf(maxTotalSize))
+
+        rollingPolicy.stop()
+        appender.stop()
+
+        rollingPolicy.start()
+        appender.start()
+    }
+}
+
+const val BASE_LOGGER_NAME = "_BaseLogger"
+
+fun setLogLevelFor(
+    name: String,
+    level: Level,
+) {
+    val logger =
+        if (name == BASE_LOGGER_NAME) {
+            getBaseLogger()
+        } else {
+            getLogger(name)
+        }
+
+    logger.level = level
 }

 fun debugLogsEnabled(config: Config) =
@@ -2,5 +2,6 @@ package xyz.nulldev.ts.config.util

 import com.typesafe.config.Config

-operator fun Config.get(key: String) = getString(key)
-    ?: throw IllegalStateException("Could not find value for config entry: $key!")
+operator fun Config.get(key: String) =
+    getString(key)
+        ?: throw IllegalStateException("Could not find value for config entry: $key!")
@@ -1,28 +1,51 @@
+plugins {
+    id(
+        libs.plugins.kotlin.jvm
+            .get()
+            .pluginId,
+    )
+    id(
+        libs.plugins.kotlin.serialization
+            .get()
+            .pluginId,
+    )
+    id(
+        libs.plugins.ktlint
+            .get()
+            .pluginId,
+    )
+}
+
 dependencies {
+    // Shared
+    implementation(libs.bundles.shared)
+    testImplementation(libs.bundles.sharedTest)
+
    // Android stub library
-    implementation("com.github.Suwayomi:android-jar:1.0.0")
+    implementation(libs.android.stubs)

    // XML
-    compileOnly("xmlpull:xmlpull:1.1.3.4a")
+    compileOnly(libs.xmlpull)

    // Config API
-    implementation(project(":AndroidCompat:Config"))
+    implementation(projects.androidCompat.config)

    // APK sig verifier
-    compileOnly("com.android.tools.build:apksig:7.1.0-beta05")
+    compileOnly(libs.apksig)

    // AndroidX annotations
-    compileOnly("androidx.annotation:annotation:1.3.0")
+    compileOnly(libs.android.annotations)

-    // substitute for duktape-android
-    implementation("org.mozilla:rhino-runtime:1.7.14") // slimmer version of 'org.mozilla:rhino'
-    implementation("org.mozilla:rhino-engine:1.7.14") // provides the same interface as 'javax.script' a.k.a Nashorn
+    // substitute for duktape-android/quickjs
+    implementation(libs.bundles.polyglot)

    // Kotlin wrapper around Java Preferences, makes certain things easier
-    val multiplatformSettingsVersion = "0.8.1"
-    implementation("com.russhwolf:multiplatform-settings-jvm:$multiplatformSettingsVersion")
-    implementation("com.russhwolf:multiplatform-settings-serialization-jvm:$multiplatformSettingsVersion")
+    implementation(libs.bundles.settings)

    // Android version of SimpleDateFormat
-    implementation("com.ibm.icu:icu4j:70.1")
+    implementation(libs.icu4j)
+
+    // OpenJDK lacks native JPEG encoder and native WEBP decoder
+    implementation(libs.bundles.twelvemonkeys)
+    implementation(libs.imageio.webp)
 }
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2016 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 android.annotation;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.PARAMETER;
+import static java.lang.annotation.RetentionPolicy.SOURCE;
+
+/**
+ * <p>Denotes that the annotated element represents a packed color
+ * long. If applied to a long array, every element in the array
+ * represents a color long. For more information on how colors
+ * are packed in a long, please refer to the documentation of
+ * the {@link android.graphics.Color} class.</p>
+ *
+ * <p>Example:</p>
+ *
+ * <pre>{@code
+ *  public void setFillColor(@ColorLong long color);
+ * }</pre>
+ *
+ * @see android.graphics.Color
+ *
+ * @hide
+ */
+@Retention(SOURCE)
+@Target({PARAMETER,METHOD,LOCAL_VARIABLE,FIELD})
+public @interface ColorLong {
+}
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2016 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 android.annotation;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.PARAMETER;
+import static java.lang.annotation.RetentionPolicy.SOURCE;
+
+/**
+ * <p>Denotes that the annotated element represents a half-precision floating point
+ * value. Such values are stored in short data types and can be manipulated with
+ * the {@link android.util.Half} class. If applied to an array of short, every
+ * element in the array represents a half-precision float.</p>
+ *
+ * <p>Example:</p>
+ *
+ * <pre>{@code
+ * public abstract void setPosition(@HalfFloat short x, @HalfFloat short y, @HalfFloat short z);
+ * }</pre>
+ *
+ * @see android.util.Half
+ * @see android.util.Half#toHalf(float)
+ * @see android.util.Half#toFloat(short)
+ *
+ * @hide
+ */
+@Retention(SOURCE)
+@Target({PARAMETER, METHOD, LOCAL_VARIABLE, FIELD})
+public @interface HalfFloat {
+}
@@ -25,7 +25,7 @@ import android.os.IBinder;
 import android.util.Log;
 import kotlin.NotImplementedError;
 import xyz.nulldev.androidcompat.service.ServiceSupport;
-import xyz.nulldev.androidcompat.util.KodeinGlobalHelper;
+import xyz.nulldev.androidcompat.util.KoinGlobalHelper;

 import java.io.FileDescriptor;
 import java.io.PrintWriter;
@@ -299,7 +299,7 @@ import java.lang.annotation.RetentionPolicy;
 */
 public abstract class Service extends ContextWrapper implements ComponentCallbacks2 {

-    private static final ServiceSupport serviceSupport = KodeinGlobalHelper.instance(ServiceSupport.class);
+    private static final ServiceSupport serviceSupport = KoinGlobalHelper.instance(ServiceSupport.class);

    private static final String TAG = "Service";
    /**
@@ -328,7 +328,7 @@ public abstract class Service extends ContextWrapper implements ComponentCallbac
    public Service() {
        //==================[THIS LINE MODIFIED FROM ANDROID SOURCE!]==================
        //Service must be initialized with a base context!
-        super(KodeinGlobalHelper.instance(Context.class));
+        super(KoinGlobalHelper.instance(Context.class));
    }
    /** Return the application that owns this service. */
    public final Application getApplication() {
@@ -0,0 +1,267 @@
+package android.graphics;
+
+import android.annotation.ColorInt;
+import android.annotation.NonNull;
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Iterator;
+import javax.imageio.IIOImage;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageWriteParam;
+import javax.imageio.ImageWriter;
+import javax.imageio.stream.ImageOutputStream;
+
+
+public final class Bitmap {
+    private final int width;
+    private final int height;
+    private final BufferedImage image;
+
+    public Bitmap(BufferedImage image) {
+        this.image = image;
+        this.width = image.getWidth();
+        this.height = image.getHeight();
+    }
+
+    public BufferedImage getImage() {
+        return image;
+    }
+
+    public int getHeight() {
+        return height;
+    }
+
+    public int getWidth() {
+        return width;
+    }
+
+    public enum CompressFormat {
+        JPEG          (0),
+        PNG           (1),
+        WEBP          (2),
+        WEBP_LOSSY    (3),
+        WEBP_LOSSLESS (4);
+
+        CompressFormat(int nativeInt) {
+            this.nativeInt = nativeInt;
+        }
+
+        final int nativeInt;
+    }
+
+    public enum Config {
+        ALPHA_8(1),
+        RGB_565(3),
+        ARGB_4444(4),
+        ARGB_8888(5),
+        RGBA_F16(6),
+        HARDWARE(7),
+        RGBA_1010102(8);
+
+        final int nativeInt;
+
+        private static final Config[] sConfigs = {
+                null, ALPHA_8, null, RGB_565, ARGB_4444, ARGB_8888, RGBA_F16, HARDWARE, RGBA_1010102
+        };
+
+        Config(int ni) {
+            this.nativeInt = ni;
+        }
+
+        static Config nativeToConfig(int ni) {
+            return sConfigs[ni];
+        }
+    }
+
+    private static int configToBufferedImageType(Config config) {
+        switch (config) {
+            case ALPHA_8:
+                return BufferedImage.TYPE_BYTE_GRAY;
+            case RGB_565:
+                return BufferedImage.TYPE_USHORT_565_RGB;
+            case ARGB_8888:
+                return BufferedImage.TYPE_INT_ARGB;
+            default:
+                throw new UnsupportedOperationException("Bitmap.Config(" + config + ") not supported");
+        }
+    }
+
+    /**
+     * Common code for checking that x and y are >= 0
+     *
+     * @param x x coordinate to ensure is >= 0
+     * @param y y coordinate to ensure is >= 0
+     */
+    private static void checkXYSign(int x, int y) {
+        if (x < 0) {
+            throw new IllegalArgumentException("x must be >= 0");
+        }
+        if (y < 0) {
+            throw new IllegalArgumentException("y must be >= 0");
+        }
+    }
+
+    /**
+     * Common code for checking that width and height are > 0
+     *
+     * @param width  width to ensure is > 0
+     * @param height height to ensure is > 0
+     */
+    private static void checkWidthHeight(int width, int height) {
+        if (width <= 0) {
+            throw new IllegalArgumentException("width must be > 0");
+        }
+        if (height <= 0) {
+            throw new IllegalArgumentException("height must be > 0");
+        }
+    }
+
+    public static Bitmap createBitmap(int width, int height, Config config) {
+        BufferedImage image = new BufferedImage(width, height, configToBufferedImageType(config));
+        return new Bitmap(image);
+    }
+
+    public static Bitmap createBitmap(@NonNull Bitmap source, int x, int y, int width, int height) {
+        checkXYSign(x, y);
+        checkWidthHeight(width, height);
+        if (x + width > source.getWidth()) {
+            throw new IllegalArgumentException("x + width must be <= bitmap.width()");
+        }
+        if (y + height > source.getHeight()) {
+            throw new IllegalArgumentException("y + height must be <= bitmap.height()");
+        }
+
+        // Android will make a copy when creating a sub image,
+        // so we do the same here
+        BufferedImage subImage = source.image.getSubimage(x, y, width, height);
+        BufferedImage newImage = new BufferedImage(subImage.getWidth(), subImage.getHeight(), subImage.getType());
+        newImage.setData(subImage.getData());
+
+        return new Bitmap(newImage);
+    }
+
+    public boolean compress(CompressFormat format, int quality, OutputStream stream) {
+        if (stream == null) {
+            throw new NullPointerException();
+        }
+
+        if (quality < 0 || quality > 100) {
+            throw new IllegalArgumentException("quality must be 0..100");
+        }
+        float qualityFloat = ((float) quality) / 100;
+
+        String formatString;
+        if (format == Bitmap.CompressFormat.PNG) {
+            formatString = "png";
+        } else if (format == Bitmap.CompressFormat.JPEG) {
+            formatString = "jpg";
+        } else if (format == Bitmap.CompressFormat.WEBP || format == Bitmap.CompressFormat.WEBP_LOSSY) {
+            formatString = "webp";
+        } else {
+            throw new IllegalArgumentException("unsupported compression format! " + format);
+        }
+
+        Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName(formatString);
+        if (!writers.hasNext()) {
+            throw new IllegalStateException("no image writers found for this format!");
+        }
+        ImageWriter writer = writers.next();
+
+        ImageOutputStream ios;
+        try {
+            ios = ImageIO.createImageOutputStream(stream);
+        } catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+        writer.setOutput(ios);
+
+        BufferedImage img = image;
+
+        ImageWriteParam param = writer.getDefaultWriteParam();
+        if ("jpg".equals(formatString)) {
+            param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
+            param.setCompressionQuality(qualityFloat);
+
+            img = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_RGB);
+            img.getGraphics().drawImage(image, 0, 0, null);
+        }
+
+        try {
+            writer.write(null, new IIOImage(img, null, null), param);
+            ios.close();
+            writer.dispose();
+        } catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+
+        return true;
+    }
+
+    public Bitmap copy(Config config, boolean isMutable) {
+        Bitmap ret = createBitmap(width, height, config);
+        ret.image.getGraphics().drawImage(image, 0, 0, null);
+        return ret;
+    }
+
+    /**
+     * Shared code to check for illegal arguments passed to getPixels()
+     * or setPixels()
+     *
+     * @param x      left edge of the area of pixels to access
+     * @param y      top edge of the area of pixels to access
+     * @param width  width of the area of pixels to access
+     * @param height height of the area of pixels to access
+     * @param offset offset into pixels[] array
+     * @param stride number of elements in pixels[] between each logical row
+     * @param pixels array to hold the area of pixels being accessed
+     */
+    private void checkPixelsAccess(int x, int y, int width, int height,
+                                   int offset, int stride, int[] pixels) {
+        checkXYSign(x, y);
+        if (width < 0) {
+            throw new IllegalArgumentException("width must be >= 0");
+        }
+        if (height < 0) {
+            throw new IllegalArgumentException("height must be >= 0");
+        }
+        if (x + width > getWidth()) {
+            throw new IllegalArgumentException(
+                    "x + width must be <= bitmap.width()");
+        }
+        if (y + height > getHeight()) {
+            throw new IllegalArgumentException(
+                    "y + height must be <= bitmap.height()");
+        }
+        if (Math.abs(stride) < width) {
+            throw new IllegalArgumentException("abs(stride) must be >= width");
+        }
+        int lastScanline = offset + (height - 1) * stride;
+        int length = pixels.length;
+        if (offset < 0 || (offset + width > length)
+                || lastScanline < 0
+                || (lastScanline + width > length)) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+    }
+
+    public void getPixels(@ColorInt int[] pixels, int offset, int stride,
+                          int x, int y, int width, int height) {
+        checkPixelsAccess(x, y, width, height, offset, stride, pixels);
+
+        image.getRGB(x, y, width, height, pixels, offset, stride);
+    }
+
+    public void eraseColor(int c) {
+        java.awt.Color color = Color.valueOf(c).toJavaColor();
+        Graphics2D graphics = image.createGraphics();
+        graphics.setColor(color);
+        graphics.fillRect(0, 0, width, height);
+        graphics.dispose();
+    }
+
+    public void recycle() {
+        // do nothing
+    }
+}
@@ -0,0 +1,51 @@
+package android.graphics;
+
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.io.IOException;
+import java.util.Iterator;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReader;
+import javax.imageio.stream.ImageInputStream;
+
+public class BitmapFactory {
+    public static Bitmap decodeStream(InputStream inputStream) {
+        Bitmap bitmap = null;
+
+        try {
+            ImageInputStream imageInputStream = ImageIO.createImageInputStream(inputStream);
+            Iterator<ImageReader> imageReaders = ImageIO.getImageReaders(imageInputStream);
+
+            if (!imageReaders.hasNext()) {
+                throw new IllegalArgumentException("no reader for image");
+            }
+
+            ImageReader imageReader = imageReaders.next();
+            imageReader.setInput(imageInputStream);
+
+            BufferedImage image = imageReader.read(0, imageReader.getDefaultReadParam());
+            bitmap = new Bitmap(image);
+
+            imageReader.dispose();
+        } catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+
+        return bitmap;
+    }
+
+    public static Bitmap decodeByteArray(byte[] data, int offset, int length) {
+        Bitmap bitmap = null;
+
+        ByteArrayInputStream byteArrayStream = new ByteArrayInputStream(data);
+        try {
+            BufferedImage image = ImageIO.read(byteArrayStream);
+            bitmap = new Bitmap(image);
+        } catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+
+        return bitmap;
+    }
+}
@@ -0,0 +1,184 @@
+package android.graphics;
+
+import android.annotation.NonNull;
+import android.util.Log;
+import java.awt.BasicStroke;
+import java.awt.Font;
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.awt.RenderingHints;
+import java.awt.Shape;
+import java.awt.font.GlyphVector;
+import java.awt.geom.AffineTransform;
+import java.awt.image.BufferedImage;
+import java.util.ArrayList;
+import java.util.List;
+import javax.imageio.ImageIO;
+
+public final class Canvas {
+    private BufferedImage canvasImage;
+    private Graphics2D canvas;
+    private List<AffineTransform> transformStack = new ArrayList<AffineTransform>();
+
+    private static final String TAG = "Canvas";
+
+    public Canvas(Bitmap bitmap) {
+        canvasImage = bitmap.getImage();
+        canvas = canvasImage.createGraphics();
+    }
+
+    public void drawBitmap(Bitmap sourceBitmap, Rect src, Rect dst, Paint paint) {
+        BufferedImage sourceImage = sourceBitmap.getImage();
+        BufferedImage sourceImageCropped = sourceImage.getSubimage(src.left, src.top, src.getWidth(), src.getHeight());
+        canvas.drawImage(sourceImageCropped, dst.left, dst.top, dst.getWidth(), dst.getHeight(), null);
+    }
+
+    public void drawBitmap(Bitmap sourceBitmap, float left, float top, Paint paint) {
+        BufferedImage sourceImage = sourceBitmap.getImage();
+        canvas.drawImage(sourceImage, null, (int) left, (int) top);
+    }
+
+    public void drawText(@NonNull char[] text, int index, int count, float x, float y,
+            @NonNull Paint paint) {
+        drawText(new String(text, index, count), x, y, paint);
+    }
+
+    public void drawText(@NonNull String text, float x, float y, @NonNull Paint paint) {
+        applyPaint(paint);
+        GlyphVector glyphVector = paint.getFont().createGlyphVector(canvas.getFontRenderContext(), text);
+        Shape textShape = glyphVector.getOutline();
+        switch (paint.getStyle()) {
+            case Paint.Style.FILL:
+                canvas.drawString(text, x, y);
+                break;
+            case Paint.Style.STROKE:
+                save();
+                translate(x, y);
+                canvas.draw(textShape);
+                restore();
+                break;
+            case Paint.Style.FILL_AND_STROKE:
+                save();
+                translate(x, y);
+                canvas.draw(textShape);
+                canvas.fill(textShape);
+                restore();
+                break;
+        }
+    }
+
+    public void drawText(@NonNull String text, int start, int end, float x, float y,
+            @NonNull Paint paint) {
+        drawText(text.substring(start, end), x, y, paint);
+    }
+
+    public void drawText(@NonNull CharSequence text, int start, int end, float x, float y,
+            @NonNull Paint paint) {
+        String str = text.subSequence(start, end).toString();
+        drawText(str, x, y, paint);
+    }
+
+    public void drawRoundRect(@NonNull RectF rect, float rx, float ry, @NonNull Paint paint) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void drawRoundRect(float left, float top, float right, float bottom, float rx, float ry,
+            @NonNull Paint paint) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void drawPath(@NonNull Path path, @NonNull Paint paint) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void translate(float dx, float dy) {
+        if (dx == 0.0f && dy == 0.0f) return;
+        // TODO: check this, should translations stack?
+        canvas.translate(dx, dy);
+    }
+
+    public void scale(float sx, float sy) {
+        if (sx == 1.0f && sy == 1.0f) return;
+        canvas.scale(sx, sy);
+    }
+
+    public final void scale(float sx, float sy, float px, float py) {
+        if (sx == 1.0f && sy == 1.0f) return;
+        translate(px, py);
+        scale(sx, sy);
+        translate(-px, -py);
+    }
+
+    public void rotate(float degrees) {
+        if (degrees == 0.0f) return;
+        canvas.rotate(degrees);
+    }
+
+    public final void rotate(float degrees, float px, float py) {
+        if (degrees == 0.0f) return;
+        canvas.rotate(degrees, px, py);
+    }
+
+    public int getSaveCount() {
+        return transformStack.size();
+    }
+
+    public int save() {
+        transformStack.add(canvas.getTransform());
+        return getSaveCount();
+    }
+
+    public void restoreToCount(int saveCount) {
+        if (saveCount < 1) {
+            throw new IllegalArgumentException(
+                    "Underflow in restoreToCount - more restores than saves");
+        }
+        if (saveCount > getSaveCount()) {
+            throw new IllegalArgumentException("Overflow in restoreToCount");
+
+        }
+        AffineTransform ts = transformStack.get(saveCount - 1);
+        canvas.setTransform(ts);
+        while (transformStack.size() >= saveCount) {
+            transformStack.remove(transformStack.size() - 1);
+        }
+    }
+
+    public void restore() {
+        restoreToCount(getSaveCount());
+    }
+
+    public boolean getClipBounds(@NonNull Rect bounds) {
+        Rectangle r = canvas.getClipBounds();
+        if (r == null) {
+            bounds.left = 0;
+            bounds.top = 0;
+            bounds.right = canvasImage.getWidth();
+            bounds.bottom = canvasImage.getHeight();
+            return true;
+        }
+        bounds.left = r.x;
+        bounds.top = r.y;
+        bounds.right = r.x + r.width;
+        bounds.bottom = r.y + r.height;
+        return r.width != 0 && r.height != 0;
+    }
+
+    private void applyPaint(Paint paint) {
+        canvas.setFont(paint.getFont());
+        java.awt.Color color = Color.valueOf(paint.getColorLong()).toJavaColor();
+        canvas.setColor(color);
+        canvas.setStroke(new BasicStroke(paint.getStrokeWidth(), BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
+        if (paint.isAntiAlias()) {
+            canvas.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+        } else {
+            canvas.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
+        }
+        if (paint.isDither()) {
+            canvas.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_ENABLE);
+        } else {
+            canvas.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
+        }
+        // TODO: use more from paint?
+    }
+}
@@ -0,0 +1,578 @@
+/*
+ * Copyright (C) 2006 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 android.graphics;
+
+import android.annotation.ColorInt;
+import android.annotation.ColorLong;
+import android.annotation.HalfFloat;
+import android.annotation.IntRange;
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.annotation.Size;
+import android.util.Half;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.function.DoubleUnaryOperator;
+
+public class Color {
+    @ColorInt public static final int BLACK       = 0xFF000000;
+    @ColorInt public static final int DKGRAY      = 0xFF444444;
+    @ColorInt public static final int GRAY        = 0xFF888888;
+    @ColorInt public static final int LTGRAY      = 0xFFCCCCCC;
+    @ColorInt public static final int WHITE       = 0xFFFFFFFF;
+    @ColorInt public static final int RED         = 0xFFFF0000;
+    @ColorInt public static final int GREEN       = 0xFF00FF00;
+    @ColorInt public static final int BLUE        = 0xFF0000FF;
+    @ColorInt public static final int YELLOW      = 0xFFFFFF00;
+    @ColorInt public static final int CYAN        = 0xFF00FFFF;
+    @ColorInt public static final int MAGENTA     = 0xFFFF00FF;
+    @ColorInt public static final int TRANSPARENT = 0;
+
+    @NonNull
+    @Size(min = 4, max = 5)
+    private final float[] mComponents;
+
+    @NonNull
+    private final ColorSpace mColorSpace;
+
+    public Color() {
+        // This constructor is required for compatibility with previous APIs
+        mComponents = new float[] { 0.0f, 0.0f, 0.0f, 1.0f };
+        mColorSpace = ColorSpace.get(ColorSpace.Named.SRGB);
+    }
+
+    private Color(float r, float g, float b, float a) {
+        this(r, g, b, a, ColorSpace.get(ColorSpace.Named.SRGB));
+    }
+
+    private Color(float r, float g, float b, float a, @NonNull ColorSpace colorSpace) {
+        mComponents = new float[] { r, g, b, a };
+        mColorSpace = colorSpace;
+    }
+
+    private Color(@Size(min = 4, max = 5) float[] components, @NonNull ColorSpace colorSpace) {
+        mComponents = components;
+        mColorSpace = colorSpace;
+    }
+
+    public java.awt.Color toJavaColor() {
+        return new java.awt.Color(red(), green(), blue(), alpha());
+    }
+
+    @NonNull
+    public ColorSpace getColorSpace() {
+        return mColorSpace;
+    }
+
+    public ColorSpace.Model getModel() {
+        return mColorSpace.getModel();
+    }
+
+    public boolean isWideGamut() {
+        return getColorSpace().isWideGamut();
+    }
+
+    public boolean isSrgb() {
+        return getColorSpace().isSrgb();
+    }
+
+    @IntRange(from = 4, to = 5)
+    public int getComponentCount() {
+        return mColorSpace.getComponentCount() + 1;
+    }
+
+    @ColorLong
+    public long pack() {
+        return pack(mComponents[0], mComponents[1], mComponents[2], mComponents[3], mColorSpace);
+    }
+
+    @NonNull
+    public Color convert(@NonNull ColorSpace colorSpace) {
+        ColorSpace.Connector connector = ColorSpace.connect(mColorSpace, colorSpace);
+        float[] color = new float[] {
+                mComponents[0], mComponents[1], mComponents[2], mComponents[3]
+        };
+        connector.transform(color);
+        return new Color(color, colorSpace);
+    }
+
+    @ColorInt
+    public int toArgb() {
+        if (mColorSpace.isSrgb()) {
+            return ((int) (mComponents[3] * 255.0f + 0.5f) << 24) |
+                   ((int) (mComponents[0] * 255.0f + 0.5f) << 16) |
+                   ((int) (mComponents[1] * 255.0f + 0.5f) <<  8) |
+                    (int) (mComponents[2] * 255.0f + 0.5f);
+        }
+
+        float[] color = new float[] {
+                mComponents[0], mComponents[1], mComponents[2], mComponents[3]
+        };
+        // The transformation saturates the output
+        ColorSpace.connect(mColorSpace).transform(color);
+
+        return ((int) (color[3] * 255.0f + 0.5f) << 24) |
+               ((int) (color[0] * 255.0f + 0.5f) << 16) |
+               ((int) (color[1] * 255.0f + 0.5f) <<  8) |
+                (int) (color[2] * 255.0f + 0.5f);
+    }
+
+    public float red() {
+        return mComponents[0];
+    }
+
+    public float green() {
+        return mComponents[1];
+    }
+
+    public float blue() {
+        return mComponents[2];
+    }
+
+    public float alpha() {
+        return mComponents[mComponents.length - 1];
+    }
+
+    @NonNull
+    @Size(min = 4, max = 5)
+    public float[] getComponents() {
+        return Arrays.copyOf(mComponents, mComponents.length);
+    }
+
+    @NonNull
+    @Size(min = 4)
+    public float[] getComponents(@Nullable @Size(min = 4) float[] components) {
+        if (components == null) {
+            return Arrays.copyOf(mComponents, mComponents.length);
+        }
+
+        if (components.length < mComponents.length) {
+            throw new IllegalArgumentException("The specified array's length must be at "
+                    + "least " + mComponents.length);
+        }
+
+        System.arraycopy(mComponents, 0, components, 0, mComponents.length);
+        return components;
+    }
+
+    public float getComponent(@IntRange(from = 0, to = 4) int component) {
+        return mComponents[component];
+    }
+
+    public float luminance() {
+        if (mColorSpace.getModel() != ColorSpace.Model.RGB) {
+            throw new IllegalArgumentException("The specified color must be encoded in an RGB " +
+                    "color space. The supplied color space is " + mColorSpace.getModel());
+        }
+
+        DoubleUnaryOperator eotf = ((ColorSpace.Rgb) mColorSpace).getEotf();
+        double r = eotf.applyAsDouble(mComponents[0]);
+        double g = eotf.applyAsDouble(mComponents[1]);
+        double b = eotf.applyAsDouble(mComponents[2]);
+
+        return saturate((float) ((0.2126 * r) + (0.7152 * g) + (0.0722 * b)));
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Color color = (Color) o;
+
+        //noinspection SimplifiableIfStatement
+        if (!Arrays.equals(mComponents, color.mComponents)) return false;
+        return mColorSpace.equals(color.mColorSpace);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = Arrays.hashCode(mComponents);
+        result = 31 * result + mColorSpace.hashCode();
+        return result;
+    }
+
+    @Override
+    @NonNull
+    public String toString() {
+        StringBuilder b = new StringBuilder("Color(");
+        for (float c : mComponents) {
+            b.append(c).append(", ");
+        }
+        b.append(mColorSpace.getName());
+        b.append(')');
+        return b.toString();
+    }
+
+    @NonNull
+    public static ColorSpace colorSpace(@ColorLong long color) {
+        return ColorSpace.get((int) (color & 0x3fL));
+    }
+
+    public static float red(@ColorLong long color) {
+        if ((color & 0x3fL) == 0L) return ((color >> 48) & 0xff) / 255.0f;
+        return Half.toFloat((short) ((color >> 48) & 0xffff));
+    }
+
+    public static float green(@ColorLong long color) {
+        if ((color & 0x3fL) == 0L) return ((color >> 40) & 0xff) / 255.0f;
+        return Half.toFloat((short) ((color >> 32) & 0xffff));
+    }
+
+    public static float blue(@ColorLong long color) {
+        if ((color & 0x3fL) == 0L) return ((color >> 32) & 0xff) / 255.0f;
+        return Half.toFloat((short) ((color >> 16) & 0xffff));
+    }
+
+    public static float alpha(@ColorLong long color) {
+        if ((color & 0x3fL) == 0L) return ((color >> 56) & 0xff) / 255.0f;
+        return ((color >> 6) & 0x3ff) / 1023.0f;
+    }
+
+    public static boolean isSrgb(@ColorLong long color) {
+        return colorSpace(color).isSrgb();
+    }
+
+    public static boolean isWideGamut(@ColorLong long color) {
+        return colorSpace(color).isWideGamut();
+    }
+
+    public static boolean isInColorSpace(@ColorLong long color, @NonNull ColorSpace colorSpace) {
+        return (int) (color & 0x3fL) == colorSpace.getId();
+    }
+
+    @ColorInt
+    public static int toArgb(@ColorLong long color) {
+        if ((color & 0x3fL) == 0L) return (int) (color >> 32);
+
+        float r = red(color);
+        float g = green(color);
+        float b = blue(color);
+        float a = alpha(color);
+
+        // The transformation saturates the output
+        float[] c = ColorSpace.connect(colorSpace(color)).transform(r, g, b);
+
+        return ((int) (a    * 255.0f + 0.5f) << 24) |
+               ((int) (c[0] * 255.0f + 0.5f) << 16) |
+               ((int) (c[1] * 255.0f + 0.5f) <<  8) |
+                (int) (c[2] * 255.0f + 0.5f);
+    }
+
+    @NonNull
+    public static Color valueOf(@ColorInt int color) {
+        float r = ((color >> 16) & 0xff) / 255.0f;
+        float g = ((color >>  8) & 0xff) / 255.0f;
+        float b = ((color      ) & 0xff) / 255.0f;
+        float a = ((color >> 24) & 0xff) / 255.0f;
+        return new Color(r, g, b, a, ColorSpace.get(ColorSpace.Named.SRGB));
+    }
+
+    @NonNull
+    public static Color valueOf(@ColorLong long color) {
+        return new Color(red(color), green(color), blue(color), alpha(color), colorSpace(color));
+    }
+
+    @NonNull
+    public static Color valueOf(float r, float g, float b) {
+        return new Color(r, g, b, 1.0f);
+    }
+
+    @NonNull
+    public static Color valueOf(float r, float g, float b, float a) {
+        return new Color(saturate(r), saturate(g), saturate(b), saturate(a));
+    }
+
+    @NonNull
+    public static Color valueOf(float r, float g, float b, float a, @NonNull ColorSpace colorSpace) {
+        if (colorSpace.getComponentCount() > 3) {
+            throw new IllegalArgumentException("The specified color space must use a color model " +
+                    "with at most 3 color components");
+        }
+        return new Color(r, g, b, a, colorSpace);
+    }
+
+    @NonNull
+    public static Color valueOf(@NonNull @Size(min = 4, max = 5) float[] components,
+            @NonNull ColorSpace colorSpace) {
+        if (components.length < colorSpace.getComponentCount() + 1) {
+            throw new IllegalArgumentException("Received a component array of length " +
+                    components.length + " but the color model requires " +
+                    (colorSpace.getComponentCount() + 1) + " (including alpha)");
+        }
+        return new Color(Arrays.copyOf(components, colorSpace.getComponentCount() + 1), colorSpace);
+    }
+
+    @ColorLong
+    public static long pack(@ColorInt int color) {
+        return (color & 0xffffffffL) << 32;
+    }
+
+    @ColorLong
+    public static long pack(float red, float green, float blue) {
+        return pack(red, green, blue, 1.0f, ColorSpace.get(ColorSpace.Named.SRGB));
+    }
+
+    @ColorLong
+    public static long pack(float red, float green, float blue, float alpha) {
+        return pack(red, green, blue, alpha, ColorSpace.get(ColorSpace.Named.SRGB));
+    }
+
+    @ColorLong
+    public static long pack(float red, float green, float blue, float alpha,
+            @NonNull ColorSpace colorSpace) {
+        if (colorSpace.isSrgb()) {
+            int argb =
+                    ((int) (alpha * 255.0f + 0.5f) << 24) |
+                    ((int) (red   * 255.0f + 0.5f) << 16) |
+                    ((int) (green * 255.0f + 0.5f) <<  8) |
+                     (int) (blue  * 255.0f + 0.5f);
+            return (argb & 0xffffffffL) << 32;
+        }
+
+        int id = colorSpace.getId();
+        if (id == ColorSpace.MIN_ID) {
+            throw new IllegalArgumentException(
+                    "Unknown color space, please use a color space returned by ColorSpace.get()");
+        }
+        if (colorSpace.getComponentCount() > 3) {
+            throw new IllegalArgumentException(
+                    "The color space must use a color model with at most 3 components");
+        }
+
+        @HalfFloat short r = Half.toHalf(red);
+        @HalfFloat short g = Half.toHalf(green);
+        @HalfFloat short b = Half.toHalf(blue);
+
+        int a = (int) (Math.max(0.0f, Math.min(alpha, 1.0f)) * 1023.0f + 0.5f);
+
+        // Suppress sign extension
+        return  (r & 0xffffL) << 48 |
+                (g & 0xffffL) << 32 |
+                (b & 0xffffL) << 16 |
+                (a & 0x3ffL ) <<  6 |
+                id & 0x3fL;
+    }
+
+    @ColorLong
+    public static long convert(@ColorInt int color, @NonNull ColorSpace colorSpace) {
+        float r = ((color >> 16) & 0xff) / 255.0f;
+        float g = ((color >>  8) & 0xff) / 255.0f;
+        float b = ((color      ) & 0xff) / 255.0f;
+        float a = ((color >> 24) & 0xff) / 255.0f;
+        ColorSpace source = ColorSpace.get(ColorSpace.Named.SRGB);
+        return convert(r, g, b, a, source, colorSpace);
+    }
+
+    @ColorLong
+    public static long convert(@ColorLong long color, @NonNull ColorSpace colorSpace) {
+        float r = red(color);
+        float g = green(color);
+        float b = blue(color);
+        float a = alpha(color);
+        ColorSpace source = colorSpace(color);
+        return convert(r, g, b, a, source, colorSpace);
+    }
+
+    @ColorLong
+    public static long convert(float r, float g, float b, float a,
+            @NonNull ColorSpace source, @NonNull ColorSpace destination) {
+        float[] c = ColorSpace.connect(source, destination).transform(r, g, b);
+        return pack(c[0], c[1], c[2], a, destination);
+    }
+
+    @ColorLong
+    public static long convert(@ColorLong long color, @NonNull ColorSpace.Connector connector) {
+        float r = red(color);
+        float g = green(color);
+        float b = blue(color);
+        float a = alpha(color);
+        return convert(r, g, b, a, connector);
+    }
+
+    @ColorLong
+    public static long convert(float r, float g, float b, float a,
+            @NonNull ColorSpace.Connector connector) {
+        float[] c = connector.transform(r, g, b);
+        return pack(c[0], c[1], c[2], a, connector.getDestination());
+    }
+
+    public static float luminance(@ColorLong long color) {
+        ColorSpace colorSpace = colorSpace(color);
+        if (colorSpace.getModel() != ColorSpace.Model.RGB) {
+            throw new IllegalArgumentException("The specified color must be encoded in an RGB " +
+                    "color space. The supplied color space is " + colorSpace.getModel());
+        }
+
+        DoubleUnaryOperator eotf = ((ColorSpace.Rgb) colorSpace).getEotf();
+        double r = eotf.applyAsDouble(red(color));
+        double g = eotf.applyAsDouble(green(color));
+        double b = eotf.applyAsDouble(blue(color));
+
+        return saturate((float) ((0.2126 * r) + (0.7152 * g) + (0.0722 * b)));
+    }
+
+    private static float saturate(float v) {
+        return v <= 0.0f ? 0.0f : (v >= 1.0f ? 1.0f : v);
+    }
+
+    @IntRange(from = 0, to = 255)
+    public static int alpha(int color) {
+        return color >>> 24;
+    }
+
+    @IntRange(from = 0, to = 255)
+    public static int red(int color) {
+        return (color >> 16) & 0xFF;
+    }
+
+    @IntRange(from = 0, to = 255)
+    public static int green(int color) {
+        return (color >> 8) & 0xFF;
+    }
+
+    @IntRange(from = 0, to = 255)
+    public static int blue(int color) {
+        return color & 0xFF;
+    }
+
+    @ColorInt
+    public static int rgb(
+            @IntRange(from = 0, to = 255) int red,
+            @IntRange(from = 0, to = 255) int green,
+            @IntRange(from = 0, to = 255) int blue) {
+        return 0xff000000 | (red << 16) | (green << 8) | blue;
+    }
+
+    @ColorInt
+    public static int rgb(float red, float green, float blue) {
+        return 0xff000000 |
+               ((int) (red   * 255.0f + 0.5f) << 16) |
+               ((int) (green * 255.0f + 0.5f) <<  8) |
+                (int) (blue  * 255.0f + 0.5f);
+    }
+
+    @ColorInt
+    public static int argb(
+            @IntRange(from = 0, to = 255) int alpha,
+            @IntRange(from = 0, to = 255) int red,
+            @IntRange(from = 0, to = 255) int green,
+            @IntRange(from = 0, to = 255) int blue) {
+        return (alpha << 24) | (red << 16) | (green << 8) | blue;
+    }
+
+    @ColorInt
+    public static int argb(float alpha, float red, float green, float blue) {
+        return ((int) (alpha * 255.0f + 0.5f) << 24) |
+               ((int) (red   * 255.0f + 0.5f) << 16) |
+               ((int) (green * 255.0f + 0.5f) <<  8) |
+                (int) (blue  * 255.0f + 0.5f);
+    }
+
+    public static float luminance(@ColorInt int color) {
+        ColorSpace.Rgb cs = (ColorSpace.Rgb) ColorSpace.get(ColorSpace.Named.SRGB);
+        DoubleUnaryOperator eotf = cs.getEotf();
+
+        double r = eotf.applyAsDouble(red(color) / 255.0);
+        double g = eotf.applyAsDouble(green(color) / 255.0);
+        double b = eotf.applyAsDouble(blue(color) / 255.0);
+
+        return (float) ((0.2126 * r) + (0.7152 * g) + (0.0722 * b));
+    }
+
+    @ColorInt
+    public static int parseColor(@Size(min=1) String colorString) {
+        if (colorString.charAt(0) == '#') {
+            // Use a long to avoid rollovers on #ffXXXXXX
+            long color = Long.parseLong(colorString.substring(1), 16);
+            if (colorString.length() == 7) {
+                // Set the alpha value
+                color |= 0x00000000ff000000;
+            } else if (colorString.length() != 9) {
+                throw new IllegalArgumentException("Unknown color");
+            }
+            return (int)color;
+        } else {
+            Integer color = sColorNameMap.get(colorString.toLowerCase(Locale.ROOT));
+            if (color != null) {
+                return color;
+            }
+        }
+        throw new IllegalArgumentException("Unknown color");
+    }
+
+    public static void RGBToHSV(
+            @IntRange(from = 0, to = 255) int red,
+            @IntRange(from = 0, to = 255) int green,
+            @IntRange(from = 0, to = 255) int blue, @Size(3) float hsv[]) {
+        if (hsv.length < 3) {
+            throw new RuntimeException("3 components required for hsv");
+        }
+        nativeRGBToHSV(red, green, blue, hsv);
+    }
+
+    public static void colorToHSV(@ColorInt int color, @Size(3) float hsv[]) {
+        RGBToHSV((color >> 16) & 0xFF, (color >> 8) & 0xFF, color & 0xFF, hsv);
+    }
+
+    @ColorInt
+    public static int HSVToColor(@Size(3) float hsv[]) {
+        return HSVToColor(0xFF, hsv);
+    }
+
+    @ColorInt
+    public static int HSVToColor(@IntRange(from = 0, to = 255) int alpha, @Size(3) float hsv[]) {
+        if (hsv.length < 3) {
+            throw new RuntimeException("3 components required for hsv");
+        }
+        return nativeHSVToColor(alpha, hsv);
+    }
+
+    private static native void nativeRGBToHSV(int red, int greed, int blue, float hsv[]);
+    private static native int nativeHSVToColor(int alpha, float hsv[]);
+
+    private static final HashMap<String, Integer> sColorNameMap;
+    static {
+        sColorNameMap = new HashMap<>();
+        sColorNameMap.put("black", BLACK);
+        sColorNameMap.put("darkgray", DKGRAY);
+        sColorNameMap.put("gray", GRAY);
+        sColorNameMap.put("lightgray", LTGRAY);
+        sColorNameMap.put("white", WHITE);
+        sColorNameMap.put("red", RED);
+        sColorNameMap.put("green", GREEN);
+        sColorNameMap.put("blue", BLUE);
+        sColorNameMap.put("yellow", YELLOW);
+        sColorNameMap.put("cyan", CYAN);
+        sColorNameMap.put("magenta", MAGENTA);
+        sColorNameMap.put("aqua", 0xFF00FFFF);
+        sColorNameMap.put("fuchsia", 0xFFFF00FF);
+        sColorNameMap.put("darkgrey", DKGRAY);
+        sColorNameMap.put("grey", GRAY);
+        sColorNameMap.put("lightgrey", LTGRAY);
+        sColorNameMap.put("lime", 0xFF00FF00);
+        sColorNameMap.put("maroon", 0xFF800000);
+        sColorNameMap.put("navy", 0xFF000080);
+        sColorNameMap.put("olive", 0xFF808000);
+        sColorNameMap.put("purple", 0xFF800080);
+        sColorNameMap.put("silver", 0xFFC0C0C0);
+        sColorNameMap.put("teal", 0xFF008080);
+
+    }
+}
+
@@ -0,0 +1,122 @@
+package android.graphics;
+
+import android.os.Parcelable;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import android.os.Parcel;
+
+public final class Rect {
+    public int left;
+    public int top;
+    public int right;
+    public int bottom;
+
+    private static final class UnflattenHelper {
+        private static final Pattern FLATTENED_PATTERN = Pattern.compile(
+            "(-?\\d+) (-?\\d+) (-?\\d+) (-?\\d+)");
+
+        static Matcher getMatcher(String str) {
+            return FLATTENED_PATTERN.matcher(str);
+        }
+    }
+
+    public Rect() {
+    }
+
+    public Rect(int left, int top, int right, int bottom) {
+        this.left = left;
+        this.top = top;
+        this.right = right;
+        this.bottom = bottom;
+    }
+
+    public Rect(Rect r) {
+        if (r == null) {
+            this.left = 0;
+            this.top = 0;
+            this.right = 0;
+            this.bottom = 0;
+        } else {
+            this.left = left;
+            this.top = top;
+            this.right = right;
+            this.bottom = bottom;
+        }
+    }
+
+    public final int getWidth() {
+        return right - left;
+    }
+
+    public final int getHeight() {
+        return bottom - top;
+    }
+
+    public static Rect unflattenFromString(String str) {
+        if (str.isEmpty()) {
+            return null;
+        }
+
+        Matcher matcher = UnflattenHelper.getMatcher(str);
+        if (!matcher.matches()) {
+            return null;
+        }
+
+        return new Rect(Integer.parseInt(matcher.group(1)),
+                        Integer.parseInt(matcher.group(2)),
+                        Integer.parseInt(matcher.group(3)),
+                        Integer.parseInt(matcher.group(4)));
+    }
+
+    public String toShortString() {
+        return toShortString(new StringBuilder(32));
+    }
+    
+    public String toShortString(StringBuilder sb) {
+        sb.setLength(0);
+        sb.append('['); sb.append(left); sb.append(',');
+        sb.append(top); sb.append("]["); sb.append(right);
+        sb.append(','); sb.append(bottom); sb.append(']');
+        return sb.toString();
+    }
+
+    public String flattenToString() {
+        StringBuilder sb = new StringBuilder(32);
+        sb.append(left);
+        sb.append(' ');
+        sb.append(top);
+        sb.append(' ');
+        sb.append(right);
+        sb.append(' ');
+        sb.append(bottom);
+        return sb.toString();
+    }
+
+    public void writeToParcel(Parcel out, int flags) {
+        out.writeInt(left);
+        out.writeInt(top);
+        out.writeInt(right);
+        out.writeInt(bottom);
+    }
+
+    public static final Parcelable.Creator<Rect> CREATOR = new Parcelable.Creator<Rect>() {
+        @Override
+        public Rect createFromParcel(Parcel in) {
+            Rect r = new Rect();
+            r.readFromParcel(in);
+            return r;
+        }
+
+        @Override
+        public Rect[] newArray(int size) {
+            return new Rect[size];
+        }
+    };
+
+    public void readFromParcel(Parcel in) {
+        left = in.readInt();
+        top = in.readInt();
+        right = in.readInt();
+        bottom = in.readInt();
+    }
+}
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2007 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 android.graphics;
+
+import com.android.internal.util.ArrayUtils;
+
+/**
+ * @hide
+ */
+public class TemporaryBuffer {
+    public static char[] obtain(int len) {
+        char[] buf;
+
+        synchronized (TemporaryBuffer.class) {
+            buf = sTemp;
+            sTemp = null;
+        }
+
+        if (buf == null || buf.length < len) {
+            buf = ArrayUtils.newUnpaddedCharArray(len);
+        }
+
+        return buf;
+    }
+
+    public static void recycle(char[] temp) {
+        if (temp.length > 1000) return;
+
+        synchronized (TemporaryBuffer.class) {
+            sTemp = temp;
+        }
+    }
+
+    private static char[] sTemp = null;
+}
+
@@ -0,0 +1,327 @@
+/*
+ * Copyright (C) 2006 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 android.graphics;
+
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.annotation.TestApi;
+import android.content.res.AssetManager;
+import android.util.Log;
+import com.android.internal.util.Preconditions;
+import java.awt.Font;
+import java.awt.FontFormatException;
+import java.awt.font.TextAttribute;
+import java.io.File;
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import android.annotation.NonNull;
+
+
+public class Typeface {
+
+    private static String TAG = "Typeface";
+
+    /** @hide */
+    public static final boolean ENABLE_LAZY_TYPEFACE_INITIALIZATION = true;
+
+    /** The default NORMAL typeface object */
+    public static final Typeface DEFAULT;
+    public static final Typeface DEFAULT_BOLD;
+    /** The NORMAL style of the default sans serif typeface. */
+    public static final Typeface SANS_SERIF;
+    /** The NORMAL style of the default serif typeface. */
+    public static final Typeface SERIF;
+    /** The NORMAL style of the default monospace typeface. */
+    public static final Typeface MONOSPACE;
+
+    public @interface Style {}
+
+    // Style
+    public static final int NORMAL = 0;
+    public static final int BOLD = 1;
+    public static final int ITALIC = 2;
+    public static final int BOLD_ITALIC = 3;
+    /** @hide */ public static final int STYLE_MASK = 0x03;
+
+    public static final String DEFAULT_FAMILY = "sans-serif";
+
+    private final Font mFont;
+
+    /** Returns the typeface's weight value */
+    public int getWeight() {
+        Map<TextAttribute, Object> atts = (Map<TextAttribute, Object>) mFont.getAttributes();
+        Object weight = atts.getOrDefault(TextAttribute.WEIGHT, TextAttribute.WEIGHT_REGULAR);
+        if (weight instanceof Float) {
+            float w = ((Float) weight).floatValue();
+            // undo the transformation
+            return (int) ((w - TextAttribute.WEIGHT_REGULAR) / (TextAttribute.WEIGHT_BOLD - TextAttribute.WEIGHT_REGULAR) * (Builder.BOLD_WEIGHT - Builder.NORMAL_WEIGHT) + Builder.NORMAL_WEIGHT);
+        }
+        return Builder.NORMAL_WEIGHT;
+    }
+
+    public float getJavaWeight() {
+        Map<TextAttribute, Object> atts = (Map<TextAttribute, Object>) mFont.getAttributes();
+        Object weight = atts.getOrDefault(TextAttribute.WEIGHT, TextAttribute.WEIGHT_REGULAR);
+        if (weight instanceof Float) {
+            return ((Float) weight).floatValue();
+        }
+        return TextAttribute.WEIGHT_REGULAR;
+    }
+
+    /** Returns the typeface's intrinsic style attributes */
+    public @Style int getStyle() {
+        if (isBold() && isItalic()) return BOLD_ITALIC;
+        if (isBold()) return BOLD;
+        if (isItalic()) return ITALIC;
+        return NORMAL;
+    }
+
+    /** Returns true if getStyle() has the BOLD bit set. */
+    public final boolean isBold() {
+        return mFont.isBold();
+    }
+
+    /** Returns true if getStyle() has the ITALIC bit set. */
+    public final boolean isItalic() {
+        return mFont.isItalic();
+    }
+
+    public final @Nullable String getSystemFontFamilyName() {
+        return mFont.getFamily();
+    }
+
+    public static Typeface findFromCache(AssetManager mgr, String path) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static final class Builder {
+        /** @hide */
+        public static final int NORMAL_WEIGHT = 400;
+        /** @hide */
+        public static final int BOLD_WEIGHT = 700;
+
+        private final String mPath;
+
+        private Font mFont;
+        private int mStyle;
+        private Map<TextAttribute, Object> mAttributes;
+
+        private String mFallbackFamilyName;
+
+        public Builder(@NonNull File path) {
+            mFont = loadFont(path);
+            Log.v(TAG, "Font loaded from " + path.toURI());
+            mPath = null;
+            mStyle = 0;
+            mAttributes = new HashMap<TextAttribute, Object>();
+        }
+
+        public Builder(@NonNull FileDescriptor fd) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public Builder(@NonNull String path) {
+            mFont = loadFont(new File(path));
+            mPath = path;
+            mStyle = 0;
+            mAttributes = new HashMap<TextAttribute, Object>();
+        }
+
+        public Builder(@NonNull AssetManager assetManager, @NonNull String path) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public Builder(@NonNull AssetManager assetManager, @NonNull String path, boolean isAsset,
+                int cookie) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public Builder setWeight(int weight) {
+            // java font weight does not follow typical weight distribution
+            // In Java, regular weight is at 1.0 and bold at 2.0, compared to 400 and 700 in TTF
+            // Typical range is 0 to 1000
+
+            float jWeight = (weight - NORMAL_WEIGHT) / (BOLD_WEIGHT - NORMAL_WEIGHT) * (TextAttribute.WEIGHT_BOLD - TextAttribute.WEIGHT_REGULAR) + TextAttribute.WEIGHT_REGULAR;
+            mAttributes.put(TextAttribute.WEIGHT, jWeight);
+            return this;
+        }
+
+        public Builder setItalic(boolean italic) {
+            if (italic) {
+                mStyle |= Font.ITALIC;
+            } else {
+                mStyle &= ~Font.ITALIC;
+            }
+            return this;
+        }
+
+        public Builder setTtcIndex(int ttcIndex) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public Builder setFontVariationSettings(@Nullable String variationSettings) {
+            throw new RuntimeException("Stub!");
+        }
+
+        public Builder setFallback(@Nullable String familyName) {
+            mFallbackFamilyName = familyName;
+            return this;
+        }
+
+        private Typeface resolveFallbackTypeface() {
+            if (mFallbackFamilyName == null) {
+                return null;
+            }
+
+            return new Typeface(new Font(mFallbackFamilyName, mStyle, 12).deriveFont(mAttributes));
+        }
+
+        public Typeface build() {
+            if (mFont == null) return resolveFallbackTypeface();
+            return new Typeface(mFont.deriveFont(mStyle).deriveFont(mAttributes));
+        }
+
+        private Font loadFont(File fontFile) {
+            try {
+                return Font.createFont(Font.TRUETYPE_FONT, fontFile);
+            } catch (FontFormatException ex) {
+                Log.v(TAG, "Failed to create font as TTF", ex);
+            } catch (IOException ex) {
+                Log.v(TAG, "Failed to create font as TTF", ex);
+                throw new RuntimeException(ex);
+            }
+            try {
+                return Font.createFont(Font.TYPE1_FONT, fontFile);
+            } catch (FontFormatException ex) {
+                Log.v(TAG, "Failed to create font as T1", ex);
+            } catch (IOException ex) {
+                Log.v(TAG, "Failed to create font as T1", ex);
+                throw new RuntimeException(ex);
+            }
+            return null;
+        }
+    }
+
+    public static Typeface create(String familyName, @Style int style) {
+        return create(getSystemDefaultTypeface(familyName), style);
+    }
+
+    public static Typeface create(Typeface family, @Style int style) {
+        if ((style & ~STYLE_MASK) != 0) {
+            style = NORMAL;
+        }
+        if (family == null) {
+            family = getSystemDefaultTypeface(DEFAULT_FAMILY);
+        }
+
+        throw new RuntimeException("Stub!");
+    }
+
+    public static @NonNull Typeface create(@Nullable Typeface family,
+            int weight, boolean italic) {
+        Preconditions.checkArgumentInRange(weight, 0, 1000, "weight");
+        if (family == null) {
+            family = getSystemDefaultTypeface(DEFAULT_FAMILY);
+        }
+        return createWeightStyle(family, weight, italic);
+    }
+
+    private static @NonNull Typeface createWeightStyle(@NonNull Typeface base,
+            int weight, boolean italic) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static Typeface defaultFromStyle(@Style int style) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static Typeface createFromAsset(AssetManager mgr, String path) {
+        Preconditions.checkNotNull(path); // for backward compatibility
+        Preconditions.checkNotNull(mgr);
+
+        Typeface typeface = new Builder(mgr, path).build();
+        if (typeface != null) return typeface;
+        // check if the file exists, and throw an exception for backward compatibility
+        try (InputStream inputStream = mgr.open(path)) {
+        } catch (IOException e) {
+            throw new RuntimeException("Font asset not found " + path);
+        }
+
+        return Typeface.DEFAULT;
+    }
+
+    public Typeface(Font fnt) {
+        mFont = fnt;
+    }
+
+    public static Typeface createFromFile(@Nullable File file) {
+        // For the compatibility reasons, leaving possible NPE here.
+        // See android.graphics.cts.TypefaceTest#testCreateFromFileByFileReferenceNull
+
+        Typeface typeface = new Builder(file).build();
+        if (typeface != null) return typeface;
+
+        // check if the file exists, and throw an exception for backward compatibility
+        if (!file.exists()) {
+            throw new RuntimeException("Font asset not found " + file.getAbsolutePath());
+        }
+
+        return Typeface.DEFAULT;
+    }
+
+    public static Typeface createFromFile(@Nullable String path) {
+        Preconditions.checkNotNull(path); // for backward compatibility
+        return createFromFile(new File(path));
+    }
+
+    private static Typeface getSystemDefaultTypeface(@NonNull String familyName) {
+        return new Typeface(new Font(familyName, 0, 12));
+    }
+
+    public Font getFont() {
+        return mFont;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Typeface typeface = (Typeface) o;
+
+        return typeface.mFont.equals(mFont);
+    }
+
+    @Override
+    public int hashCode() {
+        return mFont.hashCode();
+    }
+
+    static {
+        DEFAULT = new Typeface(new Font(null, 0, 12));
+        DEFAULT_BOLD = new Typeface(new Font(null, Font.BOLD, 12));
+        SANS_SERIF = new Typeface(new Font(Font.SANS_SERIF, 0, 12));
+        SERIF = new Typeface(new Font(Font.SERIF, 0, 12));
+        MONOSPACE = new Typeface(new Font(Font.MONOSPACED, 0, 12));
+    }
+}
+
@@ -1,7 +1,7 @@
 package android.os;

 import xyz.nulldev.androidcompat.io.AndroidFiles;
-import xyz.nulldev.androidcompat.util.KodeinGlobalHelper;
+import xyz.nulldev.androidcompat.util.KoinGlobalHelper;

 import java.io.File;

@@ -9,7 +9,7 @@ import java.io.File;
 * Android compatibility layer for files
 */
 public class Environment {
-    private static AndroidFiles androidFiles = KodeinGlobalHelper.instance(AndroidFiles.class);
+    private static AndroidFiles androidFiles = KoinGlobalHelper.instance(AndroidFiles.class);

    public static String DIRECTORY_ALARMS = getHomeDirectory("Alarms").getAbsolutePath();
    public static String DIRECTORY_DCIM = getHomeDirectory("DCIM").getAbsolutePath();
@@ -0,0 +1,25 @@
+/* //device/java/android/android/app/IActivityPendingResult.aidl
+**
+** Copyright 2007, 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 android.os;
+
+import android.os.Message;
+
+/** @hide */
+/* oneway */ interface IMessenger {
+    void send(/* in */ Message msg);
+}
@@ -0,0 +1,575 @@
+/*
+ * Copyright (C) 2006 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 android.os;
+
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.util.Log;
+import android.util.Printer;
+import android.util.Slog;
+import android.util.proto.ProtoOutputStream;
+
+import java.util.Objects;
+
+/**
+  * Class used to run a message loop for a thread.  Threads by default do
+  * not have a message loop associated with them; to create one, call
+  * {@link #prepare} in the thread that is to run the loop, and then
+  * {@link #loop} to have it process messages until the loop is stopped.
+  *
+  * <p>Most interaction with a message loop is through the
+  * {@link Handler} class.
+  *
+  * <p>This is a typical example of the implementation of a Looper thread,
+  * using the separation of {@link #prepare} and {@link #loop} to create an
+  * initial Handler to communicate with the Looper.
+  *
+  * <pre>
+  *  class LooperThread extends Thread {
+  *      public Handler mHandler;
+  *
+  *      public void run() {
+  *          Looper.prepare();
+  *
+  *          mHandler = new Handler(Looper.myLooper()) {
+  *              public void handleMessage(Message msg) {
+  *                  // process incoming messages here
+  *              }
+  *          };
+  *
+  *          Looper.loop();
+  *      }
+  *  }</pre>
+  */
+public final class Looper {
+    /*
+     * API Implementation Note:
+     *
+     * This class contains the code required to set up and manage an event loop
+     * based on MessageQueue.  APIs that affect the state of the queue should be
+     * defined on MessageQueue or Handler rather than on Looper itself.  For example,
+     * idle handlers and sync barriers are defined on the queue whereas preparing the
+     * thread, looping, and quitting are defined on the looper.
+     */
+
+    private static final String TAG = "Looper";
+
+    private static class NoImagePreloadHolder {
+        // Enable/Disable verbose logging with a system prop. e.g.
+        // adb shell 'setprop log.looper.slow.verbose false && stop && start'
+        private static final boolean sVerboseLogging =
+                SystemProperties.getBoolean("log.looper.slow.verbose", false);
+    }
+
+    // sThreadLocal.get() will return null unless you've called prepare().
+    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
+    private static Looper sMainLooper;  // guarded by Looper.class
+    private static Observer sObserver;
+
+    final MessageQueue mQueue;
+    final Thread mThread;
+    private boolean mInLoop;
+
+    private Printer mLogging;
+    private long mTraceTag;
+
+    /**
+     * If set, the looper will show a warning log if a message dispatch takes longer than this.
+     */
+    private long mSlowDispatchThresholdMs;
+
+    /**
+     * If set, the looper will show a warning log if a message delivery (actual delivery time -
+     * post time) takes longer than this.
+     */
+    private long mSlowDeliveryThresholdMs;
+
+    /**
+     * True if a message delivery takes longer than {@link #mSlowDeliveryThresholdMs}.
+     */
+    private boolean mSlowDeliveryDetected;
+
+    /** Initialize the current thread as a looper.
+      * This gives you a chance to create handlers that then reference
+      * this looper, before actually starting the loop. Be sure to call
+      * {@link #loop()} after calling this method, and end it by calling
+      * {@link #quit()}.
+      */
+    public static void prepare() {
+        prepare(true);
+    }
+
+    private static void prepare(boolean quitAllowed) {
+        if (sThreadLocal.get() != null) {
+            throw new RuntimeException("Only one Looper may be created per thread");
+        }
+        sThreadLocal.set(new Looper(quitAllowed));
+    }
+
+    /**
+     * Initialize the current thread as a looper, marking it as an
+     * application's main looper. See also: {@link #prepare()}
+     *
+     * @deprecated The main looper for your application is created by the Android environment,
+     *   so you should never need to call this function yourself.
+     */
+    @Deprecated
+    public static void prepareMainLooper() {
+        prepare(false);
+        synchronized (Looper.class) {
+            if (sMainLooper != null) {
+                throw new IllegalStateException("The main Looper has already been prepared.");
+            }
+            sMainLooper = myLooper();
+        }
+    }
+
+    /**
+     * Returns the application's main looper, which lives in the main thread of the application.
+     */
+    public static Looper getMainLooper() {
+        synchronized (Looper.class) {
+            return sMainLooper;
+        }
+    }
+
+    /**
+     * Force the application's main looper to the given value.  The main looper is typically
+     * configured automatically by the OS, so this capability is only intended to enable testing.
+     *
+     * @hide
+     */
+    public static void setMainLooperForTest(@NonNull Looper looper) {
+        synchronized (Looper.class) {
+            sMainLooper = Objects.requireNonNull(looper);
+        }
+    }
+
+    /**
+     * Clear the application's main looper to be undefined.  The main looper is typically
+     * configured automatically by the OS, so this capability is only intended to enable testing.
+     *
+     * @hide
+     */
+    public static void clearMainLooperForTest() {
+        synchronized (Looper.class) {
+            sMainLooper = null;
+        }
+    }
+
+    /**
+     * Set the transaction observer for all Loopers in this process.
+     *
+     * @hide
+     */
+    public static void setObserver(@Nullable Observer observer) {
+        sObserver = observer;
+    }
+
+    /**
+     * Poll and deliver single message, return true if the outer loop should continue.
+     */
+    @SuppressWarnings({"UnusedTokenOfOriginalCallingIdentity",
+            "ClearIdentityCallNotFollowedByTryFinally"})
+    private static boolean loopOnce(final Looper me,
+            final long ident, final int thresholdOverride) {
+        Message msg = me.mQueue.next(); // might block
+        if (msg == null) {
+            // No message indicates that the message queue is quitting.
+            return false;
+        }
+
+        // This must be in a local variable, in case a UI event sets the logger
+        final Printer logging = me.mLogging;
+        if (logging != null) {
+            logging.println(">>>>> Dispatching to " + msg.target + " "
+                    + msg.callback + ": " + msg.what);
+        }
+        // Make sure the observer won't change while processing a transaction.
+        final Observer observer = sObserver;
+
+        final long traceTag = me.mTraceTag;
+        long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
+        long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;
+
+        final boolean hasOverride = thresholdOverride >= 0;
+        if (hasOverride) {
+            slowDispatchThresholdMs = thresholdOverride;
+            slowDeliveryThresholdMs = thresholdOverride;
+        }
+        final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0 || hasOverride)
+                && (msg.when > 0);
+        final boolean logSlowDispatch = (slowDispatchThresholdMs > 0 || hasOverride);
+
+        final boolean needStartTime = logSlowDelivery || logSlowDispatch;
+        final boolean needEndTime = logSlowDispatch;
+
+        final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;
+        final long dispatchEnd;
+        Object token = null;
+        if (observer != null) {
+            token = observer.messageDispatchStarting();
+        }
+        long origWorkSource = ThreadLocalWorkSource.setUid(msg.workSourceUid);
+        try {
+            msg.target.dispatchMessage(msg);
+            if (observer != null) {
+                observer.messageDispatched(token, msg);
+            }
+        } catch (Exception exception) {
+            if (observer != null) {
+                observer.dispatchingThrewException(token, msg, exception);
+            }
+            Log.e(TAG, "Loop handler threw", exception);
+            // throw exception;
+        } finally {
+            dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
+            ThreadLocalWorkSource.restore(origWorkSource);
+        }
+        if (logSlowDelivery) {
+            boolean slow = false;
+
+            if (!me.mSlowDeliveryDetected || NoImagePreloadHolder.sVerboseLogging) {
+                slow = showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart,
+                        "delivery", msg);
+            }
+            if (me.mSlowDeliveryDetected) {
+                if (!slow && (dispatchStart - msg.when) <= 10) {
+                    Slog.w(TAG, "Drained");
+                    me.mSlowDeliveryDetected = false;
+                }
+            } else if (slow) {
+                // A slow delivery is detected, suppressing further logs unless verbose logging
+                // is enabled.
+                me.mSlowDeliveryDetected = true;
+            }
+        }
+        if (logSlowDispatch) {
+            showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", msg);
+        }
+
+        if (logging != null) {
+            logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
+        }
+
+        // Make sure that during the course of dispatching the
+        // identity of the thread wasn't corrupted.
+        // final long newIdent = Binder.clearCallingIdentity();
+        // if (ident != newIdent) {
+        //     Log.wtf(TAG, "Thread identity changed from 0x"
+        //             + Long.toHexString(ident) + " to 0x"
+        //             + Long.toHexString(newIdent) + " while dispatching to "
+        //             + msg.target.getClass().getName() + " "
+        //             + msg.callback + " what=" + msg.what);
+        // }
+
+        msg.recycleUnchecked();
+
+        return true;
+    }
+
+    /**
+     * Run the message queue in this thread. Be sure to call
+     * {@link #quit()} to end the loop.
+     */
+    @SuppressWarnings({"UnusedTokenOfOriginalCallingIdentity",
+            "ClearIdentityCallNotFollowedByTryFinally",
+            "ResultOfClearIdentityCallNotStoredInVariable"})
+    public static void loop() {
+        final Looper me = myLooper();
+        if (me == null) {
+            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
+        }
+        if (me.mInLoop) {
+            Slog.w(TAG, "Loop again would have the queued messages be executed"
+                    + " before this one completed.");
+        }
+
+        me.mInLoop = true;
+
+        // Make sure the identity of this thread is that of the local process,
+        // and keep track of what that identity token actually is.
+        // Binder.clearCallingIdentity();
+        // final long ident = Binder.clearCallingIdentity();
+        final long ident = 0;
+
+        // Allow overriding a threshold with a system prop. e.g.
+        // adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'
+        final int thresholdOverride = getThresholdOverride();
+
+        me.mSlowDeliveryDetected = false;
+
+        for (;;) {
+            if (!loopOnce(me, ident, thresholdOverride)) {
+                return;
+            }
+        }
+    }
+
+    private static int getThresholdOverride() {
+        return -1;
+        // // Allow overriding the threshold for all processes' main looper with a system prop.
+        // // e.g. adb shell 'setprop log.looper.any.main.slow 1 && stop && start'
+        // if (myLooper() == getMainLooper()) {
+        //     final int globalOverride = SystemProperties.getInt("log.looper.any.main.slow", -1);
+        //     if (globalOverride >= 0) {
+        //         return globalOverride;
+        //     }
+        // }
+
+        // // Allow overriding the threshold for all threads within a process with a system prop.
+        // // e.g. adb shell 'setprop log.looper.1000.any.slow 1 && stop && start'
+        // final int processOverride = SystemProperties.getInt("log.looper."
+        //         + Process.myUid() + ".any.slow", -1);
+        // if (processOverride >= 0) {
+        //     return processOverride;
+        // }
+
+        // return SystemProperties.getInt("log.looper."
+        //         + Process.myUid() + "."
+        //         + Thread.currentThread().getName()
+        //         + ".slow", -1);
+    }
+
+    private static int getThresholdOverride$ravenwood() {
+        return -1;
+    }
+
+    private static int getThreadGroup() {
+        int threadGroup = Process.THREAD_GROUP_DEFAULT;
+
+        if (!Process.isIsolated()) {
+            threadGroup = Process.getProcessGroup(Process.myTid());
+        }
+        return threadGroup;
+    }
+
+    private static String threadGroupToString(int threadGroup) {
+        switch (threadGroup) {
+            case Process.THREAD_GROUP_SYSTEM:
+                return "SYSTEM";
+            case Process.THREAD_GROUP_AUDIO_APP:
+                return "AUDIO_APP";
+            case Process.THREAD_GROUP_AUDIO_SYS:
+                return "AUDIO_SYS";
+            case Process.THREAD_GROUP_TOP_APP:
+                return "TOP_APP";
+            case Process.THREAD_GROUP_RT_APP:
+                return "RT_APP";
+            default:
+                return "UNKNOWN";
+        }
+    }
+
+    private static boolean showSlowLog(long threshold, long measureStart, long measureEnd,
+            String what, Message msg) {
+        final long actualTime = measureEnd - measureStart;
+        if (actualTime < threshold) {
+            return false;
+        }
+
+        String name = /* Process.myProcessName() */ "Stub!";
+        String threadGroup = threadGroupToString(getThreadGroup());
+        boolean isMain = myLooper() == getMainLooper();
+
+        // For slow delivery, the current message isn't really important, but log it anyway.
+        Slog.w(TAG, "Slow " + what + " took " + actualTime + "ms "
+                + Thread.currentThread().getName() + " app=" + name
+                + " main=" + isMain + " group=" + threadGroup
+                + " h=" + msg.target.getClass().getName() + " c=" + msg.callback
+                + " m=" + msg.what);
+        return true;
+    }
+
+    /**
+     * Return the Looper object associated with the current thread.  Returns
+     * null if the calling thread is not associated with a Looper.
+     */
+    public static @Nullable Looper myLooper() {
+        return sThreadLocal.get();
+    }
+
+    /**
+     * Return the {@link MessageQueue} object associated with the current
+     * thread.  This must be called from a thread running a Looper, or a
+     * NullPointerException will be thrown.
+     */
+    public static @NonNull MessageQueue myQueue() {
+        return myLooper().mQueue;
+    }
+
+    private Looper(boolean quitAllowed) {
+        mQueue = new MessageQueue(quitAllowed);
+        mThread = Thread.currentThread();
+    }
+
+    /**
+     * Returns true if the current thread is this looper's thread.
+     */
+    public boolean isCurrentThread() {
+        return Thread.currentThread() == mThread;
+    }
+
+    /**
+     * Control logging of messages as they are processed by this Looper.  If
+     * enabled, a log message will be written to <var>printer</var>
+     * at the beginning and ending of each message dispatch, identifying the
+     * target Handler and message contents.
+     *
+     * @param printer A Printer object that will receive log messages, or
+     * null to disable message logging.
+     */
+    public void setMessageLogging(@Nullable Printer printer) {
+        mLogging = printer;
+    }
+
+    /** {@hide} */
+    public void setTraceTag(long traceTag) {
+        mTraceTag = traceTag;
+    }
+
+    /**
+     * Set a thresholds for slow dispatch/delivery log.
+     * {@hide}
+     */
+    public void setSlowLogThresholdMs(long slowDispatchThresholdMs, long slowDeliveryThresholdMs) {
+        mSlowDispatchThresholdMs = slowDispatchThresholdMs;
+        mSlowDeliveryThresholdMs = slowDeliveryThresholdMs;
+    }
+
+    /**
+     * Quits the looper.
+     * <p>
+     * Causes the {@link #loop} method to terminate without processing any
+     * more messages in the message queue.
+     * </p><p>
+     * Any attempt to post messages to the queue after the looper is asked to quit will fail.
+     * For example, the {@link Handler#sendMessage(Message)} method will return false.
+     * </p><p class="note">
+     * Using this method may be unsafe because some messages may not be delivered
+     * before the looper terminates.  Consider using {@link #quitSafely} instead to ensure
+     * that all pending work is completed in an orderly manner.
+     * </p>
+     *
+     * @see #quitSafely
+     */
+    public void quit() {
+        mQueue.quit(false);
+    }
+
+    /**
+     * Quits the looper safely.
+     * <p>
+     * Causes the {@link #loop} method to terminate as soon as all remaining messages
+     * in the message queue that are already due to be delivered have been handled.
+     * However pending delayed messages with due times in the future will not be
+     * delivered before the loop terminates.
+     * </p><p>
+     * Any attempt to post messages to the queue after the looper is asked to quit will fail.
+     * For example, the {@link Handler#sendMessage(Message)} method will return false.
+     * </p>
+     */
+    public void quitSafely() {
+        mQueue.quit(true);
+    }
+
+    /**
+     * Gets the Thread associated with this Looper.
+     *
+     * @return The looper's thread.
+     */
+    public @NonNull Thread getThread() {
+        return mThread;
+    }
+
+    /**
+     * Gets this looper's message queue.
+     *
+     * @return The looper's message queue.
+     */
+    public @NonNull MessageQueue getQueue() {
+        return mQueue;
+    }
+
+    /**
+     * Dumps the state of the looper for debugging purposes.
+     *
+     * @param pw A printer to receive the contents of the dump.
+     * @param prefix A prefix to prepend to each line which is printed.
+     */
+    public void dump(@NonNull Printer pw, @NonNull String prefix) {
+        throw new RuntimeException("Stub!");
+    }
+
+    /**
+     * Dumps the state of the looper for debugging purposes.
+     *
+     * @param pw A printer to receive the contents of the dump.
+     * @param prefix A prefix to prepend to each line which is printed.
+     * @param handler Only dump messages for this Handler.
+     * @hide
+     */
+    public void dump(@NonNull Printer pw, @NonNull String prefix, Handler handler) {
+        throw new RuntimeException("Stub!");
+    }
+
+    /** @hide */
+    public void dumpDebug(ProtoOutputStream proto, long fieldId) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override
+    public String toString() {
+        return "Looper (" + mThread.getName() + ", tid " + mThread.getId()
+                + ") {" + Integer.toHexString(System.identityHashCode(this)) + "}";
+    }
+
+    /** {@hide} */
+    public interface Observer {
+        /**
+         * Called right before a message is dispatched.
+         *
+         * <p> The token type is not specified to allow the implementation to specify its own type.
+         *
+         * @return a token used for collecting telemetry when dispatching a single message.
+         *         The token token must be passed back exactly once to either
+         *         {@link Observer#messageDispatched} or {@link Observer#dispatchingThrewException}
+         *         and must not be reused again.
+         *
+         */
+        Object messageDispatchStarting();
+
+        /**
+         * Called when a message was processed by a Handler.
+         *
+         * @param token Token obtained by previously calling
+         *              {@link Observer#messageDispatchStarting} on the same Observer instance.
+         * @param msg The message that was dispatched.
+         */
+        void messageDispatched(Object token, Message msg);
+
+        /**
+         * Called when an exception was thrown while processing a message.
+         *
+         * @param token Token obtained by previously calling
+         *              {@link Observer#messageDispatchStarting} on the same Observer instance.
+         * @param msg The message that was dispatched and caused an exception.
+         * @param exception The exception that was thrown.
+         */
+        void dispatchingThrewException(Object token, Message msg, Exception exception);
+    }
+}
@@ -0,0 +1,630 @@
+/*
+ * Copyright (C) 2006 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 android.os;
+
+import android.annotation.Nullable;
+import android.util.TimeUtils;
+import android.util.proto.ProtoOutputStream;
+
+/**
+ *
+ * Defines a message containing a description and arbitrary data object that can be
+ * sent to a {@link Handler}.  This object contains two extra int fields and an
+ * extra object field that allow you to not do allocations in many cases.
+ *
+ * <p class="note">While the constructor of Message is public, the best way to get
+ * one of these is to call {@link #obtain Message.obtain()} or one of the
+ * {@link Handler#obtainMessage Handler.obtainMessage()} methods, which will pull
+ * them from a pool of recycled objects.</p>
+ */
+public final class Message implements Parcelable {
+    /**
+     * User-defined message code so that the recipient can identify
+     * what this message is about. Each {@link Handler} has its own name-space
+     * for message codes, so you do not need to worry about yours conflicting
+     * with other handlers.
+     *
+     * If not specified, this value is 0.
+     * Use values other than 0 to indicate custom message codes.
+     */
+    public int what;
+
+    /**
+     * arg1 and arg2 are lower-cost alternatives to using
+     * {@link #setData(Bundle) setData()} if you only need to store a
+     * few integer values.
+     */
+    public int arg1;
+
+    /**
+     * arg1 and arg2 are lower-cost alternatives to using
+     * {@link #setData(Bundle) setData()} if you only need to store a
+     * few integer values.
+     */
+    public int arg2;
+
+    /**
+     * An arbitrary object to send to the recipient.  When using
+     * {@link Messenger} to send the message across processes this can only
+     * be non-null if it contains a Parcelable of a framework class (not one
+     * implemented by the application).   For other data transfer use
+     * {@link #setData}.
+     *
+     * <p>Note that Parcelable objects here are not supported prior to
+     * the {@link android.os.Build.VERSION_CODES#FROYO} release.
+     */
+    public Object obj;
+
+    /**
+     * Optional Messenger where replies to this message can be sent.  The
+     * semantics of exactly how this is used are up to the sender and
+     * receiver.
+     */
+    public Messenger replyTo;
+
+    /**
+     * Indicates that the uid is not set;
+     *
+     * @hide Only for use within the system server.
+     */
+    public static final int UID_NONE = -1;
+
+    /**
+     * Optional field indicating the uid that sent the message.  This is
+     * only valid for messages posted by a {@link Messenger}; otherwise,
+     * it will be -1.
+     */
+    public int sendingUid = UID_NONE;
+
+    /**
+     * Optional field indicating the uid that caused this message to be enqueued.
+     *
+     * @hide Only for use within the system server.
+     */
+    public int workSourceUid = UID_NONE;
+
+    /** If set message is in use.
+     * This flag is set when the message is enqueued and remains set while it
+     * is delivered and afterwards when it is recycled.  The flag is only cleared
+     * when a new message is created or obtained since that is the only time that
+     * applications are allowed to modify the contents of the message.
+     *
+     * It is an error to attempt to enqueue or recycle a message that is already in use.
+     */
+    /*package*/ static final int FLAG_IN_USE = 1 << 0;
+
+    /** If set message is asynchronous */
+    /*package*/ static final int FLAG_ASYNCHRONOUS = 1 << 1;
+
+    /** Flags to clear in the copyFrom method */
+    /*package*/ static final int FLAGS_TO_CLEAR_ON_COPY_FROM = FLAG_IN_USE;
+
+    /*package*/ int flags;
+
+    /**
+     * The targeted delivery time of this message. The time-base is
+     * {@link SystemClock#uptimeMillis}.
+     * @hide Only for use within the tests.
+     */
+    public long when;
+
+    /** @hide */
+    @SuppressWarnings("unused")
+    public long mInsertSeq;
+
+    /*package*/ Bundle data;
+
+    /*package*/ Handler target;
+
+    /*package*/ Runnable callback;
+
+    // sometimes we store linked lists of these things
+    /*package*/ Message next;
+
+
+    /** @hide */
+    public static final Object sPoolSync = new Object();
+    private static Message sPool;
+    private static int sPoolSize = 0;
+
+    private static final int MAX_POOL_SIZE = 50;
+
+    private static boolean gCheckRecycle = true;
+
+    /**
+     * Return a new Message instance from the global pool. Allows us to
+     * avoid allocating new objects in many cases.
+     */
+    public static Message obtain() {
+        synchronized (sPoolSync) {
+            if (sPool != null) {
+                Message m = sPool;
+                sPool = m.next;
+                m.next = null;
+                m.flags = 0; // clear in-use flag
+                sPoolSize--;
+                return m;
+            }
+        }
+        return new Message();
+    }
+
+    /**
+     * Same as {@link #obtain()}, but copies the values of an existing
+     * message (including its target) into the new one.
+     * @param orig Original message to copy.
+     * @return A Message object from the global pool.
+     */
+    public static Message obtain(Message orig) {
+        Message m = obtain();
+        m.what = orig.what;
+        m.arg1 = orig.arg1;
+        m.arg2 = orig.arg2;
+        m.obj = orig.obj;
+        m.replyTo = orig.replyTo;
+        m.sendingUid = orig.sendingUid;
+        m.workSourceUid = orig.workSourceUid;
+        if (orig.data != null) {
+            m.data = new Bundle(orig.data);
+        }
+        m.target = orig.target;
+        m.callback = orig.callback;
+
+        return m;
+    }
+
+    /**
+     * Same as {@link #obtain()}, but sets the value for the <em>target</em> member on the Message returned.
+     * @param h  Handler to assign to the returned Message object's <em>target</em> member.
+     * @return A Message object from the global pool.
+     */
+    public static Message obtain(Handler h) {
+        Message m = obtain();
+        m.target = h;
+
+        return m;
+    }
+
+    /**
+     * Same as {@link #obtain(Handler)}, but assigns a callback Runnable on
+     * the Message that is returned.
+     * @param h  Handler to assign to the returned Message object's <em>target</em> member.
+     * @param callback Runnable that will execute when the message is handled.
+     * @return A Message object from the global pool.
+     */
+    public static Message obtain(Handler h, Runnable callback) {
+        Message m = obtain();
+        m.target = h;
+        m.callback = callback;
+
+        return m;
+    }
+
+    /**
+     * Same as {@link #obtain()}, but sets the values for both <em>target</em> and
+     * <em>what</em> members on the Message.
+     * @param h  Value to assign to the <em>target</em> member.
+     * @param what  Value to assign to the <em>what</em> member.
+     * @return A Message object from the global pool.
+     */
+    public static Message obtain(Handler h, int what) {
+        Message m = obtain();
+        m.target = h;
+        m.what = what;
+
+        return m;
+    }
+
+    /**
+     * Same as {@link #obtain()}, but sets the values of the <em>target</em>, <em>what</em>, and <em>obj</em>
+     * members.
+     * @param h  The <em>target</em> value to set.
+     * @param what  The <em>what</em> value to set.
+     * @param obj  The <em>object</em> method to set.
+     * @return  A Message object from the global pool.
+     */
+    public static Message obtain(Handler h, int what, Object obj) {
+        Message m = obtain();
+        m.target = h;
+        m.what = what;
+        m.obj = obj;
+
+        return m;
+    }
+
+    /**
+     * Same as {@link #obtain()}, but sets the values of the <em>target</em>, <em>what</em>,
+     * <em>arg1</em>, and <em>arg2</em> members.
+     *
+     * @param h  The <em>target</em> value to set.
+     * @param what  The <em>what</em> value to set.
+     * @param arg1  The <em>arg1</em> value to set.
+     * @param arg2  The <em>arg2</em> value to set.
+     * @return  A Message object from the global pool.
+     */
+    public static Message obtain(Handler h, int what, int arg1, int arg2) {
+        Message m = obtain();
+        m.target = h;
+        m.what = what;
+        m.arg1 = arg1;
+        m.arg2 = arg2;
+
+        return m;
+    }
+
+    /**
+     * Same as {@link #obtain()}, but sets the values of the <em>target</em>, <em>what</em>,
+     * <em>arg1</em>, <em>arg2</em>, and <em>obj</em> members.
+     *
+     * @param h  The <em>target</em> value to set.
+     * @param what  The <em>what</em> value to set.
+     * @param arg1  The <em>arg1</em> value to set.
+     * @param arg2  The <em>arg2</em> value to set.
+     * @param obj  The <em>obj</em> value to set.
+     * @return  A Message object from the global pool.
+     */
+    public static Message obtain(Handler h, int what,
+            int arg1, int arg2, Object obj) {
+        Message m = obtain();
+        m.target = h;
+        m.what = what;
+        m.arg1 = arg1;
+        m.arg2 = arg2;
+        m.obj = obj;
+
+        return m;
+    }
+
+    /** @hide */
+    public static void updateCheckRecycle(int targetSdkVersion) {
+        if (targetSdkVersion < Build.VERSION_CODES.LOLLIPOP) {
+            gCheckRecycle = false;
+        }
+    }
+
+    /**
+     * Return a Message instance to the global pool.
+     * <p>
+     * You MUST NOT touch the Message after calling this function because it has
+     * effectively been freed.  It is an error to recycle a message that is currently
+     * enqueued or that is in the process of being delivered to a Handler.
+     * </p>
+     */
+    public void recycle() {
+        if (isInUse()) {
+            if (gCheckRecycle) {
+                throw new IllegalStateException("This message cannot be recycled because it "
+                        + "is still in use.");
+            }
+            return;
+        }
+        recycleUnchecked();
+    }
+
+    /**
+     * Recycles a Message that may be in-use.
+     * Used internally by the MessageQueue and Looper when disposing of queued Messages.
+     */
+    void recycleUnchecked() {
+        // Mark the message as in use while it remains in the recycled object pool.
+        // Clear out all other details.
+        flags = FLAG_IN_USE;
+        what = 0;
+        arg1 = 0;
+        arg2 = 0;
+        obj = null;
+        replyTo = null;
+        sendingUid = UID_NONE;
+        workSourceUid = UID_NONE;
+        when = 0;
+        target = null;
+        callback = null;
+        data = null;
+
+        synchronized (sPoolSync) {
+            if (sPoolSize < MAX_POOL_SIZE) {
+                next = sPool;
+                sPool = this;
+                sPoolSize++;
+            }
+        }
+    }
+
+    /**
+     * Make this message like o.  Performs a shallow copy of the data field.
+     * Does not copy the linked list fields, nor the timestamp or
+     * target/callback of the original message.
+     */
+    public void copyFrom(Message o) {
+        this.flags = o.flags & ~FLAGS_TO_CLEAR_ON_COPY_FROM;
+        this.what = o.what;
+        this.arg1 = o.arg1;
+        this.arg2 = o.arg2;
+        this.obj = o.obj;
+        this.replyTo = o.replyTo;
+        this.sendingUid = o.sendingUid;
+        this.workSourceUid = o.workSourceUid;
+
+        if (o.data != null) {
+            this.data = (Bundle) o.data.clone();
+        } else {
+            this.data = null;
+        }
+    }
+
+    /**
+     * Return the targeted delivery time of this message, in milliseconds.
+     */
+    public long getWhen() {
+        return when;
+    }
+
+    public void setTarget(Handler target) {
+        this.target = target;
+    }
+
+    /**
+     * Retrieve the {@link android.os.Handler Handler} implementation that
+     * will receive this message. The object must implement
+     * {@link android.os.Handler#handleMessage(android.os.Message)
+     * Handler.handleMessage()}. Each Handler has its own name-space for
+     * message codes, so you do not need to
+     * worry about yours conflicting with other handlers.
+     */
+    public Handler getTarget() {
+        return target;
+    }
+
+    /**
+     * Retrieve callback object that will execute when this message is handled.
+     * This object must implement Runnable. This is called by
+     * the <em>target</em> {@link Handler} that is receiving this Message to
+     * dispatch it.  If
+     * not set, the message will be dispatched to the receiving Handler's
+     * {@link Handler#handleMessage(Message)}.
+     */
+    public Runnable getCallback() {
+        return callback;
+    }
+
+    /** @hide */
+    public Message setCallback(Runnable r) {
+        callback = r;
+        return this;
+    }
+
+    /**
+     * Obtains a Bundle of arbitrary data associated with this
+     * event, lazily creating it if necessary. Set this value by calling
+     * {@link #setData(Bundle)}.  Note that when transferring data across
+     * processes via {@link Messenger}, you will need to set your ClassLoader
+     * on the Bundle via {@link Bundle#setClassLoader(ClassLoader)
+     * Bundle.setClassLoader()} so that it can instantiate your objects when
+     * you retrieve them.
+     * @see #peekData()
+     * @see #setData(Bundle)
+     */
+    public Bundle getData() {
+        if (data == null) {
+            data = new Bundle();
+        }
+
+        return data;
+    }
+
+    /**
+     * Like getData(), but does not lazily create the Bundle.  A null
+     * is returned if the Bundle does not already exist.  See
+     * {@link #getData} for further information on this.
+     * @see #getData()
+     * @see #setData(Bundle)
+     */
+    @Nullable
+    public Bundle peekData() {
+        return data;
+    }
+
+    /**
+     * Sets a Bundle of arbitrary data values. Use arg1 and arg2 members
+     * as a lower cost way to send a few simple integer values, if you can.
+     * @see #getData()
+     * @see #peekData()
+     */
+    public void setData(Bundle data) {
+        this.data = data;
+    }
+
+    /**
+     * Chainable setter for {@link #what}
+     *
+     * @hide
+     */
+    public Message setWhat(int what) {
+        this.what = what;
+        return this;
+    }
+
+    /**
+     * Sends this Message to the Handler specified by {@link #getTarget}.
+     * Throws a null pointer exception if this field has not been set.
+     */
+    public void sendToTarget() {
+        target.sendMessage(this);
+    }
+
+    /**
+     * Returns true if the message is asynchronous, meaning that it is not
+     * subject to {@link Looper} synchronization barriers.
+     *
+     * @return True if the message is asynchronous.
+     *
+     * @see #setAsynchronous(boolean)
+     */
+    public boolean isAsynchronous() {
+        return (flags & FLAG_ASYNCHRONOUS) != 0;
+    }
+
+    /**
+     * Sets whether the message is asynchronous, meaning that it is not
+     * subject to {@link Looper} synchronization barriers.
+     * <p>
+     * Certain operations, such as view invalidation, may introduce synchronization
+     * barriers into the {@link Looper}'s message queue to prevent subsequent messages
+     * from being delivered until some condition is met.  In the case of view invalidation,
+     * messages which are posted after a call to {@link android.view.View#invalidate}
+     * are suspended by means of a synchronization barrier until the next frame is
+     * ready to be drawn.  The synchronization barrier ensures that the invalidation
+     * request is completely handled before resuming.
+     * </p><p>
+     * Asynchronous messages are exempt from synchronization barriers.  They typically
+     * represent interrupts, input events, and other signals that must be handled independently
+     * even while other work has been suspended.
+     * </p><p>
+     * Note that asynchronous messages may be delivered out of order with respect to
+     * synchronous messages although they are always delivered in order among themselves.
+     * If the relative order of these messages matters then they probably should not be
+     * asynchronous in the first place.  Use with caution.
+     * </p>
+     *
+     * @param async True if the message is asynchronous.
+     *
+     * @see #isAsynchronous()
+     */
+    public void setAsynchronous(boolean async) {
+        if (async) {
+            flags |= FLAG_ASYNCHRONOUS;
+        } else {
+            flags &= ~FLAG_ASYNCHRONOUS;
+        }
+    }
+
+    /*package*/ boolean isInUse() {
+        return ((flags & FLAG_IN_USE) == FLAG_IN_USE);
+    }
+
+    /*package*/ void markInUse() {
+        flags |= FLAG_IN_USE;
+    }
+
+    /** Constructor (but the preferred way to get a Message is to call {@link #obtain() Message.obtain()}).
+    */
+    public Message() {
+    }
+
+    @Override
+    public String toString() {
+        return toString(SystemClock.uptimeMillis());
+    }
+
+    String toString(long now) {
+        StringBuilder b = new StringBuilder();
+        b.append("{ when=");
+        TimeUtils.formatDuration(when - now, b);
+
+        if (target != null) {
+            if (callback != null) {
+                b.append(" callback=");
+                b.append(callback.getClass().getName());
+            } else {
+                b.append(" what=");
+                b.append(what);
+            }
+
+            if (arg1 != 0) {
+                b.append(" arg1=");
+                b.append(arg1);
+            }
+
+            if (arg2 != 0) {
+                b.append(" arg2=");
+                b.append(arg2);
+            }
+
+            if (obj != null) {
+                b.append(" obj=");
+                b.append(obj);
+            }
+
+            b.append(" target=");
+            b.append(target.getClass().getName());
+        } else {
+            b.append(" barrier=");
+            b.append(arg1);
+        }
+
+        b.append(" }");
+        return b.toString();
+    }
+
+    public static final @android.annotation.NonNull Parcelable.Creator<Message> CREATOR
+            = new Parcelable.Creator<Message>() {
+        public Message createFromParcel(Parcel source) {
+            Message msg = Message.obtain();
+            msg.readFromParcel(source);
+            return msg;
+        }
+
+        public Message[] newArray(int size) {
+            return new Message[size];
+        }
+    };
+
+    public int describeContents() {
+        return 0;
+    }
+
+    public void writeToParcel(Parcel dest, int flags) {
+        if (callback != null) {
+            throw new RuntimeException(
+                "Can't marshal callbacks across processes.");
+        }
+        dest.writeInt(what);
+        dest.writeInt(arg1);
+        dest.writeInt(arg2);
+        if (obj != null) {
+            try {
+                Parcelable p = (Parcelable)obj;
+                dest.writeInt(1);
+                dest.writeParcelable(p, flags);
+            } catch (ClassCastException e) {
+                throw new RuntimeException(
+                    "Can't marshal non-Parcelable objects across processes.");
+            }
+        } else {
+            dest.writeInt(0);
+        }
+        dest.writeLong(when);
+        dest.writeBundle(data);
+        Messenger.writeMessengerOrNullToParcel(replyTo, dest);
+        dest.writeInt(sendingUid);
+        dest.writeInt(workSourceUid);
+    }
+
+    private void readFromParcel(Parcel source) {
+        what = source.readInt();
+        arg1 = source.readInt();
+        arg2 = source.readInt();
+        if (source.readInt() != 0) {
+            obj = source.readParcelable(getClass().getClassLoader());
+        }
+        when = source.readLong();
+        data = source.readBundle();
+        replyTo = Messenger.readMessengerOrNullFromParcel(source);
+        sendingUid = source.readInt();
+        workSourceUid = source.readInt();
+    }
+}
@@ -42,19 +42,19 @@ public class SystemProperties {
            return native_get(key);
    }
    private static int native_get_int(String key, int def) {
-        if(configModule.hasProperty(key))
+        if(!configModule.hasProperty(key))
            return def;
        else
            return configModule.getIntProperty(key);
    }
    private static long native_get_long(String key, long def) {
-        if(configModule.hasProperty(key))
+        if(!configModule.hasProperty(key))
            return def;
        else
            return configModule.getLongProperty(key);
    }
    private static boolean native_get_boolean(String key, boolean def) {
-        if(configModule.hasProperty(key))
+        if(!configModule.hasProperty(key))
            return def;
        else
            return configModule.getBooleanProperty(key);
@@ -123,4 +123,4 @@ public class SystemProperties {
        }
        native_set(key, val);
    }
-}
+}
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2018 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 android.os;
+
+/**
+ * Tracks who triggered the work currently executed on this thread.
+ *
+ * <p>ThreadLocalWorkSource is automatically updated inside system server for incoming/outgoing
+ * binder calls and messages posted to handler threads.
+ *
+ * <p>ThreadLocalWorkSource can also be set manually if needed to refine the WorkSource.
+ *
+ * <p>Example:
+ * <ul>
+ * <li>Bluetooth process calls {@link PowerManager#isInteractive()} API on behalf of app foo.
+ * <li>ThreadLocalWorkSource will be automatically set to the UID of foo.
+ * <li>Any code on the thread handling {@link PowerManagerService#isInteractive()} can call
+ * {@link ThreadLocalWorkSource#getUid()} to blame any resource used to handle this call.
+ * <li>If a message is posted from the binder thread, the code handling the message can also call
+ * {@link ThreadLocalWorkSource#getUid()} and it will return the UID of foo since the work source is
+ * automatically propagated.
+ * </ul>
+ *
+ * @hide Only for use within system server.
+ */
+public final class ThreadLocalWorkSource {
+    public static final int UID_NONE = Message.UID_NONE;
+    private static final ThreadLocal<int []> sWorkSourceUid =
+            ThreadLocal.withInitial(() -> new int[] {UID_NONE});
+
+    /**
+     * Returns the UID to blame for the code currently executed on this thread.
+     *
+     * <p>This UID is set automatically by common frameworks (e.g. Binder and Handler frameworks)
+     * and automatically propagated inside system server.
+     * <p>It can also be set manually using {@link #setUid(int)}.
+     */
+    public static int getUid() {
+        return sWorkSourceUid.get()[0];
+    }
+
+    /**
+     * Sets the UID to blame for the code currently executed on this thread.
+     *
+     * <p>Inside system server, this UID will be automatically propagated.
+     * <p>It will be used to attribute future resources used on this thread (e.g. binder
+     * transactions or processing handler messages) and on any other threads the UID is propagated
+     * to.
+     *
+     * @return a token that can be used to restore the state.
+     */
+    public static long setUid(int uid) {
+        final long token = getToken();
+        sWorkSourceUid.get()[0] = uid;
+        return token;
+    }
+
+    /**
+     * Restores the state using the provided token.
+     */
+    public static void restore(long token) {
+        sWorkSourceUid.get()[0] = parseUidFromToken(token);
+    }
+
+    /**
+     * Clears the stored work source uid.
+     *
+     * <p>This method should be used when we do not know who to blame. If the UID to blame is the
+     * UID of the current process, it is better to attribute the work to the current process
+     * explicitly instead of clearing the work source:
+     *
+     * <pre>
+     * ThreadLocalWorkSource.setUid(Process.myUid());
+     * </pre>
+     *
+     * @return a token that can be used to restore the state.
+     */
+    public static long clear() {
+        return setUid(UID_NONE);
+    }
+
+    private static int parseUidFromToken(long token) {
+        return (int) token;
+    }
+
+    private static long getToken() {
+        return sWorkSourceUid.get()[0];
+    }
+
+    private ThreadLocalWorkSource() {
+    }
+}
@@ -0,0 +1,168 @@
+package android.os.shadows;
+// package org.robolectric.res.android;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * A unique id per object registry. Used to emulate android platform behavior of storing a long
+ * which represents a pointer to an object.
+ */
+public class NativeObjRegistry<T> {
+
+  private static final int INITIAL_ID = 1;
+
+  private final String name;
+  private final boolean debug;
+  private final HashMap<Long, T> nativeObjToIdMap = new HashMap<Long, T>();
+  private final Map<Long, DebugInfo> idToDebugInfoMap;
+
+  private long nextId = INITIAL_ID;
+
+  public NativeObjRegistry(Class<T> theClass) {
+    this(theClass, false);
+  }
+
+  public NativeObjRegistry(Class<T> theClass, boolean debug) {
+    this(theClass.getSimpleName(), debug);
+  }
+
+  public NativeObjRegistry(String name) {
+    this(name, false);
+  }
+
+  public NativeObjRegistry(String name, boolean debug) {
+    this.name = name;
+    this.debug = debug;
+    this.idToDebugInfoMap = debug ? new HashMap<>() : null;
+  }
+
+  private Long getNativeObjectId(T o) {
+    for(Map.Entry<Long, T> entry : nativeObjToIdMap.entrySet()) {
+      if (o == entry.getValue())
+        return entry.getKey();
+    }
+    return null;
+  }
+
+  /**
+   * Register and assign a new unique native id for given object (representing a C memory pointer).
+   *
+   * @throws IllegalStateException if the object was previously registered
+   */
+  public synchronized long register(T o) {
+    if (o == null)
+      throw new IllegalStateException("Object must not be null");
+    Long nativeId = getNativeObjectId(o);
+    if (nativeId != null) {
+      if (debug) {
+        DebugInfo debugInfo = idToDebugInfoMap.get(nativeId);
+        if (debugInfo != null) {
+          System.out.printf(
+              "NativeObjRegistry %s: register %d -> %s already registered:%n", name, nativeId, o);
+          debugInfo.registrationTrace.printStackTrace(System.out);
+        }
+      }
+      throw new IllegalStateException("Object was previously registered with id " + nativeId);
+    }
+
+    nativeId = nextId;
+    if (debug) {
+      System.out.printf("NativeObjRegistry %s: register %d -> %s%n", name, nativeId, o);
+      idToDebugInfoMap.put(nativeId, new DebugInfo(new Trace()));
+    }
+    nativeObjToIdMap.put(nativeId, o);
+    nextId++;
+    return nativeId;
+  }
+
+  /**
+   * Unregister an object previously registered with {@link #register(Object)}.
+   *
+   * @param nativeId the unique id (representing a C memory pointer) of the object to unregister.
+   * @throws IllegalStateException if the object was never registered, or was previously
+   *     unregistered.
+   */
+  public synchronized T unregister(long nativeId) {
+    T o = nativeObjToIdMap.remove(nativeId);
+    if (debug) {
+      System.out.printf("NativeObjRegistry %s: unregister %d -> %s%n", name, nativeId, o);
+      new RuntimeException("unregister debug").printStackTrace(System.out);
+    }
+    if (o == null) {
+      if (debug) {
+        DebugInfo debugInfo = idToDebugInfoMap.get(nativeId);
+        debugInfo.unregistrationTraces.add(new Trace());
+        if (debugInfo.unregistrationTraces.size() > 1) {
+          System.out.format("NativeObjRegistry %s: Too many unregistrations:%n", name);
+          for (Trace unregistration : debugInfo.unregistrationTraces) {
+            unregistration.printStackTrace(System.out);
+          }
+        }
+      }
+      throw new IllegalStateException(
+          nativeId + " has already been removed (or was never registered)");
+    }
+    return o;
+  }
+
+  /** Retrieve the native object for given id. Throws if object with that id cannot be found */
+  public synchronized T getNativeObject(long nativeId) {
+    T object = nativeObjToIdMap.get(nativeId);
+    if (object != null) {
+      return object;
+    } else {
+      throw new NullPointerException(
+          String.format(
+              "Could not find object with nativeId: %d. Currently registered ids: %s",
+              nativeId, nativeObjToIdMap.keySet()));
+    }
+  }
+
+  /**
+   * Updates the native object for the given id.
+   *
+   * @throws IllegalStateException if no object was registered with the given id before
+   */
+  public synchronized void update(long nativeId, T o) {
+    T previous = nativeObjToIdMap.get(nativeId);
+    if (previous == null) {
+      throw new IllegalStateException("Native id " + nativeId + " was never registered");
+    }
+    if (debug) {
+      System.out.printf("NativeObjRegistry %s: update %d -> %s%n", name, nativeId, o);
+      idToDebugInfoMap.put(nativeId, new DebugInfo(new Trace()));
+    }
+    nativeObjToIdMap.put(nativeId, o);
+  }
+
+  /**
+   * Similar to {@link #getNativeObject(long)} but returns null if object with given id cannot be
+   * found.
+   */
+  public synchronized T peekNativeObject(long nativeId) {
+    return nativeObjToIdMap.get(nativeId);
+  }
+
+  /** WARNING -- dangerous! Call {@link #unregister(long)} instead! */
+  public synchronized void clear() {
+    nextId = INITIAL_ID;
+    nativeObjToIdMap.clear();
+  }
+
+  private static class DebugInfo {
+    final Trace registrationTrace;
+    final List<Trace> unregistrationTraces = new ArrayList<>();
+
+    public DebugInfo(Trace trace) {
+      registrationTrace = trace;
+    }
+  }
+
+  private static class Trace extends Throwable {
+
+    private Trace() {}
+  }
+}
@@ -0,0 +1,73 @@
+package android.os.shadows;
+// package org.robolectric.shadows;
+//  and badly gutted
+
+import android.os.Looper;
+import android.os.Message;
+import android.os.MessageQueue;
+import android.os.MessageQueue.IdleHandler;
+import android.os.SystemClock;
+import android.util.Log;
+import java.time.Duration;
+import java.util.ArrayList;
+
+/**
+ * The shadow {@link} MessageQueue} for {@link LooperMode.Mode.PAUSED}
+ *
+ * <p>This class should not be referenced directly. Use {@link ShadowMessageQueue} instead.
+ */
+@SuppressWarnings("SynchronizeOnNonFinalField")
+public class ShadowPausedMessageQueue {
+
+  // just use this class as the native object
+  private static NativeObjRegistry<ShadowPausedMessageQueue> nativeQueueRegistry =
+      new NativeObjRegistry<ShadowPausedMessageQueue>(ShadowPausedMessageQueue.class);
+  private boolean isPolling = false;
+  private Exception uncaughtException = null;
+
+  // shadow constructor instead of nativeInit because nativeInit signature has changed across SDK
+  // versions
+  public static long nativeInit() {
+    return nativeQueueRegistry.register(new ShadowPausedMessageQueue());
+  }
+
+  public static void nativeDestroy(long ptr) {
+    nativeQueueRegistry.unregister(ptr);
+  }
+
+  public static void nativePollOnce(long ptr, int timeoutMillis) {
+    ShadowPausedMessageQueue obj = nativeQueueRegistry.getNativeObject(ptr);
+    obj.nativePollOnce(timeoutMillis);
+  }
+
+  public void nativePollOnce(int timeoutMillis) {
+    if (timeoutMillis == 0) {
+      return;
+    }
+    synchronized (this) {
+      isPolling = true;
+      try {
+        if (timeoutMillis < 0) {
+          this.wait();
+        } else {
+          this.wait(timeoutMillis);
+        }
+      } catch (InterruptedException e) {
+        // ignore
+      }
+      isPolling = false;
+    }
+  }
+
+  public static void nativeWake(long ptr) {
+    ShadowPausedMessageQueue obj = nativeQueueRegistry.getNativeObject(ptr);
+    synchronized (obj) {
+      obj.notifyAll();
+    }
+  }
+
+  public static boolean nativeIsPolling(long ptr) {
+    return nativeQueueRegistry.getNativeObject(ptr).isPolling;
+  }
+}
+
@@ -12,7 +12,7 @@ class PreferenceManager {
        fun getDefaultSharedPreferences(context: Context) =
            context.getSharedPreferences(
                context.applicationInfo.packageName,
-                Context.MODE_PRIVATE
+                Context.MODE_PRIVATE,
            )!!
    }
 }
@@ -4,7 +4,7 @@ package android.text;
 import android.graphics.drawable.Drawable;
 import org.jetbrains.annotations.NotNull;
 import org.jsoup.Jsoup;
-import org.jsoup.safety.Whitelist;
+import org.jsoup.safety.Safelist;
 import org.xml.sax.XMLReader;

 /**
@@ -18,7 +18,7 @@ import org.xml.sax.XMLReader;
 public class Html {

    public static Spanned fromHtml(String source) {
-        return new FakeSpanned(Jsoup.clean(source, Whitelist.none()));
+        return new FakeSpanned(Jsoup.clean(source, Safelist.none()));
    }

    public static Spanned fromHtml(String source, Html.ImageGetter imageGetter, Html.TagHandler tagHandler) {
@@ -0,0 +1,631 @@
+/*
+ * Copyright (C) 2006 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 android.text;
+
+import android.annotation.ColorInt;
+import android.annotation.IntRange;
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.annotation.SuppressLint;
+import android.graphics.Paint;
+import android.graphics.RectF;
+import android.util.Log;
+import java.awt.RenderingHints;
+import java.awt.font.LineBreakMeasurer;
+import java.awt.font.FontRenderContext;
+import java.awt.font.TextAttribute;
+import java.awt.font.TextLayout;
+import java.text.AttributedString;
+
+import com.android.internal.util.ArrayUtils;
+import com.android.internal.util.GrowingArrayUtils;
+
+
+public class StaticLayout extends Layout {
+    /*
+     * The break iteration is done in native code. The protocol for using the native code is as
+     * follows.
+     *
+     * First, call nInit to setup native line breaker object. Then, for each paragraph, do the
+     * following:
+     *
+     *   - Create MeasuredParagraph by MeasuredParagraph.buildForStaticLayout which measures in
+     *     native.
+     *   - Run LineBreaker.computeLineBreaks() to obtain line breaks for the paragraph.
+     *
+     * After all paragraphs, call finish() to release expensive buffers.
+     */
+
+    static final String TAG = "StaticLayout";
+
+    public final static class Builder {
+        private Builder() {}
+
+        @NonNull
+        public static Builder obtain(@NonNull CharSequence source, @IntRange(from = 0) int start,
+                @IntRange(from = 0) int end, @NonNull TextPaint paint,
+                @IntRange(from = 0) int width) {
+            Builder b = new Builder();
+
+            // set default initial values
+            b.mText = source;
+            b.mStart = start;
+            b.mEnd = end;
+            b.mPaint = paint;
+            b.mWidth = width;
+            b.mAlignment = Alignment.ALIGN_NORMAL;
+            b.mTextDir = TextDirectionHeuristics.FIRSTSTRONG_LTR;
+            b.mSpacingMult = DEFAULT_LINESPACING_MULTIPLIER;
+            b.mSpacingAdd = DEFAULT_LINESPACING_ADDITION;
+            b.mIncludePad = true;
+            b.mFallbackLineSpacing = false;
+            b.mEllipsizedWidth = width;
+            b.mEllipsize = null;
+            b.mMaxLines = Integer.MAX_VALUE;
+            b.mBreakStrategy = Layout.BREAK_STRATEGY_SIMPLE;
+            b.mHyphenationFrequency = Layout.HYPHENATION_FREQUENCY_NONE;
+            b.mJustificationMode = Layout.JUSTIFICATION_MODE_NONE;
+            b.mMinimumFontMetrics = null;
+            return b;
+        }
+
+        // release any expensive state
+        /* package */ void finish() {
+            mText = null;
+            mPaint = null;
+            mLeftIndents = null;
+            mRightIndents = null;
+            mMinimumFontMetrics = null;
+        }
+
+        public Builder setText(CharSequence source) {
+            return setText(source, 0, source.length());
+        }
+
+        @NonNull
+        public Builder setText(@NonNull CharSequence source, int start, int end) {
+            mText = source;
+            mStart = start;
+            mEnd = end;
+            return this;
+        }
+
+        @NonNull
+        public Builder setPaint(@NonNull TextPaint paint) {
+            mPaint = paint;
+            return this;
+        }
+
+        @NonNull
+        public Builder setWidth(@IntRange(from = 0) int width) {
+            mWidth = width;
+            if (mEllipsize == null) {
+                mEllipsizedWidth = width;
+            }
+            return this;
+        }
+
+        @NonNull
+        public Builder setAlignment(@NonNull Alignment alignment) {
+            mAlignment = alignment;
+            return this;
+        }
+
+        @NonNull
+        public Builder setTextDirection(@NonNull TextDirectionHeuristic textDir) {
+            mTextDir = textDir;
+            return this;
+        }
+
+        @NonNull
+        public Builder setLineSpacing(float spacingAdd, float spacingMult) {
+            mSpacingAdd = spacingAdd;
+            mSpacingMult = spacingMult;
+            return this;
+        }
+
+        @NonNull
+        public Builder setIncludePad(boolean includePad) {
+            mIncludePad = includePad;
+            return this;
+        }
+
+        @NonNull
+        public Builder setUseLineSpacingFromFallbacks(boolean useLineSpacingFromFallbacks) {
+            mFallbackLineSpacing = useLineSpacingFromFallbacks;
+            return this;
+        }
+
+        @NonNull
+        public Builder setEllipsizedWidth(@IntRange(from = 0) int ellipsizedWidth) {
+            mEllipsizedWidth = ellipsizedWidth;
+            return this;
+        }
+
+        @NonNull
+        public Builder setEllipsize(@Nullable TextUtils.TruncateAt ellipsize) {
+            mEllipsize = ellipsize;
+            return this;
+        }
+
+        @NonNull
+        public Builder setMaxLines(@IntRange(from = 0) int maxLines) {
+            mMaxLines = maxLines;
+            return this;
+        }
+
+        @NonNull
+        public Builder setBreakStrategy(@BreakStrategy int breakStrategy) {
+            mBreakStrategy = breakStrategy;
+            return this;
+        }
+
+        @NonNull
+        public Builder setHyphenationFrequency(@HyphenationFrequency int hyphenationFrequency) {
+            mHyphenationFrequency = hyphenationFrequency;
+            return this;
+        }
+
+        @NonNull
+        public Builder setIndents(@Nullable int[] leftIndents, @Nullable int[] rightIndents) {
+            mLeftIndents = leftIndents;
+            mRightIndents = rightIndents;
+            return this;
+        }
+
+        @NonNull
+        public Builder setJustificationMode(@JustificationMode int justificationMode) {
+            mJustificationMode = justificationMode;
+            return this;
+        }
+
+        @NonNull
+        /* package */ Builder setAddLastLineLineSpacing(boolean value) {
+            mAddLastLineLineSpacing = value;
+            return this;
+        }
+
+        @SuppressLint("MissingGetterMatchingBuilder")  // The base class `Layout` has a getter.
+        @NonNull
+        public Builder setUseBoundsForWidth(boolean useBoundsForWidth) {
+            mUseBoundsForWidth = useBoundsForWidth;
+            return this;
+        }
+
+        @NonNull
+        // The corresponding getter is getShiftDrawingOffsetForStartOverhang()
+        @SuppressLint("MissingGetterMatchingBuilder")
+        public Builder setShiftDrawingOffsetForStartOverhang(
+                boolean shiftDrawingOffsetForStartOverhang) {
+            mShiftDrawingOffsetForStartOverhang = shiftDrawingOffsetForStartOverhang;
+            return this;
+        }
+
+        public Builder setCalculateBounds(boolean value) {
+            mCalculateBounds = value;
+            return this;
+        }
+
+        @NonNull
+        public Builder setMinimumFontMetrics(@Nullable Paint.FontMetrics minimumFontMetrics) {
+            mMinimumFontMetrics = minimumFontMetrics;
+            return this;
+        }
+
+        @NonNull
+        public StaticLayout build() {
+            StaticLayout result = new StaticLayout(this, mIncludePad, mEllipsize != null
+                    ? COLUMNS_ELLIPSIZE : COLUMNS_NORMAL);
+            return result;
+        }
+
+        private CharSequence mText;
+        private int mStart;
+        private int mEnd;
+        private TextPaint mPaint;
+        private int mWidth;
+        private Alignment mAlignment;
+        private TextDirectionHeuristic mTextDir;
+        private float mSpacingMult;
+        private float mSpacingAdd;
+        private boolean mIncludePad;
+        private boolean mFallbackLineSpacing;
+        private int mEllipsizedWidth;
+        private TextUtils.TruncateAt mEllipsize;
+        private int mMaxLines;
+        private int mBreakStrategy;
+        private int mHyphenationFrequency;
+        @Nullable private int[] mLeftIndents;
+        @Nullable private int[] mRightIndents;
+        private int mJustificationMode;
+        private boolean mAddLastLineLineSpacing;
+        private boolean mUseBoundsForWidth;
+        private boolean mShiftDrawingOffsetForStartOverhang;
+        private boolean mCalculateBounds;
+        @Nullable private Paint.FontMetrics mMinimumFontMetrics;
+
+        private final Paint.FontMetricsInt mFontMetricsInt = new Paint.FontMetricsInt();
+    }
+
+    private StaticLayout() {
+        super(
+                null,  // text
+                null,  // paint
+                0,  // width
+                null, // alignment
+                null, // textDir
+                1, // spacing multiplier
+                0, // spacing amount
+                false, // include font padding
+                false, // fallback line spacing
+                0,  // ellipsized width
+                null, // ellipsize
+                1,  // maxLines
+                BREAK_STRATEGY_SIMPLE,
+                HYPHENATION_FREQUENCY_NONE,
+                null,  // leftIndents
+                null,  // rightIndents
+                JUSTIFICATION_MODE_NONE,
+                false,  // useBoundsForWidth
+                false,  // shiftDrawingOffsetForStartOverhang
+                null  // minimumFontMetrics
+        );
+
+        mColumns = COLUMNS_ELLIPSIZE;
+        mLineDirections = new Directions[2];
+        mLines  = new int[2 * mColumns];
+    }
+
+    @Deprecated
+    public StaticLayout(CharSequence source, TextPaint paint,
+                        int width,
+                        Alignment align, float spacingmult, float spacingadd,
+                        boolean includepad) {
+        this(source, 0, source.length(), paint, width, align,
+             spacingmult, spacingadd, includepad);
+    }
+
+    @Deprecated
+    public StaticLayout(CharSequence source, int bufstart, int bufend,
+                        TextPaint paint, int outerwidth,
+                        Alignment align,
+                        float spacingmult, float spacingadd,
+                        boolean includepad) {
+        this(source, bufstart, bufend, paint, outerwidth, align,
+             spacingmult, spacingadd, includepad, null, 0);
+    }
+
+    @Deprecated
+    public StaticLayout(CharSequence source, int bufstart, int bufend,
+            TextPaint paint, int outerwidth,
+            Alignment align,
+            float spacingmult, float spacingadd,
+            boolean includepad,
+            TextUtils.TruncateAt ellipsize, int ellipsizedWidth) {
+        this(source, bufstart, bufend, paint, outerwidth, align,
+                TextDirectionHeuristics.FIRSTSTRONG_LTR,
+                spacingmult, spacingadd, includepad, ellipsize, ellipsizedWidth, Integer.MAX_VALUE);
+    }
+
+    @Deprecated
+    public StaticLayout(CharSequence source, int bufstart, int bufend,
+                        TextPaint paint, int outerwidth,
+                        Alignment align, TextDirectionHeuristic textDir,
+                        float spacingmult, float spacingadd,
+                        boolean includepad,
+                        TextUtils.TruncateAt ellipsize, int ellipsizedWidth, int maxLines) {
+        this(Builder.obtain(source, bufstart, bufend, paint, outerwidth)
+                .setAlignment(align)
+                .setTextDirection(textDir)
+                .setLineSpacing(spacingadd, spacingmult)
+                .setIncludePad(includepad)
+                .setEllipsize(ellipsize)
+                .setEllipsizedWidth(ellipsizedWidth)
+                .setMaxLines(maxLines), includepad,
+                ellipsize != null ? COLUMNS_ELLIPSIZE : COLUMNS_NORMAL);
+    }
+
+    private StaticLayout(Builder b, boolean trackPadding, int columnSize) {
+        super((b.mEllipsize == null) ? b.mText : (b.mText instanceof Spanned)
+                    ? new SpannedEllipsizer(b.mText) : new Ellipsizer(b.mText),
+                b.mPaint, b.mWidth, b.mAlignment, b.mTextDir, b.mSpacingMult, b.mSpacingAdd,
+                b.mIncludePad, b.mFallbackLineSpacing, b.mEllipsizedWidth, b.mEllipsize,
+                b.mMaxLines, b.mBreakStrategy, b.mHyphenationFrequency, b.mLeftIndents,
+                b.mRightIndents, b.mJustificationMode, b.mUseBoundsForWidth,
+                b.mShiftDrawingOffsetForStartOverhang, b.mMinimumFontMetrics);
+
+        mColumns = columnSize;
+        if (b.mEllipsize != null) {
+            Ellipsizer e = (Ellipsizer) getText();
+
+            e.mLayout = this;
+            e.mWidth = b.mEllipsizedWidth;
+            e.mMethod = b.mEllipsize;
+            throw new UnsupportedOperationException("Ellipsis not supported");
+        }
+
+        mLineDirections = new Directions[2];
+        mLines  = new int[2 * mColumns];
+        mMaximumVisibleLineCount = b.mMaxLines;
+
+        mLeftIndents = b.mLeftIndents;
+        mRightIndents = b.mRightIndents;
+
+        String str = b.mText.subSequence(b.mStart, b.mEnd).toString();
+        AttributedString text = new AttributedString(str);
+        text.addAttribute(TextAttribute.FONT, getPaint().getFont());
+        FontRenderContext frc = new FontRenderContext(getPaint().getFont().getTransform(), RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT, RenderingHints.VALUE_FRACTIONALMETRICS_DEFAULT);
+        LineBreakMeasurer measurer = new LineBreakMeasurer(text.getIterator(), frc);
+        // TODO: directions
+
+        float y = 0;
+        while (measurer.getPosition() < str.length()) {
+            int off = mLineCount * mColumns;
+            int want = off + mColumns + TOP;
+            if (want >= mLines.length) {
+                final int[] grow = ArrayUtils.newUnpaddedIntArray(GrowingArrayUtils.growSize(want));
+                System.arraycopy(mLines, 0, grow, 0, mLines.length);
+                mLines = grow;
+            }
+
+            int pos = measurer.getPosition();
+            TextLayout l = measurer.nextLayout(getWidth());
+            mLines[off + START] = pos;
+            mLines[off + TOP] = (int) y;
+            mLines[off + DESCENT] = (int) (l.getDescent() + l.getLeading());
+            mLines[off + EXTRA] = (int) l.getLeading();
+            mLines[off + DIR] |= Layout.DIR_LEFT_TO_RIGHT << DIR_SHIFT;
+
+            y += l.getAscent();
+            y += l.getDescent() + l.getLeading();
+
+            mLines[off + mColumns + START] = measurer.getPosition();
+            mLines[off + mColumns + TOP] = (int) y;
+
+            mLineCount += 1;
+        }
+    }
+
+    // Override the base class so we can directly access our members,
+    // rather than relying on member functions.
+    // The logic mirrors that of Layout.getLineForVertical
+    // FIXME: It may be faster to do a linear search for layouts without many lines.
+    @Override
+    public int getLineForVertical(int vertical) {
+        int high = mLineCount;
+        int low = -1;
+        int guess;
+        int[] lines = mLines;
+        while (high - low > 1) {
+            guess = (high + low) >> 1;
+            if (lines[mColumns * guess + TOP] > vertical){
+                high = guess;
+            } else {
+                low = guess;
+            }
+        }
+        if (low < 0) {
+            return 0;
+        } else {
+            return low;
+        }
+    }
+
+    @Override
+    public int getLineCount() {
+        return mLineCount;
+    }
+
+    @Override
+    public int getLineTop(int line) {
+        return mLines[mColumns * line + TOP];
+    }
+
+    @Override
+    public int getLineExtra(int line) {
+        return mLines[mColumns * line + EXTRA];
+    }
+
+    @Override
+    public int getLineDescent(int line) {
+        return mLines[mColumns * line + DESCENT];
+    }
+
+    @Override
+    public int getLineStart(int line) {
+        return mLines[mColumns * line + START] & START_MASK;
+    }
+
+    @Override
+    public int getParagraphDirection(int line) {
+        return mLines[mColumns * line + DIR] >> DIR_SHIFT;
+    }
+
+    @Override
+    public boolean getLineContainsTab(int line) {
+        return (mLines[mColumns * line + TAB] & TAB_MASK) != 0;
+    }
+
+    @Override
+    public final Directions getLineDirections(int line) {
+        if (line > getLineCount()) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+        return new Directions(null);
+        // return mLineDirections[line];
+    }
+
+    @Override
+    public int getTopPadding() {
+        return mTopPadding;
+    }
+
+    @Override
+    public int getBottomPadding() {
+        return mBottomPadding;
+    }
+
+    // To store into single int field, pack the pair of start and end hyphen edit.
+    static int packHyphenEdit(
+            @Paint.StartHyphenEdit int start, @Paint.EndHyphenEdit int end) {
+        return start << START_HYPHEN_BITS_SHIFT | end;
+    }
+
+    static int unpackStartHyphenEdit(int packedHyphenEdit) {
+        return (packedHyphenEdit & START_HYPHEN_MASK) >> START_HYPHEN_BITS_SHIFT;
+    }
+
+    static int unpackEndHyphenEdit(int packedHyphenEdit) {
+        return packedHyphenEdit & END_HYPHEN_MASK;
+    }
+
+    @Override
+    public @Paint.StartHyphenEdit int getStartHyphenEdit(int lineNumber) {
+        return unpackStartHyphenEdit(mLines[mColumns * lineNumber + HYPHEN] & HYPHEN_MASK);
+    }
+
+    @Override
+    public @Paint.EndHyphenEdit int getEndHyphenEdit(int lineNumber) {
+        return unpackEndHyphenEdit(mLines[mColumns * lineNumber + HYPHEN] & HYPHEN_MASK);
+    }
+
+    @Override
+    public int getIndentAdjust(int line, Alignment align) {
+        if (align == Alignment.ALIGN_LEFT) {
+            if (mLeftIndents == null) {
+                return 0;
+            } else {
+                return mLeftIndents[Math.min(line, mLeftIndents.length - 1)];
+            }
+        } else if (align == Alignment.ALIGN_RIGHT) {
+            if (mRightIndents == null) {
+                return 0;
+            } else {
+                return -mRightIndents[Math.min(line, mRightIndents.length - 1)];
+            }
+        } else if (align == Alignment.ALIGN_CENTER) {
+            int left = 0;
+            if (mLeftIndents != null) {
+                left = mLeftIndents[Math.min(line, mLeftIndents.length - 1)];
+            }
+            int right = 0;
+            if (mRightIndents != null) {
+                right = mRightIndents[Math.min(line, mRightIndents.length - 1)];
+            }
+            return (left - right) >> 1;
+        } else {
+            throw new AssertionError("unhandled alignment " + align);
+        }
+    }
+
+    @Override
+    public int getEllipsisCount(int line) {
+        if (mColumns < COLUMNS_ELLIPSIZE) {
+            return 0;
+        }
+
+        return mLines[mColumns * line + ELLIPSIS_COUNT];
+    }
+
+    @Override
+    public int getEllipsisStart(int line) {
+        if (mColumns < COLUMNS_ELLIPSIZE) {
+            return 0;
+        }
+
+        return mLines[mColumns * line + ELLIPSIS_START];
+    }
+
+    @Override
+    @NonNull
+    public RectF computeDrawingBoundingBox() {
+        // Cache the drawing bounds result because it does not change after created.
+        if (mDrawingBounds == null) {
+            mDrawingBounds = super.computeDrawingBoundingBox();
+        }
+        return mDrawingBounds;
+    }
+
+    @Override
+    public int getHeight(boolean cap) {
+        if (cap && mLineCount > mMaximumVisibleLineCount && mMaxLineHeight == -1
+                && Log.isLoggable(TAG, Log.WARN)) {
+            Log.w(TAG, "maxLineHeight should not be -1. "
+                    + " maxLines:" + mMaximumVisibleLineCount
+                    + " lineCount:" + mLineCount);
+        }
+
+        return cap && mLineCount > mMaximumVisibleLineCount && mMaxLineHeight != -1
+                ? mMaxLineHeight : super.getHeight();
+    }
+
+    private int mLineCount;
+    private int mTopPadding, mBottomPadding;
+    private int mColumns;
+    private RectF mDrawingBounds = null;  // lazy calculation.
+
+    private boolean mEllipsized;
+
+    private int mMaxLineHeight = DEFAULT_MAX_LINE_HEIGHT;
+
+    private static final int COLUMNS_NORMAL = 5;
+    private static final int COLUMNS_ELLIPSIZE = 7;
+    private static final int START = 0;
+    private static final int DIR = START;
+    private static final int TAB = START;
+    private static final int TOP = 1;
+    private static final int DESCENT = 2;
+    private static final int EXTRA = 3;
+    private static final int HYPHEN = 4;
+    private static final int ELLIPSIS_START = 5;
+    private static final int ELLIPSIS_COUNT = 6;
+
+    private int[] mLines;
+    private Directions[] mLineDirections;
+    private int mMaximumVisibleLineCount = Integer.MAX_VALUE;
+
+    private static final int START_MASK = 0x1FFFFFFF;
+    private static final int DIR_SHIFT  = 30;
+    private static final int TAB_MASK   = 0x20000000;
+    private static final int HYPHEN_MASK = 0xFF;
+    private static final int START_HYPHEN_BITS_SHIFT = 3;
+    private static final int START_HYPHEN_MASK = 0x18; // 0b11000
+    private static final int END_HYPHEN_MASK = 0x7;  // 0b00111
+
+    private static final float TAB_INCREMENT = 20; // same as Layout, but that's private
+
+    private static final char CHAR_NEW_LINE = '\n';
+
+    private static final double EXTRA_ROUNDING = 0.5;
+
+    private static final int DEFAULT_MAX_LINE_HEIGHT = -1;
+
+    // Unused, here because of gray list private API accesses.
+    /*package*/ static class LineBreaks {
+        private static final int INITIAL_SIZE = 16;
+        public int[] breaks = new int[INITIAL_SIZE];
+        public float[] widths = new float[INITIAL_SIZE];
+        public float[] ascents = new float[INITIAL_SIZE];
+        public float[] descents = new float[INITIAL_SIZE];
+        public int[] flags = new int[INITIAL_SIZE]; // hasTab
+        // breaks, widths, and flags should all have the same length
+    }
+
+    @Nullable private int[] mLeftIndents;
+    @Nullable private int[] mRightIndents;
+}
+
@@ -0,0 +1,178 @@
+/*
+ * 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 android.text;
+
+import android.annotation.IntRange;
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.graphics.Canvas;
+import android.graphics.Paint.FontMetricsInt;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.text.Layout.Directions;
+import android.text.Layout.TabStops;
+import java.awt.RenderingHints;
+import java.awt.font.FontRenderContext;
+
+
+public class TextLine {
+    private TextPaint mPaint;
+    private CharSequence mText;
+    private int mStart;
+    private int mLen;
+    private int mDir;
+    private Directions mDirections;
+    private boolean mHasTabs;
+    private TabStops mTabs;
+    private char[] mChars;
+    private boolean mCharsValid;
+    private Spanned mSpanned;
+    private PrecomputedText mComputed;
+    private RectF mTmpRectForMeasure;
+    private RectF mTmpRectForPaintAPI;
+    private Rect mTmpRectForPrecompute;
+
+
+    public static final class LineInfo {
+        private int mClusterCount;
+
+        public int getClusterCount() {
+            return mClusterCount;
+        }
+
+        public void setClusterCount(int clusterCount) {
+            mClusterCount = clusterCount;
+        }
+    };
+
+    public float getAddedWordSpacingInPx() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public float getAddedLetterSpacingInPx() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean isJustifying() {
+        throw new RuntimeException("Stub!");
+    }
+
+    /** Not allowed to access. If it's for memory leak workaround, it was already fixed M. */
+    private static final TextLine[] sCached = new TextLine[3];
+
+    public static TextLine obtain() {
+        TextLine tl;
+        synchronized (sCached) {
+            for (int i = sCached.length; --i >= 0;) {
+                if (sCached[i] != null) {
+                    tl = sCached[i];
+                    sCached[i] = null;
+                    return tl;
+                }
+            }
+        }
+        tl = new TextLine();
+        return tl;
+    }
+
+    public static TextLine recycle(TextLine tl) {
+        synchronized(sCached) {
+            for (int i = 0; i < sCached.length; ++i) {
+                if (sCached[i] == null) {
+                    sCached[i] = tl;
+                    break;
+                }
+            }
+        }
+        return null;
+    }
+
+    public void set(TextPaint paint, CharSequence text, int start, int limit, int dir,
+            Directions directions, boolean hasTabs, TabStops tabStops,
+            int ellipsisStart, int ellipsisEnd, boolean useFallbackLineSpacing) {
+        mPaint = paint;
+        mText = text;
+        mStart = start;
+        mLen = limit - start;
+        mDir = dir;
+        mDirections = directions;
+        if (mDirections == null) {
+            throw new IllegalArgumentException("Directions cannot be null");
+        }
+        mHasTabs = hasTabs;
+        mSpanned = null;
+
+        if (text instanceof Spanned) {
+            mSpanned = (Spanned) text;
+        }
+
+        mComputed = null;
+        if (text instanceof PrecomputedText) {
+            // Here, no need to check line break strategy or hyphenation frequency since there is no
+            // line break concept here.
+            mComputed = (PrecomputedText) text;
+            if (!mComputed.getParams().getTextPaint().equalsForTextMeasurement(paint)) {
+                mComputed = null;
+            }
+        }
+
+        mTabs = tabStops;
+    }
+
+    public void justify(@Layout.JustificationMode int justificationMode, float justifyWidth) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int calculateRunFlag(int bidiRunIndex, int bidiRunCount, int lineDirection) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static int resolveRunFlagForSubSequence(int runFlag, boolean isRtlRun, int runStart,
+            int runEnd, int spanStart, int spanEnd) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public float metrics(FontMetricsInt fmi, @Nullable RectF drawBounds, boolean returnDrawWidth,
+            @Nullable LineInfo lineInfo) {
+        FontRenderContext frc = new FontRenderContext(null, RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT, RenderingHints.VALUE_FRACTIONALMETRICS_DEFAULT);
+        return (float) mPaint.getFont().getStringBounds(mText.toString(), mStart, mStart + mLen, frc).getWidth();
+    }
+
+    public float measure(@IntRange(from = 0) int offset, boolean trailing,
+            @NonNull FontMetricsInt fmi, @Nullable RectF drawBounds, @Nullable LineInfo lineInfo) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void measureAllBounds(@NonNull float[] bounds, @Nullable float[] advances) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public float[] measureAllOffsets(boolean[] trailing, FontMetricsInt fmi) {
+        throw new RuntimeException("Stub!");
+    }
+
+    // Note: keep this in sync with Minikin LineBreaker::isLineEndSpace()
+    public static boolean isLineEndSpace(char ch) {
+        return ch == ' ' || ch == '\t' || ch == 0x1680
+                || (0x2000 <= ch && ch <= 0x200A && ch != 0x2007)
+                || ch == 0x205F || ch == 0x3000;
+    }
+
+    void draw(Canvas c, float x, int top, int y, int bottom) {
+        c.drawText(mText, mStart, mStart + mLen, x, y, mPaint);
+    }
+}
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2006 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 android.text;
+
+import android.annotation.ColorInt;
+import android.graphics.Paint;
+
+public class TextPaint extends Paint {
+
+    // Special value 0 means no background paint
+    @ColorInt
+    public int bgColor;
+    public int baselineShift;
+    @ColorInt
+    public int linkColor;
+    public int[] drawableState;
+    public float density = 1.0f;
+    @ColorInt
+    public int underlineColor = 0;
+
+    public float underlineThickness;
+
+    public TextPaint() {
+        super();
+    }
+
+    public TextPaint(int flags) {
+        super(flags);
+    }
+
+    public TextPaint(Paint p) {
+        super(p);
+    }
+
+    public void set(TextPaint tp) {
+        super.set(tp);
+
+        bgColor = tp.bgColor;
+        baselineShift = tp.baselineShift;
+        linkColor = tp.linkColor;
+        drawableState = tp.drawableState;
+        density = tp.density;
+        underlineColor = tp.underlineColor;
+        underlineThickness = tp.underlineThickness;
+    }
+
+    public void setUnderlineText(int color, float thickness) {
+        underlineColor = color;
+        underlineThickness = thickness;
+    }
+
+    @Override
+    public float getUnderlineThickness() {
+        if (underlineColor != 0) { // Return custom thickness only if underline color is set.
+            return underlineThickness;
+        } else {
+            return super.getUnderlineThickness();
+        }
+    }
+}
@@ -136,4 +136,4 @@ public final class Log {
        first.append(msg);
        return first.toString();
    }
-}
+}
@@ -0,0 +1,270 @@
+/*
+ * Copyright (C) 2006 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 android.util;
+
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.annotation.SystemApi;
+import android.os.Build;
+
+/**
+ * API for sending log output to the {@link Log#LOG_ID_SYSTEM} buffer.
+ *
+ * <p>Should be used by system components. Use {@code adb logcat --buffer=system} to fetch the logs.
+ *
+ * @see Log
+ * @hide
+ */
+public final class Slog {
+
+    private Slog() {
+    }
+
+    /**
+     * Logs {@code msg} at {@link Log#VERBOSE} level.
+     *
+     * @param tag identifies the source of a log message.  It usually represents system service,
+     *            e.g. {@code PackageManager}.
+     * @param msg the message to log.
+     *
+     * @see Log#v(String, String)
+     */
+    public static int v(@Nullable String tag, @NonNull String msg) {
+        return Log.println(Log.VERBOSE, tag, msg);
+    }
+
+    /**
+     * Logs {@code msg} at {@link Log#VERBOSE} level, attaching stack trace of the {@code tr} to
+     * the end of the log statement.
+     *
+     * @param tag identifies the source of a log message.  It usually represents system service,
+     *            e.g. {@code PackageManager}.
+     * @param msg the message to log.
+     * @param tr an exception to log.
+     *
+     * @see Log#v(String, String, Throwable)
+     */
+    public static int v(@Nullable String tag, @NonNull String msg, @Nullable Throwable tr) {
+        return Log.println(Log.VERBOSE, tag,
+                msg + '\n' + Log.getStackTraceString(tr));
+    }
+
+    /**
+     * Logs {@code msg} at {@link Log#DEBUG} level.
+     *
+     * @param tag identifies the source of a log message.  It usually represents system service,
+     *            e.g. {@code PackageManager}.
+     * @param msg the message to log.
+     *
+     * @see Log#d(String, String)
+     */
+    public static int d(@Nullable String tag, @NonNull String msg) {
+        return Log.println(Log.DEBUG, tag, msg);
+    }
+
+    /**
+     * Logs {@code msg} at {@link Log#DEBUG} level, attaching stack trace of the {@code tr} to
+     * the end of the log statement.
+     *
+     * @param tag identifies the source of a log message.  It usually represents system service,
+     *            e.g. {@code PackageManager}.
+     * @param msg the message to log.
+     * @param tr an exception to log.
+     *
+     * @see Log#d(String, String, Throwable)
+     */
+    public static int d(@Nullable String tag, @NonNull String msg, @Nullable Throwable tr) {
+        return Log.println(Log.DEBUG, tag,
+                msg + '\n' + Log.getStackTraceString(tr));
+    }
+
+    /**
+     * Logs {@code msg} at {@link Log#INFO} level.
+     *
+     * @param tag identifies the source of a log message.  It usually represents system service,
+     *            e.g. {@code PackageManager}.
+     * @param msg the message to log.
+     *
+     * @see Log#i(String, String)
+     */
+    public static int i(@Nullable String tag, @NonNull String msg) {
+        return Log.println(Log.INFO, tag, msg);
+    }
+
+    /**
+     * Logs {@code msg} at {@link Log#INFO} level, attaching stack trace of the {@code tr} to
+     * the end of the log statement.
+     *
+     * @param tag identifies the source of a log message.  It usually represents system service,
+     *            e.g. {@code PackageManager}.
+     * @param msg the message to log.
+     * @param tr an exception to log.
+     *
+     * @see Log#i(String, String, Throwable)
+     */
+    public static int i(@Nullable String tag, @NonNull String msg, @Nullable Throwable tr) {
+        return Log.println(Log.INFO, tag,
+                msg + '\n' + Log.getStackTraceString(tr));
+    }
+
+    /**
+     * Logs {@code msg} at {@link Log#WARN} level.
+     *
+     * @param tag identifies the source of a log message.  It usually represents system service,
+     *            e.g. {@code PackageManager}.
+     * @param msg the message to log.
+     *
+     * @see Log#w(String, String)
+     */
+    public static int w(@Nullable String tag, @NonNull String msg) {
+        return Log.println(Log.WARN, tag, msg);
+    }
+
+    /**
+     * Logs {@code msg} at {@link Log#WARN} level, attaching stack trace of the {@code tr} to
+     * the end of the log statement.
+     *
+     * @param tag identifies the source of a log message.  It usually represents system service,
+     *            e.g. {@code PackageManager}.
+     * @param msg the message to log.
+     * @param tr an exception to log.
+     *
+     * @see Log#w(String, String, Throwable)
+     */
+    public static int w(@Nullable String tag, @NonNull String msg, @Nullable Throwable tr) {
+        return Log.println(Log.WARN, tag,
+                msg + '\n' + Log.getStackTraceString(tr));
+    }
+
+    /**
+     * Logs stack trace of {@code tr} at {@link Log#WARN} level.
+     *
+     * @param tag identifies the source of a log message.  It usually represents system service,
+     *            e.g. {@code PackageManager}.
+     * @param tr an exception to log.
+     *
+     * @see Log#w(String, Throwable)
+     */
+    public static int w(@Nullable String tag, @Nullable Throwable tr) {
+        return Log.println(Log.WARN, tag, Log.getStackTraceString(tr));
+    }
+
+    /**
+     * Logs {@code msg} at {@link Log#ERROR} level.
+     *
+     * @param tag identifies the source of a log message.  It usually represents system service,
+     *            e.g. {@code PackageManager}.
+     * @param msg the message to log.
+     *
+     * @see Log#e(String, String)
+     */
+    public static int e(@Nullable String tag, @NonNull String msg) {
+        return Log.println(Log.ERROR, tag, msg);
+    }
+
+    /**
+     * Logs {@code msg} at {@link Log#ERROR} level, attaching stack trace of the {@code tr} to
+     * the end of the log statement.
+     *
+     * @param tag identifies the source of a log message.  It usually represents system service,
+     *            e.g. {@code PackageManager}.
+     * @param msg the message to log.
+     * @param tr an exception to log.
+     *
+     * @see Log#e(String, String, Throwable)
+     */
+    public static int e(@Nullable String tag, @NonNull String msg, @Nullable Throwable tr) {
+        return Log.println(Log.ERROR, tag,
+                msg + '\n' + Log.getStackTraceString(tr));
+    }
+
+    /**
+     * Logs a condition that should never happen.
+     *
+     * <p>
+     * Similar to {@link Log#wtf(String, String)}, but will never cause the caller to crash, and
+     * will always be handled asynchronously. Primarily to be used by the system server.
+     *
+     * @param tag identifies the source of a log message.  It usually represents system service,
+     *            e.g. {@code PackageManager}.
+     * @param msg the message to log.
+     *
+     * @see Log#wtf(String, String)
+     */
+    public static int wtf(@Nullable String tag, @NonNull String msg) {
+        return Log.wtf(tag, msg, null);
+    }
+
+    /**
+     * Logs a condition that should never happen, attaching the full call stack to the log.
+     *
+     * <p>
+     * Similar to {@link Log#wtfStack(String, String)}, but will never cause the caller to crash,
+     * and will always be handled asynchronously. Primarily to be used by the system server.
+     *
+     * @param tag identifies the source of a log message.  It usually represents system service,
+     *            e.g. {@code PackageManager}.
+     * @param msg the message to log.
+     *
+     * @see Log#wtfStack(String, String)
+     */
+    public static int wtfStack(@Nullable String tag, @NonNull String msg) {
+        return Log.wtf(tag, msg, null);
+    }
+
+    /**
+     * Logs a condition that should never happen, attaching stack trace of the {@code tr} to the
+     * end of the log statement.
+     *
+     * <p>
+     * Similar to {@link Log#wtf(String, Throwable)}, but will never cause the caller to crash,
+     * and will always be handled asynchronously. Primarily to be used by the system server.
+     *
+     * @param tag identifies the source of a log message.  It usually represents system service,
+     *            e.g. {@code PackageManager}.
+     * @param tr an exception to log.
+     *
+     * @see Log#wtf(String, Throwable)
+     */
+    public static int wtf(@Nullable String tag, @Nullable Throwable tr) {
+        return Log.wtf(tag, tr.getMessage(), tr);
+    }
+
+    /**
+     * Logs a condition that should never happen, attaching stack trace of the {@code tr} to the
+     * end of the log statement.
+     *
+     * <p>
+     * Similar to {@link Log#wtf(String, String, Throwable)}, but will never cause the caller to
+     * crash, and will always be handled asynchronously. Primarily to be used by the system server.
+     *
+     * @param tag identifies the source of a log message.  It usually represents system service,
+     *            e.g. {@code PackageManager}.
+     * @param msg the message to log.
+     * @param tr an exception to log.
+     *
+     * @see Log#wtf(String, String, Throwable)
+     */
+    public static int wtf(@Nullable String tag, @NonNull String msg, @Nullable Throwable tr) {
+        return Log.wtf(tag, msg, tr);
+    }
+
+    /** @hide */
+    public static int println(int priority, @Nullable String tag, @NonNull String msg) {
+        return Log.println(priority, tag, msg);
+    }
+}
@@ -0,0 +1,371 @@
+/*
+ * Copyright (C) 2006 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 android.util;
+
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.annotation.TestApi;
+import android.os.Build;
+import android.os.SystemClock;
+
+import java.io.PrintWriter;
+import java.text.SimpleDateFormat;
+import java.time.Instant;
+import java.time.LocalTime;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * A class containing utility methods related to time zones.
+ */
+public class TimeUtils {
+    /** @hide */ public TimeUtils() {}
+    /** {@hide} */
+    private static final SimpleDateFormat sLoggingFormat =
+            new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+
+    /** @hide */
+    public static final SimpleDateFormat sDumpDateFormat =
+            new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
+
+    /**
+     * This timestamp is used in TimeUtils methods and by the SettingsUI to filter time zones
+     * to only "effective" ones in a country. It is compared against the notUsedAfter metadata that
+     * Android records for some time zones.
+     *
+     * <p>What is notUsedAfter?</p>
+     * Android chooses to avoid making users choose between functionally identical time zones at the
+     * expense of not being able to represent local times in the past.
+     *
+     * notUsedAfter exists because some time zones can "merge" with other time zones after a given
+     * point in time (i.e. they change to have identical transitions, offsets, display names, etc.).
+     * From the notUsedAfter time, the zone will express the same local time as the one it merged
+     * with.
+     *
+     * <p>Why hardcoded?</p>
+     * Rather than using System.currentTimeMillis(), a timestamp known to be in the recent past is
+     * used to ensure consistent behavior across devices and time, and avoid assumptions that the
+     * system clock on a device is currently set correctly. The fixed value should be updated
+     * occasionally, but it doesn't have to be very often as effective time zones for a country
+     * don't change very often.
+     *
+     * @hide
+     */
+    public static final Instant MIN_USE_DATE_OF_TIMEZONE =
+            Instant.ofEpochMilli(1546300800000L); // 1/1/2019 00:00 UTC
+
+    /** @hide Field length that can hold 999 days of time */
+    public static final int HUNDRED_DAY_FIELD_LEN = 19;
+
+    private static final int SECONDS_PER_MINUTE = 60;
+    private static final int SECONDS_PER_HOUR = 60 * 60;
+    private static final int SECONDS_PER_DAY = 24 * 60 * 60;
+
+    /** @hide */
+    public static final long NANOS_PER_MS = 1000000;
+
+    private static final Object sFormatSync = new Object();
+    private static char[] sFormatStr = new char[HUNDRED_DAY_FIELD_LEN+10];
+    private static char[] sTmpFormatStr = new char[HUNDRED_DAY_FIELD_LEN+10];
+
+    static private int accumField(int amt, int suffix, boolean always, int zeropad) {
+        if (amt > 999) {
+            int num = 0;
+            while (amt != 0) {
+                num++;
+                amt /= 10;
+            }
+            return num + suffix;
+        } else {
+            if (amt > 99 || (always && zeropad >= 3)) {
+                return 3+suffix;
+            }
+            if (amt > 9 || (always && zeropad >= 2)) {
+                return 2+suffix;
+            }
+            if (always || amt > 0) {
+                return 1+suffix;
+            }
+        }
+        return 0;
+    }
+
+    static private int printFieldLocked(char[] formatStr, int amt, char suffix, int pos,
+            boolean always, int zeropad) {
+        if (always || amt > 0) {
+            final int startPos = pos;
+            if (amt > 999) {
+                int tmp = 0;
+                while (amt != 0 && tmp < sTmpFormatStr.length) {
+                    int dig = amt % 10;
+                    sTmpFormatStr[tmp] = (char)(dig + '0');
+                    tmp++;
+                    amt /= 10;
+                }
+                tmp--;
+                while (tmp >= 0) {
+                    formatStr[pos] = sTmpFormatStr[tmp];
+                    pos++;
+                    tmp--;
+                }
+            } else {
+                if ((always && zeropad >= 3) || amt > 99) {
+                    int dig = amt/100;
+                    formatStr[pos] = (char)(dig + '0');
+                    pos++;
+                    amt -= (dig*100);
+                }
+                if ((always && zeropad >= 2) || amt > 9 || startPos != pos) {
+                    int dig = amt/10;
+                    formatStr[pos] = (char)(dig + '0');
+                    pos++;
+                    amt -= (dig*10);
+                }
+                formatStr[pos] = (char)(amt + '0');
+                pos++;
+            }
+            formatStr[pos] = suffix;
+            pos++;
+        }
+        return pos;
+    }
+
+    private static int formatDurationLocked(long duration, int fieldLen) {
+        if (sFormatStr.length < fieldLen) {
+            sFormatStr = new char[fieldLen];
+        }
+
+        char[] formatStr = sFormatStr;
+
+        if (duration == 0) {
+            int pos = 0;
+            fieldLen -= 1;
+            while (pos < fieldLen) {
+                formatStr[pos++] = ' ';
+            }
+            formatStr[pos] = '0';
+            return pos+1;
+        }
+
+        char prefix;
+        if (duration > 0) {
+            prefix = '+';
+        } else {
+            prefix = '-';
+            duration = -duration;
+        }
+
+        int millis = (int)(duration%1000);
+        int seconds = (int) Math.floor(duration / 1000);
+        int days = 0, hours = 0, minutes = 0;
+
+        if (seconds >= SECONDS_PER_DAY) {
+            days = seconds / SECONDS_PER_DAY;
+            seconds -= days * SECONDS_PER_DAY;
+        }
+        if (seconds >= SECONDS_PER_HOUR) {
+            hours = seconds / SECONDS_PER_HOUR;
+            seconds -= hours * SECONDS_PER_HOUR;
+        }
+        if (seconds >= SECONDS_PER_MINUTE) {
+            minutes = seconds / SECONDS_PER_MINUTE;
+            seconds -= minutes * SECONDS_PER_MINUTE;
+        }
+
+        int pos = 0;
+
+        if (fieldLen != 0) {
+            int myLen = accumField(days, 1, false, 0);
+            myLen += accumField(hours, 1, myLen > 0, 2);
+            myLen += accumField(minutes, 1, myLen > 0, 2);
+            myLen += accumField(seconds, 1, myLen > 0, 2);
+            myLen += accumField(millis, 2, true, myLen > 0 ? 3 : 0) + 1;
+            while (myLen < fieldLen) {
+                formatStr[pos] = ' ';
+                pos++;
+                myLen++;
+            }
+        }
+
+        formatStr[pos] = prefix;
+        pos++;
+
+        int start = pos;
+        boolean zeropad = fieldLen != 0;
+        pos = printFieldLocked(formatStr, days, 'd', pos, false, 0);
+        pos = printFieldLocked(formatStr, hours, 'h', pos, pos != start, zeropad ? 2 : 0);
+        pos = printFieldLocked(formatStr, minutes, 'm', pos, pos != start, zeropad ? 2 : 0);
+        pos = printFieldLocked(formatStr, seconds, 's', pos, pos != start, zeropad ? 2 : 0);
+        pos = printFieldLocked(formatStr, millis, 'm', pos, true, (zeropad && pos != start) ? 3 : 0);
+        formatStr[pos] = 's';
+        return pos + 1;
+    }
+
+    /** @hide Just for debugging; not internationalized. */
+    public static void formatDuration(long duration, StringBuilder builder) {
+        synchronized (sFormatSync) {
+            int len = formatDurationLocked(duration, 0);
+            builder.append(sFormatStr, 0, len);
+        }
+    }
+
+    /** @hide Just for debugging; not internationalized. */
+    public static void formatDuration(long duration, StringBuilder builder, int fieldLen) {
+        synchronized (sFormatSync) {
+            int len = formatDurationLocked(duration, fieldLen);
+            builder.append(sFormatStr, 0, len);
+        }
+    }
+
+    /** @hide Just for debugging; not internationalized. */
+    public static void formatDuration(long duration, PrintWriter pw, int fieldLen) {
+        synchronized (sFormatSync) {
+            int len = formatDurationLocked(duration, fieldLen);
+            pw.print(new String(sFormatStr, 0, len));
+        }
+    }
+
+    /** @hide Just for debugging; not internationalized. */
+    @TestApi
+    public static String formatDuration(long duration) {
+        synchronized (sFormatSync) {
+            int len = formatDurationLocked(duration, 0);
+            return new String(sFormatStr, 0, len);
+        }
+    }
+
+    /** @hide Just for debugging; not internationalized. */
+    public static void formatDuration(long duration, PrintWriter pw) {
+        formatDuration(duration, pw, 0);
+    }
+
+    /** @hide Just for debugging; not internationalized. */
+    public static void formatDuration(long time, long now, StringBuilder sb) {
+        if (time == 0) {
+            sb.append("--");
+            return;
+        }
+        formatDuration(time-now, sb, 0);
+    }
+
+    /** @hide Just for debugging; not internationalized. */
+    public static void formatDuration(long time, long now, PrintWriter pw) {
+        if (time == 0) {
+            pw.print("--");
+            return;
+        }
+        formatDuration(time-now, pw, 0);
+    }
+
+    /** @hide Just for debugging; not internationalized. */
+    public static String formatUptime(long time) {
+        return formatTime(time, SystemClock.uptimeMillis());
+    }
+
+    /** @hide Just for debugging; not internationalized. */
+    public static String formatRealtime(long time) {
+        return formatTime(time, SystemClock.elapsedRealtime());
+    }
+
+    /** @hide Just for debugging; not internationalized. */
+    public static String formatTime(long time, long referenceTime) {
+        long diff = time - referenceTime;
+        if (diff > 0) {
+            return time + " (in " + diff + " ms)";
+        }
+        if (diff < 0) {
+            return time + " (" + -diff + " ms ago)";
+        }
+        return time + " (now)";
+    }
+
+    /**
+     * Convert a System.currentTimeMillis() value to a time of day value like
+     * that printed in logs. MM-DD HH:MM:SS.MMM
+     *
+     * @param millis since the epoch (1/1/1970)
+     * @return String representation of the time.
+     * @hide
+     */
+    public static String logTimeOfDay(long millis) {
+        Calendar c = Calendar.getInstance();
+        if (millis >= 0) {
+            c.setTimeInMillis(millis);
+            return String.format("%tm-%td %tH:%tM:%tS.%tL", c, c, c, c, c, c);
+        } else {
+            return Long.toString(millis);
+        }
+    }
+
+    /** {@hide} */
+    public static String formatForLogging(long millis) {
+        if (millis <= 0) {
+            return "unknown";
+        } else {
+            return sLoggingFormat.format(new Date(millis));
+        }
+    }
+
+    /**
+     * Dump a currentTimeMillis style timestamp for dumpsys.
+     *
+     * @hide
+     */
+    public static void dumpTime(PrintWriter pw, long time) {
+        pw.print(sDumpDateFormat.format(new Date(time)));
+    }
+
+    /**
+     * This method is used to find if a clock time is inclusively between two other clock times
+     * @param reference The time of the day we want check if it is between start and end
+     * @param start The start time reference
+     * @param end The end time
+     * @return true if the reference time is between the two clock times, and false otherwise.
+     */
+    public static boolean isTimeBetween(@NonNull LocalTime reference,
+                                        @NonNull LocalTime start,
+                                        @NonNull LocalTime end) {
+        //    ////////E----+-----S////////
+        if ((reference.isBefore(start) && reference.isAfter(end)
+                //    -----+----S//////////E------
+                || (reference.isBefore(end) && reference.isBefore(start) && start.isBefore(end))
+                //    ---------S//////////E---+---
+                || (reference.isAfter(end) && reference.isAfter(start)) && start.isBefore(end))) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    /**
+     * Dump a currentTimeMillis style timestamp for dumpsys, with the delta time from now.
+     *
+     * @hide
+     */
+    public static void dumpTimeWithDelta(PrintWriter pw, long time, long now) {
+        pw.print(sDumpDateFormat.format(new Date(time)));
+        if (time == now) {
+            pw.print(" (now)");
+        } else {
+            pw.print(" (");
+            TimeUtils.formatDuration(time, now, pw);
+            pw.print(")");
+        }
+    }}
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package android.os;
+
+import android.annotation.NonNull;
+
+/**
+ * Supplier for custom trace messages.
+ *
+ * @hide
+ */
+public interface TraceNameSupplier {
+
+    /**
+     * Gets the name used for trace messages.
+     */
+    @NonNull String getTraceName();
+}
@@ -0,0 +1,247 @@
+package android.webkit;
+
+import android.annotation.Nullable;
+import xyz.nulldev.androidcompat.webkit.CookieManagerImpl;
+
+public abstract class CookieManager {
+    /**
+     * @deprecated This class should not be constructed by applications, use {@link #getInstance}
+     * instead to fetch the singleton instance.
+     */
+    // TODO(ntfschr): mark this as @SystemApi after a year.
+    @Deprecated
+    public CookieManager() {}
+    @Override
+    protected Object clone() throws CloneNotSupportedException {
+        throw new CloneNotSupportedException("doesn't implement Cloneable");
+    }
+
+    private static CookieManager INSTANCE = null;
+    private static final Object lock = new Object();
+    /**
+     * Gets the singleton CookieManager instance.
+     *
+     * @return the singleton CookieManager instance
+     */
+    public static CookieManager getInstance() {
+        if (INSTANCE != null) {
+            return INSTANCE;
+        } else {
+            synchronized (lock) {
+                if (INSTANCE == null) {
+                    INSTANCE = new CookieManagerImpl();
+                }
+                return INSTANCE;
+            }
+        }
+    }
+    /**
+     * Sets whether the application's {@link WebView} instances should send and
+     * accept cookies.
+     * By default this is set to {@code true} and the WebView accepts cookies.
+     * <p>
+     * When this is {@code true}
+     * {@link CookieManager#setAcceptThirdPartyCookies setAcceptThirdPartyCookies} and
+     * {@link CookieManager#setAcceptFileSchemeCookies setAcceptFileSchemeCookies}
+     * can be used to control the policy for those specific types of cookie.
+     *
+     * @param accept whether {@link WebView} instances should send and accept
+     *               cookies
+     */
+    public abstract void setAcceptCookie(boolean accept);
+    /**
+     * Gets whether the application's {@link WebView} instances send and accept
+     * cookies.
+     *
+     * @return {@code true} if {@link WebView} instances send and accept cookies
+     */
+    public abstract boolean acceptCookie();
+    /**
+     * Sets whether the {@link WebView} should allow third party cookies to be set.
+     * Allowing third party cookies is a per WebView policy and can be set
+     * differently on different WebView instances.
+     * <p>
+     * Apps that target {@link android.os.Build.VERSION_CODES#KITKAT} or below
+     * default to allowing third party cookies. Apps targeting
+     * {@link android.os.Build.VERSION_CODES#LOLLIPOP} or later default to disallowing
+     * third party cookies.
+     *
+     * @param webview the {@link WebView} instance to set the cookie policy on
+     * @param accept whether the {@link WebView} instance should accept
+     *               third party cookies
+     */
+    public abstract void setAcceptThirdPartyCookies(WebView webview, boolean accept);
+    /**
+     * Gets whether the {@link WebView} should allow third party cookies to be set.
+     *
+     * @param webview the {@link WebView} instance to get the cookie policy for
+     * @return {@code true} if the {@link WebView} accepts third party cookies
+     */
+    public abstract boolean acceptThirdPartyCookies(WebView webview);
+    /**
+     * Sets a single cookie (key-value pair) for the given URL. Any existing cookie with the same
+     * host, path and name will be replaced with the new cookie. The cookie being set
+     * will be ignored if it is expired. To set multiple cookies, your application should invoke
+     * this method multiple times.
+     *
+     * <p>The {@code value} parameter must follow the format of the {@code Set-Cookie} HTTP
+     * response header defined by
+     * <a href="https://tools.ietf.org/html/draft-ietf-httpbis-rfc6265bis-03">RFC6265bis</a>.
+     * This is a key-value pair of the form {@code "key=value"}, optionally followed by a list of
+     * cookie attributes delimited with semicolons (ex. {@code "key=value; Max-Age=123"}). Please
+     * consult the RFC specification for a list of valid attributes.
+     *
+     * <p class="note"><b>Note:</b> if specifying a {@code value} containing the {@code "Secure"}
+     * attribute, {@code url} must use the {@code "https://"} scheme.
+     *
+     * @param url the URL for which the cookie is to be set
+     * @param value the cookie as a string, using the format of the 'Set-Cookie'
+     *              HTTP response header
+     */
+    public abstract void setCookie(String url, String value);
+    /**
+     * Sets a single cookie (key-value pair) for the given URL. Any existing cookie with the same
+     * host, path and name will be replaced with the new cookie. The cookie being set
+     * will be ignored if it is expired. To set multiple cookies, your application should invoke
+     * this method multiple times.
+     *
+     * <p>The {@code value} parameter must follow the format of the {@code Set-Cookie} HTTP
+     * response header defined by
+     * <a href="https://tools.ietf.org/html/draft-ietf-httpbis-rfc6265bis-03">RFC6265bis</a>.
+     * This is a key-value pair of the form {@code "key=value"}, optionally followed by a list of
+     * cookie attributes delimited with semicolons (ex. {@code "key=value; Max-Age=123"}). Please
+     * consult the RFC specification for a list of valid attributes.
+     *
+     * <p>This method is asynchronous. If a {@link ValueCallback} is provided,
+     * {@link ValueCallback#onReceiveValue} will be called on the current
+     * thread's {@link android.os.Looper} once the operation is complete.
+     * The value provided to the callback indicates whether the cookie was set successfully.
+     * You can pass {@code null} as the callback if you don't need to know when the operation
+     * completes or whether it succeeded, and in this case it is safe to call the method from a
+     * thread without a Looper.
+     *
+     * <p class="note"><b>Note:</b> if specifying a {@code value} containing the {@code "Secure"}
+     * attribute, {@code url} must use the {@code "https://"} scheme.
+     *
+     * @param url the URL for which the cookie is to be set
+     * @param value the cookie as a string, using the format of the 'Set-Cookie'
+     *              HTTP response header
+     * @param callback a callback to be executed when the cookie has been set
+     */
+    public abstract void setCookie(String url, String value, @Nullable ValueCallback<Boolean>
+            callback);
+    /**
+     * Gets all the cookies for the given URL. This may return multiple key-value pairs if multiple
+     * cookies are associated with this URL, in which case each cookie will be delimited by {@code
+     * "; "} characters (semicolon followed by a space). Each key-value pair will be of the form
+     * {@code "key=value"}.
+     *
+     * @param url the URL for which the cookies are requested
+     * @return value the cookies as a string, using the format of the 'Cookie'
+     *               HTTP request header
+     */
+    public abstract String getCookie(String url);
+
+    /**
+     * Removes all session cookies, which are cookies without an expiration
+     * date.
+     * @deprecated use {@link #removeSessionCookies(ValueCallback)} instead.
+     */
+    @Deprecated
+    public abstract void removeSessionCookie();
+    /**
+     * Removes all session cookies, which are cookies without an expiration
+     * date.
+     * <p>
+     * This method is asynchronous.
+     * If a {@link ValueCallback} is provided,
+     * {@link ValueCallback#onReceiveValue(Object)} will be called on the current
+     * thread's {@link android.os.Looper} once the operation is complete.
+     * The value provided to the callback indicates whether any cookies were removed.
+     * You can pass {@code null} as the callback if you don't need to know when the operation
+     * completes or whether any cookie were removed, and in this case it is safe to call the
+     * method from a thread without a Looper.
+     * @param callback a callback which is executed when the session cookies have been removed
+     */
+    public abstract void removeSessionCookies(@Nullable ValueCallback<Boolean> callback);
+    /**
+     * Removes all cookies.
+     * @deprecated Use {@link #removeAllCookies(ValueCallback)} instead.
+     */
+    @Deprecated
+    public abstract void removeAllCookie();
+    /**
+     * Removes all cookies.
+     * <p>
+     * This method is asynchronous.
+     * If a {@link ValueCallback} is provided,
+     * {@link ValueCallback#onReceiveValue(Object)}  will be called on the current
+     * thread's {@link android.os.Looper} once the operation is complete.
+     * The value provided to the callback indicates whether any cookies were removed.
+     * You can pass {@code null} as the callback if you don't need to know when the operation
+     * completes or whether any cookies were removed, and in this case it is safe to call the
+     * method from a thread without a Looper.
+     * @param callback a callback which is executed when the cookies have been removed
+     */
+    public abstract void removeAllCookies(@Nullable ValueCallback<Boolean> callback);
+    /**
+     * Gets whether there are stored cookies.
+     *
+     * @return {@code true} if there are stored cookies
+     */
+    public abstract boolean hasCookies();
+    /**
+     * Removes all expired cookies.
+     * @deprecated The WebView handles removing expired cookies automatically.
+     */
+    @Deprecated
+    public abstract void removeExpiredCookie();
+    /**
+     * Ensures all cookies currently accessible through the getCookie API are
+     * written to persistent storage.
+     * This call will block the caller until it is done and may perform I/O.
+     */
+    public abstract void flush();
+    /**
+     * Gets whether the application's {@link WebView} instances send and accept
+     * cookies for file scheme URLs.
+     *
+     * @return {@code true} if {@link WebView} instances send and accept cookies for
+     *         file scheme URLs
+     */
+    // Static for backward compatibility.
+    public static boolean allowFileSchemeCookies() {
+        return getInstance().allowFileSchemeCookiesImpl();
+    }
+
+    public abstract boolean allowFileSchemeCookiesImpl();
+
+    /**
+     * Sets whether the application's {@link WebView} instances should send and accept cookies for
+     * file scheme URLs.
+     * <p>
+     * Use of cookies with file scheme URLs is potentially insecure and turned off by default. All
+     * {@code file://} URLs share all their cookies, which may lead to leaking private app cookies
+     * (ex. any malicious file can access cookies previously set by other (trusted) files).
+     * <p class="note">
+     * Loading content via {@code file://} URLs is generally discouraged. See the note in
+     * {@link WebSettings#setAllowFileAccess}.
+     * Using <a href="{@docRoot}reference/androidx/webkit/WebViewAssetLoader.html">
+     * androidx.webkit.WebViewAssetLoader</a> to load files over {@code http(s)://} URLs allows
+     * the standard web security model to be used for setting and sharing cookies for local files.
+     * <p>
+     * Note that calls to this method will have no effect if made after calling other
+     * {@link CookieManager} APIs.
+     *
+     * @deprecated This setting is not secure, please use
+     *             <a href="{@docRoot}reference/androidx/webkit/WebViewAssetLoader.html">
+     *             androidx.webkit.WebViewAssetLoader</a> instead.
+     */
+    // Static for backward compatibility.
+    @Deprecated
+    public static void setAcceptFileSchemeCookies(boolean accept) {
+        getInstance().setAcceptFileSchemeCookiesImpl(accept);
+    }
+
+    public abstract void setAcceptFileSchemeCookiesImpl(boolean accept);
+}
@@ -0,0 +1,205 @@
+/*
+ * Copyright (C) 2008 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 android.webkit;
+
+import android.annotation.Nullable;
+import android.annotation.SystemApi;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.graphics.Bitmap;
+import android.net.Uri;
+import android.os.Message;
+import android.view.View;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+public class WebChromeClient {
+
+    public void onProgressChanged(WebView view, int newProgress) {}
+
+    public void onReceivedTitle(WebView view, String title) {}
+
+    public void onReceivedIcon(WebView view, Bitmap icon) {}
+
+    public void onReceivedTouchIconUrl(WebView view, String url,
+            boolean precomposed) {}
+
+    public interface CustomViewCallback {
+        public void onCustomViewHidden();
+    }
+
+    public void onShowCustomView(View view, CustomViewCallback callback) {};
+
+    @Deprecated
+    public void onShowCustomView(View view, int requestedOrientation,
+            CustomViewCallback callback) {};
+
+    public void onHideCustomView() {}
+
+    public boolean onCreateWindow(WebView view, boolean isDialog,
+            boolean isUserGesture, Message resultMsg) {
+        return false;
+    }
+
+    public void onRequestFocus(WebView view) {}
+
+    public void onCloseWindow(WebView window) {}
+
+    public boolean onJsAlert(WebView view, String url, String message,
+            JsResult result) {
+        return false;
+    }
+
+    public boolean onJsConfirm(WebView view, String url, String message,
+            JsResult result) {
+        return false;
+    }
+
+    public boolean onJsPrompt(WebView view, String url, String message,
+            String defaultValue, JsPromptResult result) {
+        return false;
+    }
+
+    public boolean onJsBeforeUnload(WebView view, String url, String message,
+            JsResult result) {
+        return false;
+    }
+
+    @Deprecated
+    public void onExceededDatabaseQuota(String url, String databaseIdentifier,
+            long quota, long estimatedDatabaseSize, long totalQuota,
+            WebStorage.QuotaUpdater quotaUpdater) {
+        // This default implementation passes the current quota back to WebCore.
+        // WebCore will interpret this that new quota was declined.
+        quotaUpdater.updateQuota(quota);
+    }
+
+    @Deprecated
+    public void onReachedMaxAppCacheSize(long requiredStorage, long quota,
+            WebStorage.QuotaUpdater quotaUpdater) {
+        quotaUpdater.updateQuota(quota);
+    }
+
+    public void onGeolocationPermissionsShowPrompt(String origin,
+            GeolocationPermissions.Callback callback) {}
+
+    public void onGeolocationPermissionsHidePrompt() {}
+
+    public void onPermissionRequest(PermissionRequest request) {
+        request.deny();
+    }
+
+    public void onPermissionRequestCanceled(PermissionRequest request) {}
+
+    // This method was only called when using the JSC javascript engine. V8 became
+    // the default JS engine with Froyo and support for building with JSC was
+    // removed in b/5495373. V8 does not have a mechanism for making a callback such
+    // as this.
+    @Deprecated
+    public boolean onJsTimeout() {
+        return true;
+    }
+
+    @Deprecated
+    public void onConsoleMessage(String message, int lineNumber, String sourceID) { }
+
+    public boolean onConsoleMessage(ConsoleMessage consoleMessage) {
+        // Call the old version of this function for backwards compatability.
+        onConsoleMessage(consoleMessage.message(), consoleMessage.lineNumber(),
+                consoleMessage.sourceId());
+        return false;
+    }
+
+    @Nullable
+    public Bitmap getDefaultVideoPoster() {
+        return null;
+    }
+
+    @Nullable
+    public View getVideoLoadingProgressView() {
+        return null;
+    }
+
+    /** Obtains a list of all visited history items, used for link coloring
+     */
+    public void getVisitedHistory(ValueCallback<String[]> callback) {
+    }
+
+    public boolean onShowFileChooser(WebView webView, ValueCallback<Uri[]> filePathCallback,
+            FileChooserParams fileChooserParams) {
+        return false;
+    }
+
+    public static abstract class FileChooserParams {
+        @SystemApi
+        public static final long ENABLE_FILE_SYSTEM_ACCESS = 364980165L;
+
+        /** @hide */
+        @Retention(RetentionPolicy.SOURCE)
+        public @interface Mode {}
+
+        /** Open single file. Requires that the file exists before allowing the user to pick it. */
+        public static final int MODE_OPEN = 0;
+        /** Like Open but allows multiple files to be selected. */
+        public static final int MODE_OPEN_MULTIPLE = 1;
+        /** Like Open but allows a folder to be selected. */
+        public static final int MODE_OPEN_FOLDER = 2;
+        /**  Allows picking a nonexistent file and saving it. */
+        public static final int MODE_SAVE = 3;
+
+        /** @hide */
+        @Retention(RetentionPolicy.SOURCE)
+        public @interface PermissionMode {}
+
+        /** File or directory should be opened for reading only. */
+        public static final int PERMISSION_MODE_READ = 0;
+        /** File or directory should be opened for read and write. */
+        public static final int PERMISSION_MODE_READ_WRITE = 1;
+
+        @Nullable
+        public static Uri[] parseResult(int resultCode, Intent data) {
+            throw new RuntimeException("Stub!");
+        }
+
+        @Mode
+        public abstract int getMode();
+
+        public abstract String[] getAcceptTypes();
+
+        public abstract boolean isCaptureEnabled();
+
+        @Nullable
+        public abstract CharSequence getTitle();
+
+        @Nullable
+        public abstract String getFilenameHint();
+
+        @PermissionMode
+        public int getPermissionMode() {
+            return PERMISSION_MODE_READ;
+        }
+
+        public abstract Intent createIntent();
+    }
+
+    @SystemApi
+    @Deprecated
+    public void openFileChooser(ValueCallback<Uri> uploadFile, String acceptType, String capture) {
+        uploadFile.onReceiveValue(null);
+    }
+}
@@ -0,0 +1,609 @@
+/*
+ * Copyright (C) 2008 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 android.webkit;
+
+import android.annotation.Nullable;
+import android.graphics.Bitmap;
+import android.net.http.SslError;
+import android.os.Message;
+import android.view.InputEvent;
+import android.view.KeyEvent;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+public class WebViewClient {
+
+    /**
+     * Give the host application a chance to take control when a URL is about to be loaded in the
+     * current WebView. If a WebViewClient is not provided, by default WebView will ask Activity
+     * Manager to choose the proper handler for the URL. If a WebViewClient is provided, returning
+     * {@code true} causes the current WebView to abort loading the URL, while returning
+     * {@code false} causes the WebView to continue loading the URL as usual.
+     *
+     * <p class="note"><b>Note:</b> Do not call {@link WebView#loadUrl(String)} with the same
+     * URL and then return {@code true}. This unnecessarily cancels the current load and starts a
+     * new load with the same URL. The correct way to continue loading a given URL is to simply
+     * return {@code false}, without calling {@link WebView#loadUrl(String)}.
+     *
+     * <p class="note"><b>Note:</b> This method is not called for POST requests.
+     *
+     * <p class="note"><b>Note:</b> This method may be called for subframes and with non-HTTP(S)
+     * schemes; calling {@link WebView#loadUrl(String)} with such a URL will fail.
+     *
+     * @param view The WebView that is initiating the callback.
+     * @param url The URL to be loaded.
+     * @return {@code true} to cancel the current load, otherwise return {@code false}.
+     * @deprecated Use {@link #shouldOverrideUrlLoading(WebView, WebResourceRequest)
+     *             shouldOverrideUrlLoading(WebView, WebResourceRequest)} instead.
+     */
+    @Deprecated
+    public boolean shouldOverrideUrlLoading(WebView view, String url) {
+        return false;
+    }
+
+    /**
+     * Give the host application a chance to take control when a URL is about to be loaded in the
+     * current WebView. If a WebViewClient is not provided, by default WebView will ask Activity
+     * Manager to choose the proper handler for the URL. If a WebViewClient is provided, returning
+     * {@code true} causes the current WebView to abort loading the URL, while returning
+     * {@code false} causes the WebView to continue loading the URL as usual.
+     *
+     * <p>This callback is not called for all page navigations. In particular, this is not called
+     * for navigations which the app initiated with {@code loadUrl()}: this callback would not serve
+     * a purpose in this case, because the app already knows about the navigation. This callback
+     * lets the app know about navigations initiated by the web page (such as navigations initiated
+     * by JavaScript code), by the user (such as when the user taps on a link), or by an HTTP
+     * redirect (ex. if {@code loadUrl("foo.com")} redirects to {@code "bar.com"} because of HTTP
+     * 301).
+     *
+     * <p class="note"><b>Note:</b> Do not call {@link WebView#loadUrl(String)} with the request's
+     * URL and then return {@code true}. This unnecessarily cancels the current load and starts a
+     * new load with the same URL. The correct way to continue loading a given URL is to simply
+     * return {@code false}, without calling {@link WebView#loadUrl(String)}.
+     *
+     * <p class="note"><b>Note:</b> This method is not called for POST requests.
+     *
+     * <p class="note"><b>Note:</b> This method may be called for subframes and with non-HTTP(S)
+     * schemes; calling {@link WebView#loadUrl(String)} with such a URL will fail.
+     *
+     * @param view The WebView that is initiating the callback.
+     * @param request Object containing the details of the request.
+     * @return {@code true} to cancel the current load, otherwise return {@code false}.
+     */
+    public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
+        return shouldOverrideUrlLoading(view, request.getUrl().toString());
+    }
+
+    /**
+     * Notify the host application that a page has started loading. This method
+     * is called once for each main frame load so a page with iframes or
+     * framesets will call onPageStarted one time for the main frame. This also
+     * means that onPageStarted will not be called when the contents of an
+     * embedded frame changes, i.e. clicking a link whose target is an iframe,
+     * it will also not be called for fragment navigations (navigations to
+     * #fragment_id).
+     *
+     * @param view The WebView that is initiating the callback.
+     * @param url The url to be loaded.
+     * @param favicon The favicon for this page if it already exists in the
+     *            database.
+     */
+    public void onPageStarted(WebView view, String url, Bitmap favicon) {
+    }
+
+    /**
+     * Notify the host application that a page has finished loading. This method
+     * is called only for main frame. Receiving an {@code onPageFinished()} callback does not
+     * guarantee that the next frame drawn by WebView will reflect the state of the DOM at this
+     * point. In order to be notified that the current DOM state is ready to be rendered, request a
+     * visual state callback with {@link WebView#postVisualStateCallback} and wait for the supplied
+     * callback to be triggered.
+     *
+     * @param view The WebView that is initiating the callback.
+     * @param url The url of the page.
+     */
+    public void onPageFinished(WebView view, String url) {
+    }
+
+    /**
+     * Notify the host application that the WebView will load the resource
+     * specified by the given url.
+     *
+     * @param view The WebView that is initiating the callback.
+     * @param url The url of the resource the WebView will load.
+     */
+    public void onLoadResource(WebView view, String url) {
+    }
+
+    /**
+     * Notify the host application that {@link android.webkit.WebView} content left over from
+     * previous page navigations will no longer be drawn.
+     *
+     * <p>This callback can be used to determine the point at which it is safe to make a recycled
+     * {@link android.webkit.WebView} visible, ensuring that no stale content is shown. It is called
+     * at the earliest point at which it can be guaranteed that {@link WebView#onDraw} will no
+     * longer draw any content from previous navigations. The next draw will display either the
+     * {@link WebView#setBackgroundColor background color} of the {@link WebView}, or some of the
+     * contents of the newly loaded page.
+     *
+     * <p>This method is called when the body of the HTTP response has started loading, is reflected
+     * in the DOM, and will be visible in subsequent draws. This callback occurs early in the
+     * document loading process, and as such you should expect that linked resources (for example,
+     * CSS and images) may not be available.
+     *
+     * <p>For more fine-grained notification of visual state updates, see {@link
+     * WebView#postVisualStateCallback}.
+     *
+     * <p>Please note that all the conditions and recommendations applicable to
+     * {@link WebView#postVisualStateCallback} also apply to this API.
+     *
+     * <p>This callback is only called for main frame navigations.
+     *
+     * @param view The {@link android.webkit.WebView} for which the navigation occurred.
+     * @param url  The URL corresponding to the page navigation that triggered this callback.
+     */
+    public void onPageCommitVisible(WebView view, String url) {
+    }
+
+    /**
+     * Notify the host application of a resource request and allow the
+     * application to return the data.  If the return value is {@code null}, the WebView
+     * will continue to load the resource as usual.  Otherwise, the return
+     * response and data will be used.
+     *
+     * <p>This callback is invoked for a variety of URL schemes (e.g., {@code http(s):}, {@code
+     * data:}, {@code file:}, etc.), not only those schemes which send requests over the network.
+     * This is not called for {@code javascript:} URLs, {@code blob:} URLs, or for assets accessed
+     * via {@code file:///android_asset/} or {@code file:///android_res/} URLs.
+     *
+     * <p>In the case of redirects, this is only called for the initial resource URL, not any
+     * subsequent redirect URLs.
+     *
+     * <p class="note"><b>Note:</b> This method is called on a thread
+     * other than the UI thread so clients should exercise caution
+     * when accessing private data or the view system.
+     *
+     * <p class="note"><b>Note:</b> When Safe Browsing is enabled, these URLs still undergo Safe
+     * Browsing checks. If this is undesired, you can use {@link WebView#setSafeBrowsingWhitelist}
+     * to skip Safe Browsing checks for that host or dismiss the warning in {@link
+     * #onSafeBrowsingHit} by calling {@link SafeBrowsingResponse#proceed}.
+     *
+     * @param view The {@link android.webkit.WebView} that is requesting the
+     *             resource.
+     * @param url The raw url of the resource.
+     * @return A {@link android.webkit.WebResourceResponse} containing the
+     *         response information or {@code null} if the WebView should load the
+     *         resource itself.
+     * @deprecated Use {@link #shouldInterceptRequest(WebView, WebResourceRequest)
+     *             shouldInterceptRequest(WebView, WebResourceRequest)} instead.
+     */
+    @Deprecated
+    @Nullable
+    public WebResourceResponse shouldInterceptRequest(WebView view,
+            String url) {
+        return null;
+    }
+
+    /**
+     * Notify the host application of a resource request and allow the
+     * application to return the data.  If the return value is {@code null}, the WebView
+     * will continue to load the resource as usual.  Otherwise, the return
+     * response and data will be used.
+     *
+     * <p>This callback is invoked for a variety of URL schemes (e.g., {@code http(s):}, {@code
+     * data:}, {@code file:}, etc.), not only those schemes which send requests over the network.
+     * This is not called for {@code javascript:} URLs, {@code blob:} URLs, or for assets accessed
+     * via {@code file:///android_asset/} or {@code file:///android_res/} URLs.
+     *
+     * <p>In the case of redirects, this is only called for the initial resource URL, not any
+     * subsequent redirect URLs.
+     *
+     * <p class="note"><b>Note:</b> This method is called on a thread
+     * other than the UI thread so clients should exercise caution
+     * when accessing private data or the view system.
+     *
+     * <p class="note"><b>Note:</b> When Safe Browsing is enabled, these URLs still undergo Safe
+     * Browsing checks. If this is undesired, you can use {@link WebView#setSafeBrowsingWhitelist}
+     * to skip Safe Browsing checks for that host or dismiss the warning in {@link
+     * #onSafeBrowsingHit} by calling {@link SafeBrowsingResponse#proceed}.
+     *
+     * @param view The {@link android.webkit.WebView} that is requesting the
+     *             resource.
+     * @param request Object containing the details of the request.
+     * @return A {@link android.webkit.WebResourceResponse} containing the
+     *         response information or {@code null} if the WebView should load the
+     *         resource itself.
+     */
+    @Nullable
+    public WebResourceResponse shouldInterceptRequest(WebView view,
+            WebResourceRequest request) {
+        return shouldInterceptRequest(view, request.getUrl().toString());
+    }
+
+    /**
+     * Notify the host application that there have been an excessive number of
+     * HTTP redirects. As the host application if it would like to continue
+     * trying to load the resource. The default behavior is to send the cancel
+     * message.
+     *
+     * @param view The WebView that is initiating the callback.
+     * @param cancelMsg The message to send if the host wants to cancel
+     * @param continueMsg The message to send if the host wants to continue
+     * @deprecated This method is no longer called. When the WebView encounters
+     *             a redirect loop, it will cancel the load.
+     */
+    @Deprecated
+    public void onTooManyRedirects(WebView view, Message cancelMsg,
+            Message continueMsg) {
+        cancelMsg.sendToTarget();
+    }
+
+    // These ints must match up to the hidden values in EventHandler.
+    /** Generic error */
+    public static final int ERROR_UNKNOWN = -1;
+    /** Server or proxy hostname lookup failed */
+    public static final int ERROR_HOST_LOOKUP = -2;
+    /** Unsupported authentication scheme (not basic or digest) */
+    public static final int ERROR_UNSUPPORTED_AUTH_SCHEME = -3;
+    /** User authentication failed on server */
+    public static final int ERROR_AUTHENTICATION = -4;
+    /** User authentication failed on proxy */
+    public static final int ERROR_PROXY_AUTHENTICATION = -5;
+    /** Failed to connect to the server */
+    public static final int ERROR_CONNECT = -6;
+    /** Failed to read or write to the server */
+    public static final int ERROR_IO = -7;
+    /** Connection timed out */
+    public static final int ERROR_TIMEOUT = -8;
+    /** Too many redirects */
+    public static final int ERROR_REDIRECT_LOOP = -9;
+    /** Unsupported URI scheme */
+    public static final int ERROR_UNSUPPORTED_SCHEME = -10;
+    /** Failed to perform SSL handshake */
+    public static final int ERROR_FAILED_SSL_HANDSHAKE = -11;
+    /** Malformed URL */
+    public static final int ERROR_BAD_URL = -12;
+    /** Generic file error */
+    public static final int ERROR_FILE = -13;
+    /** File not found */
+    public static final int ERROR_FILE_NOT_FOUND = -14;
+    /** Too many requests during this load */
+    public static final int ERROR_TOO_MANY_REQUESTS = -15;
+    /** Resource load was canceled by Safe Browsing */
+    public static final int ERROR_UNSAFE_RESOURCE = -16;
+
+    /** @hide */
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface SafeBrowsingThreat {}
+
+    /** The resource was blocked for an unknown reason. */
+    public static final int SAFE_BROWSING_THREAT_UNKNOWN = 0;
+    /** The resource was blocked because it contains malware. */
+    public static final int SAFE_BROWSING_THREAT_MALWARE = 1;
+    /** The resource was blocked because it contains deceptive content. */
+    public static final int SAFE_BROWSING_THREAT_PHISHING = 2;
+    /** The resource was blocked because it contains unwanted software. */
+    public static final int SAFE_BROWSING_THREAT_UNWANTED_SOFTWARE = 3;
+    /**
+     * The resource was blocked because it may trick the user into a billing agreement.
+     *
+     * <p>This constant is only used when targetSdkVersion is at least {@link
+     * android.os.Build.VERSION_CODES#Q}. Otherwise, {@link #SAFE_BROWSING_THREAT_UNKNOWN} is used
+     * instead.
+     */
+    public static final int SAFE_BROWSING_THREAT_BILLING = 4;
+
+    /**
+     * Report an error to the host application. These errors are unrecoverable
+     * (i.e. the main resource is unavailable). The {@code errorCode} parameter
+     * corresponds to one of the {@code ERROR_*} constants.
+     * @param view The WebView that is initiating the callback.
+     * @param errorCode The error code corresponding to an ERROR_* value.
+     * @param description A String describing the error.
+     * @param failingUrl The url that failed to load.
+     * @deprecated Use {@link #onReceivedError(WebView, WebResourceRequest, WebResourceError)
+     *             onReceivedError(WebView, WebResourceRequest, WebResourceError)} instead.
+     */
+    @Deprecated
+    public void onReceivedError(WebView view, int errorCode,
+            String description, String failingUrl) {
+    }
+
+    /**
+     * Report web resource loading error to the host application. These errors usually indicate
+     * inability to connect to the server. Note that unlike the deprecated version of the callback,
+     * the new version will be called for any resource (iframe, image, etc.), not just for the main
+     * page. Thus, it is recommended to perform minimum required work in this callback.
+     * @param view The WebView that is initiating the callback.
+     * @param request The originating request.
+     * @param error Information about the error occurred.
+     */
+    public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
+        if (request.isForMainFrame()) {
+            onReceivedError(view,
+                    error.getErrorCode(), error.getDescription().toString(),
+                    request.getUrl().toString());
+        }
+    }
+
+    /**
+     * Notify the host application that an HTTP error has been received from the server while
+     * loading a resource.  HTTP errors have status codes &gt;= 400.  This callback will be called
+     * for any resource (iframe, image, etc.), not just for the main page. Thus, it is recommended
+     * to perform minimum required work in this callback. Note that the content of the server
+     * response may not be provided within the {@code errorResponse} parameter.
+     * @param view The WebView that is initiating the callback.
+     * @param request The originating request.
+     * @param errorResponse Information about the error occurred.
+     */
+    public void onReceivedHttpError(
+            WebView view, WebResourceRequest request, WebResourceResponse errorResponse) {
+    }
+
+    /**
+     * As the host application if the browser should resend data as the
+     * requested page was a result of a POST. The default is to not resend the
+     * data.
+     *
+     * @param view The WebView that is initiating the callback.
+     * @param dontResend The message to send if the browser should not resend
+     * @param resend The message to send if the browser should resend data
+     */
+    public void onFormResubmission(WebView view, Message dontResend,
+            Message resend) {
+        dontResend.sendToTarget();
+    }
+
+    /**
+     * Notify the host application to update its visited links database.
+     *
+     * @param view The WebView that is initiating the callback.
+     * @param url The url being visited.
+     * @param isReload {@code true} if this url is being reloaded.
+     */
+    public void doUpdateVisitedHistory(WebView view, String url,
+            boolean isReload) {
+    }
+
+    /**
+     * Notifies the host application that an SSL error occurred while loading a
+     * resource. The host application must call either
+     * {@link SslErrorHandler#cancel()} or {@link SslErrorHandler#proceed()}.
+     *
+     * <p class="warning"><b>Warning:</b> Application overrides of this method
+     * can be used to display custom error pages or to silently log issues, but
+     * the host application should always call {@code SslErrorHandler#cancel()}
+     * and never proceed past errors.
+     *
+     * <p class="note"><b>Note:</b> Do not prompt the user about SSL errors.
+     * Users are unlikely to be able to make an informed security decision, and
+     * {@code WebView} does not provide a UI for showing the details of the
+     * error in a meaningful way.
+     *
+     * <p>The decision to call {@code proceed()} or {@code cancel()} may be
+     * retained to facilitate responses to future SSL errors. The default
+     * behavior is to cancel the resource loading process.
+     *
+     * <p>This API is called only for recoverable SSL certificate errors. For
+     * non-recoverable errors (such as when the server fails the client), the
+     * {@code WebView} calls {@link #onReceivedError(WebView,
+     * WebResourceRequest, WebResourceError) onReceivedError(WebView,
+     * WebResourceRequest, WebResourceError)} with the
+     * {@link #ERROR_FAILED_SSL_HANDSHAKE} argument.
+     *
+     * @param view {@code WebView} that initiated the callback.
+     * @param handler {@link SslErrorHandler} that handles the user's response.
+     * @param error SSL error object.
+     */
+    public void onReceivedSslError(WebView view, SslErrorHandler handler,
+            SslError error) {
+        handler.cancel();
+    }
+
+    /**
+     * Notify the host application to handle a SSL client certificate request. The host application
+     * is responsible for showing the UI if desired and providing the keys. There are three ways to
+     * respond: {@link ClientCertRequest#proceed}, {@link ClientCertRequest#cancel}, or {@link
+     * ClientCertRequest#ignore}. Webview stores the response in memory (for the life of the
+     * application) if {@link ClientCertRequest#proceed} or {@link ClientCertRequest#cancel} is
+     * called and does not call {@code onReceivedClientCertRequest()} again for the same host and
+     * port pair. Webview does not store the response if {@link ClientCertRequest#ignore}
+     * is called. Note that, multiple layers in chromium network stack might be
+     * caching the responses, so the behavior for ignore is only a best case
+     * effort.
+     *
+     * This method is called on the UI thread. During the callback, the
+     * connection is suspended.
+     *
+     * For most use cases, the application program should implement the
+     * {@link android.security.KeyChainAliasCallback} interface and pass it to
+     * {@link android.security.KeyChain#choosePrivateKeyAlias} to start an
+     * activity for the user to choose the proper alias. The keychain activity will
+     * provide the alias through the callback method in the implemented interface. Next
+     * the application should create an async task to call
+     * {@link android.security.KeyChain#getPrivateKey} to receive the key.
+     *
+     * An example implementation of client certificates can be seen at
+     * <A href="https://android.googlesource.com/platform/packages/apps/Browser/+/android-5.1.1_r1/src/com/android/browser/Tab.java">
+     * AOSP Browser</a>
+     *
+     * The default behavior is to cancel, returning no client certificate.
+     *
+     * @param view The WebView that is initiating the callback
+     * @param request An instance of a {@link ClientCertRequest}
+     *
+     */
+    public void onReceivedClientCertRequest(WebView view, ClientCertRequest request) {
+        request.cancel();
+    }
+
+    /**
+     * Notifies the host application that the WebView received an HTTP
+     * authentication request. The host application can use the supplied
+     * {@link HttpAuthHandler} to set the WebView's response to the request.
+     * The default behavior is to cancel the request.
+     *
+     * <p class="note"><b>Note:</b> The supplied HttpAuthHandler must be used on
+     * the UI thread.
+     *
+     * @param view the WebView that is initiating the callback
+     * @param handler the HttpAuthHandler used to set the WebView's response
+     * @param host the host requiring authentication
+     * @param realm the realm for which authentication is required
+     * @see WebView#getHttpAuthUsernamePassword
+     */
+    public void onReceivedHttpAuthRequest(WebView view,
+            HttpAuthHandler handler, String host, String realm) {
+        handler.cancel();
+    }
+
+    /**
+     * Give the host application a chance to handle the key event synchronously.
+     * e.g. menu shortcut key events need to be filtered this way. If return
+     * true, WebView will not handle the key event. If return {@code false}, WebView
+     * will always handle the key event, so none of the super in the view chain
+     * will see the key event. The default behavior returns {@code false}.
+     *
+     * @param view The WebView that is initiating the callback.
+     * @param event The key event.
+     * @return {@code true} if the host application wants to handle the key event
+     *         itself, otherwise return {@code false}
+     */
+    public boolean shouldOverrideKeyEvent(WebView view, KeyEvent event) {
+        return false;
+    }
+
+    /**
+     * Notify the host application that a key was not handled by the WebView.
+     * Except system keys, WebView always consumes the keys in the normal flow
+     * or if {@link #shouldOverrideKeyEvent} returns {@code true}. This is called asynchronously
+     * from where the key is dispatched. It gives the host application a chance
+     * to handle the unhandled key events.
+     *
+     * @param view The WebView that is initiating the callback.
+     * @param event The key event.
+     */
+    public void onUnhandledKeyEvent(WebView view, KeyEvent event) {
+        onUnhandledInputEventInternal(view, event);
+    }
+
+    /**
+     * Notify the host application that a input event was not handled by the WebView.
+     * Except system keys, WebView always consumes input events in the normal flow
+     * or if {@link #shouldOverrideKeyEvent} returns {@code true}. This is called asynchronously
+     * from where the event is dispatched. It gives the host application a chance
+     * to handle the unhandled input events.
+     *
+     * Note that if the event is a {@link android.view.MotionEvent}, then it's lifetime is only
+     * that of the function call. If the WebViewClient wishes to use the event beyond that, then it
+     * <i>must</i> create a copy of the event.
+     *
+     * It is the responsibility of overriders of this method to call
+     * {@link #onUnhandledKeyEvent(WebView, KeyEvent)}
+     * when appropriate if they wish to continue receiving events through it.
+     *
+     * @param view The WebView that is initiating the callback.
+     * @param event The input event.
+     * @removed
+     */
+    public void onUnhandledInputEvent(WebView view, InputEvent event) {
+        if (event instanceof KeyEvent) {
+            onUnhandledKeyEvent(view, (KeyEvent) event);
+            return;
+        }
+        onUnhandledInputEventInternal(view, event);
+    }
+
+    private void onUnhandledInputEventInternal(WebView view, InputEvent event) {
+        throw new RuntimeException("Stub!");
+    }
+
+    /**
+     * Notify the host application that the scale applied to the WebView has
+     * changed.
+     *
+     * @param view The WebView that is initiating the callback.
+     * @param oldScale The old scale factor
+     * @param newScale The new scale factor
+     */
+    public void onScaleChanged(WebView view, float oldScale, float newScale) {
+    }
+
+    /**
+     * Notify the host application that a request to automatically log in the
+     * user has been processed.
+     * @param view The WebView requesting the login.
+     * @param realm The account realm used to look up accounts.
+     * @param account An optional account. If not {@code null}, the account should be
+     *                checked against accounts on the device. If it is a valid
+     *                account, it should be used to log in the user.
+     * @param args Authenticator specific arguments used to log in the user.
+     */
+    public void onReceivedLoginRequest(WebView view, String realm,
+            @Nullable String account, String args) {
+    }
+
+    /**
+     * Notify host application that the given WebView's render process has exited.
+     *
+     * Multiple WebView instances may be associated with a single render process;
+     * onRenderProcessGone will be called for each WebView that was affected.
+     * The application's implementation of this callback should only attempt to
+     * clean up the specific WebView given as a parameter, and should not assume
+     * that other WebView instances are affected.
+     *
+     * The given WebView can't be used, and should be removed from the view hierarchy,
+     * all references to it should be cleaned up, e.g any references in the Activity
+     * or other classes saved using {@link android.view.View#findViewById} and similar calls, etc.
+     *
+     * To cause an render process crash for test purpose, the application can
+     * call {@code loadUrl("chrome://crash")} on the WebView. Note that multiple WebView
+     * instances may be affected if they share a render process, not just the
+     * specific WebView which loaded chrome://crash.
+     *
+     * @param view The WebView which needs to be cleaned up.
+     * @param detail the reason why it exited.
+     * @return {@code true} if the host application handled the situation that process has
+     *         exited, otherwise, application will crash if render process crashed,
+     *         or be killed if render process was killed by the system.
+     */
+    public boolean onRenderProcessGone(WebView view, RenderProcessGoneDetail detail) {
+        return false;
+    }
+
+    /**
+     * Notify the host application that a loading URL has been flagged by Safe Browsing.
+     *
+     * The application must invoke the callback to indicate the preferred response. The default
+     * behavior is to show an interstitial to the user, with the reporting checkbox visible.
+     *
+     * If the application needs to show its own custom interstitial UI, the callback can be invoked
+     * asynchronously with {@link SafeBrowsingResponse#backToSafety} or {@link
+     * SafeBrowsingResponse#proceed}, depending on user response.
+     *
+     * @param view The WebView that hit the malicious resource.
+     * @param request Object containing the details of the request.
+     * @param threatType The reason the resource was caught by Safe Browsing, corresponding to a
+     *                   {@code SAFE_BROWSING_THREAT_*} value.
+     * @param callback Applications must invoke one of the callback methods.
+     */
+    public void onSafeBrowsingHit(WebView view, WebResourceRequest request,
+            @SafeBrowsingThreat int threatType, SafeBrowsingResponse callback) {
+        callback.showInterstitial(/* allowReporting */ true);
+    }
+}
@@ -0,0 +1,541 @@
+/*
+ * 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 android.webkit;
+
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.annotation.SuppressLint;
+import android.annotation.SystemApi;
+import android.content.Intent;
+import android.content.res.Configuration;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Picture;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.net.http.SslCertificate;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.print.PrintDocumentAdapter;
+import android.util.LongSparseArray;
+import android.util.SparseArray;
+import android.view.DragEvent;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.PointerIcon;
+import android.view.View;
+import android.view.ViewGroup.LayoutParams;
+import android.view.WindowInsets;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.accessibility.AccessibilityNodeInfo;
+import android.view.accessibility.AccessibilityNodeProvider;
+import android.view.autofill.AutofillId;
+import android.view.autofill.AutofillValue;
+import android.view.inputmethod.EditorInfo;
+import android.view.inputmethod.InputConnection;
+import android.view.textclassifier.TextClassifier;
+import android.webkit.WebView.HitTestResult;
+import android.webkit.WebView.PictureListener;
+import android.webkit.WebView.VisualStateCallback;
+
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import java.util.function.Consumer;
+
+/**
+ * WebView backend provider interface: this interface is the abstract backend to a WebView
+ * instance; each WebView object is bound to exactly one WebViewProvider object which implements
+ * the runtime behavior of that WebView.
+ *
+ * All methods must behave as per their namesake in {@link WebView}, unless otherwise noted.
+ *
+ * @hide Not part of the public API; only required by system implementors.
+ */
+@SystemApi
+public interface WebViewProvider {
+    //-------------------------------------------------------------------------
+    // Main interface for backend provider of the WebView class.
+    //-------------------------------------------------------------------------
+    /**
+     * Initialize this WebViewProvider instance. Called after the WebView has fully constructed.
+     * @param javaScriptInterfaces is a Map of interface names, as keys, and
+     * object implementing those interfaces, as values.
+     * @param privateBrowsing If {@code true} the web view will be initialized in private /
+     * incognito mode.
+     */
+    public void init(Map<String, Object> javaScriptInterfaces,
+            boolean privateBrowsing);
+
+    // Deprecated - should never be called
+    public void setHorizontalScrollbarOverlay(boolean overlay);
+
+    // Deprecated - should never be called
+    public void setVerticalScrollbarOverlay(boolean overlay);
+
+    // Deprecated - should never be called
+    public boolean overlayHorizontalScrollbar();
+
+    // Deprecated - should never be called
+    public boolean overlayVerticalScrollbar();
+
+    public int getVisibleTitleHeight();
+
+    public SslCertificate getCertificate();
+
+    public void setCertificate(SslCertificate certificate);
+
+    public void savePassword(String host, String username, String password);
+
+    public void setHttpAuthUsernamePassword(String host, String realm,
+            String username, String password);
+
+    public String[] getHttpAuthUsernamePassword(String host, String realm);
+
+    /**
+     * See {@link WebView#destroy()}.
+     * As well as releasing the internal state and resources held by the implementation,
+     * the provider should null all references it holds on the WebView proxy class, and ensure
+     * no further method calls are made to it.
+     */
+    public void destroy();
+
+    public void setNetworkAvailable(boolean networkUp);
+
+    public WebBackForwardList saveState(Bundle outState);
+
+    public boolean savePicture(Bundle b, final File dest);
+
+    public boolean restorePicture(Bundle b, File src);
+
+    public WebBackForwardList restoreState(Bundle inState);
+
+    public void loadUrl(String url, Map<String, String> additionalHttpHeaders);
+
+    public void loadUrl(String url);
+
+    public void postUrl(String url, byte[] postData);
+
+    public void loadData(String data, String mimeType, String encoding);
+
+    public void loadDataWithBaseURL(String baseUrl, String data,
+            String mimeType, String encoding, String historyUrl);
+
+    public void evaluateJavaScript(String script, ValueCallback<String> resultCallback);
+
+    public void saveWebArchive(String filename);
+
+    public void saveWebArchive(String basename, boolean autoname, ValueCallback<String> callback);
+
+    public void stopLoading();
+
+    public void reload();
+
+    public boolean canGoBack();
+
+    public void goBack();
+
+    public boolean canGoForward();
+
+    public void goForward();
+
+    public boolean canGoBackOrForward(int steps);
+
+    public void goBackOrForward(int steps);
+
+    public boolean isPrivateBrowsingEnabled();
+
+    public boolean pageUp(boolean top);
+
+    public boolean pageDown(boolean bottom);
+
+    public void insertVisualStateCallback(long requestId, VisualStateCallback callback);
+
+    public void clearView();
+
+    public Picture capturePicture();
+
+    public PrintDocumentAdapter createPrintDocumentAdapter(String documentName);
+
+    public float getScale();
+
+    public void setInitialScale(int scaleInPercent);
+
+    public void invokeZoomPicker();
+
+    public HitTestResult getHitTestResult();
+
+    public void requestFocusNodeHref(Message hrefMsg);
+
+    public void requestImageRef(Message msg);
+
+    public String getUrl();
+
+    public String getOriginalUrl();
+
+    public String getTitle();
+
+    public Bitmap getFavicon();
+
+    public String getTouchIconUrl();
+
+    public int getProgress();
+
+    public int getContentHeight();
+
+    public int getContentWidth();
+
+    public void pauseTimers();
+
+    public void resumeTimers();
+
+    public void onPause();
+
+    public void onResume();
+
+    public boolean isPaused();
+
+    public void freeMemory();
+
+    public void clearCache(boolean includeDiskFiles);
+
+    public void clearFormData();
+
+    public void clearHistory();
+
+    public void clearSslPreferences();
+
+    public WebBackForwardList copyBackForwardList();
+
+    public void setFindListener(WebView.FindListener listener);
+
+    public void findNext(boolean forward);
+
+    public int findAll(String find);
+
+    public void findAllAsync(String find);
+
+    public boolean showFindDialog(String text, boolean showIme);
+
+    public void clearMatches();
+
+    public void documentHasImages(Message response);
+
+    public void setWebViewClient(WebViewClient client);
+
+    public WebViewClient getWebViewClient();
+
+    @Nullable
+    public WebViewRenderProcess getWebViewRenderProcess();
+
+    public void setWebViewRenderProcessClient(
+            @Nullable Executor executor,
+            @Nullable WebViewRenderProcessClient client);
+
+    @Nullable
+    public WebViewRenderProcessClient getWebViewRenderProcessClient();
+
+    public void setDownloadListener(DownloadListener listener);
+
+    public void setWebChromeClient(WebChromeClient client);
+
+    public WebChromeClient getWebChromeClient();
+
+    public void setPictureListener(PictureListener listener);
+
+    public void addJavascriptInterface(Object obj, String interfaceName);
+
+    public void removeJavascriptInterface(String interfaceName);
+
+    public WebMessagePort[] createWebMessageChannel();
+
+    public void postMessageToMainFrame(WebMessage message, Uri targetOrigin);
+
+    public WebSettings getSettings();
+
+    public void setMapTrackballToArrowKeys(boolean setMap);
+
+    public void flingScroll(int vx, int vy);
+
+    public View getZoomControls();
+
+    public boolean canZoomIn();
+
+    public boolean canZoomOut();
+
+    public boolean zoomBy(float zoomFactor);
+
+    public boolean zoomIn();
+
+    public boolean zoomOut();
+
+    public void dumpViewHierarchyWithProperties(BufferedWriter out, int level);
+
+    public View findHierarchyView(String className, int hashCode);
+
+    public void setRendererPriorityPolicy(int rendererRequestedPriority, boolean waivedWhenNotVisible);
+
+    public int getRendererRequestedPriority();
+
+    public boolean getRendererPriorityWaivedWhenNotVisible();
+
+    @SuppressWarnings("unused")
+    public default void setTextClassifier(@Nullable TextClassifier textClassifier) {}
+
+    @NonNull
+    public default TextClassifier getTextClassifier() { return TextClassifier.NO_OP; }
+
+    //-------------------------------------------------------------------------
+    // Provider internal methods
+    //-------------------------------------------------------------------------
+
+    /**
+     * @return the ViewDelegate implementation. This provides the functionality to back all of
+     * the name-sake functions from the View and ViewGroup base classes of WebView.
+     */
+    /* package */ ViewDelegate getViewDelegate();
+
+    /**
+     * @return a ScrollDelegate implementation. Normally this would be same object as is
+     * returned by getViewDelegate().
+     */
+    /* package */ ScrollDelegate getScrollDelegate();
+
+    /**
+     * Only used by FindActionModeCallback to inform providers that the find dialog has
+     * been dismissed.
+     */
+    public void notifyFindDialogDismissed();
+
+    //-------------------------------------------------------------------------
+    // View / ViewGroup delegation methods
+    //-------------------------------------------------------------------------
+
+    /**
+     * Provides mechanism for the name-sake methods declared in View and ViewGroup to be delegated
+     * into the WebViewProvider instance.
+     * NOTE: For many of these methods, the WebView will provide a super.Foo() call before or after
+     * making the call into the provider instance. This is done for convenience in the common case
+     * of maintaining backward compatibility. For remaining super class calls (e.g. where the
+     * provider may need to only conditionally make the call based on some internal state) see the
+     * {@link WebView.PrivateAccess} callback class.
+     */
+    // TODO: See if the pattern of the super-class calls can be rationalized at all, and document
+    // the remainder on the methods below.
+    interface ViewDelegate {
+        public boolean shouldDelayChildPressedState();
+
+        public void onProvideVirtualStructure(android.view.ViewStructure structure);
+
+        default void onProvideAutofillVirtualStructure(
+                @SuppressWarnings("unused") android.view.ViewStructure structure,
+                @SuppressWarnings("unused") int flags) {
+        }
+
+        default void autofill(@SuppressWarnings("unused") SparseArray<AutofillValue> values) {
+        }
+
+        default boolean isVisibleToUserForAutofill(@SuppressWarnings("unused") int virtualId) {
+            return true; // true is the default value returned by View.isVisibleToUserForAutofill()
+        }
+
+        default void onProvideContentCaptureStructure(
+                @NonNull @SuppressWarnings("unused") android.view.ViewStructure structure,
+                @SuppressWarnings("unused") int flags) {
+        }
+
+        // @SuppressLint("NullableCollection")
+        // default void onCreateVirtualViewTranslationRequests(
+        //         @NonNull @SuppressWarnings("unused") long[] virtualIds,
+        //         @NonNull @SuppressWarnings("unused") @DataFormat int[] supportedFormats,
+        //         @NonNull @SuppressWarnings("unused")
+        //                 Consumer<ViewTranslationRequest> requestsCollector) {
+        // }
+
+        // default void onVirtualViewTranslationResponses(
+        //         @NonNull @SuppressWarnings("unused")
+        //                 LongSparseArray<ViewTranslationResponse> response) {
+        // }
+
+        // default void dispatchCreateViewTranslationRequest(
+        //         @NonNull @SuppressWarnings("unused") Map<AutofillId, long[]> viewIds,
+        //         @NonNull @SuppressWarnings("unused") @DataFormat int[] supportedFormats,
+        //         @Nullable @SuppressWarnings("unused") TranslationCapability capability,
+        //         @NonNull @SuppressWarnings("unused") List<ViewTranslationRequest> requests) {
+
+        // }
+
+        public AccessibilityNodeProvider getAccessibilityNodeProvider();
+
+        public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info);
+
+        public void onInitializeAccessibilityEvent(AccessibilityEvent event);
+
+        public boolean performAccessibilityAction(int action, Bundle arguments);
+
+        public void setOverScrollMode(int mode);
+
+        public void setScrollBarStyle(int style);
+
+        public void onDrawVerticalScrollBar(Canvas canvas, Drawable scrollBar, int l, int t,
+                int r, int b);
+
+        public void onOverScrolled(int scrollX, int scrollY, boolean clampedX, boolean clampedY);
+
+        public void onWindowVisibilityChanged(int visibility);
+
+        public void onDraw(Canvas canvas);
+
+        public void setLayoutParams(LayoutParams layoutParams);
+
+        public boolean performLongClick();
+
+        public void onConfigurationChanged(Configuration newConfig);
+
+        public InputConnection onCreateInputConnection(EditorInfo outAttrs);
+
+        public boolean onDragEvent(DragEvent event);
+
+        public boolean onKeyMultiple(int keyCode, int repeatCount, KeyEvent event);
+
+        public boolean onKeyDown(int keyCode, KeyEvent event);
+
+        public boolean onKeyUp(int keyCode, KeyEvent event);
+
+        public void onAttachedToWindow();
+
+        public void onDetachedFromWindow();
+
+        public default void onMovedToDisplay(int displayId, Configuration config) {}
+
+        public void onVisibilityChanged(View changedView, int visibility);
+
+        public void onWindowFocusChanged(boolean hasWindowFocus);
+
+        public void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect);
+
+        public boolean setFrame(int left, int top, int right, int bottom);
+
+        public void onSizeChanged(int w, int h, int ow, int oh);
+
+        public void onScrollChanged(int l, int t, int oldl, int oldt);
+
+        public boolean dispatchKeyEvent(KeyEvent event);
+
+        public boolean onTouchEvent(MotionEvent ev);
+
+        public boolean onHoverEvent(MotionEvent event);
+
+        public boolean onGenericMotionEvent(MotionEvent event);
+
+        public boolean onTrackballEvent(MotionEvent ev);
+
+        public boolean requestFocus(int direction, Rect previouslyFocusedRect);
+
+        public void onMeasure(int widthMeasureSpec, int heightMeasureSpec);
+
+        public boolean requestChildRectangleOnScreen(View child, Rect rect, boolean immediate);
+
+        public void setBackgroundColor(int color);
+
+        public void setLayerType(int layerType, Paint paint);
+
+        public void preDispatchDraw(Canvas canvas);
+
+        public void onStartTemporaryDetach();
+
+        public void onFinishTemporaryDetach();
+
+        public void onActivityResult(int requestCode, int resultCode, Intent data);
+
+        public Handler getHandler(Handler originalHandler);
+
+        public View findFocus(View originalFocusedView);
+
+        @SuppressWarnings("unused")
+        default boolean onCheckIsTextEditor() {
+            return false;
+        }
+
+        /**
+         * @see View#onApplyWindowInsets(WindowInsets).
+         *
+         * <p>This is the entry point for the WebView implementation to override. It returns
+         * {@code null} when the WebView implementation hasn't implemented the WindowInsets support
+         * on S yet. In this case, the {@link View#onApplyWindowInsets()} super method will be
+         * called instead.
+         *
+         * @param insets Insets to apply
+         * @return The supplied insets with any applied insets consumed.
+         */
+        @SuppressWarnings("unused")
+        @Nullable
+        default WindowInsets onApplyWindowInsets(@Nullable WindowInsets insets) {
+            return null;
+        }
+
+        /**
+         * @hide Only used by WebView.
+         */
+        @SuppressWarnings("unused")
+        @Nullable
+        default PointerIcon onResolvePointerIcon(@NonNull MotionEvent event, int pointerIndex) {
+            return null;
+        }
+    }
+
+    interface ScrollDelegate {
+        // These methods are declared protected in the ViewGroup base class. This interface
+        // exists to promote them to public so they may be called by the WebView proxy class.
+        // TODO: Combine into ViewDelegate?
+        /**
+         * See {@link android.webkit.WebView#computeHorizontalScrollRange}
+         */
+        public int computeHorizontalScrollRange();
+
+        /**
+         * See {@link android.webkit.WebView#computeHorizontalScrollOffset}
+         */
+        public int computeHorizontalScrollOffset();
+
+        /**
+         * See {@link android.webkit.WebView#computeVerticalScrollRange}
+         */
+        public int computeVerticalScrollRange();
+
+        /**
+         * See {@link android.webkit.WebView#computeVerticalScrollOffset}
+         */
+        public int computeVerticalScrollOffset();
+
+        /**
+         * See {@link android.webkit.WebView#computeVerticalScrollExtent}
+         */
+        public int computeVerticalScrollExtent();
+
+        /**
+         * See {@link android.webkit.WebView#computeScroll}
+         */
+        public void computeScroll();
+    }
+}
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2006 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 android.widget;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.util.AttributeSet;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.RemoteViews.RemoteView;
+
+
+@Deprecated
+@RemoteView
+public class AbsoluteLayout extends ViewGroup {
+    public AbsoluteLayout(Context context) {
+        this(context, null);
+    }
+
+    public AbsoluteLayout(Context context, AttributeSet attrs) {
+        this(context, attrs, 0);
+    }
+
+    public AbsoluteLayout(Context context, AttributeSet attrs, int defStyleAttr) {
+        this(context, attrs, defStyleAttr, 0);
+    }
+
+    public AbsoluteLayout(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+        super(context, attrs, defStyleAttr, defStyleRes);
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override
+    protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
+        return new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT, 0, 0);
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t,
+            int r, int b) {
+       throw new RuntimeException("Stub!");
+    }
+
+    @Override
+    public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) {
+        return new AbsoluteLayout.LayoutParams(getContext(), attrs);
+    }
+
+    // Override to allow type-checking of LayoutParams. 
+    @Override
+    protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
+        return p instanceof AbsoluteLayout.LayoutParams;
+    }
+
+    @Override
+    protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
+        return new LayoutParams(p);
+    }
+
+    @Override
+    public boolean shouldDelayChildPressedState() {
+        return false;
+    }
+
+    public static class LayoutParams extends ViewGroup.LayoutParams {
+        public int x;
+        public int y;
+
+        public LayoutParams(int width, int height, int x, int y) {
+            super(width, height);
+            this.x = x;
+            this.y = y;
+        }
+
+        public LayoutParams(Context c, AttributeSet attrs) {
+            super(c, attrs);
+            throw new RuntimeException("Stub!");
+        }
+
+        public LayoutParams(ViewGroup.LayoutParams source) {
+            super(source);
+        }
+
+        public String debug(String output) {
+            return output + "Absolute.LayoutParams={width="
+                    + String.valueOf(width) + ", height=" + String.valueOf(height)
+                    + " x=" + x + " y=" + y + "}";
+        }
+    }
+}
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:Suppress("NOTHING_TO_INLINE") // Aliases to public API.
+
+package androidx.core.net
+
+import android.net.Uri
+import java.io.File
+
+/**
+ * Creates a Uri from the given encoded URI string.
+ *
+ * @see Uri.parse
+ */
+public inline fun String.toUri(): Uri = Uri.parse(this)
+
+/**
+ * Creates a Uri from the given file.
+ *
+ * @see Uri.fromFile
+ */
+public inline fun File.toUri(): Uri = Uri.fromFile(this)
+
+/**
+ * Creates a [File] from the given [Uri]. Note that this will throw an
+ * [IllegalArgumentException] when invoked on a [Uri] that lacks `file` scheme.
+ */
+public fun Uri.toFile(): File {
+    require(scheme == "file") { "Uri lacks 'file' scheme: $this" }
+    return File(requireNotNull(path) { "Uri path is null: $this" })
+}
@@ -22,6 +22,8 @@ public class Preference {
    @JsonIgnore
    protected Context context;

+    private boolean isVisible;
+    private boolean isEnabled = true;
    private String key;
    private CharSequence title;
    private CharSequence summary;
@@ -67,7 +69,11 @@ public class Preference {
    }

    public void setEnabled(boolean enabled) {
-        throw new RuntimeException("Stub!");
+        isEnabled = enabled;
+    }
+
+    public boolean isEnabled() {
+        return isEnabled;
    }

    public String getKey() {
@@ -100,6 +106,14 @@ public class Preference {
        return sharedPreferences;
    }

+    public void setVisible(boolean visible) {
+        isVisible = visible;
+    }
+
+    public boolean getVisible() {
+        return isVisible;
+    }
+
    /** Tachidesk specific API */
    public void setSharedPreferences(SharedPreferences sharedPreferences) {
        this.sharedPreferences = sharedPreferences;
@@ -11,7 +11,8 @@ import android.content.Context;
 import com.fasterxml.jackson.annotation.JsonIgnore;

 public class TwoStatePreference extends Preference {
-    // Note: remove @JsonIgnore and implement methods if any extension ever uses these methods or the variables behind them
+    private CharSequence mSummaryOn;
+    private CharSequence mSummaryOff;

    public TwoStatePreference(Context context) {
        super(context);
@@ -25,16 +26,41 @@ public class TwoStatePreference extends Preference {
    public void setChecked(boolean checked) { throw new RuntimeException("Stub!"); }

    @JsonIgnore
-    public CharSequence getSummaryOn() { throw new RuntimeException("Stub!"); }
+    public CharSequence getSummaryOn() {
+        return mSummaryOn;
+    }

    @JsonIgnore
-    public void setSummaryOn(CharSequence summary) { throw new RuntimeException("Stub!"); }
+    public void setSummaryOn(CharSequence summary) {
+        this.mSummaryOn = summary;
+    }

    @JsonIgnore
-    public CharSequence getSummaryOff() { throw new RuntimeException("Stub!"); }
+    public CharSequence getSummaryOff() {
+        return mSummaryOff;
+    }

    @JsonIgnore
-    public void setSummaryOff(CharSequence summary) { throw new RuntimeException("Stub!"); }
+    public void setSummaryOff(CharSequence summary) {
+        this.mSummaryOff = summary;
+    }
+
+    @Override
+    public CharSequence getSummary() {
+        final CharSequence summary = super.getSummary();
+        if (summary != null) {
+            return summary;
+        }
+
+        final boolean checked = (Boolean) getCurrentValue();
+        if (checked && mSummaryOn != null) {
+            return mSummaryOn;
+        } else if (!checked && mSummaryOff != null) {
+            return mSummaryOff;
+        }
+
+        return null;
+    }

    @JsonIgnore
    public boolean getDisableDependentsState() { throw new RuntimeException("Stub!"); }
@@ -0,0 +1,99 @@
+package app.cash.quickjs;
+
+import org.graalvm.polyglot.*;
+
+import java.io.Closeable;
+import java.math.BigInteger;
+import java.util.Arrays;
+
+public final class QuickJs implements Closeable {
+    private Context context;
+
+    public static QuickJs create() {
+        return new QuickJs();
+    }
+
+    public QuickJs() {
+        this.context = Context
+                .newBuilder("js")
+                .allowHostAccess(HostAccess.ALL)
+                .allowPolyglotAccess(PolyglotAccess.NONE)
+                .allowHostClassLoading(false)
+                .build();
+        context.enter();
+    }
+
+    public Object evaluate(String script, String ignoredFileName) {
+        return this.evaluate(script);
+    }
+
+    public Object evaluate(String script) {
+        try {
+            Value value = context.eval("js", script);
+            return translateType(value);
+        } catch (Exception exception) {
+            throw new QuickJsException(exception.getMessage(), exception);
+        }
+    }
+
+    private Object translateType(Value obj) {
+        if (obj.isBoolean()) {
+            return obj.asBoolean();
+        } else if (obj.hasArrayElements()) {
+            if (obj.getArraySize() == 0) {
+                return new int[0];
+            } else {
+                Value element = obj.getArrayElement(0);
+                if (element.isBoolean()) {
+                    return obj.as(boolean[].class);
+                } else if (element.isNumber()) {
+                    if (element.fitsInInt()) {
+                        return obj.as(int[].class);
+                    } else if (element.fitsInBigInteger()) {
+                        return Arrays.stream(obj.as(BigInteger[].class)).map(BigInteger::longValue).toArray();
+                    } else {
+                        return obj.as(double[].class);
+                    }
+                } else if (element.isHostObject()) {
+                    return obj.as(Object[].class);
+                } else if (element.isString()) {
+                    return obj.as(String[].class);
+                }
+            }
+        } else if (obj.isNumber()) {
+            if (obj.fitsInInt()) {
+                return obj.asInt();
+            } else if (obj.fitsInBigInteger()) {
+                return obj.asBigInteger().longValue();
+            } else {
+                return obj.asDouble();
+            }
+        } else if (obj.isHostObject()) {
+            return obj.asHostObject();
+        } else if (obj.isString()) {
+            return obj.asString();
+        }
+        return obj;
+    }
+
+    public byte[] compile(String sourceCode, String ignoredFileName) {
+        return sourceCode.getBytes();
+    }
+
+    public Object execute(byte[] bytecode) {
+        return this.evaluate(new String(bytecode));
+    }
+
+    public <T> void set(String name, Class<T> ignoredType, T object) {
+        context.getBindings("js").putMember(name, object);
+    }
+
+    @Override
+    public void close() {
+        if (this.context != null) {
+            this.context.leave();
+            this.context.close();
+            this.context = null;
+        }
+    }
+}
@@ -0,0 +1,7 @@
+package app.cash.quickjs;
+
+public final class QuickJsException extends RuntimeException {
+    public QuickJsException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
@@ -14,13 +14,13 @@
 * limitations under the License.
 */
 package com.android.internal.util;
-import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.util.ArraySet;
-import libcore.util.EmptyArray;
-
 import java.lang.reflect.Array;
 import java.util.*;
+import libcore.util.EmptyArray;
+import android.annotation.NonNull;
+
 /**
 * ArrayUtils contains some methods that you can call to find out
 * the most efficient increments by which to grow arrays.
@@ -50,6 +50,10 @@ public class ArrayUtils {
    public static Object[] newUnpaddedObjectArray(int minLen) {
        return new Object[minLen];
    }
+    @SuppressWarnings("unchecked")
+    public static <T> T[] newUnpaddedArray(Class<T> clazz, int minLen) {
+        return (T[])Array.newInstance(clazz, minLen);
+    }
    /**
     * Checks if the beginnings of two byte arrays are equal.
     *
@@ -468,4 +472,4 @@ public class ArrayUtils {
        }
        return size - leftIdx;
    }
-}
+}
@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2014 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.android.internal.util;
+
+public final class GrowingArrayUtils {
+
+    public static <T> T[] append(T[] array, int currentSize, T element) {
+        assert currentSize <= array.length;
+
+        if (currentSize + 1 > array.length) {
+            @SuppressWarnings("unchecked")
+            T[] newArray = ArrayUtils.newUnpaddedArray(
+                    (Class<T>) array.getClass().getComponentType(), growSize(currentSize));
+            System.arraycopy(array, 0, newArray, 0, currentSize);
+            array = newArray;
+        }
+        array[currentSize] = element;
+        return array;
+    }
+
+    public static int[] append(int[] array, int currentSize, int element) {
+        assert currentSize <= array.length;
+
+        if (currentSize + 1 > array.length) {
+            int[] newArray = ArrayUtils.newUnpaddedIntArray(growSize(currentSize));
+            System.arraycopy(array, 0, newArray, 0, currentSize);
+            array = newArray;
+        }
+        array[currentSize] = element;
+        return array;
+    }
+
+    public static long[] append(long[] array, int currentSize, long element) {
+        assert currentSize <= array.length;
+
+        if (currentSize + 1 > array.length) {
+            long[] newArray = ArrayUtils.newUnpaddedLongArray(growSize(currentSize));
+            System.arraycopy(array, 0, newArray, 0, currentSize);
+            array = newArray;
+        }
+        array[currentSize] = element;
+        return array;
+    }
+
+    public static boolean[] append(boolean[] array, int currentSize, boolean element) {
+        assert currentSize <= array.length;
+
+        if (currentSize + 1 > array.length) {
+            boolean[] newArray = ArrayUtils.newUnpaddedBooleanArray(growSize(currentSize));
+            System.arraycopy(array, 0, newArray, 0, currentSize);
+            array = newArray;
+        }
+        array[currentSize] = element;
+        return array;
+    }
+
+    public static float[] append(float[] array, int currentSize, float element) {
+        assert currentSize <= array.length;
+
+        if (currentSize + 1 > array.length) {
+            float[] newArray = ArrayUtils.newUnpaddedFloatArray(growSize(currentSize));
+            System.arraycopy(array, 0, newArray, 0, currentSize);
+            array = newArray;
+        }
+        array[currentSize] = element;
+        return array;
+    }
+
+    public static <T> T[] insert(T[] array, int currentSize, int index, T element) {
+        assert currentSize <= array.length;
+
+        if (currentSize + 1 <= array.length) {
+            System.arraycopy(array, index, array, index + 1, currentSize - index);
+            array[index] = element;
+            return array;
+        }
+
+        @SuppressWarnings("unchecked")
+        T[] newArray = ArrayUtils.newUnpaddedArray((Class<T>)array.getClass().getComponentType(),
+                growSize(currentSize));
+        System.arraycopy(array, 0, newArray, 0, index);
+        newArray[index] = element;
+        System.arraycopy(array, index, newArray, index + 1, array.length - index);
+        return newArray;
+    }
+
+    public static int[] insert(int[] array, int currentSize, int index, int element) {
+        assert currentSize <= array.length;
+
+        if (currentSize + 1 <= array.length) {
+            System.arraycopy(array, index, array, index + 1, currentSize - index);
+            array[index] = element;
+            return array;
+        }
+
+        int[] newArray = ArrayUtils.newUnpaddedIntArray(growSize(currentSize));
+        System.arraycopy(array, 0, newArray, 0, index);
+        newArray[index] = element;
+        System.arraycopy(array, index, newArray, index + 1, array.length - index);
+        return newArray;
+    }
+
+    public static long[] insert(long[] array, int currentSize, int index, long element) {
+        assert currentSize <= array.length;
+
+        if (currentSize + 1 <= array.length) {
+            System.arraycopy(array, index, array, index + 1, currentSize - index);
+            array[index] = element;
+            return array;
+        }
+
+        long[] newArray = ArrayUtils.newUnpaddedLongArray(growSize(currentSize));
+        System.arraycopy(array, 0, newArray, 0, index);
+        newArray[index] = element;
+        System.arraycopy(array, index, newArray, index + 1, array.length - index);
+        return newArray;
+    }
+
+    public static boolean[] insert(boolean[] array, int currentSize, int index, boolean element) {
+        assert currentSize <= array.length;
+
+        if (currentSize + 1 <= array.length) {
+            System.arraycopy(array, index, array, index + 1, currentSize - index);
+            array[index] = element;
+            return array;
+        }
+
+        boolean[] newArray = ArrayUtils.newUnpaddedBooleanArray(growSize(currentSize));
+        System.arraycopy(array, 0, newArray, 0, index);
+        newArray[index] = element;
+        System.arraycopy(array, index, newArray, index + 1, array.length - index);
+        return newArray;
+    }
+
+    public static int growSize(int currentSize) {
+        return currentSize <= 4 ? 8 : currentSize * 2;
+    }
+
+    // Uninstantiable
+    private GrowingArrayUtils() {}
+}
@@ -17,7 +17,7 @@ package dalvik.system;

 import org.jetbrains.annotations.Nullable;
 import xyz.nulldev.androidcompat.pm.PackageController;
-import xyz.nulldev.androidcompat.util.KodeinGlobalHelper;
+import xyz.nulldev.androidcompat.util.KoinGlobalHelper;

 import java.io.File;
 import java.io.IOException;
@@ -33,7 +33,7 @@ import java.util.Enumeration;
 * {@link ClassLoader} implementations.
 */
 public class BaseDexClassLoader extends ClassLoader {
-    private PackageController controller = KodeinGlobalHelper.instance(PackageController.class);
+    private PackageController controller = KoinGlobalHelper.instance(PackageController.class);

    private final URLClassLoader realClassloader;

@@ -1,14 +1,11 @@
 package xyz.nulldev.androidcompat

 import android.app.Application
-import org.kodein.di.DI
-import org.kodein.di.conf.global
-import org.kodein.di.instance
+import org.koin.mp.KoinPlatformTools
 import xyz.nulldev.androidcompat.androidimpl.CustomContext

 class AndroidCompat {
-
-    val context: CustomContext by DI.global.instance()
+    val context: CustomContext by KoinPlatformTools.defaultContext().get().inject()

    fun startApp(application: Application) {
        application.attach(context)
@@ -1,10 +1,10 @@
 package xyz.nulldev.androidcompat

-import org.kodein.di.DI
-import org.kodein.di.conf.global
+import android.webkit.WebView
 import xyz.nulldev.androidcompat.config.ApplicationInfoConfigModule
 import xyz.nulldev.androidcompat.config.FilesConfigModule
 import xyz.nulldev.androidcompat.config.SystemConfigModule
+import xyz.nulldev.androidcompat.webkit.KcefWebViewProvider
 import xyz.nulldev.ts.config.GlobalConfigManager

 /**
@@ -12,16 +12,19 @@ import xyz.nulldev.ts.config.GlobalConfigManager
 */
 class AndroidCompatInitializer {
    fun init() {
-        DI.global.addImport(AndroidCompatModule().create())
-
        // Register config modules
        GlobalConfigManager.registerModules(
            FilesConfigModule.register(GlobalConfigManager.config),
            ApplicationInfoConfigModule.register(GlobalConfigManager.config),
-            SystemConfigModule.register(GlobalConfigManager.config)
+            SystemConfigModule.register(GlobalConfigManager.config),
        )

+        WebView.setProviderFactory({ view: WebView -> KcefWebViewProvider(view) })
+
        // Set some properties extensions use
-        System.setProperty("http.agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36")
+        System.setProperty(
+            "http.agent",
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+        )
    }
 }
@@ -1,11 +1,8 @@
 package xyz.nulldev.androidcompat

 import android.content.Context
-import org.kodein.di.DI
-import org.kodein.di.bind
-import org.kodein.di.conf.global
-import org.kodein.di.instance
-import org.kodein.di.singleton
+import org.koin.core.module.Module
+import org.koin.dsl.module
 import xyz.nulldev.androidcompat.androidimpl.CustomContext
 import xyz.nulldev.androidcompat.androidimpl.FakePackageManager
 import xyz.nulldev.androidcompat.info.ApplicationInfoImpl
@@ -17,23 +14,19 @@ import xyz.nulldev.androidcompat.service.ServiceSupport
 * AndroidCompatModule
 */

-class AndroidCompatModule {
-    fun create() = DI.Module("AndroidCompat") {
-        bind<AndroidFiles>() with singleton { AndroidFiles() }
+fun androidCompatModule(): Module =
+    module {
+        single { AndroidFiles() }

-        bind<ApplicationInfoImpl>() with singleton { ApplicationInfoImpl() }
+        single { ApplicationInfoImpl(get()) }

-        bind<ServiceSupport>() with singleton { ServiceSupport() }
+        single { ServiceSupport() }

-        bind<FakePackageManager>() with singleton { FakePackageManager() }
+        single { FakePackageManager() }

-        bind<PackageController>() with singleton { PackageController() }
+        single { PackageController() }

-        // Context
-        bind<CustomContext>() with singleton { CustomContext() }
-        bind<Context>() with singleton {
-            val context: Context by DI.global.instance<CustomContext>()
-            context
-        }
+        single { CustomContext() }
+
+        single<Context> { get<CustomContext>() }
    }
-}
@@ -0,0 +1,5 @@
+package xyz.nulldev.androidcompat
+
+fun interface CallableArgument<A, R> {
+    fun call(arg: A): R
+}
@@ -32,15 +32,14 @@ import android.os.*;
 import android.view.Display;
 import android.view.DisplayAdjustments;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.kodein.di.*;
+import org.koin.core.Koin;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import xyz.nulldev.androidcompat.info.ApplicationInfoImpl;
 import xyz.nulldev.androidcompat.io.AndroidFiles;
 import xyz.nulldev.androidcompat.io.sharedprefs.JavaSharedPreferences;
 import xyz.nulldev.androidcompat.service.ServiceSupport;
-import xyz.nulldev.androidcompat.util.KodeinGlobalHelper;
+import xyz.nulldev.androidcompat.util.KoinGlobalHelper;

 import java.io.*;
 import java.util.HashMap;
@@ -51,26 +50,25 @@ import java.util.Map;
 * Custom context implementation.
 *
 */
-public class CustomContext extends Context implements DIAware {
-    private final DI kodein;
+public class CustomContext extends Context {
+    private final Koin koin;
    public CustomContext() {
-        this(KodeinGlobalHelper.kodein());
+        this(KoinGlobalHelper.koin());
    }

-    public CustomContext(DI kodein) {
-        this.kodein = kodein;
+    public CustomContext(Koin koin) {
+        this.koin = koin;

        //Init configs
-        androidFiles = KodeinGlobalHelper.instance(AndroidFiles.class, getDi());
-        applicationInfo = KodeinGlobalHelper.instance(ApplicationInfoImpl.class, getDi());
-        serviceSupport = KodeinGlobalHelper.instance(ServiceSupport.class, getDi());
-        fakePackageManager = KodeinGlobalHelper.instance(FakePackageManager.class, getDi());
+        androidFiles = KoinGlobalHelper.instance(AndroidFiles.class, getDi());
+        applicationInfo = KoinGlobalHelper.instance(ApplicationInfoImpl.class, getDi());
+        serviceSupport = KoinGlobalHelper.instance(ServiceSupport.class, getDi());
+        fakePackageManager = KoinGlobalHelper.instance(FakePackageManager.class, getDi());
    }

    @NotNull
-    @Override
-    public DI getDi() {
-        return kodein;
+    public Koin getDi() {
+        return koin;
    }

    private AndroidFiles androidFiles;
@@ -719,17 +717,5 @@ public class CustomContext extends Context implements DIAware {
    public boolean isCredentialProtectedStorage() {
        return false;
    }
-
-    @NotNull
-    @Override
-    public DIContext<?> getDiContext() {
-        return getDi().getDiContext();
-    }
-
-    @Nullable
-    @Override
-    public DITrigger getDiTrigger() {
-        return null;
-    }
 }

@@ -16,14 +16,14 @@ import android.os.UserHandle;
 import kotlin.NotImplementedError;
 import xyz.nulldev.androidcompat.pm.InstalledPackage;
 import xyz.nulldev.androidcompat.pm.PackageController;
-import xyz.nulldev.androidcompat.util.KodeinGlobalHelper;
+import xyz.nulldev.androidcompat.util.KoinGlobalHelper;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;

 public class FakePackageManager extends PackageManager {
-    private PackageController controller = KodeinGlobalHelper.instance(PackageController.class);
+    private PackageController controller = KoinGlobalHelper.instance(PackageController.class);

    @Override
    public PackageInfo getPackageInfo(String packageName, int flags) throws NameNotFoundException {
@@ -8,12 +8,13 @@ import xyz.nulldev.ts.config.ConfigModule
 * Application info config.
 */

-class ApplicationInfoConfigModule(config: Config) : ConfigModule(config) {
-    val packageName: String by config
-    val debug: Boolean by config
+class ApplicationInfoConfigModule(
+    getConfig: () -> Config,
+) : ConfigModule(getConfig) {
+    val packageName: String by getConfig()
+    val debug: Boolean by getConfig()

    companion object {
-        fun register(config: Config) =
-            ApplicationInfoConfigModule(config.getConfig("android.app"))
+        fun register(config: Config) = ApplicationInfoConfigModule { config.getConfig("android.app") }
    }
 }
@@ -8,27 +8,28 @@ import xyz.nulldev.ts.config.ConfigModule
 * Files configuration modules. Specifies where to store the Android files.
 */

-class FilesConfigModule(config: Config) : ConfigModule(config) {
-    val dataDir: String by config
-    val filesDir: String by config
-    val noBackupFilesDir: String by config
-    val externalFilesDirs: MutableList<String> by config
-    val obbDirs: MutableList<String> by config
-    val cacheDir: String by config
-    val codeCacheDir: String by config
-    val externalCacheDirs: MutableList<String> by config
-    val externalMediaDirs: MutableList<String> by config
-    val rootDir: String by config
-    val externalStorageDir: String by config
-    val downloadCacheDir: String by config
-    val databasesDir: String by config
+class FilesConfigModule(
+    getConfig: () -> Config,
+) : ConfigModule(getConfig) {
+    val dataDir: String by getConfig()
+    val filesDir: String by getConfig()
+    val noBackupFilesDir: String by getConfig()
+    val externalFilesDirs: MutableList<String> by getConfig()
+    val obbDirs: MutableList<String> by getConfig()
+    val cacheDir: String by getConfig()
+    val codeCacheDir: String by getConfig()
+    val externalCacheDirs: MutableList<String> by getConfig()
+    val externalMediaDirs: MutableList<String> by getConfig()
+    val rootDir: String by getConfig()
+    val externalStorageDir: String by getConfig()
+    val downloadCacheDir: String by getConfig()
+    val databasesDir: String by getConfig()

-    val prefsDir: String by config
+    val prefsDir: String by getConfig()

-    val packageDir: String by config
+    val packageDir: String by getConfig()

    companion object {
-        fun register(config: Config) =
-            FilesConfigModule(config.getConfig("android.files"))
+        fun register(config: Config) = FilesConfigModule { config.getConfig("android.files") }
    }
 }
@@ -4,19 +4,24 @@ import com.typesafe.config.Config
 import io.github.config4k.getValue
 import xyz.nulldev.ts.config.ConfigModule

-class SystemConfigModule(val config: Config) : ConfigModule(config) {
-    val isDebuggable: Boolean by config
+class SystemConfigModule(
+    val getConfig: () -> Config,
+) : ConfigModule(getConfig) {
+    val isDebuggable: Boolean by getConfig()

    val propertyPrefix = "properties."

-    fun getStringProperty(property: String) = config.getString("$propertyPrefix$property")!!
-    fun getIntProperty(property: String) = config.getInt("$propertyPrefix$property")
-    fun getLongProperty(property: String) = config.getLong("$propertyPrefix$property")
-    fun getBooleanProperty(property: String) = config.getBoolean("$propertyPrefix$property")
-    fun hasProperty(property: String) = config.hasPath("$propertyPrefix$property")
+    fun getStringProperty(property: String) = getConfig().getString("$propertyPrefix$property")!!
+
+    fun getIntProperty(property: String) = getConfig().getInt("$propertyPrefix$property")
+
+    fun getLongProperty(property: String) = getConfig().getLong("$propertyPrefix$property")
+
+    fun getBooleanProperty(property: String) = getConfig().getBoolean("$propertyPrefix$property")
+
+    fun hasProperty(property: String) = getConfig().hasPath("$propertyPrefix$property")

    companion object {
-        fun register(config: Config) =
-            SystemConfigModule(config.getConfig("android.system"))
+        fun register(config: Config) = SystemConfigModule { config.getConfig("android.system") }
    }
 }
@@ -1,16 +1,12 @@
 package xyz.nulldev.androidcompat.info

 import android.content.pm.ApplicationInfo
-import org.kodein.di.DI
-import org.kodein.di.DIAware
-import org.kodein.di.conf.global
-import org.kodein.di.instance
 import xyz.nulldev.androidcompat.config.ApplicationInfoConfigModule
 import xyz.nulldev.ts.config.ConfigManager

-class ApplicationInfoImpl(override val di: DI = DI.global) : ApplicationInfo(), DIAware {
-    val configManager: ConfigManager by di.instance()
-
+class ApplicationInfoImpl(
+    private val configManager: ConfigManager,
+) : ApplicationInfo() {
    val appInfoConfig: ApplicationInfoConfigModule
        get() = configManager.module()

@@ -8,7 +8,9 @@ import java.io.File
 /**
 * Android file constants.
 */
-class AndroidFiles(val configManager: ConfigManager = GlobalConfigManager) {
+class AndroidFiles(
+    val configManager: ConfigManager = GlobalConfigManager,
+) {
    val filesConfig: FilesConfigModule
        get() = configManager.module()

@@ -30,9 +32,8 @@ class AndroidFiles(val configManager: ConfigManager = GlobalConfigManager) {

    val packagesDir: File get() = registerFile(filesConfig.packageDir)

-    fun registerFile(file: String): File {
-        return File(file).apply {
+    fun registerFile(file: String): File =
+        File(file).apply {
            mkdirs()
        }
-    }
 }
@@ -9,124 +9,211 @@ package xyz.nulldev.androidcompat.io.sharedprefs

 import android.content.SharedPreferences
 import com.russhwolf.settings.ExperimentalSettingsApi
-import com.russhwolf.settings.ExperimentalSettingsImplementation
-import com.russhwolf.settings.JvmPreferencesSettings
+import com.russhwolf.settings.PropertiesSettings
+import com.russhwolf.settings.Settings
 import com.russhwolf.settings.serialization.decodeValue
 import com.russhwolf.settings.serialization.decodeValueOrNull
 import com.russhwolf.settings.serialization.encodeValue
+import io.github.oshai.kotlinlogging.KotlinLogging
 import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.SerializationException
 import kotlinx.serialization.builtins.SetSerializer
 import kotlinx.serialization.builtins.serializer
-import java.util.prefs.PreferenceChangeListener
-import java.util.prefs.Preferences
+import xyz.nulldev.androidcompat.util.SafePath
+import xyz.nulldev.ts.config.ApplicationRootDir
+import java.util.Properties
+import kotlin.io.path.Path
+import kotlin.io.path.createParentDirectories
+import kotlin.io.path.deleteIfExists
+import kotlin.io.path.exists
+import kotlin.io.path.inputStream
+import kotlin.io.path.outputStream

-@OptIn(ExperimentalSettingsImplementation::class, ExperimentalSerializationApi::class, ExperimentalSettingsApi::class)
-class JavaSharedPreferences(key: String) : SharedPreferences {
-    private val javaPreferences = Preferences.userRoot().node("suwayomi/tachidesk/$key")
-    private val preferences = JvmPreferencesSettings(javaPreferences)
-    private val listeners = mutableMapOf<SharedPreferences.OnSharedPreferenceChangeListener, PreferenceChangeListener>()
-
-    // TODO: 2021-05-29 Need to find a way to get this working with all pref types
-    override fun getAll(): MutableMap<String, *> {
-        return preferences.keys.associateWith { preferences.getStringOrNull(it) }.toMutableMap()
+@OptIn(ExperimentalSerializationApi::class, ExperimentalSettingsApi::class)
+class JavaSharedPreferences(
+    key: String,
+) : SharedPreferences {
+    companion object {
+        private val logger = KotlinLogging.logger {}
    }

-    override fun getString(key: String, defValue: String?): String? {
-        return if (defValue != null) {
+    private val file =
+        Path(
+            ApplicationRootDir,
+            "settings",
+            "${SafePath.buildValidFilename(key)}.xml",
+        )
+    private val properties =
+        Properties().also { properties ->
+            try {
+                if (file.exists()) {
+                    file.inputStream().use { properties.loadFromXML(it) }
+                }
+            } catch (e: Exception) {
+                logger.error(e) { "Error loading settings from $key" }
+            }
+        }
+    private val preferences =
+        PropertiesSettings(
+            properties,
+            onModify = { properties ->
+                try {
+                    if (properties.isEmpty) {
+                        file.deleteIfExists()
+                    } else {
+                        file.createParentDirectories()
+                        file.outputStream().use {
+                            properties.storeToXML(it, null)
+                        }
+                    }
+                } catch (e: Exception) {
+                    logger.error(e) { "Error saving settings in $key" }
+                }
+            },
+        )
+    private val listeners = mutableMapOf<SharedPreferences.OnSharedPreferenceChangeListener, (String) -> Unit>()
+
+    // TODO: 2021-05-29 Need to find a way to get this working with all pref types
+    override fun getAll(): MutableMap<String, *> = preferences.keys.associateWith { preferences.getStringOrNull(it) }.toMutableMap()
+
+    override fun getString(
+        key: String,
+        defValue: String?,
+    ): String? =
+        if (defValue != null) {
            preferences.getString(key, defValue)
        } else {
            preferences.getStringOrNull(key)
        }
-    }

-    override fun getStringSet(key: String, defValues: Set<String>?): Set<String>? {
+    override fun getStringSet(
+        key: String,
+        defValues: Set<String>?,
+    ): Set<String>? {
        try {
            return if (defValues != null) {
                preferences.decodeValue(SetSerializer(String.serializer()), key, defValues)
            } else {
                preferences.decodeValueOrNull(SetSerializer(String.serializer()), key)
            }
-        } catch (e: SerializationException) {
+        } catch (_: SerializationException) {
            throw ClassCastException("$key was not a StringSet")
        }
    }

-    override fun getInt(key: String, defValue: Int): Int {
-        return preferences.getInt(key, defValue)
-    }
+    override fun getInt(
+        key: String,
+        defValue: Int,
+    ): Int = preferences.getInt(key, defValue)

-    override fun getLong(key: String, defValue: Long): Long {
-        return preferences.getLong(key, defValue)
-    }
+    override fun getLong(
+        key: String,
+        defValue: Long,
+    ): Long = preferences.getLong(key, defValue)

-    override fun getFloat(key: String, defValue: Float): Float {
-        return preferences.getFloat(key, defValue)
-    }
+    override fun getFloat(
+        key: String,
+        defValue: Float,
+    ): Float = preferences.getFloat(key, defValue)

-    override fun getBoolean(key: String, defValue: Boolean): Boolean {
-        return preferences.getBoolean(key, defValue)
-    }
+    override fun getBoolean(
+        key: String,
+        defValue: Boolean,
+    ): Boolean = preferences.getBoolean(key, defValue)

-    override fun contains(key: String): Boolean {
-        return key in preferences.keys
-    }
+    override fun contains(key: String): Boolean = key in preferences.keys

-    override fun edit(): SharedPreferences.Editor {
-        return Editor(preferences)
-    }
-
-    class Editor(private val preferences: JvmPreferencesSettings) : SharedPreferences.Editor {
-        val itemsToAdd = mutableMapOf<String, Any>()
-
-        override fun putString(key: String, value: String?): SharedPreferences.Editor {
-            if (value != null) {
-                itemsToAdd[key] = value
-            } else {
-                remove(key)
+    override fun edit(): SharedPreferences.Editor =
+        Editor(preferences) { key ->
+            listeners.forEach { (_, listener) ->
+                listener(key)
            }
+        }
+
+    class Editor(
+        private val preferences: Settings,
+        private val notify: (String) -> Unit,
+    ) : SharedPreferences.Editor {
+        private val actions = mutableListOf<Action>()
+
+        private sealed class Action {
+            data class Add(
+                val key: String,
+                val value: Any,
+            ) : Action()
+
+            data class Remove(
+                val key: String,
+            ) : Action()
+
+            data object Clear : Action()
+        }
+
+        override fun putString(
+            key: String,
+            value: String?,
+        ): SharedPreferences.Editor {
+            actions +=
+                if (value != null) {
+                    Action.Add(key, value)
+                } else {
+                    Action.Remove(key)
+                }
            return this
        }

        override fun putStringSet(
            key: String,
-            values: MutableSet<String>?
+            values: MutableSet<String>?,
        ): SharedPreferences.Editor {
-            if (values != null) {
-                itemsToAdd[key] = values
-            } else {
-                remove(key)
-            }
+            actions +=
+                if (values != null) {
+                    Action.Add(key, values)
+                } else {
+                    Action.Remove(key)
+                }
            return this
        }

-        override fun putInt(key: String, value: Int): SharedPreferences.Editor {
-            itemsToAdd[key] = value
+        override fun putInt(
+            key: String,
+            value: Int,
+        ): SharedPreferences.Editor {
+            actions += Action.Add(key, value)
            return this
        }

-        override fun putLong(key: String, value: Long): SharedPreferences.Editor {
-            itemsToAdd[key] = value
+        override fun putLong(
+            key: String,
+            value: Long,
+        ): SharedPreferences.Editor {
+            actions += Action.Add(key, value)
            return this
        }

-        override fun putFloat(key: String, value: Float): SharedPreferences.Editor {
-            itemsToAdd[key] = value
+        override fun putFloat(
+            key: String,
+            value: Float,
+        ): SharedPreferences.Editor {
+            actions += Action.Add(key, value)
            return this
        }

-        override fun putBoolean(key: String, value: Boolean): SharedPreferences.Editor {
-            itemsToAdd[key] = value
+        override fun putBoolean(
+            key: String,
+            value: Boolean,
+        ): SharedPreferences.Editor {
+            actions += Action.Add(key, value)
            return this
        }

        override fun remove(key: String): SharedPreferences.Editor {
-            itemsToAdd.remove(key)
+            actions += Action.Remove(key)
            return this
        }

        override fun clear(): SharedPreferences.Editor {
-            itemsToAdd.clear()
+            actions.add(Action.Clear)
            return this
        }

@@ -140,38 +227,56 @@ class JavaSharedPreferences(key: String) : SharedPreferences {
        }

        private fun addToPreferences() {
-            itemsToAdd.forEach { (key, value) ->
+            actions.forEach {
                @Suppress("UNCHECKED_CAST")
-                when (value) {
-                    is Set<*> -> preferences.encodeValue(SetSerializer(String.serializer()), key, value as Set<String>)
-                    is String -> preferences.putString(key, value)
-                    is Int -> preferences.putInt(key, value)
-                    is Long -> preferences.putLong(key, value)
-                    is Float -> preferences.putFloat(key, value)
-                    is Double -> preferences.putDouble(key, value)
-                    is Boolean -> preferences.putBoolean(key, value)
+                when (it) {
+                    is Action.Add -> {
+                        when (val value = it.value) {
+                            is Set<*> -> preferences.encodeValue(SetSerializer(String.serializer()), it.key, value as Set<String>)
+                            is String -> preferences.putString(it.key, value)
+                            is Int -> preferences.putInt(it.key, value)
+                            is Long -> preferences.putLong(it.key, value)
+                            is Float -> preferences.putFloat(it.key, value)
+                            is Double -> preferences.putDouble(it.key, value)
+                            is Boolean -> preferences.putBoolean(it.key, value)
+                        }
+                        notify(it.key)
+                    }
+                    is Action.Remove -> {
+                        preferences.remove(it.key)
+                        /**
+                         * Set<String> are stored like
+                         * key.0 = value1
+                         * key.1 = value2
+                         * key.size = 2
+                         */
+                        preferences.keys.forEach { key ->
+                            if (key.startsWith(it.key + ".")) {
+                                preferences.remove(key)
+                            }
+                        }
+
+                        notify(it.key)
+                    }
+                    Action.Clear -> preferences.clear()
                }
            }
        }
    }

    override fun registerOnSharedPreferenceChangeListener(listener: SharedPreferences.OnSharedPreferenceChangeListener) {
-        val javaListener = PreferenceChangeListener {
-            listener.onSharedPreferenceChanged(this, it.key)
+        val javaListener: (String) -> Unit = {
+            listener.onSharedPreferenceChanged(this, it)
        }
        listeners[listener] = javaListener
-        javaPreferences.addPreferenceChangeListener(javaListener)
    }

    override fun unregisterOnSharedPreferenceChangeListener(listener: SharedPreferences.OnSharedPreferenceChangeListener) {
-        val registeredListener = listeners.remove(listener)
-        if (registeredListener != null) {
-            javaPreferences.removePreferenceChangeListener(registeredListener)
-        }
+        listeners.remove(listener)
    }

    fun deleteAll(): Boolean {
-        javaPreferences.removeNode()
+        preferences.clear()
        return true
    }
 }
@@ -14,48 +14,60 @@ import java.io.File
 import javax.imageio.ImageIO
 import javax.xml.parsers.DocumentBuilderFactory

-data class InstalledPackage(val root: File) {
+data class InstalledPackage(
+    val root: File,
+) {
    val apk = File(root, "package.apk")
    val jar = File(root, "translated.jar")
    val icon = File(root, "icon.png")

    val info: PackageInfo
-        get() = ApkParsers.getMetaInfo(apk).toPackageInfo(apk).also {
-            val parsed = ApkFile(apk)
-            val dbFactory = DocumentBuilderFactory.newInstance()
-            val dBuilder = dbFactory.newDocumentBuilder()
-            val doc = parsed.manifestXml.byteInputStream().use {
-                dBuilder.parse(it)
+        get() =
+            ApkParsers.getMetaInfo(apk).toPackageInfo(apk).also {
+                val parsed = ApkFile(apk)
+                val dbFactory = DocumentBuilderFactory.newInstance()
+                val dBuilder = dbFactory.newDocumentBuilder()
+                val doc =
+                    parsed.manifestXml.byteInputStream().use {
+                        dBuilder.parse(it)
+                    }
+
+                it.applicationInfo.metaData =
+                    Bundle().apply {
+                        val appTag = doc.getElementsByTagName("application").item(0)
+
+                        appTag
+                            ?.childNodes
+                            ?.toList()
+                            ?.filter {
+                                it.nodeType == Node.ELEMENT_NODE
+                            }?.map {
+                                it as Element
+                            }?.filter {
+                                it.tagName == "meta-data"
+                            }?.map {
+                                putString(
+                                    it.attributes.getNamedItem("android:name").nodeValue,
+                                    it.attributes.getNamedItem("android:value").nodeValue,
+                                )
+                            }
+                    }
+
+                it.signatures =
+                    (
+                        parsed.apkSingers.flatMap { it.certificateMetas }
+                        // + parsed.apkV2Singers.flatMap { it.certificateMetas }
+                    ) // Blocked by: https://github.com/hsiafan/apk-parser/issues/72
+                        .map { Signature(it.data) }
+                        .toTypedArray()
            }

-            it.applicationInfo.metaData = Bundle().apply {
-                val appTag = doc.getElementsByTagName("application").item(0)
-
-                appTag?.childNodes?.toList()?.filter {
-                    it.nodeType == Node.ELEMENT_NODE
-                }?.map {
-                    it as Element
-                }?.filter {
-                    it.tagName == "meta-data"
-                }?.map {
-                    putString(
-                        it.attributes.getNamedItem("android:name").nodeValue,
-                        it.attributes.getNamedItem("android:value").nodeValue
-                    )
-                }
-            }
-
-            it.signatures = (
-                parsed.apkSingers.flatMap { it.certificateMetas }
-                /*+ parsed.apkV2Singers.flatMap { it.certificateMetas }*/
-                ) // Blocked by: https://github.com/hsiafan/apk-parser/issues/72
-                .map { Signature(it.data) }.toTypedArray()
-        }
-
    fun verify(): Boolean {
-        val res = ApkVerifier.Builder(apk)
-            .build()
-            .verify()
+        val res =
+            ApkVerifier
+                .Builder(apk)
+                .build()
+                .verify()

        return res.isVerified
    }
@@ -64,11 +76,15 @@ data class InstalledPackage(val root: File) {
        try {
            val icons = ApkFile(apk).allIcons

-            val read = icons.filter { it.isFile }.map {
-                it.data.inputStream().use {
-                    ImageIO.read(it)
-                }
-            }.sortedByDescending { it.width * it.height }.firstOrNull() ?: return
+            val read =
+                icons
+                    .filter { it.isFile }
+                    .map {
+                        it.data.inputStream().use {
+                            ImageIO.read(it)
+                        }
+                    }.sortedByDescending { it.width * it.height }
+                    .firstOrNull() ?: return

            ImageIO.write(read, "png", icon)
        } catch (e: Exception) {
@@ -88,8 +104,9 @@ data class InstalledPackage(val root: File) {
        fun NodeList.toList(): List<Node> {
            val out = mutableListOf<Node>()

-            for (i in 0 until length)
+            for (i in 0 until length) {
                out += item(i)
+            }

            return out
        }
@@ -1,14 +1,12 @@
 package xyz.nulldev.androidcompat.pm

 import net.dongliu.apk.parser.ApkParsers
-import org.kodein.di.DI
-import org.kodein.di.conf.global
-import org.kodein.di.instance
+import org.koin.mp.KoinPlatformTools
 import xyz.nulldev.androidcompat.io.AndroidFiles
 import java.io.File

 class PackageController {
-    private val androidFiles by DI.global.instance<AndroidFiles>()
+    private val androidFiles: AndroidFiles by KoinPlatformTools.defaultContext().get().inject()
    private val uninstallListeners = mutableListOf<(String) -> Unit>()

    fun registerUninstallListener(listener: (String) -> Unit) {
@@ -25,7 +23,10 @@ class PackageController {
        return File(androidFiles.packagesDir, pn)
    }

-    fun installPackage(apk: File, allowReinstall: Boolean) {
+    fun installPackage(
+        apk: File,
+        allowReinstall: Boolean,
+    ) {
        val root = findRoot(apk)

        if (root.exists()) {
@@ -54,13 +55,15 @@ class PackageController {
        }
    }

-    fun listInstalled(): List<InstalledPackage> {
-        return androidFiles.packagesDir.listFiles().orEmpty().filter {
-            it.isDirectory
-        }.map {
-            InstalledPackage(it)
-        }
-    }
+    fun listInstalled(): List<InstalledPackage> =
+        androidFiles.packagesDir
+            .listFiles()
+            .orEmpty()
+            .filter {
+                it.isDirectory
+            }.map {
+                InstalledPackage(it)
+            }

    fun deletePackage(pack: InstalledPackage) {
        if (!pack.root.exists()) error("Package was never installed!")
@@ -74,10 +77,11 @@ class PackageController {

    fun findPackage(packageName: String): InstalledPackage? {
        val file = File(androidFiles.packagesDir, packageName)
-        return if (file.exists())
+        return if (file.exists()) {
            InstalledPackage(file)
-        else
+        } else {
            null
+        }
    }

    fun findJarFromApk(apkFile: File): File? {
@@ -6,22 +6,24 @@ import android.content.pm.PackageInfo
 import net.dongliu.apk.parser.bean.ApkMeta
 import java.io.File

-fun ApkMeta.toPackageInfo(apk: File): PackageInfo {
-    return PackageInfo().also {
+fun ApkMeta.toPackageInfo(apk: File): PackageInfo =
+    PackageInfo().also {
        it.packageName = packageName
        it.versionCode = versionCode.toInt()
        it.versionName = versionName

-        it.reqFeatures = usesFeatures.map {
-            FeatureInfo().apply {
-                name = it.name
-            }
-        }.toTypedArray()
+        it.reqFeatures =
+            usesFeatures
+                .map {
+                    FeatureInfo().apply {
+                        name = it.name
+                    }
+                }.toTypedArray()

-        it.applicationInfo = ApplicationInfo().apply {
-            packageName = it.packageName
-            nonLocalizedLabel = label
-            sourceDir = apk.absolutePath
-        }
+        it.applicationInfo =
+            ApplicationInfo().apply {
+                packageName = it.packageName
+                nonLocalizedLabel = label
+                sourceDir = apk.absolutePath
+            }
    }
-}
@@ -1,7 +1,7 @@
 package xyz.nulldev.androidcompat.res;

 import xyz.nulldev.androidcompat.info.ApplicationInfoImpl;
-import xyz.nulldev.androidcompat.util.KodeinGlobalHelper;
+import xyz.nulldev.androidcompat.util.KoinGlobalHelper;

 import java.text.SimpleDateFormat;
 import java.util.Calendar;
@@ -10,7 +10,7 @@ import java.util.Calendar;
 * BuildConfig compat class.
 */
 public class BuildConfigCompat {
-    private static ApplicationInfoImpl applicationInfo = KodeinGlobalHelper.instance(ApplicationInfoImpl.class);
+    private static ApplicationInfoImpl applicationInfo = KoinGlobalHelper.instance(ApplicationInfoImpl.class);

    public static final boolean DEBUG = applicationInfo.getDebug();

@@ -1,6 +1,8 @@
 package xyz.nulldev.androidcompat.res

-class DrawableResource(val location: String) : Resource {
+class DrawableResource(
+    val location: String,
+) : Resource {
    override fun getType() = DrawableResource::class.java

    override fun getValue() = javaClass.getResourceAsStream(location)
@@ -19,7 +19,9 @@ package xyz.nulldev.androidcompat.res
 /**
 * String resource.
 */
-class StringResource(val string: String) : Resource {
+class StringResource(
+    val string: String,
+) : Resource {
    override fun getValue() = string

    override fun getType() = StringResource::class.java
@@ -3,7 +3,7 @@ package xyz.nulldev.androidcompat.service
 import android.app.Service
 import android.content.Context
 import android.content.Intent
-import mu.KotlinLogging
+import io.github.oshai.kotlinlogging.KotlinLogging
 import java.util.concurrent.ConcurrentHashMap
 import kotlin.concurrent.thread

@@ -18,7 +18,10 @@ class ServiceSupport {

    private val logger = KotlinLogging.logger {}

-    fun startService(@Suppress("UNUSED_PARAMETER") context: Context, intent: Intent) {
+    fun startService(
+        @Suppress("UNUSED_PARAMETER") context: Context,
+        intent: Intent,
+    ) {
        val name = intentToClassName(intent)

        logger.debug { "Starting service: $name" }
@@ -35,7 +38,10 @@ class ServiceSupport {
        }
    }

-    fun stopService(@Suppress("UNUSED_PARAMETER") context: Context, intent: Intent) {
+    fun stopService(
+        @Suppress("UNUSED_PARAMETER") context: Context,
+        intent: Intent,
+    ) {
        val name = intentToClassName(intent)
        stopService(name)
    }
@@ -1,67 +0,0 @@
-package xyz.nulldev.androidcompat.util
-
-import android.content.Context
-import org.kodein.di.DI
-import org.kodein.di.conf.global
-import org.kodein.di.instance
-import xyz.nulldev.androidcompat.androidimpl.CustomContext
-import xyz.nulldev.androidcompat.androidimpl.FakePackageManager
-import xyz.nulldev.androidcompat.info.ApplicationInfoImpl
-import xyz.nulldev.androidcompat.io.AndroidFiles
-import xyz.nulldev.androidcompat.pm.PackageController
-import xyz.nulldev.androidcompat.service.ServiceSupport
-
-/**
- * Helper class to allow access to Kodein from Java
- */
-object KodeinGlobalHelper {
-    /**
-     * Get the Kodein object
-     */
-    @JvmStatic
-    fun kodein() = DI.global
-
-    /**
-     * Get a dependency
-     */
-    @JvmStatic
-    @Suppress("UNCHECKED_CAST")
-    fun <T : Any> instance(type: Class<T>, kodein: DI? = null): T {
-        return when (type) {
-            AndroidFiles::class.java -> {
-                val instance: AndroidFiles by (kodein ?: kodein()).instance()
-                instance as T
-            }
-            ApplicationInfoImpl::class.java -> {
-                val instance: ApplicationInfoImpl by (kodein ?: kodein()).instance()
-                instance as T
-            }
-            ServiceSupport::class.java -> {
-                val instance: ServiceSupport by (kodein ?: kodein()).instance()
-                instance as T
-            }
-            FakePackageManager::class.java -> {
-                val instance: FakePackageManager by (kodein ?: kodein()).instance()
-                instance as T
-            }
-            PackageController::class.java -> {
-                val instance: PackageController by (kodein ?: kodein()).instance()
-                instance as T
-            }
-            CustomContext::class.java -> {
-                val instance: CustomContext by (kodein ?: kodein()).instance()
-                instance as T
-            }
-            Context::class.java -> {
-                val instance: Context by (kodein ?: kodein()).instance()
-                instance as T
-            }
-            else -> throw IllegalArgumentException("Kodein instance not found")
-        }
-    }
-
-    @JvmStatic
-    fun <T : Any> instance(type: Class<T>): T {
-        return instance(type, null)
-    }
-}
@@ -0,0 +1,27 @@
+package xyz.nulldev.androidcompat.util
+
+import org.koin.core.Koin
+import org.koin.mp.KoinPlatformTools
+
+/**
+ * Helper class to allow access to Kodein from Java
+ */
+object KoinGlobalHelper {
+    /**
+     * Get the Kodein object
+     */
+    @JvmStatic
+    fun koin() = KoinPlatformTools.defaultContext().get()
+
+    /**
+     * Get a dependency
+     */
+    @JvmStatic
+    fun <T : Any> instance(
+        type: Class<T>,
+        koin: Koin? = null,
+    ): T = (koin ?: koin()).get(type.kotlin)
+
+    @JvmStatic
+    fun <T : Any> instance(type: Class<T>): T = instance(type, null)
+}
@@ -1,4 +1,4 @@
-package suwayomi.tachidesk.manga.impl.util.storage
+package xyz.nulldev.androidcompat.util

 /*
 * Copyright (C) Contributors to the Suwayomi project
@@ -24,5 +24,7 @@ import java.net.URI
 * Utilites to convert between Java and Android Uris.
 */
 fun Uri.java() = URI(this.toString())
+
 fun Uri.file() = File(this.path)
+
 fun URI.android() = Uri.parse(this.toString())!!
@@ -0,0 +1,96 @@
+package xyz.nulldev.androidcompat.webkit
+
+import android.webkit.CookieManager
+import android.webkit.ValueCallback
+import android.webkit.WebView
+import java.net.CookieHandler
+import java.net.HttpCookie
+import java.net.URI
+
+@Suppress("DEPRECATION")
+class CookieManagerImpl : CookieManager() {
+    private val cookieHandler = CookieHandler.getDefault() as java.net.CookieManager
+    private var acceptCookie = true
+    private var acceptThirdPartyCookies = true
+    private var allowFileSchemeCookies = false
+
+    override fun setAcceptCookie(accept: Boolean) {
+        acceptCookie = accept
+    }
+
+    override fun acceptCookie(): Boolean = acceptCookie
+
+    override fun setAcceptThirdPartyCookies(
+        webview: WebView?,
+        accept: Boolean,
+    ) {
+        acceptThirdPartyCookies = accept
+    }
+
+    override fun acceptThirdPartyCookies(webview: WebView?): Boolean = acceptThirdPartyCookies
+
+    override fun setCookie(
+        url: String,
+        value: String?,
+    ) {
+        val uri =
+            if (url.startsWith("http")) {
+                URI(url)
+            } else {
+                URI("http://$url")
+            }
+
+        HttpCookie.parse(value).forEach {
+            cookieHandler.cookieStore.add(uri, it)
+        }
+    }
+
+    override fun setCookie(
+        url: String,
+        value: String?,
+        callback: ValueCallback<Boolean>?,
+    ) {
+        setCookie(url, value)
+        callback?.onReceiveValue(true)
+    }
+
+    override fun getCookie(url: String): String {
+        val uri =
+            if (url.startsWith("http")) {
+                URI(url)
+            } else {
+                URI("http://$url")
+            }
+        return cookieHandler.cookieStore
+            .get(uri)
+            .joinToString("; ") { "${it.name}=${it.value}" }
+    }
+
+    @Deprecated("Deprecated in Java")
+    override fun removeSessionCookie() {}
+
+    override fun removeSessionCookies(callback: ValueCallback<Boolean>?) {}
+
+    @Deprecated("Deprecated in Java")
+    override fun removeExpiredCookie() {}
+
+    @Deprecated("Deprecated in Java")
+    override fun removeAllCookie() {
+        cookieHandler.cookieStore.removeAll()
+    }
+
+    override fun removeAllCookies(callback: ValueCallback<Boolean>?) {
+        val removedCookies = cookieHandler.cookieStore.removeAll()
+        callback?.onReceiveValue(removedCookies)
+    }
+
+    override fun hasCookies(): Boolean = cookieHandler.cookieStore.cookies.isNotEmpty()
+
+    override fun flush() {}
+
+    override fun allowFileSchemeCookiesImpl(): Boolean = allowFileSchemeCookies
+
+    override fun setAcceptFileSchemeCookiesImpl(accept: Boolean) {
+        allowFileSchemeCookies = acceptCookie
+    }
+}
@@ -0,0 +1,429 @@
+package xyz.nulldev.androidcompat.webkit
+
+import android.webkit.WebSettings
+
+class KcefWebSettings : WebSettings() {
+    // Boolean settings
+    private var navDumps = false
+    private var mediaPlaybackRequiresUserGesture = true
+    private var builtInZoomControls = false
+    private var displayZoomControls = true
+    private var allowFileAccess = true
+    private var allowContentAccess = true
+    private var pluginsEnabled = false
+    private var loadWithOverviewMode = false
+    private var enableSmoothTransition = false
+    private var useWebViewBackgroundForOverscrollBackground = false
+    private var saveFormData = true
+    private var savePassword = false
+    private var acceptThirdPartyCookies = true
+    private var lightTouchEnabled = false
+    private var useWideViewPort = true
+    private var supportMultipleWindows = false
+    private var loadsImagesAutomatically = true
+    private var blockNetworkImage = false
+    private var blockNetworkLoads = false
+    private var javaScriptEnabled = true
+    private var allowUniversalAccessFromFileURLs = false
+    private var allowFileAccessFromFileURLs = false
+    private var domStorageEnabled = true
+    private var geolocationEnabled = true
+    private var javaScriptCanOpenWindowsAutomatically = false
+    private var needInitialFocus = false
+    private var offscreenPreRaster = false
+    private var videoOverlayForEmbeddedEncryptedVideoEnabled = false
+    private var safeBrowsingEnabled = true
+
+    // Integer settings
+    private var textZoom = 100
+    private var minimumFontSize = 8
+    private var minimumLogicalFontSize = 8
+    private var defaultFontSize = 16
+    private var defaultFixedFontSize = 13
+    private var cacheMode = 0
+    private var mixedContentMode = 0
+    private var disabledActionModeMenuItems = 0
+
+    // String settings
+    private var databasePath: String? = null
+    private var geolocationDatabasePath: String? = null
+    private var appCachePath: String? = null
+    private var defaultTextEncodingName: String? = null
+    private var userAgentString: String? = null
+    private var standardFontFamily: String? = null
+    private var fixedFontFamily: String? = null
+    private var sansSerifFontFamily: String? = null
+    private var serifFontFamily: String? = null
+    private var cursiveFontFamily: String? = null
+    private var fantasyFontFamily: String? = null
+
+    // Enum settings
+    private var defaultZoom: ZoomDensity? = null
+    private var layoutAlgorithm: LayoutAlgorithm? = null
+    private var pluginState: PluginState? = null
+    private var renderPriority: RenderPriority? = null
+
+    // Long settings
+    private var appCacheMaxSize: Long = 0L
+
+    // Implementations
+
+    @SuppressWarnings("HiddenAbstractMethod")
+    @Deprecated("inherit")
+    override fun setNavDump(p0: Boolean) {
+        navDumps = p0
+    }
+
+    @Deprecated("inherit")
+    @SuppressWarnings("HiddenAbstractMethod")
+    override fun getNavDump(): Boolean = navDumps
+
+    override fun setSupportZoom(p0: Boolean) {
+        mediaPlaybackRequiresUserGesture = p0
+    }
+
+    override fun supportZoom() = mediaPlaybackRequiresUserGesture
+
+    override fun setMediaPlaybackRequiresUserGesture(p0: Boolean) {
+        mediaPlaybackRequiresUserGesture = p0
+    }
+
+    override fun getMediaPlaybackRequiresUserGesture() = mediaPlaybackRequiresUserGesture
+
+    override fun setBuiltInZoomControls(p0: Boolean) {
+        builtInZoomControls = p0
+    }
+
+    override fun getBuiltInZoomControls() = builtInZoomControls
+
+    override fun setDisplayZoomControls(p0: Boolean) {
+        displayZoomControls = p0
+    }
+
+    override fun getDisplayZoomControls() = displayZoomControls
+
+    override fun setAllowFileAccess(p0: Boolean) {
+        allowFileAccess = p0
+    }
+
+    override fun getAllowFileAccess() = allowFileAccess
+
+    override fun setAllowContentAccess(p0: Boolean) {
+        allowContentAccess = p0
+    }
+
+    override fun getAllowContentAccess() = allowContentAccess
+
+    override fun setLoadWithOverviewMode(p0: Boolean) {
+        loadWithOverviewMode = p0
+    }
+
+    override fun getLoadWithOverviewMode() = loadWithOverviewMode
+
+    @Deprecated("inherit")
+    override fun setPluginsEnabled(p0: Boolean) {
+        pluginsEnabled = p0
+    }
+
+    @Deprecated("inherit")
+    override fun getPluginsEnabled() = pluginsEnabled
+
+    @Deprecated("inherit")
+    override fun setEnableSmoothTransition(p0: Boolean) {
+        enableSmoothTransition = p0
+    }
+
+    @Deprecated("inherit")
+    override fun enableSmoothTransition() = enableSmoothTransition
+
+    @Deprecated("inherit")
+    override fun setUseWebViewBackgroundForOverscrollBackground(p0: Boolean) {
+        useWebViewBackgroundForOverscrollBackground = p0
+    }
+
+    @Deprecated("inherit")
+    override fun getUseWebViewBackgroundForOverscrollBackground() = useWebViewBackgroundForOverscrollBackground
+
+    @Deprecated("inherit")
+    override fun setSaveFormData(p0: Boolean) {
+        saveFormData = p0
+    }
+
+    @Deprecated("inherit")
+    override fun getSaveFormData() = saveFormData
+
+    @Deprecated("inherit")
+    override fun setSavePassword(p0: Boolean) {
+        savePassword = p0
+    }
+
+    @Deprecated("inherit")
+    override fun getSavePassword() = savePassword
+
+    override fun setTextZoom(p0: Int) {
+        textZoom = p0
+    }
+
+    override fun getTextZoom() = textZoom
+
+    @Deprecated("inherit")
+    override fun setDefaultZoom(p0: ZoomDensity?) {
+        defaultZoom = p0
+    }
+
+    override fun setAcceptThirdPartyCookies(p0: Boolean) {
+        acceptThirdPartyCookies = p0
+    }
+
+    override fun getAcceptThirdPartyCookies() = acceptThirdPartyCookies
+
+    @Deprecated("inherit")
+    override fun getDefaultZoom() = defaultZoom
+
+    @Deprecated("inherit")
+    override fun setLightTouchEnabled(p0: Boolean) {
+        lightTouchEnabled = p0
+    }
+
+    @Deprecated("inherit")
+    override fun getLightTouchEnabled() = lightTouchEnabled
+
+    @Deprecated("inherit")
+    override fun setUserAgent(ua: Int) = throw RuntimeException("Stub!")
+
+    @Deprecated("inherit")
+    override fun getUserAgent(): Int = throw RuntimeException("Stub!")
+
+    override fun setUseWideViewPort(p0: Boolean) {
+        useWideViewPort = p0
+    }
+
+    override fun getUseWideViewPort() = useWideViewPort
+
+    override fun setSupportMultipleWindows(p0: Boolean) {
+        supportMultipleWindows = p0
+    }
+
+    override fun supportMultipleWindows() = supportMultipleWindows
+
+    override fun setLayoutAlgorithm(p0: LayoutAlgorithm?) {
+        layoutAlgorithm = p0
+    }
+
+    override fun getLayoutAlgorithm() = layoutAlgorithm
+
+    override fun setStandardFontFamily(p0: String?) {
+        standardFontFamily = p0
+    }
+
+    override fun getStandardFontFamily() = standardFontFamily
+
+    override fun setFixedFontFamily(p0: String?) {
+        fixedFontFamily = p0
+    }
+
+    override fun getFixedFontFamily() = fixedFontFamily
+
+    override fun setSansSerifFontFamily(p0: String?) {
+        sansSerifFontFamily = p0
+    }
+
+    override fun getSansSerifFontFamily() = sansSerifFontFamily
+
+    override fun setSerifFontFamily(p0: String?) {
+        serifFontFamily = p0
+    }
+
+    override fun getSerifFontFamily() = serifFontFamily
+
+    override fun setCursiveFontFamily(p0: String?) {
+        cursiveFontFamily = p0
+    }
+
+    override fun getCursiveFontFamily() = cursiveFontFamily
+
+    override fun setFantasyFontFamily(p0: String?) {
+        fantasyFontFamily = p0
+    }
+
+    override fun getFantasyFontFamily() = fantasyFontFamily
+
+    override fun setMinimumFontSize(p0: Int) {
+        minimumFontSize = p0
+    }
+
+    override fun getMinimumFontSize() = minimumFontSize
+
+    override fun setMinimumLogicalFontSize(p0: Int) {
+        minimumLogicalFontSize = p0
+    }
+
+    override fun getMinimumLogicalFontSize() = minimumLogicalFontSize
+
+    override fun setDefaultFontSize(p0: Int) {
+        defaultFontSize = p0
+    }
+
+    override fun getDefaultFontSize() = defaultFontSize
+
+    override fun setDefaultFixedFontSize(p0: Int) {
+        defaultFixedFontSize = p0
+    }
+
+    override fun getDefaultFixedFontSize() = defaultFixedFontSize
+
+    override fun setLoadsImagesAutomatically(p0: Boolean) {
+        loadsImagesAutomatically = p0
+    }
+
+    override fun getLoadsImagesAutomatically() = loadsImagesAutomatically
+
+    override fun setBlockNetworkImage(p0: Boolean) {
+        blockNetworkImage = p0
+    }
+
+    override fun getBlockNetworkImage() = blockNetworkImage
+
+    override fun setBlockNetworkLoads(p0: Boolean) {
+        blockNetworkLoads = p0
+    }
+
+    override fun getBlockNetworkLoads() = blockNetworkLoads
+
+    override fun setJavaScriptEnabled(p0: Boolean) {
+        javaScriptEnabled = p0
+    }
+
+    override fun getJavaScriptEnabled() = javaScriptEnabled
+
+    @Deprecated("inherit")
+    override fun setAllowUniversalAccessFromFileURLs(p0: Boolean) {
+        allowUniversalAccessFromFileURLs = p0
+    }
+
+    override fun getAllowUniversalAccessFromFileURLs() = allowUniversalAccessFromFileURLs
+
+    @Deprecated("inherit")
+    override fun setAllowFileAccessFromFileURLs(p0: Boolean) {
+        allowFileAccessFromFileURLs = p0
+    }
+
+    override fun getAllowFileAccessFromFileURLs() = allowFileAccessFromFileURLs
+
+    @Deprecated("inherit")
+    override fun setPluginState(p0: PluginState?) {
+        pluginState = p0
+    }
+
+    @Deprecated("inherit")
+    override fun getPluginState() = pluginState
+
+    @Deprecated("inherit")
+    override fun setDatabasePath(p0: String?) {
+        databasePath = p0
+    }
+
+    @Deprecated("inherit")
+    override fun getDatabasePath() = databasePath ?: ""
+
+    @Deprecated("inherit")
+    override fun setGeolocationDatabasePath(p0: String?) {
+        geolocationDatabasePath = p0
+    }
+
+    @Deprecated("inherit")
+    override fun setAppCacheEnabled(p0: Boolean) {}
+
+    @Deprecated("inherit")
+    override fun setAppCachePath(p0: String?) {
+        appCachePath = p0
+    }
+
+    @Deprecated("inherit")
+    override fun setAppCacheMaxSize(p0: Long) {
+        appCacheMaxSize = p0
+    }
+
+    @Deprecated("inherit")
+    override fun setDatabaseEnabled(p0: Boolean) {}
+
+    @Deprecated("inherit")
+    override fun getDatabaseEnabled() = true
+
+    override fun setDomStorageEnabled(p0: Boolean) {
+        domStorageEnabled = p0
+    }
+
+    override fun getDomStorageEnabled() = domStorageEnabled
+
+    override fun setGeolocationEnabled(p0: Boolean) {
+        geolocationEnabled = p0
+    }
+
+    override fun setJavaScriptCanOpenWindowsAutomatically(p0: Boolean) {
+        javaScriptCanOpenWindowsAutomatically = p0
+    }
+
+    override fun getJavaScriptCanOpenWindowsAutomatically() = javaScriptCanOpenWindowsAutomatically
+
+    override fun setDefaultTextEncodingName(p0: String?) {
+        defaultTextEncodingName = p0
+    }
+
+    override fun getDefaultTextEncodingName() = defaultTextEncodingName ?: ""
+
+    override fun setUserAgentString(p0: String?) {
+        userAgentString = p0
+    }
+
+    override fun getUserAgentString() = userAgentString ?: defaultUserAgent()
+
+    override fun setNeedInitialFocus(p0: Boolean) {
+        needInitialFocus = p0
+    }
+
+    @Deprecated("inherit")
+    override fun setRenderPriority(p0: RenderPriority?) {
+        renderPriority = p0
+    }
+
+    override fun setCacheMode(p0: Int) {
+        cacheMode = p0
+    }
+
+    override fun getCacheMode() = cacheMode
+
+    override fun setMixedContentMode(p0: Int) {
+        mixedContentMode = p0
+    }
+
+    override fun getMixedContentMode() = mixedContentMode
+
+    override fun setOffscreenPreRaster(p0: Boolean) {
+        offscreenPreRaster = p0
+    }
+
+    override fun getOffscreenPreRaster() = offscreenPreRaster
+
+    override fun setVideoOverlayForEmbeddedEncryptedVideoEnabled(p0: Boolean) {
+        videoOverlayForEmbeddedEncryptedVideoEnabled = p0
+    }
+
+    override fun getVideoOverlayForEmbeddedEncryptedVideoEnabled() = videoOverlayForEmbeddedEncryptedVideoEnabled
+
+    override fun setSafeBrowsingEnabled(p0: Boolean) {
+        safeBrowsingEnabled = p0
+    }
+
+    override fun getSafeBrowsingEnabled() = safeBrowsingEnabled
+
+    override fun setDisabledActionModeMenuItems(p0: Int) {
+        disabledActionModeMenuItems = p0
+    }
+
+    override fun getDisabledActionModeMenuItems() = disabledActionModeMenuItems
+
+    companion object {
+        fun defaultUserAgent() = System.getProperty("http.agent")
+    }
+}
@@ -2,10 +2,10 @@
 ## TL;DR
 - N/A

-## Tachidesk-Server Changelog
+## Suwayomi-Server Changelog
 - N/A

-## Tachidesk-WebUI Changelog
+## Suwayomi-WebUI Changelog
 - N/A


--- a/Show More
+++ b/Show More