iOS version bump 0.14.2

Version bump v0.14.2-beta
Add Arabic, Hebrew, Korean and Slovak language options
2026-11-13 12:23:47 +01:00 · 2026-09-27 17:50:38 -05:00 · 2026-09-27 17:23:31 -05:00 · 2026-09-27 17:17:45 -05:00 · 2026-09-27 17:06:19 -05:00 · 2026-09-27 17:06:02 -05:00
354 changed files with 29382 additions and 13242 deletions
@@ -1,13 +1,12 @@
-# editorconfig.org
 root = true

 [*]
 indent_style = space
 indent_size = 2
-end_of_line = lf
 charset = utf-8
-trim_trailing_whitespace = true
 insert_final_newline = true
+trim_trailing_whitespace = true

-[*.md]
-trim_trailing_whitespace = false
+[*.swift]
+indent_style = space
+indent_size = 4
@@ -1,37 +0,0 @@
---
-name: Bug report
-about: Create a report to help us improve
-labels: bug
-
---
-
-### Steps to reproduce
-
-1.
-2.
-3.
-
-### Expected behaviour
- Tell us what should happen
-
-### Actual behaviour
- Tell us what happens
-
-### Environment data
-
-Audiobookshelf Version:
-
- [ ] Android App?
- [ ] iOS App?
-
-#### Android Issue
-Android version:
-
-Device model:
-
-Stock or customized system:
-
-#### iOS Issue
-iOS Version:
-
-iPhone model:
@@ -0,0 +1,98 @@
+name: 🐞 ABS App Bug Report
+description: File a bug/issue and help us improve the Audiobookshelf mobile apps.
+title: '[Bug]: '
+labels: ['bug', 'triage']
+body:
+  - type: markdown
+    attributes:
+      value: '## App Bug Description'
+  - type: markdown
+    attributes:
+      value: 'Thank you for filing a bug report! 🐛'
+  - type: markdown
+    attributes:
+      value: 'Join the [discord server](https://discord.gg/HQgCbd6E75) for questions or if you are not sure about a bug.'
+  - type: dropdown
+    id: confirm-check
+    attributes:
+      label: I have verified that the [bug is not already awaiting release](https://github.com/advplyr/audiobookshelf-app/issues?q=is%3Aissue%20label%3A%22awaiting%20release%22)
+      multiple: false
+      options:
+        - 'Yes'
+        - 'No'
+    validations:
+      required: true
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: What was the Problem?
+      description: Please help us understand the problem.
+      placeholder: Describe the problem you saw or experienced in detail! Include a screenshot or video, if applicable.
+    validations:
+      required: true
+  - type: textarea
+    id: steps-to-reproduce
+    attributes:
+      label: Steps to Reproduce the Issue
+      description: Please help us understand how we can reliably reproduce the issue.
+      placeholder: '1. Go to the library page of a Podcast library and...'
+    validations:
+      required: true
+  - type: textarea
+    id: what-was-expected
+    attributes:
+      label: What was Expected?
+      description: Please help us understand what should have happened.
+      placeholder: Please help us visualize by including a doodle or screenshot.
+    validations:
+      required: true
+  - type: markdown
+    attributes:
+      value: '## Mobile Environment'
+  - type: input
+    id: phone-model
+    attributes:
+      label: Phone Model
+      description: What kind of phone are you using?
+      placeholder: e.g. Pixel 6, iPhone 14, Samsung Galaxy s23, etc
+    validations:
+      required: true
+  - type: input
+    id: phone-os
+    attributes:
+      label: Phone OS
+      description: What operating system? If Android, is it stock or a custom system?
+      placeholder: e.g. Android 14, iOS 17.4, etc
+    validations:
+      required: true
+  - type: dropdown
+    id: app-version
+    attributes:
+      label: Audiobookshelf App Version
+      description: Please ensure your app is up to date. *If you are using a 3rd-party app, please reach out to them directly.*
+      multiple: true
+      options:
+        - 'Android App - 0.14.1'
+        - 'iOS App - 0.14.1'
+        - 'Android App - 0.14.0'
+        - 'iOS App - 0.14.0'
+    validations:
+      required: true
+  - type: dropdown
+    id: install-source
+    attributes:
+      label: Installation Source
+      multiple: true
+      options:
+        - 'Google Play Store'
+        - 'Testflight'
+        - 'SideStore'
+        - 'Other (List in "Additional Notes")'
+    validations:
+      required: true
+  - type: textarea
+    id: additional-notes
+    attributes:
+      label: Additional Notes
+      description: Anything else you want to add?
+      placeholder: 'e.g. I have tried X, Y, and Z.'
@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Discord
+    url: https://discord.gg/HQgCbd6E75
+    about: Ask questions, get help troubleshooting, and join the Abs community here.
@@ -1,18 +0,0 @@
---
-name: Feature request
-about: Suggest an idea for this project
-labels: enhancement
-
---
-
-### Is your feature request related to a problem? Please describe.
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-### Describe the solution you'd like
-A clear and concise description of what you want to happen.
-
-### Describe alternatives you've considered
-A clear and concise description of any alternative solutions or features you've considered.
-
-### Additional context
-Add any other context or screenshots about the feature request here.
@@ -0,0 +1,57 @@
+name: 🚀 App Feature Request
+description: Request a feature/enhancement
+title: '[Enhancement]: '
+labels: ['enhancement']
+body:
+  - type: markdown
+    attributes:
+      value: '## App Feature Request Description'
+  - type: markdown
+    attributes:
+      value: 'Please first search in both issues & discussions for your enhancement and make sure your app is up to date.'
+  - type: textarea
+    id: describe
+    attributes:
+      label: Describe the Feature/Enhancement
+      description: Please help us understand what you want.
+      placeholder: What is your vision?
+    validations:
+      required: true
+  - type: textarea
+    id: the-why
+    attributes:
+      label: Why would this be helpful?
+      description: Please help us understand why this would enhance your experience.
+      placeholder: Explain the "why" or "use case".
+    validations:
+      required: true
+  - type: textarea
+    id: image
+    attributes:
+      label: Future Implementation (Screenshot)
+      description: Please help us visualize by including a doodle or screenshot.
+      placeholder: How could this look or where could it go?
+    validations:
+      required: true
+  - type: markdown
+    attributes:
+      value: '## App Current Implementation'
+  - type: dropdown
+    id: version
+    attributes:
+      label: Audiobookshelf App Version
+      description: Please ensure your app is up to date. *If you are using a 3rd-party app, please reach out to them directly.*
+      multiple: true
+      options:
+        - 'Android App - 0.14.1'
+        - 'iOS App - 0.14.1'
+        - 'Android App - 0.14.0'
+        - 'iOS App - 0.14.0'
+    validations:
+      required: true
+  - type: textarea
+    id: current-image
+    attributes:
+      label: Current Implementation (Screenshot)
+      description: What screen were you looking at when you thought of this enhancement?
+      placeholder: If an image is not applicable, please explain why.
@@ -0,0 +1,41 @@
+<!--
+For Work In Progress Pull Requests, please use the Draft PR feature,
+see https://github.blog/2019-02-14-introducing-draft-pull-requests/ for further details.
+
+If you do not follow this template, the PR may be closed without review.
+
+Please ensure all checks pass.
+If you are a new contributor, the workflows will need to be manually approved before they run.
+-->
+
+## Brief summary
+
+<!-- Please provide a brief summary of what your PR attempts to achieve. -->
+
+## Which issue is fixed?
+
+<!-- Which issue number does this PR fix? Ex: "Fixes #1234" -->
+
+## Pull Request Type
+
+<!--
+Does this affect only Android, only iOS, or both?
+Does this change the frontend or the backend of the apps?
+-->
+
+## In-depth Description
+
+<!--
+Describe your solution in more depth.
+How does it work? Why is this the best solution?
+Does it solve a problem that affects multiple users or is this an edge case for your setup?
+-->
+
+## How have you tested this?
+
+<!-- Please describe in detail with reproducible steps how you tested your changes. -->
+
+## Screenshots
+
+<!-- If your PR includes any changes to the front-end, please include screenshots or a
+short video from before and after your changes. -->
@@ -13,41 +13,41 @@ jobs:
  main:
    runs-on: ubuntu-latest
    steps:
-    - name: checkout sources
-      uses: actions/checkout@v3
+      - name: checkout sources
+        uses: actions/checkout@v3

-    - name: use Node.js 20.x
-      uses: actions/setup-node@v3
-      with:
-        node-version: 20
+      - name: use Node.js 20.x
+        uses: actions/setup-node@v3
+        with:
+          node-version: 20

-    - name: Set up Java
-      uses: actions/setup-java@v2
-      with:
-        distribution: "temurin"
-        java-version: 17
+      - name: Set up Java
+        uses: actions/setup-java@v2
+        with:
+          distribution: 'temurin'
+          java-version: 21

-    - name: install dependencies
-      run: npm ci
+      - name: install dependencies
+        run: npm ci --omit=optional

-    - name: build Nuxt project
-      run: npm run generate
+      - name: build Nuxt project
+        run: npm run generate

-    - name: copy to Android project
-      run: npx cap sync
+      - name: copy to Android project
+        run: npx cap sync

-    - name: build Android app
-      run: ./android/gradlew assembleDebug -p android --no-daemon
+      - name: build Android app
+        run: ./android/gradlew assembleDebug -p android --no-daemon

-    - name: rename apk
-      working-directory: android/app/build/outputs/apk/debug/
-      run: |
-        build="$(date +%Y%m%d-%H%M%S)-$(git rev-parse --short HEAD)"
-        name="audiobookshelf-${build}.apk"
-        mv -v app-debug.apk "${name}"
+      - name: rename apk
+        working-directory: android/app/build/outputs/apk/debug/
+        run: |
+          build="$(date +%Y%m%d-%H%M%S)-$(git rev-parse --short HEAD)"
+          name="audiobookshelf-${build}.apk"
+          mv -v app-debug.apk "${name}"

-    - name: upload app
-      uses: actions/upload-artifact@v3
-      with:
-        name: audiobookshelf-apk
-        path: android/app/build/outputs/apk/debug/*.apk
+      - name: upload app
+        uses: actions/upload-artifact@v4
+        with:
+          name: audiobookshelf-apk
+          path: android/app/build/outputs/apk/debug/*.apk
@@ -0,0 +1,68 @@
+name: Build iOS
+
+on:
+  push:
+    paths-ignore:
+      - 'android/**'
+      - '.github/workflows/build-apk.yml'
+      - '.github/workflows/deploy-apk.yml'
+      - 'readme.md'
+  pull_request:
+    paths-ignore:
+      - 'android/**'
+      - '.github/workflows/build-apk.yml'
+      - '.github/workflows/deploy-apk.yml'
+      - 'readme.md'
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: Build iOS simulator app
+    runs-on: macos-latest
+    steps:
+      - name: Check out sources
+        uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: npm
+
+      - name: Install JavaScript dependencies
+        run: npm ci --omit=optional
+
+      - name: Build shared web app
+        run: npm run generate
+
+      - name: Sync Capacitor iOS project
+        run: npx cap sync ios
+
+      - name: Install CocoaPods dependencies
+        working-directory: ios/App
+        run: pod install --deployment
+
+      - name: Build iOS simulator app
+        working-directory: ios/App
+        run: |
+          xcodebuild -quiet \
+            -workspace App.xcworkspace \
+            -scheme App \
+            -configuration Debug \
+            -sdk iphonesimulator \
+            -destination 'generic/platform=iOS Simulator' \
+            -derivedDataPath build \
+            ASSETCATALOG_COMPILER_APPICON_NAME=IconsDebug \
+            CODE_SIGNING_ALLOWED=NO \
+            build
+
+          echo "iOS simulator build succeeded."
+
+      - name: Upload iOS simulator app
+        uses: actions/upload-artifact@v4
+        with:
+          name: audiobookshelf-ios-simulator
+          path: ios/App/build/Build/Products/Debug-iphonesimulator/Audiobookshelf.app
+          if-no-files-found: error
@@ -0,0 +1,20 @@
+name: Close fixed issues on release.
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+  issues: write
+
+jobs:
+  comment:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Close issues marked as fixed upon a release.
+        uses: gcampbell-msft/fixed-pending-release@7fa1b75a0c04bcd4b375110522878e5f6100cff5
+        with:
+          label: 'awaiting release'
+          removeLabel: true
+          applyToAll: true
+          message: Fixed in [${releaseTag}](${releaseUrl}).
@@ -0,0 +1,42 @@
+name: Close Issues not using a template
+
+on:
+  issues:
+    types:
+      - opened
+
+permissions:
+  issues: write
+
+jobs:
+  close_issue:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check issue headings
+        uses: actions/github-script@v6
+        with:
+          script: |
+            const issueBody = context.payload.issue.body || "";
+            
+            // Match Markdown headings (e.g., # Heading, ## Heading)
+            const headingRegex = /^(#{1,6})\s.+/gm;
+            const headings = [...issueBody.matchAll(headingRegex)];
+
+            if (headings.length < 3) {
+              // Post a comment
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.payload.issue.number,
+                body: "Thank you for opening an issue! To help us review your request efficiently, please use one of the provided issue templates. If you're seeking information or have a general question, consider opening a Discussion or joining the conversation on our Discord. Thanks!"
+              });
+
+              // Close the issue
+              await github.rest.issues.update({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.payload.issue.number,
+                state: "closed"
+              });
+            }
@@ -12,57 +12,57 @@ jobs:
  build:
    runs-on: ubuntu-latest
    steps:
-    - name: checkout sources
-      uses: actions/checkout@v3
+      - name: checkout sources
+        uses: actions/checkout@v3

-    - name: use Node.js 20.x
-      uses: actions/setup-node@v3
-      with:
-        node-version: 20
+      - name: use Node.js 20.x
+        uses: actions/setup-node@v3
+        with:
+          node-version: 20

-    - name: Set up Java
-      uses: actions/setup-java@v2
-      with:
-        distribution: "temurin"
-        java-version: 17
+      - name: Set up Java
+        uses: actions/setup-java@v2
+        with:
+          distribution: 'temurin'
+          java-version: 21

-    - name: install dependencies
-      run: npm ci
+      - name: install dependencies
+        run: npm ci --omit=optional

-    - name: build Nuxt project
-      run: npm run generate
+      - name: build Nuxt project
+        run: npm run generate

-    - name: copy to Android project
-      run: npx cap sync
+      - name: copy to Android project
+        run: npx cap sync

-    - name: build Android app
-      run: ./android/gradlew assembleDebug -p android --no-daemon
+      - name: build Android app
+        run: ./android/gradlew assembleDebug -p android --no-daemon

-    - name: rename apk
-      working-directory: android/app/build/outputs/apk/debug/
-      run: |
-        build="$(date +%Y%m%d-%H%M%S)-$(git rev-parse --short HEAD)"
-        name="audiobookshelf-${build}.apk"
-        mv -v app-debug.apk "${name}"
+      - name: rename apk
+        working-directory: android/app/build/outputs/apk/debug/
+        run: |
+          build="$(date +%Y%m%d-%H%M%S)-$(git rev-parse --short HEAD)"
+          name="audiobookshelf-${build}.apk"
+          mv -v app-debug.apk "${name}"

-    - name: prepare test page ressources
-      run: |
-        mkdir ghpages
-        cp android/app/build/outputs/apk/debug/*apk ghpages/
-        cp static/Logo.png ghpages/logo.png
-        cp .github/testing-page-template.html ghpages/index.html
+      - name: prepare test page ressources
+        run: |
+          mkdir ghpages
+          cp android/app/build/outputs/apk/debug/*apk ghpages/
+          cp static/Logo.png ghpages/logo.png
+          cp .github/testing-page-template.html ghpages/index.html

-    - name: build test page
-      working-directory: ghpages
-      run: |
-        sed -i "s/__DATE__/$(date)/g" index.html
-        sed -i "s/__COMMIT__/$(git rev-parse --short HEAD)/g" index.html
-        sed -i "s/__APK__/$(ls *apk)/g" index.html
+      - name: build test page
+        working-directory: ghpages
+        run: |
+          sed -i "s/__DATE__/$(date)/g" index.html
+          sed -i "s/__COMMIT__/$(git rev-parse --short HEAD)/g" index.html
+          sed -i "s/__APK__/$(ls *apk)/g" index.html

-    - name: upload test page artifact
-      uses: actions/upload-pages-artifact@v1
-      with:
-        path: ./ghpages
+      - name: upload test page artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: ./ghpages

  deploy:
    needs: build
@@ -79,4 +79,4 @@ jobs:
    steps:
      - name: deploy to GitHub Pages
        id: deployment
-        uses: actions/deploy-pages@v1
+        uses: actions/deploy-pages@v4
@@ -0,0 +1,28 @@
+name: Verify all i18n files are alphabetized
+
+on:
+  push:
+  pull_request:
+    paths:
+      - strings/** # Should only check if any strings changed
+
+jobs:
+  update_translations:
+    runs-on: ubuntu-latest
+    steps:
+    # Check out the repository
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Set up node to run the javascript
+    - name: Set up node
+      uses: actions/setup-node@v4
+      with:
+        node-version: '20'
+
+    # The only argument is the `directory`, which is where the i18n files are
+    # stored.
+    - name: Run Update JSON Files action
+      uses: audiobookshelf/audiobookshelf-i18n-updater@v1.3.0
+      with:
+        directory: 'strings/'  # Adjust the directory path as needed
@@ -0,0 +1,25 @@
+name: Prepare translation credits
+
+on:
+  push:
+    branches:
+      - master
+  workflow_dispatch:
+
+jobs:
+  release-notes:
+    if: github.event_name == 'workflow_dispatch' || contains(github.event.head_commit.message, 'weblate')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - id: translator-credits
+        uses: audiobookshelf/get-translator-credits@v1.1.0
+
+      - name: Show translator credits
+        run: |
+          printf '%s\n' "${{ steps.translator-credits.outputs.credits }}"
@@ -0,0 +1,17 @@
+{
+  "semi": false,
+  "singleQuote": true,
+  "printWidth": 400,
+  "proseWrap": "never",
+  "trailingComma": "none",
+  "overrides": [
+    {
+      "files": ["*.html"],
+      "options": {
+        "singleQuote": false,
+        "wrapAttributes": false,
+        "sortAttributes": false
+      }
+    }
+  ]
+}
@@ -0,0 +1,7 @@
+{
+  "recommendations": [
+    "EditorConfig.EditorConfig",
+    "esbenp.prettier-vscode",
+    "octref.vetur"
+  ]
+}
@@ -0,0 +1,27 @@
+{
+  "vetur.format.defaultFormatterOptions": {
+    "prettier": {
+      "semi": false,
+      "singleQuote": true,
+      "printWidth": 400,
+      "proseWrap": "never",
+      "trailingComma": "none"
+    },
+    "prettyhtml": {
+      "printWidth": 400,
+      "singleQuote": false,
+      "wrapAttributes": false,
+      "sortAttributes": false
+    }
+  },
+  "editor.formatOnSave": true,
+  "editor.detectIndentation": true,
+  "editor.tabSize": 2,
+  "javascript.format.semicolons": "remove",
+  "[javascript][json][jsonc]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[vue]": {
+    "editor.defaultFormatter": "octref.vetur"
+  }
+}
@@ -0,0 +1,6 @@
+{
+  "java.project.root": "android",
+  "java.import.gradle.enabled": true,
+  "java.import.gradle.wrapper.enabled": true,
+  "java.import.gradle.user.home": "${workspaceFolder}/.gradle"
+}
@@ -18,54 +18,55 @@ kotlin {
    "--add-opens=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED",
    "--add-opens=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED"
  ]
+
+  jvmToolchain(17)
 }

 android {
  namespace 'com.audiobookshelf.app'
  buildFeatures {
    viewBinding true
+    buildConfig true
  }
  kotlinOptions {
-      freeCompilerArgs = ['-Xjvm-default=all']
+    freeCompilerArgs = ['-Xjvm-default=all']
+  }
+  compileSdk rootProject.ext.compileSdkVersion
+  defaultConfig {
+    applicationId "com.audiobookshelf.app"
+    minSdkVersion rootProject.ext.minSdkVersion
+    targetSdkVersion rootProject.ext.targetSdkVersion
+    versionCode 121
+    versionName "0.14.2-beta"
+    testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    manifestPlaceholders = [
+      "appAuthRedirectScheme": "com.audiobookshelf.app"
+    ]
+    aaptOptions {
+      // Files and dirs to omit from the packaged assets dir, modified to accommodate modern web apps.
+      // Default: https://android.googlesource.com/platform/frameworks/base/+/282e181b58cf72b6ca770dc7ca5f91f135444502/tools/aapt/AaptAssets.cpp#61
+      ignoreAssetsPattern '!.svn:!.git:!.ds_store:!*.scc:.*:!CVS:!thumbs.db:!picasa.ini:!*~'
    }
-    compileSdkVersion rootProject.ext.compileSdkVersion
-    defaultConfig {
-        applicationId "com.audiobookshelf.app"
-        minSdkVersion rootProject.ext.minSdkVersion
-        targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 103
-        versionName "0.9.72-beta"
-        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
-        manifestPlaceholders = [
-          "appAuthRedirectScheme": "com.audiobookshelf.app"
-        ]
-        aaptOptions {
-             // Files and dirs to omit from the packaged assets dir, modified to accommodate modern web apps.
-             // Default: https://android.googlesource.com/platform/frameworks/base/+/282e181b58cf72b6ca770dc7ca5f91f135444502/tools/aapt/AaptAssets.cpp#61
-            ignoreAssetsPattern '!.svn:!.git:!.ds_store:!*.scc:.*:!CVS:!thumbs.db:!picasa.ini:!*~'
-        }
+  }
+  buildTypes {
+    debug {
+      applicationIdSuffix ".debug"
+      versionNameSuffix "-debug"
+      minifyEnabled false
+      proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
    }
-    buildTypes {
-        debug {
-          applicationIdSuffix ".debug"
-          versionNameSuffix "-debug"
-          minifyEnabled false
-          proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
-        }
-        release {
-            minifyEnabled false
-            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
-        }
+    release {
+      minifyEnabled false
+      proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
    }
+  }
 }

 repositories {
-    flatDir{
-        dirs '../capacitor-cordova-android-plugins/src/main/libs', 'libs'
-    }
+  flatDir {
+    dirs '../capacitor-cordova-android-plugins/src/main/libs', 'libs'
+  }
  mavenCentral()
-  // TODO: Temporarily using SNAPSHOT version of Simple Storage that resolves https://github.com/anggrayudi/SimpleStorage/issues/133
-  maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
 }

 configurations.configureEach {
@@ -80,19 +81,19 @@ configurations.configureEach {
 }

 dependencies {
-    implementation "androidx.core:core-splashscreen:$coreSplashScreenVersion"
+  implementation "androidx.core:core-splashscreen:$coreSplashScreenVersion"
  implementation fileTree(include: ['*.jar'], dir: 'libs')
  implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
  implementation project(':capacitor-android')

-  implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
+  implementation 'androidx.constraintlayout:constraintlayout:2.2.1'
  implementation "androidx.coordinatorlayout:coordinatorlayout:$androidxCoordinatorLayoutVersion"

  implementation project(':capacitor-cordova-android-plugins')

  implementation "androidx.core:core-ktx:$androidx_core_ktx_version"
+  implementation "androidx.work:work-runtime-ktx:2.9.1"

-  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version"
  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$kotlin_coroutines_version"

@@ -120,7 +121,7 @@ dependencies {
  implementation 'io.github.pilgr:paperdb:2.7.2'

  // Simple Storage
-  implementation "com.anggrayudi:storage:1.5.5-SNAPSHOT"
+  implementation "com.anggrayudi:storage:1.5.6"

  // OK HTTP
  implementation 'com.squareup.okhttp3:okhttp:4.9.2'
@@ -9,7 +9,9 @@ android {

 apply from: "../capacitor-cordova-android-plugins/cordova.variables.gradle"
 dependencies {
-    implementation project(':byteowls-capacitor-filesharer')
+    implementation project(':webnativellc-capacitor-filesharer')
+    implementation project(':capacitor-community-keep-awake')
+    implementation project(':capacitor-community-volume-buttons')
    implementation project(':capacitor-app')
    implementation project(':capacitor-browser')
    implementation project(':capacitor-clipboard')
@@ -6,11 +6,14 @@

    <!-- Permissions -->
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission
        android:name="android.permission.WRITE_EXTERNAL_STORAGE"
        android:maxSdkVersion="28" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />

    <application
        android:allowBackup="true"
@@ -35,6 +38,10 @@
          <meta-data
            android:name="android.appwidget.provider"
            android:resource="@xml/media_player_widget_info" />
+
+          <meta-data
+            android:name="com.samsung.android.appwidget.provider"
+            android:resource="@xml/samsung_cover_widget_info" />
        </receiver>

        <!-- Used by Android Auto -->
@@ -50,7 +57,7 @@

        <activity
            android:name=".MainActivity"
-            android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|smallestScreenSize|screenLayout|uiMode"
+            android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|smallestScreenSize|screenLayout|uiMode|navigation"
            android:exported="true"
            android:label="@string/title_activity_main"
            android:launchMode="singleTask"
@@ -93,6 +100,12 @@
            </intent-filter>
        </service>

+        <service
+            android:name=".services.DownloadService"
+            android:enabled="true"
+            android:exported="false"
+            android:foregroundServiceType="dataSync" />
+
        <provider
          android:name="androidx.core.content.FileProvider"
          android:authorities="${applicationId}.fileprovider"
@@ -2,10 +2,16 @@
 	"appId": "com.audiobookshelf.app",
 	"appName": "audiobookshelf-app",
 	"webDir": "dist",
-	"bundledWebRuntime": false,
 	"plugins": {
 		"CapacitorHttp": {
 			"enabled": false
+		},
+		"StatusBar": {
+			"backgroundColor": "#232323",
+			"style": "DARK"
 		}
+	},
+	"server": {
+		"androidScheme": "http"
 	}
 }
@@ -1,8 +1,16 @@
 [
 	{
-		"pkg": "@byteowls/capacitor-filesharer",
+		"pkg": "@webnativellc/capacitor-filesharer",
 		"classpath": "com.byteowls.capacitor.filesharer.FileSharerPlugin"
 	},
+	{
+		"pkg": "@capacitor-community/keep-awake",
+		"classpath": "com.getcapacitor.community.keepawake.KeepAwakePlugin"
+	},
+	{
+		"pkg": "@capacitor-community/volume-buttons",
+		"classpath": "com.ryltsov.alex.plugins.volume.buttons.VolumeButtonsPlugin"
+	},
 	{
 		"pkg": "@capacitor/app",
 		"classpath": "com.capacitorjs.plugins.app.AppPlugin"
@@ -6,10 +6,15 @@ import android.content.Context
 import android.content.Intent
 import android.content.ServiceConnection
 import android.content.pm.PackageManager
+import android.os.Build
 import android.os.Bundle
 import android.os.IBinder
 import android.util.Log
+import android.view.ViewGroup
+import android.view.WindowInsets
+import android.webkit.WebView
 import androidx.core.app.ActivityCompat
+import androidx.core.view.updateLayoutParams
 import com.anggrayudi.storage.SimpleStorage
 import com.anggrayudi.storage.SimpleStorageHelper
 import com.audiobookshelf.app.managers.DbManager
@@ -18,6 +23,7 @@ import com.audiobookshelf.app.plugins.AbsAudioPlayer
 import com.audiobookshelf.app.plugins.AbsDatabase
 import com.audiobookshelf.app.plugins.AbsDownloader
 import com.audiobookshelf.app.plugins.AbsFileSystem
+import com.audiobookshelf.app.plugins.AbsLogger
 import com.getcapacitor.BridgeActivity


@@ -34,40 +40,75 @@ class MainActivity : BridgeActivity() {
  val storage = SimpleStorage(this)

  val REQUEST_PERMISSIONS = 1
-  var PERMISSIONS_ALL = arrayOf(
-    Manifest.permission.READ_EXTERNAL_STORAGE
-  )

  public override fun onCreate(savedInstanceState: Bundle?) {
-    // TODO: Optimize using strict mode logs
-//    StrictMode.setThreadPolicy(StrictMode.ThreadPolicy.Builder()
-//      .detectDiskReads()
-//      .detectDiskWrites().detectAll()
-//      .detectNetwork() // or .detectAll() for all detectable problems
-//      .penaltyLog()
-//      .build())
-//    StrictMode.setVmPolicy(VmPolicy.Builder()
-//      .detectLeakedSqlLiteObjects()
-//      .detectLeakedClosableObjects()
-//      .penaltyLog()
-//      .build())
    DbManager.initialize(applicationContext)

    registerPlugin(AbsAudioPlayer::class.java)
    registerPlugin(AbsDownloader::class.java)
    registerPlugin(AbsFileSystem::class.java)
    registerPlugin(AbsDatabase::class.java)
+    registerPlugin(AbsLogger::class.java)

    super.onCreate(savedInstanceState)
    Log.d(tag, "onCreate")

+    // Update the margins to handle edge-to-edge enforced in SDK 35
+    // See: https://developer.android.com/develop/ui/views/layout/edge-to-edge
+    val webView: WebView = findViewById(R.id.webview)
+    webView.setOnApplyWindowInsetsListener { v, insets ->
+      val (left, top, right, bottom) = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+        val sysInsets = insets.getInsets(WindowInsets.Type.systemBars())
+        Log.d(tag, "safe sysInsets: $sysInsets")
+        arrayOf(sysInsets.left, sysInsets.top, sysInsets.right, sysInsets.bottom)
+      } else {
+        arrayOf(
+          insets.systemWindowInsetLeft,
+          insets.systemWindowInsetTop,
+          insets.systemWindowInsetRight,
+          insets.systemWindowInsetBottom
+        )
+      }

+      // Inject as CSS variables
+      // NOTE: Possibly able to use in the future to support edge-to-edge better.
+       val js = """
+       document.documentElement.style.setProperty('--safe-area-inset-top', '${top}px');
+       document.documentElement.style.setProperty('--safe-area-inset-bottom', '${bottom}px');
+       document.documentElement.style.setProperty('--safe-area-inset-left', '${left}px');
+       document.documentElement.style.setProperty('--safe-area-inset-right', '${right}px');
+      """.trimIndent()
+      webView.evaluateJavascript(js, null)

-    val permission = ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE)
-    if (permission != PackageManager.PERMISSION_GRANTED) {
-      ActivityCompat.requestPermissions(this,
-        PERMISSIONS_ALL,
-        REQUEST_PERMISSIONS)
+      // Set margins
+      v.updateLayoutParams<ViewGroup.MarginLayoutParams> {
+        leftMargin = left
+        bottomMargin = bottom
+        rightMargin = right
+        topMargin = top
+      }
+
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+        WindowInsets.CONSUMED
+      } else {
+        insets
+      }
+    }
+
+    requestNeededPermissions()
+  }
+
+  private fun requestNeededPermissions() {
+    val needed = mutableListOf<String>()
+    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
+      needed.add(Manifest.permission.READ_EXTERNAL_STORAGE)
+    }
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU &&
+            ActivityCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
+      needed.add(Manifest.permission.POST_NOTIFICATIONS)
+    }
+    if (needed.isNotEmpty()) {
+      ActivityCompat.requestPermissions(this, needed.toTypedArray(), REQUEST_PERMISSIONS)
    }
  }

@@ -103,6 +144,9 @@ class MainActivity : BridgeActivity() {
    }
  }

+  fun isPlayerNotificationServiceInitialized():Boolean {
+    return ::foregroundService.isInitialized
+  }

  fun stopMyService() {
    if (mBounded) {
@@ -1,74 +0,0 @@
-package com.audiobookshelf.app.data
-
-import com.fasterxml.jackson.annotation.JsonIgnore
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties
-
-@JsonIgnoreProperties(ignoreUnknown = true)
-data class AudioProbeStream(
-  val index:Int,
-  val codec_name:String,
-  val codec_long_name:String,
-  val channels:Int,
-  val channel_layout:String,
-  val duration:Double,
-  val bit_rate:Double
-)
-
-@JsonIgnoreProperties(ignoreUnknown = true)
-data class AudioProbeChapterTags(
-  val title:String
-)
-
-@JsonIgnoreProperties(ignoreUnknown = true)
-data class AudioProbeChapter(
-  val id:Int,
-  val start:Long,
-  val end:Long,
-  val tags:AudioProbeChapterTags?
-) {
-  @JsonIgnore
-  fun getBookChapter():BookChapter {
-    val startS = start / 1000.0
-    val endS = end / 1000.0
-    val title = tags?.title ?: "Chapter $id"
-    return BookChapter(id, startS, endS, title)
-  }
-}
-
-@JsonIgnoreProperties(ignoreUnknown = true)
-data class AudioProbeFormatTags(
-  val artist:String?,
-  val album:String?,
-  val comment:String?,
-  val date:String?,
-  val genre:String?,
-  val title:String?
-)
-
-@JsonIgnoreProperties(ignoreUnknown = true)
-data class AudioProbeFormat(
-  val filename:String,
-  val format_name:String,
-  val duration:Double,
-  val size:Long,
-  val bit_rate:Double,
-  val tags:AudioProbeFormatTags?
-)
-
-@JsonIgnoreProperties(ignoreUnknown = true)
-class AudioProbeResult (
-  val streams:MutableList<AudioProbeStream>,
-  val chapters:MutableList<AudioProbeChapter>,
-  val format:AudioProbeFormat) {
-
-  val duration get() = format.duration
-  val size get() = format.size
-  val title get() = format.tags?.title ?: format.filename.split("/").last()
-  val artist get() = format.tags?.artist ?: ""
-
-  @JsonIgnore
-  fun getBookChapters(): List<BookChapter> {
-    if (chapters.isEmpty()) return mutableListOf()
-    return chapters.map { it.getBookChapter() }
-  }
-}
@@ -5,30 +5,34 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties

@JsonIgnoreProperties(ignoreUnknown = true)
 data class AudioTrack(
-  var index:Int,
-  var startOffset:Double,
-  var duration:Double,
-  var title:String,
-  var contentUrl:String,
-  var mimeType:String,
-  var metadata:FileMetadata?,
-  var isLocal:Boolean,
-  var localFileId:String?,
-  var audioProbeResult:AudioProbeResult?,
-  var serverIndex:Int? // Need to know if server track index is different
+        var index: Int,
+        var startOffset: Double,
+        var duration: Double,
+        var title: String,
+        var contentUrl: String,
+        var mimeType: String?,
+        var metadata: FileMetadata?,
+        var isLocal: Boolean,
+        var localFileId: String?,
+        // TODO: This should no longer be necessary
+        var serverIndex: Int? // Need to know if server track index is different
 ) {

  @get:JsonIgnore
-  val startOffsetMs get() = (startOffset * 1000L).toLong()
+  val startOffsetMs
+    get() = (startOffset * 1000L).toLong()
  @get:JsonIgnore
-  val durationMs get() = (duration * 1000L).toLong()
+  val durationMs
+    get() = (duration * 1000L).toLong()
  @get:JsonIgnore
-  val endOffsetMs get() = startOffsetMs + durationMs
+  val endOffsetMs
+    get() = startOffsetMs + durationMs
  @get:JsonIgnore
-  val relPath get() = metadata?.relPath ?: ""
+  val relPath
+    get() = metadata?.relPath ?: ""

  @JsonIgnore
-  fun getBookChapter():BookChapter {
-    return BookChapter(index + 1,startOffset, startOffset + duration, title)
+  fun getBookChapter(): BookChapter {
+    return BookChapter(index + 1, startOffset, startOffset + duration, title)
  }
 }
@@ -0,0 +1,36 @@
+package com.audiobookshelf.app.data
+
+import android.content.Context
+import android.os.Bundle
+import android.support.v4.media.MediaDescriptionCompat
+import com.fasterxml.jackson.annotation.JsonIgnore
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+class CollapsedSeries(
+  id:String,
+  var libraryId:String?,
+  var name:String,
+  //var nameIgnorePrefix:String,
+  var sequence:String?,
+  var libraryItemIds:MutableList<String>
+) : LibraryItemWrapper(id) {
+  @get:JsonIgnore
+  val title get() = name
+  @get:JsonIgnore
+  val numBooks get() = libraryItemIds.size
+
+  @JsonIgnore
+  override fun getMediaDescription(progress:MediaProgressWrapper?, ctx: Context): MediaDescriptionCompat {
+    val extras = Bundle()
+
+    val mediaId = "__LIBRARY__${libraryId}__SERIE__${id}"
+    return MediaDescriptionCompat.Builder()
+      .setMediaId(mediaId)
+      .setTitle(title)
+      //.setIconUri(getCoverUri())
+      .setSubtitle("${numBooks} books")
+      .setExtras(extras)
+      .build()
+  }
+}
@@ -1,12 +1,15 @@
 package com.audiobookshelf.app.data

 import android.content.Context
+import android.icu.text.DateFormat
 import android.os.Bundle
 import android.support.v4.media.MediaDescriptionCompat
 import android.support.v4.media.MediaMetadataCompat
 import androidx.media.utils.MediaConstants
 import com.audiobookshelf.app.media.MediaManager
 import com.fasterxml.jackson.annotation.*
+import com.audiobookshelf.app.media.getUriToAbsIconDrawable
+import java.util.Date

 // This auto-detects whether it is a Book or Podcast
@JsonTypeInfo(use=JsonTypeInfo.Id.DEDUCTION)
@@ -25,7 +28,8 @@ open class MediaType(var metadata:MediaTypeMetadata, var coverPath:String?) {
  open fun removeAudioTrack(localFileId:String) { }
  @JsonIgnore
  open fun getLocalCopy():MediaType { return MediaType(MediaTypeMetadata("", false),null) }
-
+  @JsonIgnore
+  open fun checkHasTracks():Boolean { return false }
 }

@JsonIgnoreProperties(ignoreUnknown = true)
@@ -93,10 +97,15 @@ class Podcast(
    return Podcast(metadata as PodcastMetadata,coverPath,tags, mutableListOf(),autoDownloadEpisodes, 0)
  }

+  @JsonIgnore
+  override fun checkHasTracks():Boolean {
+    return (episodes?.size ?: numEpisodes ?: 0) > 0
+  }
+
  @JsonIgnore
  fun addEpisode(audioTrack:AudioTrack, episode:PodcastEpisode):PodcastEpisode {
    val localEpisodeId = "local_ep_" + episode.id
-    val newEpisode = PodcastEpisode(localEpisodeId,(episodes?.size ?: 0) + 1,episode.episode,episode.episodeType,episode.title,episode.subtitle,episode.description,null,null,null,audioTrack,episode.chapters,audioTrack.duration,0, episode.id, localEpisodeId)
+    val newEpisode = PodcastEpisode(localEpisodeId,(episodes?.size ?: 0) + 1,episode.episode,episode.episodeType,episode.title,episode.subtitle,episode.description,null,null,null,audioTrack,episode.chapters,audioTrack.duration,episode.size, episode.id, localEpisodeId)
    episodes?.add(newEpisode)

    var index = 1
@@ -182,6 +191,11 @@ class Book(
  override fun getLocalCopy(): Book {
    return Book(metadata as BookMetadata,coverPath,tags, mutableListOf(),chapters,mutableListOf(), ebookFile, null,null, 0)
  }
+
+  @JsonIgnore
+  override fun checkHasTracks():Boolean {
+    return (tracks?.size ?: numTracks ?: 0) > 0
+  }
 }

 // This auto-detects whether it is a BookMetadata or PodcastMetadata
@@ -214,7 +228,9 @@ class BookMetadata(
  var authorName:String?,
  var authorNameLF:String?,
  var narratorName:String?,
-  var seriesName:String?
+  var seriesName:String?,
+  @JsonFormat(with=[JsonFormat.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY])
+  var series:List<SeriesType>?
 ) : MediaTypeMetadata(title, explicit) {
  @JsonIgnore
  override fun getAuthorDisplayName():String { return authorName ?: "Unknown" }
@@ -299,11 +315,18 @@ data class PodcastEpisode(

    val libraryItemDescription = libraryItem.getMediaDescription(null, ctx)
    val mediaId = localEpisodeId ?: id
+    var subtitle = libraryItemDescription.title
+    if (publishedAt !== null) {
+      val sdf = DateFormat.getDateInstance()
+      val publishedAtDT = Date(publishedAt!!)
+      subtitle = "${sdf.format(publishedAtDT)} / $subtitle"
+    }
+
    val mediaDescriptionBuilder = MediaDescriptionCompat.Builder()
      .setMediaId(mediaId)
      .setTitle(title)
      .setIconUri(coverUri)
-      .setSubtitle(libraryItemDescription.title)
+      .setSubtitle(subtitle)
      .setExtras(extras)

    libraryItemDescription.iconBitmap?.let {
@@ -342,18 +365,39 @@ data class Library(
  var name:String,
  var folders:MutableList<Folder>,
  var icon:String,
-  var mediaType:String
+  var mediaType:String,
+  var stats: LibraryStats?
 ) {
  @JsonIgnore
-  fun getMediaMetadata(): MediaMetadataCompat {
+  fun getMediaMetadata(context: Context, targetType: String? = null): MediaMetadataCompat {
+    var mediaId = id
+    if (targetType !== null) {
+      mediaId = "__RECENTLY__$id"
+    }
    return MediaMetadataCompat.Builder().apply {
-      putString(MediaMetadataCompat.METADATA_KEY_MEDIA_ID, id)
+      putString(MediaMetadataCompat.METADATA_KEY_MEDIA_ID, mediaId)
      putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_TITLE, name)
      putString(MediaMetadataCompat.METADATA_KEY_TITLE, name)
+      putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI, getUriToAbsIconDrawable(context, icon).toString())
    }.build()
  }
 }

+@JsonIgnoreProperties(ignoreUnknown = true)
+data class LibraryStats(
+  var totalItems: Int,
+  var totalSize: Long,
+  var totalDuration: Double,
+  var numAudioFiles: Int
+)
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class SeriesType(
+  var id: String,
+  var name: String,
+  var sequence: String?
+)
+
@JsonIgnoreProperties(ignoreUnknown = true)
 data class Folder(
  var id:String,
@@ -387,3 +431,84 @@ data class LibraryItemWithEpisode(
  var libraryItemWrapper:LibraryItemWrapper,
  var episode:PodcastEpisode
 )
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class LibraryItemSearchResultSeriesItemType(
+  var series: LibrarySeriesItem,
+  var books: List<LibraryItem>?
+)
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class LibraryItemSearchResultLibraryItemType(
+  val libraryItem: LibraryItem
+)
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class LibraryItemSearchResultType(
+  var book:List<LibraryItemSearchResultLibraryItemType>?,
+  var podcast:List<LibraryItemSearchResultLibraryItemType>?,
+  var series:List<LibraryItemSearchResultSeriesItemType>?,
+  var authors:List<LibraryAuthorItem>?
+)
+
+// For personalized shelves
+@JsonTypeInfo(
+  use=JsonTypeInfo.Id.NAME,
+  property = "type",
+  include = JsonTypeInfo.As.PROPERTY,
+  visible = true
+)
+@JsonSubTypes(
+  JsonSubTypes.Type(LibraryShelfBookEntity::class, name = "book"),
+  JsonSubTypes.Type(LibraryShelfSeriesEntity::class, name = "series"),
+  JsonSubTypes.Type(LibraryShelfAuthorEntity::class, name = "authors"),
+  JsonSubTypes.Type(LibraryShelfEpisodeEntity::class, name = "episode"),
+  JsonSubTypes.Type(LibraryShelfPodcastEntity::class, name = "podcast")
+)
+@JsonIgnoreProperties(ignoreUnknown = true)
+sealed class LibraryShelfType(
+  open val id: String,
+  open val label: String,
+  open val total: Int,
+  open val type: String,
+)
+
+data class LibraryShelfBookEntity(
+  override val id: String,
+  override val label: String,
+  override val total: Int,
+  override val type: String,
+  val entities: List<LibraryItem>?
+) : LibraryShelfType(id, label, total, type)
+
+data class LibraryShelfSeriesEntity(
+  override val id: String,
+  override val label: String,
+  override val total: Int,
+  override val type: String,
+  val entities: List<LibrarySeriesItem>?
+) :  LibraryShelfType(id, label, total, type)
+
+data class LibraryShelfAuthorEntity(
+  override val id: String,
+  override val label: String,
+  override val total: Int,
+  override val type: String,
+  val entities: List<LibraryAuthorItem>?
+) :  LibraryShelfType(id, label, total, type)
+
+data class LibraryShelfEpisodeEntity(
+  override val id: String,
+  override val label: String,
+  override val total: Int,
+  override val type: String,
+  val entities: List<LibraryItem>?
+) :  LibraryShelfType(id, label, total, type)
+
+data class LibraryShelfPodcastEntity(
+  override val id: String,
+  override val label: String,
+  override val total: Int,
+  override val type: String,
+  val entities: List<LibraryItem>?
+) :  LibraryShelfType(id, label, total, type)
@@ -1,59 +1,102 @@
 package com.audiobookshelf.app.data

 import android.content.Context
+import android.net.Uri
 import android.support.v4.media.MediaDescriptionCompat
 import android.util.Log
 import com.fasterxml.jackson.annotation.JsonIgnore
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties
 import com.fasterxml.jackson.annotation.JsonSubTypes
 import com.fasterxml.jackson.annotation.JsonTypeInfo
+import java.io.File

 enum class LockOrientationSetting {
-  NONE, PORTRAIT, LANDSCAPE
+  NONE,
+  PORTRAIT,
+  LANDSCAPE
 }

 enum class HapticFeedbackSetting {
-  OFF, LIGHT, MEDIUM, HEAVY
+  OFF,
+  LIGHT,
+  MEDIUM,
+  HEAVY
 }

 enum class ShakeSensitivitySetting {
-  VERY_LOW, LOW, MEDIUM, HIGH, VERY_HIGH
+  VERY_LOW,
+  LOW,
+  MEDIUM,
+  HIGH,
+  VERY_HIGH
 }

+enum class DownloadUsingCellularSetting {
+  ASK,
+  ALWAYS,
+  NEVER
+}
+
+enum class StreamingUsingCellularSetting {
+  ASK,
+  ALWAYS,
+  NEVER
+}
+
+enum class AndroidAutoBrowseSeriesSequenceOrderSetting {
+  ASC,
+  DESC
+}
+
+@JsonIgnoreProperties(ignoreUnknown = true)
 data class ServerConnectionConfig(
-  var id:String,
-  var index:Int,
-  var name:String,
-  var address:String,
-  var userId:String,
-  var username:String,
-  var token:String,
-  var customHeaders:Map<String, String>?
+        var id: String,
+        var index: Int,
+        var name: String,
+        var address: String,
+        // version added after 0.9.81-beta
+        var version: String?,
+        var userId: String,
+        var username: String,
+        var token: String,
+        var customHeaders: Map<String, String>?
 )

@JsonIgnoreProperties(ignoreUnknown = true)
 data class LocalFile(
-  var id:String,
-  var filename:String?,
-  var contentUrl:String,
-  var basePath:String,
-  var absolutePath:String,
-  var simplePath:String,
-  var mimeType:String?,
-  var size:Long
+        var id: String,
+        var filename: String?,
+        var contentUrl: String,
+        var basePath: String,
+        var absolutePath: String,
+        var mimeType: String?,
+        var size: Long
 ) {
  @JsonIgnore
-  fun isAudioFile():Boolean {
+  fun exists(ctx: Context): Boolean {
+    if (contentUrl.startsWith("content:")) {
+      return try {
+        ctx.contentResolver.openFileDescriptor(Uri.parse(contentUrl), "r")?.use { true } ?: false
+      } catch (e: Exception) {
+        Log.w("LocalFile", "Cannot access SAF file $contentUrl", e)
+        false
+      }
+    }
+    return File(absolutePath).exists()
+  }
+
+  @JsonIgnore
+  fun isAudioFile(): Boolean {
    if (mimeType == "application/octet-stream") return true
    if (mimeType == "video/mp4") return true
    return mimeType?.startsWith("audio") == true
  }
  @JsonIgnore
-  fun isEBookFile():Boolean {
+  fun isEBookFile(): Boolean {
    return getEBookFormat() != null
  }
  @JsonIgnore
-  fun getEBookFormat():String? {
+  fun getEBookFormat(): String? {
    if (mimeType == "application/epub+zip") return "epub"
    if (mimeType == "application/pdf") return "pdf"
    if (mimeType == "application/x-mobipocket-ebook") return "mobi"
@@ -66,109 +109,127 @@ data class LocalFile(

@JsonIgnoreProperties(ignoreUnknown = true)
 data class LocalFolder(
-  var id:String,
-  var name:String,
-  var contentUrl:String,
-  var basePath:String,
-  var absolutePath:String,
-  var simplePath:String,
-  var storageType:String,
-  var mediaType:String
+        var id: String,
+        var name: String,
+        var contentUrl: String,
+        var basePath: String,
+        var absolutePath: String,
+        var storageType: String,
+        var mediaType: String
 )

-@JsonTypeInfo(use= JsonTypeInfo.Id.DEDUCTION)
-@JsonSubTypes(
-  JsonSubTypes.Type(LibraryItem::class),
-  JsonSubTypes.Type(LocalLibraryItem::class)
-)
-open class LibraryItemWrapper(var id:String) {
+@JsonTypeInfo(use = JsonTypeInfo.Id.DEDUCTION)
+@JsonSubTypes(JsonSubTypes.Type(LibraryItem::class), JsonSubTypes.Type(LocalLibraryItem::class))
+open class LibraryItemWrapper(var id: String) {
  @JsonIgnore
-  open fun getMediaDescription(progress:MediaProgressWrapper?, ctx: Context): MediaDescriptionCompat { return MediaDescriptionCompat.Builder().build() }
+  open fun getMediaDescription(
+          progress: MediaProgressWrapper?,
+          ctx: Context
+  ): MediaDescriptionCompat {
+    return MediaDescriptionCompat.Builder().build()
+  }
 }

@JsonIgnoreProperties(ignoreUnknown = true)
 data class DeviceInfo(
-  var deviceId:String,
-  var manufacturer:String,
-  var model:String,
-  var sdkVersion:Int,
-  var clientVersion: String
+        var deviceId: String,
+        var manufacturer: String,
+        var model: String,
+        var sdkVersion: Int,
+        var clientVersion: String
 )

@JsonIgnoreProperties(ignoreUnknown = true)
 data class PlayItemRequestPayload(
-  var mediaPlayer:String,
-  var forceDirectPlay:Boolean,
-  var forceTranscode:Boolean,
-  var deviceInfo:DeviceInfo
+        var mediaPlayer: String,
+        var forceDirectPlay: Boolean,
+        var forceTranscode: Boolean,
+        var deviceInfo: DeviceInfo
 )

@JsonIgnoreProperties(ignoreUnknown = true)
 data class DeviceSettings(
-  var disableAutoRewind:Boolean,
-  var enableAltView:Boolean,
-  var jumpBackwardsTime:Int,
-  var jumpForwardTime:Int,
-  var enableMp3IndexSeeking:Boolean,
-  var disableShakeToResetSleepTimer:Boolean,
-  var shakeSensitivity: ShakeSensitivitySetting,
-  var lockOrientation: LockOrientationSetting,
-  var hapticFeedback: HapticFeedbackSetting,
-  var autoSleepTimer: Boolean,
-  var autoSleepTimerStartTime: String,
-  var autoSleepTimerEndTime: String,
-  var autoSleepTimerAutoRewind: Boolean,
-  var autoSleepTimerAutoRewindTime: Long, //Time in milliseconds
-  var sleepTimerLength: Long, // Time in milliseconds
-  var disableSleepTimerFadeOut: Boolean,
-  var disableSleepTimerResetFeedback: Boolean,
-  var languageCode: String
+        var disableAutoRewind: Boolean,
+        var enableAltView: Boolean,
+        var allowSeekingOnMediaControls: Boolean,
+        var jumpBackwardsTime: Int,
+        var jumpForwardTime: Int,
+        var enableMp3IndexSeeking: Boolean,
+        var disableShakeToResetSleepTimer: Boolean,
+        var shakeSensitivity: ShakeSensitivitySetting,
+        var lockOrientation: LockOrientationSetting,
+        var hapticFeedback: HapticFeedbackSetting,
+        var autoSleepTimer: Boolean,
+        var autoSleepTimerStartTime: String,
+        var autoSleepTimerEndTime: String,
+        var autoSleepTimerAutoRewind: Boolean,
+        var autoSleepTimerAutoRewindTime: Long, // Time in milliseconds
+        var sleepTimerLength: Long, // Time in milliseconds
+        var disableSleepTimerFadeOut: Boolean,
+        var disableSleepTimerResetFeedback: Boolean,
+        var enableSleepTimerAlmostDoneChime: Boolean,
+        var languageCode: String,
+        var downloadUsingCellular: DownloadUsingCellularSetting,
+        var streamingUsingCellular: StreamingUsingCellularSetting,
+        var androidAutoBrowseLimitForGrouping: Int,
+        var androidAutoBrowseSeriesSequenceOrder: AndroidAutoBrowseSeriesSequenceOrderSetting
 ) {
  companion object {
    // Static method to get default device settings
-    fun default():DeviceSettings {
+    fun default(): DeviceSettings {
      return DeviceSettings(
-        disableAutoRewind = false,
-        enableAltView = true,
-        jumpBackwardsTime = 10,
-        jumpForwardTime = 10,
-        enableMp3IndexSeeking = false,
-        disableShakeToResetSleepTimer = false,
-        shakeSensitivity = ShakeSensitivitySetting.MEDIUM,
-        lockOrientation = LockOrientationSetting.NONE,
-        hapticFeedback = HapticFeedbackSetting.LIGHT,
-        autoSleepTimer = false,
-        autoSleepTimerStartTime = "22:00",
-        autoSleepTimerEndTime = "06:00",
-        sleepTimerLength = 900000L, // 15 minutes
-        autoSleepTimerAutoRewind = false,
-        autoSleepTimerAutoRewindTime = 300000L, // 5 minutes
-        disableSleepTimerFadeOut = false,
-        disableSleepTimerResetFeedback = false,
-        languageCode = "en-us"
+              disableAutoRewind = false,
+              enableAltView = true,
+              allowSeekingOnMediaControls = false,
+              jumpBackwardsTime = 10,
+              jumpForwardTime = 10,
+              enableMp3IndexSeeking = false,
+              disableShakeToResetSleepTimer = false,
+              shakeSensitivity = ShakeSensitivitySetting.MEDIUM,
+              lockOrientation = LockOrientationSetting.NONE,
+              hapticFeedback = HapticFeedbackSetting.LIGHT,
+              autoSleepTimer = false,
+              autoSleepTimerStartTime = "22:00",
+              autoSleepTimerEndTime = "06:00",
+              sleepTimerLength = 900000L, // 15 minutes
+              autoSleepTimerAutoRewind = false,
+              autoSleepTimerAutoRewindTime = 300000L, // 5 minutes
+              disableSleepTimerFadeOut = false,
+              disableSleepTimerResetFeedback = false,
+              enableSleepTimerAlmostDoneChime = false,
+              languageCode = "en-us",
+              downloadUsingCellular = DownloadUsingCellularSetting.ALWAYS,
+              streamingUsingCellular = StreamingUsingCellularSetting.ALWAYS,
+              androidAutoBrowseLimitForGrouping = 100,
+              androidAutoBrowseSeriesSequenceOrder = AndroidAutoBrowseSeriesSequenceOrderSetting.ASC
      )
    }
  }

  @get:JsonIgnore
-  val jumpBackwardsTimeMs get() = jumpBackwardsTime * 1000L
+  val jumpBackwardsTimeMs
+    get() = jumpBackwardsTime * 1000L
  @get:JsonIgnore
-  val jumpForwardTimeMs get() = jumpForwardTime * 1000L
+  val jumpForwardTimeMs
+    get() = jumpForwardTime * 1000L
  @get:JsonIgnore
-  val autoSleepTimerStartHour get() = autoSleepTimerStartTime.split(":")[0].toInt()
+  val autoSleepTimerStartHour
+    get() = autoSleepTimerStartTime.split(":")[0].toInt()
  @get:JsonIgnore
-  val autoSleepTimerStartMinute get() = autoSleepTimerStartTime.split(":")[1].toInt()
+  val autoSleepTimerStartMinute
+    get() = autoSleepTimerStartTime.split(":")[1].toInt()
  @get:JsonIgnore
-  val autoSleepTimerEndHour get() = autoSleepTimerEndTime.split(":")[0].toInt()
+  val autoSleepTimerEndHour
+    get() = autoSleepTimerEndTime.split(":")[0].toInt()
  @get:JsonIgnore
-  val autoSleepTimerEndMinute get() = autoSleepTimerEndTime.split(":")[1].toInt()
-
+  val autoSleepTimerEndMinute
+    get() = autoSleepTimerEndTime.split(":")[1].toInt()

  @JsonIgnore
-  fun getShakeThresholdGravity() : Float { // Used in ShakeDetector
-    return if (shakeSensitivity == ShakeSensitivitySetting.VERY_HIGH) 1.2f
-    else if (shakeSensitivity == ShakeSensitivitySetting.HIGH) 1.4f
-    else if (shakeSensitivity == ShakeSensitivitySetting.MEDIUM) 1.6f
+  fun getShakeThresholdGravity(): Float { // Used in ShakeDetector
+    return if (shakeSensitivity == ShakeSensitivitySetting.VERY_HIGH) 1.1f
+    else if (shakeSensitivity == ShakeSensitivitySetting.HIGH) 1.3f
+    else if (shakeSensitivity == ShakeSensitivitySetting.MEDIUM) 1.5f
    else if (shakeSensitivity == ShakeSensitivitySetting.LOW) 2f
    else if (shakeSensitivity == ShakeSensitivitySetting.VERY_LOW) 2.7f
    else {
@@ -179,10 +240,10 @@ data class DeviceSettings(
 }

 data class DeviceData(
-  var serverConnectionConfigs:MutableList<ServerConnectionConfig>,
-  var lastServerConnectionConfigId:String?,
-  var deviceSettings: DeviceSettings?,
-  var lastPlaybackSession: PlaybackSession?
+        var serverConnectionConfigs: MutableList<ServerConnectionConfig>,
+        var lastServerConnectionConfigId: String?,
+        var deviceSettings: DeviceSettings?,
+        var lastPlaybackSession: PlaybackSession?
 ) {
  @JsonIgnore
  fun getLastServerConnectionConfig(): ServerConnectionConfig? {
@@ -191,4 +252,3 @@ data class DeviceData(
    }
  }
 }
-
@@ -1,15 +0,0 @@
-package com.audiobookshelf.app.data
-
-data class FolderScanResult(
-  var itemsAdded:Int,
-  var itemsUpdated:Int,
-  var itemsRemoved:Int,
-  var itemsUpToDate:Int,
-  val localFolder:LocalFolder,
-  val localLibraryItems:List<LocalLibraryItem>,
-)
-
-data class LocalLibraryItemScanResult(
-  val updated:Boolean,
-  val localLibraryItem:LocalLibraryItem,
-)
@@ -5,8 +5,7 @@
 package com.audiobookshelf.app.data

 import com.fasterxml.jackson.annotation.JsonIgnoreProperties
-import com.fasterxml.jackson.core.json.JsonReadFeature
-import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.module.kotlin.readValue
 import org.json.JSONObject

@@ -18,8 +17,7 @@ data class ItemInProgress(
  val isLocal: Boolean
 ) {
  companion object {
-    fun makeFromServerObject(serverItem: JSONObject):ItemInProgress {
-      val jacksonMapper = jacksonObjectMapper().enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature())
+    fun makeFromServerObject(serverItem: JSONObject, jacksonMapper: ObjectMapper):ItemInProgress {
      val libraryItem = jacksonMapper.readValue<LibraryItem>(serverItem.toString())

      var episode:PodcastEpisode? = null
@@ -0,0 +1,63 @@
+package com.audiobookshelf.app.data
+
+import android.content.Context
+import android.net.Uri
+import android.os.Bundle
+import android.support.v4.media.MediaDescriptionCompat
+import androidx.media.utils.MediaConstants
+import com.audiobookshelf.app.BuildConfig
+import com.audiobookshelf.app.R
+import com.audiobookshelf.app.device.DeviceManager
+import com.fasterxml.jackson.annotation.JsonIgnore
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+class LibraryAuthorItem(
+  id:String,
+  var libraryId:String,
+  var name:String,
+  var description:String?,
+  var imagePath:String?,
+  var addedAt:Long,
+  var updatedAt:Long,
+  var numBooks:Int?,
+  var libraryItems:MutableList<LibraryItem>?,
+  var series:MutableList<LibrarySeriesItem>?
+) : LibraryItemWrapper(id) {
+  @get:JsonIgnore
+  val title get() = name
+
+  @get:JsonIgnore
+  val bookCount get() = if (numBooks != null) numBooks else libraryItems!!.size
+
+  @JsonIgnore
+  fun getPortraitUri(): Uri {
+    if (imagePath == null) {
+      return Uri.parse("android.resource://${BuildConfig.APPLICATION_ID}/" + R.drawable.md_account_outline)
+    }
+
+    return Uri.parse("${DeviceManager.serverAddress}/api/authors/$id/image?token=${DeviceManager.token}")
+  }
+
+  @JsonIgnore
+  fun getMediaDescription(progress:MediaProgressWrapper?, ctx: Context, groupTitle: String?): MediaDescriptionCompat {
+    val extras = Bundle()
+    if (groupTitle !== null) {
+      extras.putString(MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_GROUP_TITLE, groupTitle)
+    }
+
+    val mediaId = "__LIBRARY__${libraryId}__AUTHOR__${id}"
+    return MediaDescriptionCompat.Builder()
+      .setMediaId(mediaId)
+      .setTitle(title)
+      .setIconUri(getPortraitUri())
+      .setSubtitle("${bookCount} books")
+      .setExtras(extras)
+      .build()
+  }
+
+  @JsonIgnore
+  override fun getMediaDescription(progress:MediaProgressWrapper?, ctx: Context): MediaDescriptionCompat {
+    return getMediaDescription(progress, ctx, null)
+  }
+}
@@ -0,0 +1,40 @@
+package com.audiobookshelf.app.data
+
+import android.content.Context
+import android.os.Bundle
+import android.support.v4.media.MediaDescriptionCompat
+import com.fasterxml.jackson.annotation.JsonIgnore
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+class LibraryCollection(
+  id:String,
+  var libraryId:String,
+  var name:String,
+  //var userId:String?,
+  var description:String?,
+  var books:MutableList<LibraryItem>?,
+) : LibraryItemWrapper(id) {
+  @get:JsonIgnore
+  val title get() = name
+
+  @get:JsonIgnore
+  val bookCount get() = if (books != null) books!!.size else 0
+
+  @get:JsonIgnore
+  val audiobookCount get() = books?.filter { book -> (book.media as Book).getAudioTracks().isNotEmpty() }?.size ?: 0
+
+  @JsonIgnore
+  override fun getMediaDescription(progress:MediaProgressWrapper?, ctx: Context): MediaDescriptionCompat {
+    val extras = Bundle()
+
+    val mediaId = "__LIBRARY__${libraryId}__COLLECTION__${id}"
+    return MediaDescriptionCompat.Builder()
+      .setMediaId(mediaId)
+      .setTitle(title)
+      //.setIconUri(getCoverUri())
+      .setSubtitle("${bookCount} books")
+      .setExtras(extras)
+      .build()
+  }
+}
@@ -32,10 +32,18 @@ class LibraryItem(
  var media:MediaType,
  var libraryFiles:MutableList<LibraryFile>?,
  var userMediaProgress:MediaProgress?, // Only included when requesting library item with progress (for downloads)
-  var localLibraryItemId:String? // For Android Auto
+  var collapsedSeries: CollapsedSeries?,
+  var localLibraryItemId:String?, // For Android Auto
+  val recentEpisode: PodcastEpisode?  // Podcast episode shelf uses this
 ) : LibraryItemWrapper(id) {
  @get:JsonIgnore
-  val title get() = media.metadata.title
+  val title: String
+    get() {
+      if (collapsedSeries != null) {
+        return collapsedSeries!!.title
+      }
+      return media.metadata.title
+    }
  @get:JsonIgnore
  val authorName get() = media.metadata.getAuthorDisplayName()

@@ -45,62 +53,126 @@ class LibraryItem(
      return Uri.parse("android.resource://${BuildConfig.APPLICATION_ID}/" + R.drawable.icon)
    }

+    // As of v2.17.0 token is not needed with cover image requests
+    if (DeviceManager.isServerVersionGreaterThanOrEqualTo("2.17.0")) {
+      return Uri.parse("${DeviceManager.serverAddress}/api/items/$id/cover")
+    }
+
    return Uri.parse("${DeviceManager.serverAddress}/api/items/$id/cover?token=${DeviceManager.token}")
  }

  @JsonIgnore
  fun checkHasTracks():Boolean {
-    return if (mediaType == "podcast") {
-      ((media as Podcast).numEpisodes ?: 0) > 0
-    } else {
-      ((media as Book).numTracks ?: 0) > 0
+    return media.checkHasTracks()
+  }
+
+  @get:JsonIgnore
+  val seriesSequence: String
+    get() {
+      if (mediaType != "podcast") {
+        return ((media as Book).metadata as BookMetadata).series?.get(0)?.sequence.orEmpty()
+      } else {
+        return ""
+      }
    }
+
+  @get:JsonIgnore
+  val seriesSequenceParts: List<String>
+    get() {
+      if (seriesSequence.isEmpty()) {
+        return listOf("")
+      }
+      return seriesSequence.split(".", limit = 2)
+    }
+
+  @JsonIgnore
+  fun getMediaDescription(progress:MediaProgressWrapper?, ctx: Context, authorId: String?, showSeriesNumber: Boolean?, groupTitle: String?): MediaDescriptionCompat {
+    val extras = Bundle()
+
+    if (collapsedSeries == null) {
+      if (localLibraryItemId != null) {
+        extras.putLong(
+          MediaDescriptionCompat.EXTRA_DOWNLOAD_STATUS,
+          MediaDescriptionCompat.STATUS_DOWNLOADED
+        )
+      }
+
+      if (progress != null) {
+        if (progress.isFinished) {
+          extras.putInt(
+            MediaConstants.DESCRIPTION_EXTRAS_KEY_COMPLETION_STATUS,
+            MediaConstants.DESCRIPTION_EXTRAS_VALUE_COMPLETION_STATUS_FULLY_PLAYED
+          )
+        } else {
+          extras.putInt(
+            MediaConstants.DESCRIPTION_EXTRAS_KEY_COMPLETION_STATUS,
+            MediaConstants.DESCRIPTION_EXTRAS_VALUE_COMPLETION_STATUS_PARTIALLY_PLAYED
+          )
+          extras.putDouble(
+            MediaConstants.DESCRIPTION_EXTRAS_KEY_COMPLETION_PERCENTAGE, progress.progress
+          )
+        }
+      } else if (mediaType != "podcast") {
+        extras.putInt(
+          MediaConstants.DESCRIPTION_EXTRAS_KEY_COMPLETION_STATUS,
+          MediaConstants.DESCRIPTION_EXTRAS_VALUE_COMPLETION_STATUS_NOT_PLAYED
+        )
+      }
+
+      if (media.metadata.explicit) {
+        extras.putLong(
+          MediaConstants.METADATA_KEY_IS_EXPLICIT,
+          MediaConstants.METADATA_VALUE_ATTRIBUTE_PRESENT
+        )
+      }
+    }
+    if (groupTitle !== null) {
+      extras.putString(MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_GROUP_TITLE, groupTitle)
+    }
+
+    val mediaId = if (localLibraryItemId != null) {
+      localLibraryItemId
+    } else if (collapsedSeries != null) {
+      if (authorId != null) {
+        "__LIBRARY__${libraryId}__AUTHOR_SERIES__${authorId}__${collapsedSeries!!.id}"
+      } else {
+        "__LIBRARY__${libraryId}__SERIES__${collapsedSeries!!.id}"
+      }
+    } else {
+      id
+    }
+    var subtitle = authorName
+    if (collapsedSeries != null) {
+      subtitle = "${collapsedSeries!!.numBooks} books"
+    }
+    var itemTitle = title
+    if (showSeriesNumber == true && seriesSequence != "") {
+      itemTitle = "$seriesSequence. $itemTitle"
+    }
+    return MediaDescriptionCompat.Builder()
+      .setMediaId(mediaId)
+      .setTitle(itemTitle)
+      .setIconUri(getCoverUri())
+      .setSubtitle(subtitle)
+      .setExtras(extras)
+      .build()
+  }
+
+  @JsonIgnore
+  fun getMediaDescription(progress:MediaProgressWrapper?, ctx: Context, authorId: String?, showSeriesNumber: Boolean?): MediaDescriptionCompat {
+    return getMediaDescription(progress, ctx, authorId, showSeriesNumber, null)
+  }
+
+  @JsonIgnore
+  fun getMediaDescription(progress:MediaProgressWrapper?, ctx: Context, authorId: String?): MediaDescriptionCompat {
+    return getMediaDescription(progress, ctx, authorId, null, null)
  }

  @JsonIgnore
  override fun getMediaDescription(progress:MediaProgressWrapper?, ctx: Context): MediaDescriptionCompat {
-    val extras = Bundle()
-
-    if (localLibraryItemId != null) {
-      extras.putLong(
-        MediaDescriptionCompat.EXTRA_DOWNLOAD_STATUS,
-        MediaDescriptionCompat.STATUS_DOWNLOADED
-      )
-    }
-
-    if (progress != null) {
-      if (progress.isFinished) {
-        extras.putInt(
-          MediaConstants.DESCRIPTION_EXTRAS_KEY_COMPLETION_STATUS,
-          MediaConstants.DESCRIPTION_EXTRAS_VALUE_COMPLETION_STATUS_FULLY_PLAYED
-        )
-      } else {
-        extras.putInt(
-          MediaConstants.DESCRIPTION_EXTRAS_KEY_COMPLETION_STATUS,
-          MediaConstants.DESCRIPTION_EXTRAS_VALUE_COMPLETION_STATUS_PARTIALLY_PLAYED
-        )
-        extras.putDouble(
-          MediaConstants.DESCRIPTION_EXTRAS_KEY_COMPLETION_PERCENTAGE, progress.progress
-        )
-      }
-    } else if (mediaType != "podcast") {
-      extras.putInt(
-        MediaConstants.DESCRIPTION_EXTRAS_KEY_COMPLETION_STATUS,
-        MediaConstants.DESCRIPTION_EXTRAS_VALUE_COMPLETION_STATUS_NOT_PLAYED
-      )
-    }
-
-    if (media.metadata.explicit) {
-      extras.putLong(MediaConstants.METADATA_KEY_IS_EXPLICIT, MediaConstants.METADATA_VALUE_ATTRIBUTE_PRESENT)
-    }
-
-    val mediaId = localLibraryItemId ?: id
-    return MediaDescriptionCompat.Builder()
-      .setMediaId(mediaId)
-      .setTitle(title)
-      .setIconUri(getCoverUri())
-      .setSubtitle(authorName)
-      .setExtras(extras)
-      .build()
+    /*
+    This is needed so Android auto library hierarchy for author series can be implemented
+     */
+    return getMediaDescription(progress, ctx, null, null, null)
  }
 }
@@ -0,0 +1,60 @@
+package com.audiobookshelf.app.data
+
+import android.content.Context
+import android.os.Bundle
+import android.support.v4.media.MediaDescriptionCompat
+import androidx.media.utils.MediaConstants
+import com.fasterxml.jackson.annotation.JsonIgnore
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+class LibrarySeriesItem(
+  id:String,
+  var libraryId:String,
+  var name:String,
+  var description:String?,
+  var addedAt:Long,
+  var updatedAt:Long,
+  var books:MutableList<LibraryItem>?,
+  var localLibraryItemId:String? // For Android Auto
+) : LibraryItemWrapper(id) {
+  @get:JsonIgnore
+  val title get() = name
+
+  @get:JsonIgnore
+  val audiobookCount: Int
+    get() {
+      if (books == null) return 0
+      val booksWithAudio = books?.filter { b -> b.media.checkHasTracks() }
+      return booksWithAudio?.size ?: 0
+    }
+
+  @JsonIgnore
+  fun getMediaDescription(progress:MediaProgressWrapper?, ctx: Context, groupTitle: String?): MediaDescriptionCompat {
+    val extras = Bundle()
+
+    if (localLibraryItemId != null) {
+      extras.putLong(
+        MediaDescriptionCompat.EXTRA_DOWNLOAD_STATUS,
+        MediaDescriptionCompat.STATUS_DOWNLOADED
+      )
+    }
+    if (groupTitle !== null) {
+      extras.putString(MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_GROUP_TITLE, groupTitle)
+    }
+
+    val mediaId = "__LIBRARY__${libraryId}__SERIES__${id}"
+    return MediaDescriptionCompat.Builder()
+      .setMediaId(mediaId)
+      .setTitle(title)
+      //.setIconUri(getCoverUri())
+      .setSubtitle("$audiobookCount books")
+      .setExtras(extras)
+      .build()
+  }
+
+  @JsonIgnore
+  override fun getMediaDescription(progress:MediaProgressWrapper?, ctx: Context): MediaDescriptionCompat {
+    return getMediaDescription(progress, ctx, null)
+  }
+}
@@ -18,6 +18,7 @@ import com.audiobookshelf.app.device.DeviceManager
 import com.fasterxml.jackson.annotation.JsonIgnore
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties
 import com.audiobookshelf.app.player.PLAYMETHOD_LOCAL
+import java.io.File
 import java.util.*

@JsonIgnoreProperties(ignoreUnknown = true)
@@ -78,6 +79,30 @@ class LocalLibraryItem(
    }
  }

+  @JsonIgnore
+  fun hasTracks(ctx: Context, episode:PodcastEpisode?): Boolean {
+    var audioTracks = media.getAudioTracks() as MutableList<AudioTrack>
+    if (episode != null) { // Get podcast episode audio track
+      episode.audioTrack?.let { at -> mutableListOf(at) }?.let { tracks -> audioTracks = tracks }
+    }
+    if (audioTracks.size == 0) return false
+    audioTracks.forEach {
+      // Check that metadata is not null
+      if (it.metadata === null) {
+        return false
+      }
+      if (!trackExists(ctx, it.contentUrl, it.metadata!!.path)) {
+        return false
+      }
+    }
+    return true
+  }
+
+  @JsonIgnore
+  private fun trackExists(ctx: Context, contentUrl: String?, path: String): Boolean {
+    return LocalFile("", null, contentUrl ?: "", "", path, null, 0).exists(ctx)
+  }
+
  @JsonIgnore
  fun getPlaybackSession(episode:PodcastEpisode?, deviceInfo:DeviceInfo):PlaybackSession {
    val localEpisodeId = episode?.id
@@ -86,7 +111,7 @@ class LocalLibraryItem(
    // Get current progress for local media
    val mediaProgressId = if (localEpisodeId.isNullOrEmpty()) id else "$id-$localEpisodeId"
    val mediaProgress = DeviceManager.dbManager.getLocalMediaProgress(mediaProgressId)
-    val currentTime = mediaProgress?.currentTime ?: 0.0
+    val currentTime = if (mediaProgress?.isFinished == true) 0.0 else mediaProgress?.currentTime ?: 0.0


    val mediaMetadata = media.metadata
@@ -4,70 +4,64 @@ import com.fasterxml.jackson.annotation.JsonIgnore
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties

 /*
-  Used as a helper class to generate LocalLibraryItem from scan results
- */
+ Used as a helper class to generate LocalLibraryItem from scan results
+*/

@JsonIgnoreProperties(ignoreUnknown = true)
 data class LocalMediaItem(
-  var id:String,
-  var name: String,
-  var mediaType:String,
-  var folderId:String,
-  var contentUrl:String,
-  var simplePath: String,
-  var basePath:String,
-  var absolutePath:String,
-  var audioTracks:MutableList<AudioTrack>,
-  var ebookFile:EBookFile?,
-  var localFiles:MutableList<LocalFile>,
-  var coverContentUrl:String?,
-  var coverAbsolutePath:String?
+        var id: String,
+        var name: String,
+        var mediaType: String,
+        var folderId: String,
+        var contentUrl: String,
+        var basePath: String,
+        var absolutePath: String,
+        var audioTracks: MutableList<AudioTrack>,
+        var ebookFile: EBookFile?,
+        var localFiles: MutableList<LocalFile>,
+        var coverContentUrl: String?,
+        var coverAbsolutePath: String?
 ) {

  @JsonIgnore
-  fun getDuration():Double {
+  fun getDuration(): Double {
    var total = 0.0
-    audioTracks.forEach{ total += it.duration }
+    audioTracks.forEach { total += it.duration }
    return total
  }

  @JsonIgnore
-  fun getTotalSize():Long {
+  fun getTotalSize(): Long {
    var total = 0L
    localFiles.forEach { total += it.size }
    return total
  }

  @JsonIgnore
-  fun getMediaMetadata():MediaTypeMetadata {
+  fun getMediaMetadata(): MediaTypeMetadata {
    return if (mediaType == "book") {
-      BookMetadata(name,null, mutableListOf(), mutableListOf(), mutableListOf(),null,null,null,null,null,null,null,false,null,null,null,null)
+      BookMetadata(
+              name,
+              null,
+              mutableListOf(),
+              mutableListOf(),
+              mutableListOf(),
+              null,
+              null,
+              null,
+              null,
+              null,
+              null,
+              null,
+              false,
+              null,
+              null,
+              null,
+              null,
+              null
+      )
    } else {
-      PodcastMetadata(name,null,null, mutableListOf(), false)
-    }
-  }
-
-  @JsonIgnore
-  fun getAudiobookChapters():List<BookChapter> {
-    if (mediaType != "book" || audioTracks.isEmpty()) return mutableListOf()
-    if (audioTracks.size == 1) { // Single track audiobook look for chapters from ffprobe
-      return audioTracks[0].audioProbeResult?.getBookChapters() ?: mutableListOf()
-    }
-    // Multi-track make chapters from tracks
-    return audioTracks.map { it.getBookChapter() }
-  }
-
-  @JsonIgnore
-  fun getLocalLibraryItem():LocalLibraryItem {
-    val mediaMetadata = getMediaMetadata()
-    if (mediaType == "book") {
-      val chapters = getAudiobookChapters()
-      val book = Book(mediaMetadata as BookMetadata, coverAbsolutePath, mutableListOf(), mutableListOf(), chapters,audioTracks,ebookFile,getTotalSize(),getDuration(),audioTracks.size)
-      return LocalLibraryItem(id, folderId, basePath,absolutePath, contentUrl,  false,mediaType, book, localFiles, coverContentUrl, coverAbsolutePath,true,null,null,null,null)
-    } else {
-      val podcast = Podcast(mediaMetadata as PodcastMetadata, coverAbsolutePath, mutableListOf(), mutableListOf(), false, 0)
-      podcast.setAudioTracks(audioTracks) // Builds episodes from audio tracks
-      return LocalLibraryItem(id, folderId, basePath,absolutePath, contentUrl, false, mediaType, podcast,localFiles,coverContentUrl, coverAbsolutePath, true, null,null,null,null)
+      PodcastMetadata(name, null, null, mutableListOf(), false)
    }
  }
 }
@@ -46,6 +46,10 @@ class LocalMediaProgress(
      progress = if (finished) 1.0 else 0.0
    }

+    if (finished) {
+      currentTime = 0.0
+    }
+
    isFinished = finished
    lastUpdate = System.currentTimeMillis()
    finishedAt = if (isFinished) lastUpdate else null
@@ -4,14 +4,14 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties

@JsonIgnoreProperties(ignoreUnknown = true)
 class MediaItemHistory(
-  var id: String, // media id
-  var mediaDisplayTitle: String,
-  var libraryItemId: String,
-  var episodeId: String?,
-  var isLocal:Boolean,
-  var serverConnectionConfigId:String?,
-  var serverAddress:String?,
-  var serverUserId:String?,
-  var createdAt: Long,
-  var events:MutableList<MediaItemEvent>,
+        var id: String, // media id
+        var mediaDisplayTitle: String,
+        var libraryItemId: String,
+        var episodeId: String?,
+        var isLocal: Boolean,
+        var serverConnectionConfigId: String?,
+        var serverAddress: String?,
+        var serverUserId: String?,
+        var createdAt: Long,
+        var events: MutableList<MediaItemEvent>,
 )
@@ -1,6 +1,7 @@
 package com.audiobookshelf.app.data

 import android.content.Context
+import android.graphics.Bitmap
 import android.graphics.ImageDecoder
 import android.net.Uri
 import android.os.Build
@@ -12,6 +13,7 @@ import com.audiobookshelf.app.BuildConfig
 import com.audiobookshelf.app.R
 import com.audiobookshelf.app.device.DeviceManager
 import com.audiobookshelf.app.media.MediaProgressSyncData
+import com.audiobookshelf.app.player.*
 import com.fasterxml.jackson.annotation.JsonIgnore
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties
 import com.google.android.exoplayer2.MediaItem
@@ -19,61 +21,73 @@ import com.google.android.exoplayer2.MediaMetadata
 import com.google.android.gms.cast.MediaInfo
 import com.google.android.gms.cast.MediaQueueItem
 import com.google.android.gms.common.images.WebImage
-import com.audiobookshelf.app.player.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch

@JsonIgnoreProperties(ignoreUnknown = true)
 class PlaybackSession(
-  var id:String,
-  var userId:String?,
-  var libraryItemId:String?,
-  var episodeId:String?,
-  var mediaType:String,
-  var mediaMetadata:MediaTypeMetadata,
-  var deviceInfo:DeviceInfo,
-  var chapters:List<BookChapter>,
-  var displayTitle: String?,
-  var displayAuthor: String?,
-  var coverPath:String?,
-  var duration:Double,
-  var playMethod:Int,
-  var startedAt:Long,
-  var updatedAt:Long,
-  var timeListening:Long,
-  var audioTracks:MutableList<AudioTrack>,
-  var currentTime:Double,
-  var libraryItem:LibraryItem?,
-  var localLibraryItem:LocalLibraryItem?,
-  var localEpisodeId:String?,
-  var serverConnectionConfigId:String?,
-  var serverAddress:String?,
-  var mediaPlayer:String?
+        var id: String,
+        var userId: String?,
+        var libraryItemId: String?,
+        var episodeId: String?,
+        var mediaType: String,
+        var mediaMetadata: MediaTypeMetadata,
+        var deviceInfo: DeviceInfo,
+        var chapters: List<BookChapter>,
+        var displayTitle: String?,
+        var displayAuthor: String?,
+        var coverPath: String?,
+        var duration: Double,
+        var playMethod: Int,
+        var startedAt: Long,
+        var updatedAt: Long,
+        var timeListening: Long,
+        var audioTracks: MutableList<AudioTrack>,
+        var currentTime: Double,
+        var libraryItem: LibraryItem?,
+        var localLibraryItem: LocalLibraryItem?,
+        var localEpisodeId: String?,
+        var serverConnectionConfigId: String?,
+        var serverAddress: String?,
+        var mediaPlayer: String?
 ) {

  @get:JsonIgnore
-  val isHLS get() = playMethod == PLAYMETHOD_TRANSCODE
+  val isHLS
+    get() = playMethod == PLAYMETHOD_TRANSCODE
  @get:JsonIgnore
-  val isDirectPlay get() = playMethod == PLAYMETHOD_DIRECTPLAY
+  val isDirectPlay
+    get() = playMethod == PLAYMETHOD_DIRECTPLAY
  @get:JsonIgnore
-  val isLocal get() = playMethod == PLAYMETHOD_LOCAL
+  val isLocal
+    get() = playMethod == PLAYMETHOD_LOCAL
  @get:JsonIgnore
-  val isPodcastEpisode get() = mediaType == "podcast"
+  val isPodcastEpisode
+    get() = mediaType == "podcast"
  @get:JsonIgnore
-  val currentTimeMs get() = (currentTime * 1000L).toLong()
+  val currentTimeMs
+    get() = (currentTime * 1000L).toLong()
  @get:JsonIgnore
-  val totalDurationMs get() = (getTotalDuration() * 1000L).toLong()
+  val totalDurationMs
+    get() = (getTotalDuration() * 1000L).toLong()
  @get:JsonIgnore
-  val localLibraryItemId get() = localLibraryItem?.id ?: ""
+  val localLibraryItemId
+    get() = localLibraryItem?.id ?: ""
  @get:JsonIgnore
-  val localMediaProgressId get() = if (localEpisodeId.isNullOrEmpty()) localLibraryItemId else "$localLibraryItemId-$localEpisodeId"
+  val localMediaProgressId
+    get() =
+            if (localEpisodeId.isNullOrEmpty()) localLibraryItemId
+            else "$localLibraryItemId-$localEpisodeId"
  @get:JsonIgnore
-  val progress get() = currentTime / getTotalDuration()
+  val progress
+    get() = currentTime / getTotalDuration()
  @get:JsonIgnore
-  val isLocalLibraryItemOnly get() = localLibraryItemId != "" && libraryItemId == null
-  @get:JsonIgnore
-  val mediaItemId get() = if (isLocalLibraryItemOnly) localMediaProgressId else if (episodeId.isNullOrEmpty()) libraryItemId ?: "" else "$libraryItemId-$episodeId"
+  val mediaItemId
+    get() = if (episodeId.isNullOrEmpty()) libraryItemId ?: "" else "$libraryItemId-$episodeId"

  @JsonIgnore
-  fun getCurrentTrackIndex():Int {
+  fun getCurrentTrackIndex(): Int {
    for (i in 0 until audioTracks.size) {
      val track = audioTracks[i]
      if (currentTimeMs >= track.startOffsetMs && (track.endOffsetMs > currentTimeMs)) {
@@ -84,7 +98,7 @@ class PlaybackSession(
  }

  @JsonIgnore
-  fun getNextTrackIndex():Int {
+  fun getNextTrackIndex(): Int {
    for (i in 0 until audioTracks.size) {
      val track = audioTracks[i]
      if (currentTimeMs < track.startOffsetMs) {
@@ -95,125 +109,204 @@ class PlaybackSession(
  }

  @JsonIgnore
-  fun getChapterForTime(time:Long):BookChapter? {
+  fun getChapterForTime(time: Long): BookChapter? {
    if (chapters.isEmpty()) return null
-    return chapters.find { time >= it.startMs && it.endMs > time}
+    return chapters.find { time >= it.startMs && it.endMs > time }
  }

  @JsonIgnore
-  fun getCurrentTrackEndTime():Long {
+  fun getCurrentTrackEndTime(): Long {
    val currentTrack = audioTracks[this.getCurrentTrackIndex()]
    return currentTrack.startOffsetMs + currentTrack.durationMs
  }

  @JsonIgnore
-  fun getNextChapterForTime(time:Long):BookChapter? {
+  fun getNextChapterForTime(time: Long): BookChapter? {
    if (chapters.isEmpty()) return null
    return chapters.find { time < it.startMs } // First chapter where start time is > then time
  }

  @JsonIgnore
-  fun getNextTrackEndTime():Long {
+  fun getNextTrackEndTime(): Long {
    val currentTrack = audioTracks[this.getNextTrackIndex()]
    return currentTrack.startOffsetMs + currentTrack.durationMs
  }

  @JsonIgnore
-  fun getCurrentTrackTimeMs():Long {
+  fun getCurrentTrackTimeMs(): Long {
    val currentTrack = audioTracks[this.getCurrentTrackIndex()]
    val time = currentTime - currentTrack.startOffset
    return (time * 1000L).toLong()
  }

  @JsonIgnore
-  fun getTrackStartOffsetMs(index:Int):Long {
+  fun getTrackStartOffsetMs(index: Int): Long {
    if (index < 0 || index >= audioTracks.size) return 0L
    val currentTrack = audioTracks[index]
    return (currentTrack.startOffset * 1000L).toLong()
  }

  @JsonIgnore
-  fun getTotalDuration():Double {
+  fun getTotalDuration(): Double {
    var total = 0.0
    audioTracks.forEach { total += it.duration }
    return total
  }

  @JsonIgnore
-  fun getCoverUri(ctx:Context): Uri {
+  fun checkIsServerVersionGte(compareVersion: String): Boolean {
+    // Safety check this playback session is the same one currently connected (should always be)
+    if (DeviceManager.serverConnectionConfigId != serverConnectionConfigId) {
+      return false
+    }
+
+    return DeviceManager.isServerVersionGreaterThanOrEqualTo(compareVersion)
+  }
+
+  @JsonIgnore
+  fun getCoverUri(ctx: Context): Uri {
    if (localLibraryItem?.coverContentUrl != null) {
      var coverUri = Uri.parse(localLibraryItem?.coverContentUrl.toString())
      if (coverUri.toString().startsWith("file:")) {
-        coverUri = FileProvider.getUriForFile(ctx, "${BuildConfig.APPLICATION_ID}.fileprovider", coverUri.toFile())
+        coverUri =
+                FileProvider.getUriForFile(
+                        ctx,
+                        "${BuildConfig.APPLICATION_ID}.fileprovider",
+                        coverUri.toFile()
+                )
      }

-      return coverUri ?: Uri.parse("android.resource://${BuildConfig.APPLICATION_ID}/" + R.drawable.icon)
+      return coverUri
+              ?: Uri.parse("android.resource://${BuildConfig.APPLICATION_ID}/" + R.drawable.icon)
    }

-    if (coverPath == null) return Uri.parse("android.resource://${BuildConfig.APPLICATION_ID}/" + R.drawable.icon)
+    if (coverPath == null)
+            return Uri.parse("android.resource://${BuildConfig.APPLICATION_ID}/" + R.drawable.icon)
+
+    // As of v2.17.0 token is not needed with cover image requests
+    if (checkIsServerVersionGte("2.17.0")) {
+      return Uri.parse("$serverAddress/api/items/$libraryItemId/cover")
+    }
    return Uri.parse("$serverAddress/api/items/$libraryItemId/cover?token=${DeviceManager.token}")
  }

  @JsonIgnore
-  fun getContentUri(audioTrack:AudioTrack): Uri {
+  fun getContentUri(audioTrack: AudioTrack): Uri {
    if (isLocal) return Uri.parse(audioTrack.contentUrl) // Local content url
+    // As of v2.22.0 tracks use a different endpoint
+    // See: https://github.com/advplyr/audiobookshelf/pull/4263
+    if (checkIsServerVersionGte("2.22.0")) {
+      return if (isDirectPlay) {
+        Uri.parse("$serverAddress/public/session/$id/track/${audioTrack.index}")
+      } else {
+        // Transcode uses HlsRouter on server
+        Uri.parse("$serverAddress${audioTrack.contentUrl}")
+      }
+    }
    return Uri.parse("$serverAddress${audioTrack.contentUrl}?token=${DeviceManager.token}")
  }

+  /** Bitmap for the cover art, once resolved */
+  @JsonIgnore
+  private var resolvedCoverBitmap: Bitmap? = null
+
+  /**
+   * Builds the current session metadata, including the cover art bitmap if it has already been resolved.
+   */
  @JsonIgnore
  fun getMediaMetadataCompat(ctx: Context): MediaMetadataCompat {
    val coverUri = getCoverUri(ctx)

-    val metadataBuilder = MediaMetadataCompat.Builder()
-      .putString(MediaMetadataCompat.METADATA_KEY_TITLE, displayTitle)
-      .putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_TITLE, displayTitle)
-      .putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_SUBTITLE, displayAuthor)
-      .putString(MediaMetadataCompat.METADATA_KEY_AUTHOR, displayAuthor)
-      .putString(MediaMetadataCompat.METADATA_KEY_ARTIST, displayAuthor)
-      .putString(MediaMetadataCompat.METADATA_KEY_ALBUM, displayAuthor)
-      .putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ARTIST, displayAuthor)
-      .putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_DESCRIPTION, displayAuthor)
-      .putString(MediaMetadataCompat.METADATA_KEY_MEDIA_ID, id)
-      .putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI, coverUri.toString())
-      .putString(MediaMetadataCompat.METADATA_KEY_ART_URI, coverUri.toString())
-      .putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_ICON_URI, coverUri.toString())
+    val metadataBuilder =
+            MediaMetadataCompat.Builder()
+                    .putString(MediaMetadataCompat.METADATA_KEY_TITLE, displayTitle)
+                    .putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_TITLE, displayTitle)
+                    .putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_SUBTITLE, displayAuthor)
+                    .putString(MediaMetadataCompat.METADATA_KEY_AUTHOR, displayAuthor)
+                    .putString(MediaMetadataCompat.METADATA_KEY_ARTIST, displayAuthor)
+                    .putString(MediaMetadataCompat.METADATA_KEY_ALBUM, displayAuthor)
+                    .putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ARTIST, displayAuthor)
+                    .putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_DESCRIPTION, displayAuthor)
+                    .putString(MediaMetadataCompat.METADATA_KEY_MEDIA_ID, id)
+                      .putLong(MediaMetadataCompat.METADATA_KEY_DURATION, totalDurationMs)
+                    .putString(
+                            MediaMetadataCompat.METADATA_KEY_DISPLAY_ICON_URI,
+                            coverUri.toString()
+                    )

-    // Local covers get bitmap
-    if (localLibraryItem?.coverContentUrl != null) {
-      val bitmap = if (Build.VERSION.SDK_INT < 28) {
-        MediaStore.Images.Media.getBitmap(ctx.contentResolver, coverUri)
-      } else {
-        val source: ImageDecoder.Source = ImageDecoder.createSource(ctx.contentResolver, coverUri)
-        ImageDecoder.decodeBitmap(source)
-      }
-      metadataBuilder.putBitmap(MediaMetadataCompat.METADATA_KEY_ALBUM_ART, bitmap)
-      metadataBuilder.putBitmap(MediaMetadataCompat.METADATA_KEY_ART, bitmap)
+    if (resolvedCoverBitmap != null) {
+      metadataBuilder
+        .putBitmap(MediaMetadataCompat.METADATA_KEY_ALBUM_ART, resolvedCoverBitmap)
+        .putBitmap(MediaMetadataCompat.METADATA_KEY_ART, resolvedCoverBitmap)
+    } else {
+      metadataBuilder
+        .putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI, coverUri.toString())
+        .putString(MediaMetadataCompat.METADATA_KEY_ART_URI, coverUri.toString())
    }

    return metadataBuilder.build()
  }

+  /**
+   * Resolves the cover art bitmap (local covers are decoded synchronously, server-side covers
+   * are fetched asynchronously) and calls `onArtResolved` once it's available
+   *
+   * Returns the Job for the async fetch, or `null` if the bitmap was resolved synchronously.
+   */
  @JsonIgnore
-  fun getExoMediaMetadata(ctx:Context): MediaMetadata {
+  fun resolveCoverBitmapAsync(
+          ctx: Context,
+          coroutineScope: CoroutineScope,
+          onArtResolved: () -> Unit
+  ): Job? {
    val coverUri = getCoverUri(ctx)

-    val metadataBuilder = MediaMetadata.Builder()
-      .setTitle(displayTitle)
-      .setDisplayTitle(displayTitle)
-      .setArtist(displayAuthor)
-      .setAlbumArtist(displayAuthor)
-      .setSubtitle(displayAuthor)
-      .setAlbumTitle(displayAuthor)
-      .setDescription(displayAuthor)
-      .setArtworkUri(coverUri)
-      .setMediaType(MediaMetadata.MEDIA_TYPE_AUDIO_BOOK)
+    // Local covers get bitmap synchronously, no async fetch needed
+    if (localLibraryItem?.coverContentUrl != null) {
+      resolvedCoverBitmap =
+              if (Build.VERSION.SDK_INT < 28) {
+                MediaStore.Images.Media.getBitmap(ctx.contentResolver, coverUri)
+              } else {
+                val source: ImageDecoder.Source =
+                        ImageDecoder.createSource(ctx.contentResolver, coverUri)
+                ImageDecoder.decodeBitmap(source)
+              }
+      onArtResolved()
+      return null
+    }
+
+    // Server-side cover: resolve the art bitmap async
+    return coroutineScope.launch {
+      val bitmap = resolveUriAsBitmap(ctx, coverUri)
+      bitmap?.let {
+        resolvedCoverBitmap = it
+        onArtResolved()
+      }
+    }
+  }
+
+  @JsonIgnore
+  fun getExoMediaMetadata(ctx: Context): MediaMetadata {
+    val coverUri = getCoverUri(ctx)
+
+    val metadataBuilder =
+            MediaMetadata.Builder()
+                    .setTitle(displayTitle)
+                    .setDisplayTitle(displayTitle)
+                    .setArtist(displayAuthor)
+                    .setAlbumArtist(displayAuthor)
+                    .setSubtitle(displayAuthor)
+                    .setAlbumTitle(displayAuthor)
+                    .setDescription(displayAuthor)
+                    .setArtworkUri(coverUri)
+                    .setMediaType(MediaMetadata.MEDIA_TYPE_AUDIO_BOOK)

    return metadataBuilder.build()
  }

  @JsonIgnore
-  fun getMediaItems(ctx:Context):List<MediaItem> {
-    val mediaItems:MutableList<MediaItem> = mutableListOf()
+  fun getMediaItems(ctx: Context): List<MediaItem> {
+    val mediaItems: MutableList<MediaItem> = mutableListOf()

    for (audioTrack in audioTracks) {
      val mediaMetadata = this.getExoMediaMetadata(ctx)
@@ -221,50 +314,107 @@ class PlaybackSession(
      val mimeType = audioTrack.mimeType

      val queueItem = getQueueItem(audioTrack) // Queue item used in exo player CastManager
-      val mediaItem = MediaItem.Builder().setUri(mediaUri).setTag(queueItem).setMediaMetadata(mediaMetadata).setMimeType(mimeType).build()
+      val mediaItem =
+              MediaItem.Builder()
+                      .setUri(mediaUri)
+                      .setTag(queueItem)
+                      .setMediaMetadata(mediaMetadata)
+                      .setMimeType(mimeType)
+                      .build()
      mediaItems.add(mediaItem)
    }
    return mediaItems
  }

  @JsonIgnore
-  fun getCastMediaMetadata(audioTrack:AudioTrack):com.google.android.gms.cast.MediaMetadata {
-    val castMetadata = com.google.android.gms.cast.MediaMetadata(com.google.android.gms.cast.MediaMetadata.MEDIA_TYPE_AUDIOBOOK_CHAPTER)
+  fun getCastMediaMetadata(audioTrack: AudioTrack): com.google.android.gms.cast.MediaMetadata {
+    val castMetadata =
+            com.google.android.gms.cast.MediaMetadata(
+                    com.google.android.gms.cast.MediaMetadata.MEDIA_TYPE_AUDIOBOOK_CHAPTER
+            )

+    // As of v2.17.0 token is not needed with cover image requests
+    val coverUri = if (checkIsServerVersionGte("2.17.0")) {
+      Uri.parse("$serverAddress/api/items/$libraryItemId/cover")
+    } else {
+      Uri.parse("$serverAddress/api/items/$libraryItemId/cover?token=${DeviceManager.token}")
+    }
+
+    // Cast always uses server cover uri
    coverPath?.let {
-      castMetadata.addImage(WebImage(Uri.parse("$serverAddress/api/items/$libraryItemId/cover?token=${DeviceManager.token}")))
+      castMetadata.addImage(WebImage(coverUri))
    }

    castMetadata.putString(com.google.android.gms.cast.MediaMetadata.KEY_TITLE, displayTitle ?: "")
-    castMetadata.putString(com.google.android.gms.cast.MediaMetadata.KEY_ARTIST, displayAuthor ?: "")
-    castMetadata.putString(com.google.android.gms.cast.MediaMetadata.KEY_ALBUM_TITLE, displayAuthor ?: "")
-    castMetadata.putString(com.google.android.gms.cast.MediaMetadata.KEY_CHAPTER_TITLE, audioTrack.title)
+    castMetadata.putString(
+            com.google.android.gms.cast.MediaMetadata.KEY_ARTIST,
+            displayAuthor ?: ""
+    )
+    castMetadata.putString(
+            com.google.android.gms.cast.MediaMetadata.KEY_ALBUM_TITLE,
+            displayAuthor ?: ""
+    )
+    castMetadata.putString(
+            com.google.android.gms.cast.MediaMetadata.KEY_CHAPTER_TITLE,
+            audioTrack.title
+    )

-    castMetadata.putInt(com.google.android.gms.cast.MediaMetadata.KEY_TRACK_NUMBER, audioTrack.index)
+    castMetadata.putInt(
+            com.google.android.gms.cast.MediaMetadata.KEY_TRACK_NUMBER,
+            audioTrack.index
+    )
    return castMetadata
  }

  @JsonIgnore
-  fun getQueueItem(audioTrack:AudioTrack):MediaQueueItem {
+  fun getQueueItem(audioTrack: AudioTrack): MediaQueueItem {
    val castMetadata = getCastMediaMetadata(audioTrack)

    val mediaUri = getContentUri(audioTrack)

-    val mediaInfo = MediaInfo.Builder(mediaUri.toString()).apply {
-      setContentUrl(mediaUri.toString())
-      setContentType(audioTrack.mimeType)
-      setMetadata(castMetadata)
-      setStreamType(MediaInfo.STREAM_TYPE_BUFFERED)
-    }.build()
+    val mediaInfo =
+            MediaInfo.Builder(mediaUri.toString())
+                    .apply {
+                      setContentUrl(mediaUri.toString())
+                      setContentType(audioTrack.mimeType ?: "")
+                      setMetadata(castMetadata)
+                      setStreamType(MediaInfo.STREAM_TYPE_BUFFERED)
+                    }
+                    .build()

-    return MediaQueueItem.Builder(mediaInfo).apply {
-      setPlaybackDuration(audioTrack.duration)
-    }.build()
+    return MediaQueueItem.Builder(mediaInfo)
+            .apply { setPlaybackDuration(audioTrack.duration) }
+            .build()
  }

  @JsonIgnore
-  fun clone():PlaybackSession {
-    return PlaybackSession(id,userId,libraryItemId,episodeId,mediaType,mediaMetadata,deviceInfo,chapters,displayTitle,displayAuthor,coverPath,duration,playMethod,startedAt,updatedAt,timeListening,audioTracks,currentTime,libraryItem,localLibraryItem,localEpisodeId,serverConnectionConfigId,serverAddress, mediaPlayer)
+  fun clone(): PlaybackSession {
+    return PlaybackSession(
+            id,
+            userId,
+            libraryItemId,
+            episodeId,
+            mediaType,
+            mediaMetadata,
+            deviceInfo,
+            chapters,
+            displayTitle,
+            displayAuthor,
+            coverPath,
+            duration,
+            playMethod,
+            startedAt,
+            updatedAt,
+            timeListening,
+            audioTracks,
+            currentTime,
+            libraryItem,
+            localLibraryItem,
+            localEpisodeId,
+            serverConnectionConfigId,
+            serverAddress,
+            mediaPlayer
+    )
  }

  @JsonIgnore
@@ -275,7 +425,25 @@ class PlaybackSession(
  }

  @JsonIgnore
-  fun getNewLocalMediaProgress():LocalMediaProgress {
-    return LocalMediaProgress(localMediaProgressId,localLibraryItemId,localEpisodeId,getTotalDuration(),progress,currentTime,false,null,null,updatedAt,startedAt,null,serverConnectionConfigId,serverAddress,userId,libraryItemId,episodeId)
+  fun getNewLocalMediaProgress(): LocalMediaProgress {
+    return LocalMediaProgress(
+            localMediaProgressId,
+            localLibraryItemId,
+            localEpisodeId,
+            getTotalDuration(),
+            progress,
+            currentTime,
+            false,
+            null,
+            null,
+            updatedAt,
+            startedAt,
+            null,
+            serverConnectionConfigId,
+            serverAddress,
+            userId,
+            libraryItemId,
+            episodeId
+    )
  }
 }
@@ -12,11 +12,19 @@ import com.audiobookshelf.app.managers.DbManager
 import com.audiobookshelf.app.player.PlayerNotificationService
 import com.audiobookshelf.app.updateAppWidget

+/** Interface for widget event handling. */
 interface WidgetEventEmitter {
-  fun onPlayerChanged(pns:PlayerNotificationService)
+  /**
+   * Called when the player state changes.
+   * @param pns The PlayerNotificationService instance.
+   */
+  fun onPlayerChanged(pns: PlayerNotificationService)
+
+  /** Called when the player is closed. */
  fun onPlayerClosed()
 }

+/** Singleton object for managing device-related operations. */
 object DeviceManager {
  const val tag = "DeviceManager"

@@ -25,20 +33,29 @@ object DeviceManager {
  var serverConnectionConfig: ServerConnectionConfig? = null

  val serverConnectionConfigId get() = serverConnectionConfig?.id ?: ""
-  val serverAddress get() = serverConnectionConfig?.address ?: ""
-  val serverUserId get() = serverConnectionConfig?.userId ?: ""
-  val token get() = serverConnectionConfig?.token ?: ""
-  val isConnectedToServer get() = serverConnectionConfig != null
+  val serverConnectionConfigName get() = serverConnectionConfig?.name ?: ""
+  val serverConnectionConfigString get() = serverConnectionConfig?.name ?: "No server connection"
+  val serverAddress
+    get() = serverConnectionConfig?.address ?: ""
+  val serverUserId
+    get() = serverConnectionConfig?.userId ?: ""
+  val token
+    get() = serverConnectionConfig?.token ?: ""
+  val serverVersion get() = serverConnectionConfig?.version ?: ""
+  val isConnectedToServer
+    get() = serverConnectionConfig != null

-  var widgetUpdater:WidgetEventEmitter? = null
+  var widgetUpdater: WidgetEventEmitter? = null

  init {
    Log.d(tag, "Device Manager Singleton invoked")

    // Initialize new sleep timer settings and shake sensitivity added in v0.9.61
-    if (deviceData.deviceSettings?.autoSleepTimerStartTime == null || deviceData.deviceSettings?.autoSleepTimerEndTime == null) {
+    if (deviceData.deviceSettings?.autoSleepTimerStartTime == null ||
+                    deviceData.deviceSettings?.autoSleepTimerEndTime == null
+    ) {
      deviceData.deviceSettings?.autoSleepTimerStartTime = "22:00"
-      deviceData.deviceSettings?.autoSleepTimerStartTime = "06:00"
+      deviceData.deviceSettings?.autoSleepTimerEndTime = "06:00"
      deviceData.deviceSettings?.sleepTimerLength = 900000L
    }
    if (deviceData.deviceSettings?.shakeSensitivity == null) {
@@ -48,24 +65,96 @@ object DeviceManager {
    if (deviceData.deviceSettings?.autoSleepTimerAutoRewindTime == null) {
      deviceData.deviceSettings?.autoSleepTimerAutoRewindTime = 300000L // 5 minutes
    }
+    // Initialize sleep timer almost done chime added in v0.9.81
+    if (deviceData.deviceSettings?.enableSleepTimerAlmostDoneChime == null) {
+      deviceData.deviceSettings?.enableSleepTimerAlmostDoneChime = false
+    }

    // Language added in v0.9.69
    if (deviceData.deviceSettings?.languageCode == null) {
      deviceData.deviceSettings?.languageCode = "en-us"
    }
+
+    if (deviceData.deviceSettings?.downloadUsingCellular == null) {
+      deviceData.deviceSettings?.downloadUsingCellular = DownloadUsingCellularSetting.ALWAYS
+    }
+
+    if (deviceData.deviceSettings?.streamingUsingCellular == null) {
+      deviceData.deviceSettings?.streamingUsingCellular = StreamingUsingCellularSetting.ALWAYS
+    }
+    if (deviceData.deviceSettings?.androidAutoBrowseLimitForGrouping == null) {
+      deviceData.deviceSettings?.androidAutoBrowseLimitForGrouping = 100
+    }
+    if (deviceData.deviceSettings?.androidAutoBrowseSeriesSequenceOrder == null) {
+      deviceData.deviceSettings?.androidAutoBrowseSeriesSequenceOrder =
+              AndroidAutoBrowseSeriesSequenceOrderSetting.ASC
+    }
  }

-  fun getBase64Id(id:String):String {
-    return android.util.Base64.encodeToString(id.toByteArray(), android.util.Base64.URL_SAFE or android.util.Base64.NO_WRAP)
+  /**
+   * Encodes the given ID to a Base64 string.
+   * @param id The ID to encode.
+   * @return The Base64 encoded string.
+   */
+  fun getBase64Id(id: String): String {
+    return android.util.Base64.encodeToString(
+            id.toByteArray(),
+            android.util.Base64.URL_SAFE or android.util.Base64.NO_WRAP
+    )
  }

-  fun getServerConnectionConfig(id:String?):ServerConnectionConfig? {
-    if (id == null) return null
-    return deviceData.serverConnectionConfigs.find { it.id == id }
+  /**
+   * Retrieves the server connection configuration for the given ID.
+   * @param id The ID of the server connection configuration.
+   * @return The ServerConnectionConfig instance or null if not found.
+   */
+  fun getServerConnectionConfig(id: String?): ServerConnectionConfig? {
+    return id?.let { deviceData.serverConnectionConfigs.find { it.id == id } }
  }

-  fun checkConnectivity(ctx:Context): Boolean {
-    val connectivityManager = ctx.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+  /**
+   * Check if the currently connected server version is >= compareVersion
+   * Abs server only uses major.minor.patch
+   * Note: Version is returned in Abs auth payloads starting v2.6.0
+   * Note: Version is saved with the server connection config starting after v0.9.81
+   *
+   * @example
+   * serverVersion=2.25.1
+   * isServerVersionGreaterThanOrEqualTo("2.26.0") = false
+   *
+   * serverVersion=2.26.1
+   * isServerVersionGreaterThanOrEqualTo("2.26.0") = true
+   */
+  fun isServerVersionGreaterThanOrEqualTo(compareVersion:String):Boolean {
+    if (serverVersion == "") return false
+    if (compareVersion == "") return true
+
+    val serverVersionParts = serverVersion.split(".").map { it.toIntOrNull() ?: 0 }
+    val compareVersionParts = compareVersion.split(".").map { it.toIntOrNull() ?: 0 }
+
+    // Compare major, minor, and patch components
+    for (i in 0 until maxOf(serverVersionParts.size, compareVersionParts.size)) {
+      val serverVersionComponent = serverVersionParts.getOrElse(i) { 0 }
+      val compareVersionComponent = compareVersionParts.getOrElse(i) { 0 }
+
+      if (serverVersionComponent < compareVersionComponent) {
+        return false // Server version is less than compareVersion
+      } else if (serverVersionComponent > compareVersionComponent) {
+        return true // Server version is greater than compareVersion
+      }
+    }
+
+    return true // versions are equal in major, minor, and patch
+  }
+
+  /**
+   * Checks the network connectivity status.
+   * @param ctx The context to use for checking connectivity.
+   * @return True if connected to the internet, false otherwise.
+   */
+  fun checkConnectivity(ctx: Context): Boolean {
+    val connectivityManager =
+            ctx.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    val capabilities = connectivityManager.getNetworkCapabilities(connectivityManager.activeNetwork)
    if (capabilities != null) {
      if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
@@ -82,35 +171,58 @@ object DeviceManager {
    return false
  }

-  fun setLastPlaybackSession(playbackSession:PlaybackSession) {
+  /**
+   * Sets the last playback session.
+   * @param playbackSession The playback session to set.
+   */
+  fun setLastPlaybackSession(playbackSession: PlaybackSession) {
    deviceData.lastPlaybackSession = playbackSession
    dbManager.saveDeviceData(deviceData)
  }

-  fun initializeWidgetUpdater(context:Context) {
+  /**
+   * Initializes the widget updater.
+   * @param context The context to use for initializing the widget updater.
+   */
+  fun initializeWidgetUpdater(context: Context) {
    Log.d(tag, "Initializing widget updater")
-    widgetUpdater = (object : WidgetEventEmitter {
-      override fun onPlayerChanged(pns: PlayerNotificationService) {
+    widgetUpdater =
+            (object : WidgetEventEmitter {
+              override fun onPlayerChanged(pns: PlayerNotificationService) {
+                val isPlaying = pns.currentPlayer.isPlaying

-        val isPlaying = pns.currentPlayer.isPlaying
+                val appWidgetManager = AppWidgetManager.getInstance(context)
+                val componentName = ComponentName(context, MediaPlayerWidget::class.java)
+                val ids = appWidgetManager.getAppWidgetIds(componentName)
+                val playbackSession = pns.getCurrentPlaybackSessionCopy()

-        val appWidgetManager = AppWidgetManager.getInstance(context)
-        val componentName = ComponentName(context, MediaPlayerWidget::class.java)
-        val ids = appWidgetManager.getAppWidgetIds(componentName)
-        val playbackSession = pns.getCurrentPlaybackSessionCopy()
+                for (widgetId in ids) {
+                  updateAppWidget(
+                          context,
+                          appWidgetManager,
+                          widgetId,
+                          playbackSession,
+                          isPlaying,
+                          PlayerNotificationService.isClosed
+                  )
+                }
+              }

-        for (widgetId in ids) {
-          updateAppWidget(context, appWidgetManager, widgetId, playbackSession, isPlaying, PlayerNotificationService.isClosed)
-        }
-      }
-      override fun onPlayerClosed() {
-        val appWidgetManager = AppWidgetManager.getInstance(context)
-        val componentName = ComponentName(context, MediaPlayerWidget::class.java)
-        val ids = appWidgetManager.getAppWidgetIds(componentName)
-        for (widgetId in ids) {
-          updateAppWidget(context, appWidgetManager, widgetId, deviceData.lastPlaybackSession, false, PlayerNotificationService.isClosed)
-        }
-      }
-    })
+              override fun onPlayerClosed() {
+                val appWidgetManager = AppWidgetManager.getInstance(context)
+                val componentName = ComponentName(context, MediaPlayerWidget::class.java)
+                val ids = appWidgetManager.getAppWidgetIds(componentName)
+                for (widgetId in ids) {
+                  updateAppWidget(
+                          context,
+                          appWidgetManager,
+                          widgetId,
+                          deviceData.lastPlaybackSession,
+                          false,
+                          PlayerNotificationService.isClosed
+                  )
+                }
+              }
+            })
  }
 }
@@ -7,360 +7,306 @@ import androidx.documentfile.provider.DocumentFile
 import com.anggrayudi.storage.file.*
 import com.audiobookshelf.app.data.*
 import com.audiobookshelf.app.models.DownloadItem
-import com.fasterxml.jackson.core.json.JsonReadFeature
-import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.audiobookshelf.app.models.DownloadItemPart
 import java.io.File

-class FolderScanner(var ctx: Context) {
+/** Creates local-library records from a completed download manifest. */
+class FolderScanner(private val ctx: Context) {
  private val tag = "FolderScanner"
-  private var jacksonMapper = jacksonObjectMapper().enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature())

-  data class DownloadItemScanResult(val localLibraryItem:LocalLibraryItem, var localMediaProgress:LocalMediaProgress?)
+  data class DownloadItemScanResult(
+          val localLibraryItem: LocalLibraryItem,
+          var localMediaProgress: LocalMediaProgress?
+  )

-  private fun getLocalLibraryItemId(mediaItemId:String):String {
-    return "local_" + DeviceManager.getBase64Id(mediaItemId)
-  }
+  private fun localLibraryItemId(mediaItemId: String) =
+          "local_${DeviceManager.getBase64Id(mediaItemId)}"

-  private fun scanInternalDownloadItem(downloadItem:DownloadItem, cb: (DownloadItemScanResult?) -> Unit) {
-    val localLibraryItemId = "local_${downloadItem.libraryItemId}"
-
-    var localEpisodeId:String? = null
-    var localLibraryItem:LocalLibraryItem?
-    if (downloadItem.mediaType == "book") {
-      localLibraryItem = LocalLibraryItem(localLibraryItemId, downloadItem.localFolder.id, downloadItem.itemFolderPath, downloadItem.itemFolderPath, "", false, downloadItem.mediaType, downloadItem.media.getLocalCopy(), mutableListOf(), null, null, true, downloadItem.serverConnectionConfigId, downloadItem.serverAddress, downloadItem.serverUserId, downloadItem.libraryItemId)
-    } else {
-      // Lookup or create podcast local library item
-      localLibraryItem = DeviceManager.dbManager.getLocalLibraryItem(localLibraryItemId)
-      if (localLibraryItem == null) {
-        Log.d(tag, "[FolderScanner] Podcast local library item not created yet for ${downloadItem.media.metadata.title}")
-        localLibraryItem = LocalLibraryItem(localLibraryItemId, downloadItem.localFolder.id, downloadItem.itemFolderPath, downloadItem.itemFolderPath, "", false, downloadItem.mediaType, downloadItem.media.getLocalCopy(), mutableListOf(), null, null, true,downloadItem.serverConnectionConfigId,downloadItem.serverAddress,downloadItem.serverUserId,downloadItem.libraryItemId)
-      }
+  private fun createLocalFile(
+          part: DownloadItemPart,
+          externalFile: DocumentFile? = null
+  ): LocalFile? {
+    if (part.isInternalStorage) {
+      val file = File(part.finalDestinationPath)
+      if (!file.exists()) return null
+      return LocalFile(
+              DeviceManager.getBase64Id(file.name),
+              file.name,
+              Uri.fromFile(file).toString(),
+              file.getBasePath(ctx),
+              file.absolutePath,
+              file.mimeType,
+              file.length()
+      )
    }

-    val audioTracks:MutableList<AudioTrack> = mutableListOf()
-    var foundEBookFile = false
+    part.completedDestinationUri?.let { contentUrl ->
+      val uri = Uri.parse(contentUrl)
+      val size =
+              try {
+                ctx.contentResolver.openFileDescriptor(uri, "r")?.use { descriptor ->
+                  descriptor.statSize.coerceAtLeast(0L)
+                }
+                        ?: 0L
+              } catch (e: Exception) {
+                Log.e(tag, "Could not open completed SAF file: $contentUrl", e)
+                return null
+              }
+      // Android 10 DownloadsProvider may not reconstruct a DocumentFile for an audio URI even
+      // though the URI remains readable. Keep the URI as the authoritative local-file location.
+      return LocalFile(
+              DeviceManager.getBase64Id(contentUrl),
+              part.filename,
+              contentUrl,
+              part.localFolderName,
+              part.finalDestinationPath,
+              mimeTypeFor(part),
+              size
+      )
+    }

-    downloadItem.downloadItemParts.forEach { downloadItemPart ->
-      Log.d(tag, "Scan internal storage item with finalDestinationUri=${downloadItemPart.finalDestinationUri}")
+    // Do not reconstruct a DocumentFile from an absolute path: on Android 10 that becomes a
+    // file:// URI, which DocumentsContract rejects. The caller resolves this from the persisted
+    // SAF tree grant instead.
+    val document = externalFile
+    if (document == null || !document.exists()) {
+      Log.e(tag, "Could not resolve downloaded SAF file: ${part.finalDestinationPath}")
+      return null
+    }
+    return LocalFile(
+            DeviceManager.getBase64Id(document.id),
+            document.name,
+            document.uri.toString(),
+            document.getBasePath(ctx),
+            document.getAbsolutePath(ctx),
+            document.mimeType,
+            document.length()
+    )
+  }

-      val file = File(downloadItemPart.finalDestinationPath)
-      Log.d(tag, "Scan internal storage item created file ${file.name}")
-
-      if (file == null) {
-        Log.e(tag, "scanInternalDownloadItem: Null docFile for path ${downloadItemPart.finalDestinationPath}")
-      } else {
-        if (downloadItemPart.audioTrack != null) {
-          val audioTrackFromServer = downloadItemPart.audioTrack
-          Log.d(
-            tag,
-            "scanInternalDownloadItem: Audio Track from Server index = ${audioTrackFromServer.index}"
+  private fun newLocalLibraryItem(
+          id: String,
+          downloadItem: DownloadItem,
+          basePath: String,
+          absolutePath: String,
+          contentUrl: String
+  ) =
+          LocalLibraryItem(
+                  id,
+                  downloadItem.localFolder.id,
+                  basePath,
+                  absolutePath,
+                  contentUrl,
+                  false,
+                  downloadItem.mediaType,
+                  downloadItem.media.getLocalCopy(),
+                  mutableListOf(),
+                  null,
+                  null,
+                  true,
+                  downloadItem.serverConnectionConfigId,
+                  downloadItem.serverAddress,
+                  downloadItem.serverUserId,
+                  downloadItem.libraryItemId
          )

-          val localFileId = DeviceManager.getBase64Id(file.name)
-          Log.d(tag, "Scan internal file localFileId=$localFileId")
-          val localFile = LocalFile(
-            localFileId,
-            file.name,
-            downloadItemPart.finalDestinationUri.toString(),
-            file.getBasePath(ctx),
-            file.absolutePath,
-            file.getSimplePath(ctx),
-            file.mimeType,
-            file.length()
-          )
-          localLibraryItem.localFiles.add(localFile)
+  private fun scanParts(
+          item: DownloadItem,
+          localItem: LocalLibraryItem,
+          externalFolder: DocumentFile? = null,
+          callback: (DownloadItemScanResult?) -> Unit
+  ) {
+    val tracks = mutableListOf<AudioTrack>()
+    var foundEbook = false
+    var localEpisodeId: String? = null

-          // Create new audio track
-          val track = AudioTrack(
-            audioTrackFromServer.index,
-            audioTrackFromServer.startOffset,
-            audioTrackFromServer.duration,
-            localFile.filename ?: "",
-            localFile.contentUrl,
-            localFile.mimeType ?: "",
-            null,
-            true,
-            localFileId,
-            null,
-            audioTrackFromServer.index
-          )
-          audioTracks.add(track)
-
-          Log.d(
-            tag,
-            "scanInternalDownloadItem: Created Audio Track with index ${track.index} from local file ${localFile.absolutePath}"
-          )
-
-          // Add podcast episodes to library
-          downloadItemPart.episode?.let { podcastEpisode ->
-            val podcast = localLibraryItem.media as Podcast
-            val newEpisode = podcast.addEpisode(track, podcastEpisode)
-            localEpisodeId = newEpisode.id
-            Log.d(
-              tag,
-              "scanInternalDownloadItem: Added episode to podcast ${podcastEpisode.title} ${track.title} | Track index: ${podcastEpisode.audioTrack?.index}"
-            )
+    item.downloadItemParts.forEach { part ->
+      val externalFile =
+              if (part.isInternalStorage) {
+                null
+              } else {
+                part.completedDestinationUri?.let { DocumentFileCompat.fromUri(ctx, Uri.parse(it)) }
+                        ?: resolveExternalFile(externalFolder, part)
+              }
+      Log.d(tag, "Resolve part ${part.filename}: externalFile=${externalFile?.uri}")
+      val localFile = createLocalFile(part, externalFile) ?: return@forEach
+      when {
+        part.audioTrack != null -> {
+          val serverTrack = part.audioTrack
+          localItem.localFiles.removeAll { it.id == localFile.id }
+          localItem.localFiles.add(localFile)
+          val metadata =
+                  FileMetadata(
+                          localFile.filename ?: "",
+                          File(localFile.filename ?: "").extension,
+                          localFile.absolutePath,
+                          localFile.basePath,
+                          localFile.size
+                  )
+          val track =
+                  AudioTrack(
+                          serverTrack.index,
+                          serverTrack.startOffset,
+                          serverTrack.duration,
+                          localFile.filename ?: "",
+                          localFile.contentUrl,
+                          localFile.mimeType ?: "",
+                          metadata,
+                          true,
+                          localFile.id,
+                          serverTrack.index
+                  )
+          tracks.add(track)
+          Log.d(tag, "Added local audio track ${track.contentUrl} (${track.metadata?.path})")
+          part.episode?.let { episode ->
+            val podcast = localItem.media as Podcast
+            localEpisodeId = podcast.addEpisode(track, episode).id
          }
-
-        } else if (downloadItemPart.ebookFile != null) {
-          foundEBookFile = true
-          Log.d(tag, "scanInternalDownloadItem: Ebook file found with mimetype=${file.mimeType}")
-          val localFileId = DeviceManager.getBase64Id(file.name)
-          val localFile = LocalFile(
-            localFileId,
-            file.name,
-            Uri.fromFile(file).toString(),
-            file.getBasePath(ctx),
-            file.absolutePath,
-            file.getSimplePath(ctx),
-            file.mimeType,
-            file.length()
-          )
-          localLibraryItem.localFiles.add(localFile)
-
-          val ebookFile = EBookFile(
-            downloadItemPart.ebookFile.ino,
-            downloadItemPart.ebookFile.metadata,
-            downloadItemPart.ebookFile.ebookFormat,
-            true,
-            localFileId,
-            localFile.contentUrl
-          )
-          (localLibraryItem.media as Book).ebookFile = ebookFile
-          Log.d(tag, "scanInternalDownloadItem: Ebook file added to lli ${localFile.contentUrl}")
-        } else {
-          val localFileId = DeviceManager.getBase64Id(file.name)
-          val localFile = LocalFile(localFileId,file.name,Uri.fromFile(file).toString(),file.getBasePath(ctx),file.absolutePath,file.getSimplePath(ctx),file.mimeType,file.length())
-
-          localLibraryItem.coverAbsolutePath = localFile.absolutePath
-          localLibraryItem.coverContentUrl = localFile.contentUrl
-          localLibraryItem.localFiles.add(localFile)
+        }
+        part.ebookFile != null -> {
+          foundEbook = true
+          localItem.localFiles.removeAll { it.id == localFile.id }
+          localItem.localFiles.add(localFile)
+          (localItem.media as Book).ebookFile =
+                  EBookFile(
+                          part.ebookFile.ino,
+                          part.ebookFile.metadata,
+                          part.ebookFile.ebookFormat,
+                          true,
+                          localFile.id,
+                          localFile.contentUrl
+                  )
+        }
+        else -> {
+          localItem.coverAbsolutePath = localFile.absolutePath
+          localItem.coverContentUrl = localFile.contentUrl
+          localItem.localFiles.removeAll { it.id == localFile.id }
+          localItem.localFiles.add(localFile)
        }
      }
    }

-    if (audioTracks.isEmpty() && !foundEBookFile) {
-      Log.d(tag, "scanDownloadItem did not find any audio tracks or ebook file in folder for ${downloadItem.itemFolderPath}")
-      return cb(null)
+    if (tracks.isEmpty() && !foundEbook) {
+      callback(null)
+      return
    }
-
-    // For books sort audio tracks then set
-    if (downloadItem.mediaType == "book") {
-      audioTracks.sortBy { it.index }
-
-      var indexCheck = 1
-      var startOffset = 0.0
-      audioTracks.forEach { audioTrack ->
-        if (audioTrack.index != indexCheck || audioTrack.startOffset != startOffset) {
-          audioTrack.index = indexCheck
-          audioTrack.startOffset = startOffset
-        }
-        indexCheck++
-        startOffset += audioTrack.duration
+    if (item.mediaType == "book") {
+      tracks.sortBy { it.index }
+      var expectedIndex = 1
+      var offset = 0.0
+      tracks.forEach { track ->
+        track.index = expectedIndex++
+        track.startOffset = offset
+        offset += track.duration
      }
-
-      localLibraryItem.media.setAudioTracks(audioTracks)
+      localItem.media.setAudioTracks(tracks)
    }

-    val downloadItemScanResult = DownloadItemScanResult(localLibraryItem,null)
-
-    // If library item had media progress then make local media progress and save
-    downloadItem.userMediaProgress?.let { mediaProgress ->
-      val localMediaProgressId = if (downloadItem.episodeId.isNullOrEmpty()) localLibraryItemId else "$localLibraryItemId-$localEpisodeId"
-      val newLocalMediaProgress = LocalMediaProgress(
-        id = localMediaProgressId,
-        localLibraryItemId = localLibraryItemId,
-        localEpisodeId = localEpisodeId,
-        duration = mediaProgress.duration,
-        progress = mediaProgress.progress,
-        currentTime = mediaProgress.currentTime,
-        isFinished = mediaProgress.isFinished,
-        ebookLocation = mediaProgress.ebookLocation,
-        ebookProgress = mediaProgress.ebookProgress,
-        lastUpdate = mediaProgress.lastUpdate,
-        startedAt = mediaProgress.startedAt,
-        finishedAt = mediaProgress.finishedAt,
-        serverConnectionConfigId = downloadItem.serverConnectionConfigId,
-        serverAddress = downloadItem.serverAddress,
-        serverUserId = downloadItem.serverUserId,
-        libraryItemId = downloadItem.libraryItemId,
-        episodeId = downloadItem.episodeId)
-      Log.d(tag, "scanLibraryItemFolder: Saving local media progress ${newLocalMediaProgress.id} at progress ${newLocalMediaProgress.progress}")
-      DeviceManager.dbManager.saveLocalMediaProgress(newLocalMediaProgress)
-
-      downloadItemScanResult.localMediaProgress = newLocalMediaProgress
+    val result = DownloadItemScanResult(localItem, null)
+    item.userMediaProgress?.let { progress ->
+      val progressId =
+              if (item.episodeId.isNullOrEmpty()) localItem.id
+              else "${localItem.id}-$localEpisodeId"
+      result.localMediaProgress =
+              LocalMediaProgress(
+                      progressId,
+                      localItem.id,
+                      localEpisodeId,
+                      progress.duration,
+                      progress.progress,
+                      progress.currentTime,
+                      progress.isFinished,
+                      progress.ebookLocation,
+                      progress.ebookProgress,
+                      progress.lastUpdate,
+                      progress.startedAt,
+                      progress.finishedAt,
+                      item.serverConnectionConfigId,
+                      item.serverAddress,
+                      item.serverUserId,
+                      item.libraryItemId,
+                      item.episodeId
+              )
+      DeviceManager.dbManager.saveLocalMediaProgress(result.localMediaProgress!!)
    }
-
-    DeviceManager.dbManager.saveLocalLibraryItem(localLibraryItem)
-
-    cb(downloadItemScanResult)
+    DeviceManager.dbManager.saveLocalLibraryItem(localItem)
+    callback(result)
  }

-  // Scan item after download and create local library item
-  fun scanDownloadItem(downloadItem: DownloadItem, cb: (DownloadItemScanResult?) -> Unit) {
-    // If downloading to internal storage handle separately
-    if (downloadItem.isInternalStorage) {
-      scanInternalDownloadItem(downloadItem, cb)
+  private fun findFolderByPath(root: DocumentFile, subPath: String): DocumentFile? {
+    if (subPath.isBlank()) return root
+    var current = root
+    subPath.split('/').filter { it.isNotBlank() }.forEach { segment ->
+      if (segment == "." || segment == "..") return null
+      current = current.findFile(segment) ?: return null
+    }
+    return current
+  }
+
+  /**
+   * DownloadsProvider on Android 10 may expose an audio document without its extension through
+   * DocumentFile.findFile(). Match the manifest first, then match the provider-normalized base
+   * filename. MIME type and server-reported size are unreliable for Opus on this platform.
+   */
+  private fun resolveExternalFile(folder: DocumentFile?, part: DownloadItemPart): DocumentFile? {
+    if (folder == null) return null
+    folder.findFile(part.filename)?.let {
+      return it
+    }
+    val expectedBaseName = part.filename.substringBeforeLast('.')
+    return folder.listFiles().firstOrNull { document ->
+      document.name == part.filename ||
+              document.fullName == part.filename ||
+              (part.audioTrack != null &&
+                      document.isFile &&
+                      (document.name ?: "").substringBeforeLast('.') == expectedBaseName) ||
+              (part.audioTrack != null &&
+                      document.isFile &&
+                      document.fullName.substringBeforeLast('.') == expectedBaseName)
+    }
+  }
+
+  private fun mimeTypeFor(part: DownloadItemPart): String? {
+    return part.audioTrack?.mimeType
+            ?: when (part.ebookFile?.ebookFormat?.lowercase()) {
+              "epub" -> "application/epub+zip"
+              "pdf" -> "application/pdf"
+              else -> "image/jpeg"
+            }
+  }
+
+  fun scanDownloadItem(item: DownloadItem, callback: (DownloadItemScanResult?) -> Unit) {
+    if (item.isInternalStorage) {
+      val id = "local_${item.libraryItemId}"
+      val localItem =
+              DeviceManager.dbManager.getLocalLibraryItem(id)
+                      ?: newLocalLibraryItem(id, item, item.itemFolderPath, item.itemFolderPath, "")
+      scanParts(item, localItem, callback = callback)
      return
    }

-    val folderDf = DocumentFileCompat.fromUri(ctx, Uri.parse(downloadItem.localFolder.contentUrl))
-    val foldersFound =  folderDf?.search(true, DocumentFileType.FOLDER) ?: mutableListOf()
-
-    var itemFolderId = ""
-    var itemFolderUrl = ""
-    var itemFolderBasePath = ""
-    var itemFolderAbsolutePath = ""
-    foldersFound.forEach {
-      // e.g. absolute path is "storage/emulated/0/Audiobooks/Orson Scott Card/Enders Game"
-      //        and itemSubfolder is "Orson Scott Card/Enders Game"
-      if (it.getAbsolutePath(ctx).endsWith(downloadItem.itemSubfolder)) {
-        itemFolderId = it.id
-        itemFolderUrl = it.uri.toString()
-        itemFolderBasePath = it.getBasePath(ctx)
-        itemFolderAbsolutePath = it.getAbsolutePath(ctx)
-      }
+    val root = DocumentFileCompat.fromUri(ctx, Uri.parse(item.localFolder.contentUrl))
+    if (root == null) {
+      Log.e(tag, "Invalid SAF root: ${item.localFolder.contentUrl}")
+      callback(null)
+      return
    }
-
-    if (itemFolderUrl == "") {
-      Log.d(tag, "scanDownloadItem failed to find media folder")
-      return cb(null)
+    val itemFolder = findFolderByPath(root, item.itemSubfolder)
+    if (itemFolder == null) {
+      Log.e(tag, "SAF item folder not found: ${item.itemSubfolder}")
+      callback(null)
+      return
    }
-    val df: DocumentFile? = DocumentFileCompat.fromUri(ctx, Uri.parse(itemFolderUrl))
-
-    if (df == null) {
-      Log.e(tag, "Folder Doc File Invalid ${downloadItem.itemFolderPath}")
-      return cb(null)
-    }
-
-    val localLibraryItemId = getLocalLibraryItemId(itemFolderId)
-    Log.d(tag, "scanDownloadItem starting for ${downloadItem.itemFolderPath} | ${df.uri} | Item Folder Id:$itemFolderId | LLI Id:$localLibraryItemId")
-
-    // Search for files in media item folder
-    // m4b files showing as mimeType application/octet-stream on Android 10 and earlier see #154
-    val filesFound = df.search(false, DocumentFileType.FILE, arrayOf("audio/*", "image/*", "video/mp4", "application/*"))
-    Log.d(tag, "scanDownloadItem ${filesFound.size} files found in ${downloadItem.itemFolderPath}")
-
-    var localEpisodeId:String? = null
-    var localLibraryItem:LocalLibraryItem?
-    if (downloadItem.mediaType == "book") {
-      localLibraryItem = LocalLibraryItem(localLibraryItemId, downloadItem.localFolder.id, itemFolderBasePath, itemFolderAbsolutePath, itemFolderUrl, false, downloadItem.mediaType, downloadItem.media.getLocalCopy(), mutableListOf(), null, null, true, downloadItem.serverConnectionConfigId, downloadItem.serverAddress, downloadItem.serverUserId, downloadItem.libraryItemId)
-    } else {
-      // Lookup or create podcast local library item
-      localLibraryItem = DeviceManager.dbManager.getLocalLibraryItem(localLibraryItemId)
-      if (localLibraryItem == null) {
-        Log.d(tag, "[FolderScanner] Podcast local library item not created yet for ${downloadItem.media.metadata.title}")
-        localLibraryItem = LocalLibraryItem(localLibraryItemId, downloadItem.localFolder.id, itemFolderBasePath, itemFolderAbsolutePath, itemFolderUrl, false, downloadItem.mediaType, downloadItem.media.getLocalCopy(), mutableListOf(), null, null, true,downloadItem.serverConnectionConfigId,downloadItem.serverAddress,downloadItem.serverUserId,downloadItem.libraryItemId)
-      }
-    }
-
-    val audioTracks:MutableList<AudioTrack> = mutableListOf()
-    var foundEBookFile = false
-
-    filesFound.forEach { docFile ->
-      val itemPart = downloadItem.downloadItemParts.find { itemPart ->
-        itemPart.filename == docFile.name
-      }
-      if (itemPart == null) {
-        if (downloadItem.mediaType == "book") { // for books every download item should be a file found
-          Log.e(tag, "scanDownloadItem: Item part not found for doc file ${docFile.name} | ${docFile.getAbsolutePath(ctx)} | ${docFile.uri}")
-        }
-      } else if (itemPart.audioTrack != null) { // Is audio track
-        val audioTrackFromServer = itemPart.audioTrack
-        Log.d(tag, "scanDownloadItem: Audio Track from Server index = ${audioTrackFromServer.index}")
-
-        val localFileId = DeviceManager.getBase64Id(docFile.id)
-        val localFile = LocalFile(localFileId,docFile.name,docFile.uri.toString(),docFile.getBasePath(ctx),docFile.getAbsolutePath(ctx),docFile.getSimplePath(ctx),docFile.mimeType,docFile.length())
-        localLibraryItem.localFiles.add(localFile)
-
-        // Create new audio track
-        val track = AudioTrack(audioTrackFromServer.index, audioTrackFromServer.startOffset, audioTrackFromServer.duration, localFile.filename ?: "", localFile.contentUrl, localFile.mimeType ?: "", null, true, localFileId, null, audioTrackFromServer.index)
-        audioTracks.add(track)
-
-        Log.d(tag, "scanDownloadItem: Created Audio Track with index ${track.index} from local file ${localFile.absolutePath}")
-
-        // Add podcast episodes to library
-        itemPart.episode?.let { podcastEpisode ->
-          val podcast = localLibraryItem.media as Podcast
-          val newEpisode = podcast.addEpisode(track, podcastEpisode)
-          localEpisodeId = newEpisode.id
-          Log.d(tag, "scanDownloadItem: Added episode to podcast ${podcastEpisode.title} ${track.title} | Track index: ${podcastEpisode.audioTrack?.index}")
-        }
-      } else if (itemPart.ebookFile != null) { // Ebook
-        foundEBookFile = true
-        Log.d(tag, "scanDownloadItem: Ebook file found with mimetype=${docFile.mimeType}")
-        val localFileId = DeviceManager.getBase64Id(docFile.id)
-        val localFile = LocalFile(localFileId,docFile.name,docFile.uri.toString(),docFile.getBasePath(ctx),docFile.getAbsolutePath(ctx),docFile.getSimplePath(ctx),docFile.mimeType,docFile.length())
-        localLibraryItem.localFiles.add(localFile)
-
-        val ebookFile = EBookFile(itemPart.ebookFile.ino, itemPart.ebookFile.metadata, itemPart.ebookFile.ebookFormat, true, localFileId, localFile.contentUrl)
-        (localLibraryItem.media as Book).ebookFile = ebookFile
-        Log.d(tag, "scanDownloadItem: Ebook file added to lli ${localFile.contentUrl}")
-      } else { // Cover image
-        val localFileId = DeviceManager.getBase64Id(docFile.id)
-        val localFile = LocalFile(localFileId,docFile.name,docFile.uri.toString(),docFile.getBasePath(ctx),docFile.getAbsolutePath(ctx),docFile.getSimplePath(ctx),docFile.mimeType,docFile.length())
-
-        localLibraryItem.coverAbsolutePath = localFile.absolutePath
-        localLibraryItem.coverContentUrl = localFile.contentUrl
-        localLibraryItem.localFiles.add(localFile)
-      }
-    }
-
-    if (audioTracks.isEmpty() && !foundEBookFile) {
-      Log.d(tag, "scanDownloadItem did not find any audio tracks or ebook file in folder for ${downloadItem.itemFolderPath}")
-      return cb(null)
-    }
-
-    // For books sort audio tracks then set
-    if (downloadItem.mediaType == "book") {
-      audioTracks.sortBy { it.index }
-
-      var indexCheck = 1
-      var startOffset = 0.0
-      audioTracks.forEach { audioTrack ->
-        if (audioTrack.index != indexCheck || audioTrack.startOffset != startOffset) {
-          audioTrack.index = indexCheck
-          audioTrack.startOffset = startOffset
-        }
-        indexCheck++
-        startOffset += audioTrack.duration
-      }
-
-      localLibraryItem.media.setAudioTracks(audioTracks)
-    }
-
-    val downloadItemScanResult = DownloadItemScanResult(localLibraryItem,null)
-
-    // If library item had media progress then make local media progress and save
-    downloadItem.userMediaProgress?.let { mediaProgress ->
-      val localMediaProgressId = if (downloadItem.episodeId.isNullOrEmpty()) localLibraryItemId else "$localLibraryItemId-$localEpisodeId"
-      val newLocalMediaProgress = LocalMediaProgress(
-        id = localMediaProgressId,
-        localLibraryItemId = localLibraryItemId,
-        localEpisodeId = localEpisodeId,
-        duration = mediaProgress.duration,
-        progress = mediaProgress.progress,
-        currentTime = mediaProgress.currentTime,
-        isFinished = mediaProgress.isFinished,
-        ebookLocation = mediaProgress.ebookLocation,
-        ebookProgress = mediaProgress.ebookProgress,
-        lastUpdate = mediaProgress.lastUpdate,
-        startedAt = mediaProgress.startedAt,
-        finishedAt = mediaProgress.finishedAt,
-        serverConnectionConfigId = downloadItem.serverConnectionConfigId,
-        serverAddress = downloadItem.serverAddress,
-        serverUserId = downloadItem.serverUserId,
-        libraryItemId = downloadItem.libraryItemId,
-        episodeId = downloadItem.episodeId)
-      Log.d(tag, "scanLibraryItemFolder: Saving local media progress ${newLocalMediaProgress.id} at progress ${newLocalMediaProgress.progress}")
-
-      DeviceManager.dbManager.saveLocalMediaProgress(newLocalMediaProgress)
-
-      downloadItemScanResult.localMediaProgress = newLocalMediaProgress
-    }
-
-    DeviceManager.dbManager.saveLocalLibraryItem(localLibraryItem)
-
-    cb(downloadItemScanResult)
+    val id = localLibraryItemId(itemFolder.id)
+    val localItem =
+            DeviceManager.dbManager.getLocalLibraryItem(id)
+                    ?: newLocalLibraryItem(
+                            id,
+                            item,
+                            itemFolder.getBasePath(ctx),
+                            itemFolder.getAbsolutePath(ctx),
+                            itemFolder.uri.toString()
+                    )
+    scanParts(item, localItem, itemFolder, callback)
  }
 }
@@ -4,8 +4,9 @@ import android.content.Context
 import android.util.Log
 import com.audiobookshelf.app.data.*
 import com.audiobookshelf.app.models.DownloadItem
+import com.audiobookshelf.app.plugins.AbsLog
+import com.audiobookshelf.app.plugins.AbsLogger
 import io.paperdb.Paper
-import java.io.File

 class DbManager {
  val tag = "DbManager"
@@ -22,45 +23,47 @@ class DbManager {
  }

  fun getDeviceData(): DeviceData {
-    return Paper.book("device").read("data") ?: DeviceData(mutableListOf(), null, DeviceSettings.default(), null)
+    return Paper.book("device").read("data")
+            ?: DeviceData(mutableListOf(), null, DeviceSettings.default(), null)
  }
  fun saveDeviceData(deviceData: DeviceData) {
    Paper.book("device").write("data", deviceData)
  }

-  fun getLocalLibraryItems(mediaType:String? = null):MutableList<LocalLibraryItem> {
-    val localLibraryItems:MutableList<LocalLibraryItem> = mutableListOf()
+  fun getLocalLibraryItems(mediaType: String? = null): MutableList<LocalLibraryItem> {
+    val localLibraryItems: MutableList<LocalLibraryItem> = mutableListOf()
    Paper.book("localLibraryItems").allKeys.forEach {
      val localLibraryItem: LocalLibraryItem? = Paper.book("localLibraryItems").read(it)
-      if (localLibraryItem != null && (mediaType.isNullOrEmpty() || mediaType == localLibraryItem.mediaType)) {
+      if (localLibraryItem != null &&
+                      (mediaType.isNullOrEmpty() || mediaType == localLibraryItem.mediaType)
+      ) {
        localLibraryItems.add(localLibraryItem)
      }
    }
    return localLibraryItems
  }

-  fun getLocalLibraryItemsInFolder(folderId:String):List<LocalLibraryItem> {
+  fun getLocalLibraryItemsInFolder(folderId: String): List<LocalLibraryItem> {
    val localLibraryItems = getLocalLibraryItems()
-    return localLibraryItems.filter {
-      it.folderId == folderId
-    }
+    return localLibraryItems.filter { it.folderId == folderId }
  }

-  fun getLocalLibraryItemByLId(libraryItemId:String): LocalLibraryItem? {
+  fun getLocalLibraryItemByLId(libraryItemId: String): LocalLibraryItem? {
    return getLocalLibraryItems().find { it.libraryItemId == libraryItemId }
  }

-  fun getLocalLibraryItem(localLibraryItemId:String): LocalLibraryItem? {
+  fun getLocalLibraryItem(localLibraryItemId: String): LocalLibraryItem? {
    return Paper.book("localLibraryItems").read(localLibraryItemId)
  }

-  fun getLocalLibraryItemWithEpisode(podcastEpisodeId:String): LibraryItemWithEpisode? {
+  fun getLocalLibraryItemWithEpisode(podcastEpisodeId: String): LibraryItemWithEpisode? {
    var podcastEpisode: PodcastEpisode? = null
-    val localLibraryItem = getLocalLibraryItems("podcast").find { localLibraryItem ->
-      val podcast = localLibraryItem.media as Podcast
-      podcastEpisode = podcast.episodes?.find { it.id == podcastEpisodeId }
-      podcastEpisode != null
-    }
+    val localLibraryItem =
+            getLocalLibraryItems("podcast").find { localLibraryItem ->
+              val podcast = localLibraryItem.media as Podcast
+              podcastEpisode = podcast.episodes?.find { it.id == podcastEpisodeId }
+              podcastEpisode != null
+            }
    return if (localLibraryItem != null) {
      LibraryItemWithEpisode(localLibraryItem, podcastEpisode!!)
    } else {
@@ -68,14 +71,12 @@ class DbManager {
    }
  }

-  fun removeLocalLibraryItem(localLibraryItemId:String) {
+  fun removeLocalLibraryItem(localLibraryItemId: String) {
    Paper.book("localLibraryItems").delete(localLibraryItemId)
  }

-  fun saveLocalLibraryItems(localLibraryItems:List<LocalLibraryItem>) {
-    localLibraryItems.map {
-        Paper.book("localLibraryItems").write(it.id, it)
-      }
+  fun saveLocalLibraryItems(localLibraryItems: List<LocalLibraryItem>) {
+    localLibraryItems.map { Paper.book("localLibraryItems").write(it.id, it) }
  }

  fun saveLocalLibraryItem(localLibraryItem: LocalLibraryItem) {
@@ -83,28 +84,24 @@ class DbManager {
  }

  fun saveLocalFolder(localFolder: LocalFolder) {
-    Paper.book("localFolders").write(localFolder.id,localFolder)
+    Paper.book("localFolders").write(localFolder.id, localFolder)
  }

-  fun getLocalFolder(folderId:String): LocalFolder? {
+  fun getLocalFolder(folderId: String): LocalFolder? {
    return Paper.book("localFolders").read(folderId)
  }

-  fun getAllLocalFolders():List<LocalFolder> {
-    val localFolders:MutableList<LocalFolder> = mutableListOf()
+  fun getAllLocalFolders(): List<LocalFolder> {
+    val localFolders: MutableList<LocalFolder> = mutableListOf()
    Paper.book("localFolders").allKeys.forEach { localFolderId ->
-      Paper.book("localFolders").read<LocalFolder>(localFolderId)?.let {
-        localFolders.add(it)
-      }
+      Paper.book("localFolders").read<LocalFolder>(localFolderId)?.let { localFolders.add(it) }
    }
    return localFolders
  }

-  fun removeLocalFolder(folderId:String) {
+  fun removeLocalFolder(folderId: String) {
    val localLibraryItems = getLocalLibraryItemsInFolder(folderId)
-    localLibraryItems.forEach {
-      Paper.book("localLibraryItems").delete(it.id)
-    }
+    localLibraryItems.forEach { Paper.book("localLibraryItems").delete(it.id) }
    Paper.book("localFolders").delete(folderId)
  }

@@ -112,29 +109,108 @@ class DbManager {
    Paper.book("downloadItems").write(downloadItem.id, downloadItem)
  }

-  fun removeDownloadItem(downloadItemId:String) {
+  fun removeDownloadItem(downloadItemId: String) {
    Paper.book("downloadItems").delete(downloadItemId)
  }

-  fun getDownloadItems():List<DownloadItem> {
-    val downloadItems:MutableList<DownloadItem> = mutableListOf()
+  fun getDownloadItems(): List<DownloadItem> {
+    val downloadItems: MutableList<DownloadItem> = mutableListOf()
    Paper.book("downloadItems").allKeys.forEach { downloadItemId ->
-      Paper.book("downloadItems").read<DownloadItem>(downloadItemId)?.let {
-        downloadItems.add(it)
-      }
+      Paper.book("downloadItems").read<DownloadItem>(downloadItemId)?.let { downloadItems.add(it) }
    }
    return downloadItems
  }

-  fun saveLocalMediaProgress(mediaProgress: LocalMediaProgress) {
-    Paper.book("localMediaProgress").write(mediaProgress.id,mediaProgress)
+  /**
+   * Validate persisted download queue entries before restoring them.
+   *
+   * Queue entries can become incompatible or malformed, for example after an app update. If any
+   * entry cannot be read or fails the checks required for queue restoration, the entire persisted
+   * queue is cleared so startup can continue without restoring invalid data.
+   *
+   * @return true if the queue passes validation or was successfully cleared; false if an invalid
+   * queue could not be cleared
+   */
+  fun ensureValidDownloadQueue(): Boolean {
+    val downloadBook = Paper.book("downloadItems")
+    val queueIsValid =
+            try {
+              downloadBook.allKeys
+                      .map { downloadItemId ->
+                        val item =
+                                downloadBook.read<DownloadItem>(downloadItemId)
+                                        ?: throw IllegalStateException(
+                                                "Download queue entry $downloadItemId could not be read"
+                                        )
+                        if (item.id != downloadItemId) {
+                          throw IllegalStateException(
+                                  "Download queue entry $downloadItemId has a mismatched item ID"
+                          )
+                        }
+                        item
+                      }
+                      .all { item ->
+                        listOf<String?>(item.id, item.libraryItemId, item.localFolder.id).all {
+                          !it.isNullOrBlank()
+                        } &&
+                                item.downloadItemParts.isNotEmpty() &&
+                                item.downloadItemParts.all { part ->
+                                  listOf<String?>(
+                                                  part.id,
+                                                  part.downloadItemId,
+                                                  part.filename,
+                                                  part.destinationPath,
+                                                  part.finalDestinationPath,
+                                                  part.serverPath,
+                                                  part.localFolderId
+                                          )
+                                          .all { !it.isNullOrBlank() } &&
+                                          part.downloadItemId == item.id
+                                }
+                      }
+            } catch (readError: Exception) {
+              AbsLogger.error(
+                      tag,
+                      "Could not read persisted download queue; clearing queue (${readError.message})"
+              )
+              false
+            }
+
+    if (queueIsValid) return true
+
+    AbsLogger.error(tag, "Persisted download queue contains invalid data; clearing queue")
+    return try {
+      downloadBook.destroy()
+      val remainingKeys = downloadBook.allKeys
+      if (remainingKeys.isEmpty()) {
+        AbsLogger.info(tag, "Cleared invalid persisted download queue")
+        true
+      } else {
+        AbsLogger.error(
+                tag,
+                "Invalid persisted download queue still contains ${remainingKeys.size} entries after clearing"
+        )
+        false
+      }
+    } catch (clearError: Exception) {
+      AbsLogger.error(
+              tag,
+              "Could not clear invalid persisted download queue (${clearError.message})"
+      )
+      false
+    }
  }
-  // For books this will just be the localLibraryItemId for podcast episodes this will be "{localLibraryItemId}-{episodeId}"
-  fun getLocalMediaProgress(localMediaProgressId:String): LocalMediaProgress? {
+
+  fun saveLocalMediaProgress(mediaProgress: LocalMediaProgress) {
+    Paper.book("localMediaProgress").write(mediaProgress.id, mediaProgress)
+  }
+  // For books this will just be the localLibraryItemId for podcast episodes this will be
+  // "{localLibraryItemId}-{episodeId}"
+  fun getLocalMediaProgress(localMediaProgressId: String): LocalMediaProgress? {
    return Paper.book("localMediaProgress").read(localMediaProgressId)
  }
-  fun getAllLocalMediaProgress():List<LocalMediaProgress> {
-    val mediaProgress:MutableList<LocalMediaProgress> = mutableListOf()
+  fun getAllLocalMediaProgress(): List<LocalMediaProgress> {
+    val mediaProgress: MutableList<LocalMediaProgress> = mutableListOf()
    Paper.book("localMediaProgress").allKeys.forEach { localMediaProgressId ->
      Paper.book("localMediaProgress").read<LocalMediaProgress>(localMediaProgressId)?.let {
        mediaProgress.add(it)
@@ -142,7 +218,7 @@ class DbManager {
    }
    return mediaProgress
  }
-  fun removeLocalMediaProgress(localMediaProgressId:String) {
+  fun removeLocalMediaProgress(localMediaProgressId: String) {
    Paper.book("localMediaProgress").delete(localMediaProgressId)
  }

@@ -151,57 +227,82 @@ class DbManager {
  }

  // Make sure all local file ids still exist
-  fun cleanLocalLibraryItems() {
+  fun cleanLocalLibraryItems(context: Context) {
    val localLibraryItems = getLocalLibraryItems()

    localLibraryItems.forEach { lli ->
      var hasUpdates = false

      // Check local files
-      lli.localFiles = lli.localFiles.filter { localFile ->
-
-        val file = File(localFile.absolutePath)
-        if (!file.exists()) {
-          Log.d(tag, "cleanLocalLibraryItems: Local file ${localFile.absolutePath} was removed from library item ${lli.media.metadata.title}")
-          hasUpdates = true
-        }
-        file.exists()
-      } as MutableList<LocalFile>
+      lli.localFiles =
+              lli.localFiles.filter { localFile ->
+                val exists = localFile.exists(context)
+                if (!exists) {
+                  Log.d(
+                          tag,
+                          "cleanLocalLibraryItems: Local file ${localFile.absolutePath} was removed from library item ${lli.media.metadata.title}"
+                  )
+                  hasUpdates = true
+                }
+                exists
+              } as
+                      MutableList<LocalFile>

      // Check audio tracks and episodes
      if (lli.isPodcast) {
        val podcast = lli.media as Podcast
-        podcast.episodes = podcast.episodes?.filter { ep ->
-          if (lli.localFiles.find { lf -> lf.id == ep.audioTrack?.localFileId } == null) {
-            Log.d(tag, "cleanLocalLibraryItems: Podcast episode ${ep.title} was removed from library item ${lli.media.metadata.title}")
-            hasUpdates = true
-          }
-          ep.audioTrack != null && lli.localFiles.find { lf -> lf.id == ep.audioTrack?.localFileId } != null
-        } as MutableList<PodcastEpisode>
+        podcast.episodes =
+                podcast.episodes?.filter { ep ->
+                  if (lli.localFiles.find { lf -> lf.id == ep.audioTrack?.localFileId } == null) {
+                    Log.d(
+                            tag,
+                            "cleanLocalLibraryItems: Podcast episode ${ep.title} was removed from library item ${lli.media.metadata.title}"
+                    )
+                    hasUpdates = true
+                  }
+                  ep.audioTrack != null &&
+                          lli.localFiles.find { lf -> lf.id == ep.audioTrack?.localFileId } != null
+                } as
+                        MutableList<PodcastEpisode>
      } else {
        val book = lli.media as Book
-        book.tracks = book.tracks?.filter { track ->
-          if (lli.localFiles.find { lf -> lf.id == track.localFileId } == null) {
-            Log.d(tag, "cleanLocalLibraryItems: Audio track ${track.title} was removed from library item ${lli.media.metadata.title}")
-            hasUpdates = true
-          }
-          lli.localFiles.find { lf -> lf.id == track.localFileId } != null
-        } as MutableList<AudioTrack>
+        book.tracks =
+                book.tracks?.filter { track ->
+                  if (lli.localFiles.find { lf -> lf.id == track.localFileId } == null) {
+                    Log.d(
+                            tag,
+                            "cleanLocalLibraryItems: Audio track ${track.title} was removed from library item ${lli.media.metadata.title}"
+                    )
+                    hasUpdates = true
+                  }
+                  lli.localFiles.find { lf -> lf.id == track.localFileId } != null
+                } as
+                        MutableList<AudioTrack>
      }

      // Check cover still there
      lli.coverAbsolutePath?.let {
-        val coverFile = File(it)
-
-        if (!coverFile.exists()) {
-          Log.d(tag, "cleanLocalLibraryItems: Cover $it was removed from library item ${lli.media.metadata.title}")
+        val coverExists =
+                lli.localFiles.any { localFile ->
+                  localFile.absolutePath == it && localFile.exists(context)
+                }
+        if (!coverExists) {
+          Log.d(
+                  tag,
+                  "cleanLocalLibraryItems: Cover $it was removed from library item ${lli.media.metadata.title}"
+          )
          lli.coverAbsolutePath = null
          lli.coverContentUrl = null
          hasUpdates = true
        }
      }

-      if (hasUpdates) {
+      if (lli.serverConnectionConfigId == null) {
+        // Local-only item support was removed in app version 0.9.67, remove any remaining local
+        // only items beginning in 0.9.80
+        Log.d(tag, "cleanLocalLibraryItems: Local only item ${lli.id} - removing from ABS")
+        Paper.book("localLibraryItems").delete(lli.id)
+      } else if (hasUpdates) {
        Log.d(tag, "cleanLocalLibraryItems: Saving local library item ${lli.id}")
        Paper.book("localLibraryItems").write(lli.id, lli)
      }
@@ -215,11 +316,18 @@ class DbManager {
    localMediaProgress.forEach {
      val matchingLLI = localLibraryItems.find { lli -> lli.id == it.localLibraryItemId }
      if (!it.id.startsWith("local")) {
-        // A bug on the server when syncing local media progress was replacing the media progress id causing duplicate progress. Remove them.
-        Log.d(tag, "cleanLocalMediaProgress: Invalid local media progress does not start with 'local' (fixed on server 2.0.24)")
+        // A bug on the server when syncing local media progress was replacing the media progress id
+        // causing duplicate progress. Remove them.
+        Log.d(
+                tag,
+                "cleanLocalMediaProgress: Invalid local media progress does not start with 'local' (fixed on server 2.0.24)"
+        )
        Paper.book("localMediaProgress").delete(it.id)
      } else if (matchingLLI == null) {
-        Log.d(tag, "cleanLocalMediaProgress: No matching local library item for local media progress ${it.id} - removing")
+        Log.d(
+                tag,
+                "cleanLocalMediaProgress: No matching local library item for local media progress ${it.id} - removing"
+        )
        Paper.book("localMediaProgress").delete(it.id)
      } else if (matchingLLI.isPodcast) {
        if (it.localEpisodeId.isNullOrEmpty()) {
@@ -229,7 +337,10 @@ class DbManager {
          val podcast = matchingLLI.media as Podcast
          val matchingLEp = podcast.episodes?.find { ep -> ep.id == it.localEpisodeId }
          if (matchingLEp == null) {
-            Log.d(tag, "cleanLocalMediaProgress: Podcast media progress for episode ${it.localEpisodeId} not found - removing")
+            Log.d(
+                    tag,
+                    "cleanLocalMediaProgress: Podcast media progress for episode ${it.localEpisodeId} not found - removing"
+            )
            Paper.book("localMediaProgress").delete(it.id)
          }
        }
@@ -238,20 +349,20 @@ class DbManager {
  }

  fun saveMediaItemHistory(mediaItemHistory: MediaItemHistory) {
-    Paper.book("mediaItemHistory").write(mediaItemHistory.id,mediaItemHistory)
+    Paper.book("mediaItemHistory").write(mediaItemHistory.id, mediaItemHistory)
  }
-  fun getMediaItemHistory(id:String): MediaItemHistory? {
+  fun getMediaItemHistory(id: String): MediaItemHistory? {
    return Paper.book("mediaItemHistory").read(id)
  }

  fun savePlaybackSession(playbackSession: PlaybackSession) {
-    Paper.book("playbackSession").write(playbackSession.id,playbackSession)
+    Paper.book("playbackSession").write(playbackSession.id, playbackSession)
  }
-  fun removePlaybackSession(playbackSessionId:String) {
+  fun removePlaybackSession(playbackSessionId: String) {
    Paper.book("playbackSession").delete(playbackSessionId)
  }
-  fun getPlaybackSessions():List<PlaybackSession> {
-    val sessions:MutableList<PlaybackSession> = mutableListOf()
+  fun getPlaybackSessions(): List<PlaybackSession> {
+    val sessions: MutableList<PlaybackSession> = mutableListOf()
    Paper.book("playbackSession").allKeys.forEach { playbackSessionId ->
      Paper.book("playbackSession").read<PlaybackSession>(playbackSessionId)?.let {
        sessions.add(it)
@@ -259,4 +370,36 @@ class DbManager {
    }
    return sessions
  }
+
+  fun saveLog(log: AbsLog) {
+    Paper.book("log").write(log.id, log)
+  }
+  fun getAllLogs(): List<AbsLog> {
+    val logs: MutableList<AbsLog> = mutableListOf()
+    Paper.book("log").allKeys.forEach { logId ->
+      Paper.book("log").read<AbsLog>(logId)?.let { logs.add(it) }
+    }
+    return logs.sortedBy { it.timestamp }
+  }
+  fun removeAllLogs() {
+    Paper.book("log").destroy()
+  }
+  fun cleanLogs() {
+    val numberOfHoursToKeep = 48
+    val keepLogCutoff = System.currentTimeMillis() - (3600000 * numberOfHoursToKeep)
+    val allLogs = getAllLogs()
+    var logsRemoved = 0
+    allLogs.forEach {
+      if (it.timestamp < keepLogCutoff) {
+        Paper.book("log").delete(it.id)
+        logsRemoved++
+      }
+    }
+    if (logsRemoved > 0) {
+      AbsLogger.info(
+              "DbManager",
+              "cleanLogs: Removed $logsRemoved logs older than $numberOfHoursToKeep hours"
+      )
+    }
+  }
 }
@@ -0,0 +1,89 @@
+package com.audiobookshelf.app.managers
+
+import android.content.Context
+import androidx.work.ExistingWorkPolicy
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.WorkManager
+import androidx.work.Worker
+import androidx.work.WorkerParameters
+import com.audiobookshelf.app.device.DeviceManager
+import com.audiobookshelf.app.models.DownloadItem
+import com.audiobookshelf.app.plugins.AbsLogger
+import java.io.File
+import java.util.concurrent.TimeUnit
+
+/** Removes only staging data for terminally failed downloads after their retention window. */
+object IncompleteDownloadCleanup {
+  private const val tag = "IncompleteDownloadCleanup"
+  private const val RETENTION_MS = 24L * 60L * 60L * 1000L
+  private const val WORK_PREFIX = "incomplete-download-"
+
+  fun schedule(context: Context, item: DownloadItem) {
+    val failedAt = item.terminalFailureAt ?: return
+    if (item.stagingCleanupAt != null) return
+    val delay = (failedAt + RETENTION_MS - System.currentTimeMillis()).coerceAtLeast(0L)
+    val request = OneTimeWorkRequestBuilder<IncompleteDownloadCleanupWorker>()
+            .setInitialDelay(delay, TimeUnit.MILLISECONDS)
+            .build()
+    WorkManager.getInstance(context).enqueueUniqueWork(
+            WORK_PREFIX + item.id, ExistingWorkPolicy.REPLACE, request)
+  }
+
+  fun cancel(context: Context, itemId: String) {
+    WorkManager.getInstance(context).cancelUniqueWork(WORK_PREFIX + itemId)
+  }
+
+  /** Cleans staging data retained longer than 24 hours when scheduled work did not run. */
+  @Synchronized
+  fun cleanupExpired(context: Context) {
+    val now = System.currentTimeMillis()
+    DeviceManager.dbManager.getDownloadItems()
+            .filter { item -> isEligible(item, now) }
+            .forEach { item ->
+              deleteItem(context, item)
+            }
+  }
+
+  private fun isEligible(item: DownloadItem, now: Long): Boolean {
+    val failedAt = item.terminalFailureAt ?: return false
+    if (item.stagingCleanupAt != null) return false
+    if (now - failedAt < RETENTION_MS) return false
+    return item.downloadItemParts.all { part ->
+      part.moved || (part.failed && !part.isMoving)
+    }
+  }
+
+  private fun deleteItem(context: Context, item: DownloadItem) {
+    item.downloadItemParts.forEach { part ->
+      deleteAppOwnedFile(context, File(part.destinationPath))
+      if (!part.moved) {
+        part.bytesDownloaded = 0L
+        part.completed = false
+      }
+    }
+    item.stagingCleanupAt = System.currentTimeMillis()
+    DeviceManager.dbManager.saveDownloadItem(item)
+    cancel(context, item.id)
+    AbsLogger.info(tag, "Deleted staging files for terminally failed download item ${item.id}")
+  }
+
+  private fun deleteAppOwnedFile(context: Context, file: File) {
+    val path = file.absolutePath
+    val internal = context.filesDir.absolutePath
+    val external = context.getExternalFilesDir(null)?.absolutePath
+    if (path.startsWith(internal) || (external != null && path.startsWith(external))) {
+      if (file.exists() && !file.delete()) AbsLogger.error(tag, "Could not delete expired staging file $path")
+      file.parentFile?.takeIf { it.isDirectory && it.list()?.isEmpty() == true }?.delete()
+    } else {
+      AbsLogger.error(tag, "Refusing to delete non-app-owned path $path")
+    }
+  }
+}
+
+class IncompleteDownloadCleanupWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
+  override fun doWork(): Result {
+    DbManager.initialize(applicationContext)
+    IncompleteDownloadCleanup.cleanupExpired(applicationContext)
+    return Result.success()
+  }
+}
@@ -1,74 +1,203 @@
 package com.audiobookshelf.app.managers

-import android.util.Log
-import com.google.common.net.HttpHeaders.CONTENT_LENGTH
-import okhttp3.*
-import java.io.*
-import java.util.*
+import com.audiobookshelf.app.plugins.AbsLogger
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicReference
+import java.util.concurrent.TimeUnit
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response

-class InternalDownloadManager(outputStream:FileOutputStream, private val progressCallback: DownloadItemManager.InternalProgressCallback) : AutoCloseable {
+/** Streams a download into an app-owned staging file. */
+class InternalDownloadManager(
+        private val destinationFile: File,
+        private val expectedSize: Long,
+        private val progressCallback: DownloadItemManager.InternalProgressCallback,
+        private val hasAvailableSpace: () -> Boolean
+) {
  private val tag = "InternalDownloadManager"

-  private val client: OkHttpClient = OkHttpClient()
-  private val writer = BinaryFileWriter(outputStream, progressCallback)
-
-  @Throws(IOException::class)
-  fun download(url:String) {
-    val request: Request = Request.Builder().url(url).build()
-    client.newCall(request).enqueue(object : Callback {
-      override fun onFailure(call: Call, e: IOException) {
-        Log.e(tag, "download URL $url FAILED")
-        progressCallback.onComplete(true)
-      }
-
-      override fun onResponse(call: Call, response: Response) {
-        val responseBody: ResponseBody = response.body
-          ?: throw IllegalStateException("Response doesn't contain a file")
-
-        val length: Long = (response.header(CONTENT_LENGTH, "1") ?: "0").toLong()
-        writer.write(responseBody.byteStream(), length)
-      }
-    })
+  interface DownloadHandle {
+    fun cancel()
  }

-  @Throws(Exception::class)
-  override fun close() {
-    writer.close()
-  }
-}
+  private class ActiveDownloadHandle : DownloadHandle {
+    private val cancelled = AtomicBoolean(false)
+    private val activeCall = AtomicReference<Call?>()

-class BinaryFileWriter(outputStream: OutputStream, progressCallback: DownloadItemManager.InternalProgressCallback) :
-  AutoCloseable {
-  private val outputStream: OutputStream
-  private val progressCallback: DownloadItemManager.InternalProgressCallback
+    fun setCall(call: Call) {
+      activeCall.set(call)
+      if (cancelled.get()) call.cancel()
+    }

-  init {
-    this.outputStream = outputStream
-    this.progressCallback = progressCallback
-  }
-
-  @Throws(IOException::class)
-  fun write(inputStream: InputStream?, length: Long): Long {
-    BufferedInputStream(inputStream).use { input ->
-      val dataBuffer = ByteArray(CHUNK_SIZE)
-      var readBytes: Int
-      var totalBytes: Long = 0
-      while (input.read(dataBuffer).also { readBytes = it } != -1) {
-        totalBytes += readBytes.toLong()
-        outputStream.write(dataBuffer, 0, readBytes)
-        progressCallback.onProgress(totalBytes, (totalBytes * 100L) / length)
-      }
-      progressCallback.onComplete(false)
-      return totalBytes
+    override fun cancel() {
+      cancelled.set(true)
+      activeCall.get()?.cancel()
    }
  }
-
-  @Throws(IOException::class)
-  override fun close() {
-    outputStream.close()
+  /**
+   * Starts or resumes a download.
+   *
+   * @param url download URL
+   * @param token access token sent in the Authorization header
+   * @return logical handle used to cancel the active request, including a restarted request
+   */
+  fun download(url: String, token: String): DownloadHandle {
+    destinationFile.parentFile?.mkdirs()
+    val handle = ActiveDownloadHandle()
+    startRequest(url, token, handle, allowRestart = true)
+    return handle
  }

-  companion object {
-    private const val CHUNK_SIZE = 1024
+  private fun startRequest(
+          url: String,
+          token: String,
+          handle: ActiveDownloadHandle,
+          allowRestart: Boolean
+  ) {
+    var existingBytes = destinationFile.takeIf { it.exists() }?.length() ?: 0L
+    AbsLogger.info(
+            tag,
+            "Starting ${if (existingBytes > 0L) "resumed" else "new"} download for ${destinationFile.name} at byte $existingBytes")
+    val request =
+            Request.Builder()
+                    .url(url)
+                    .addHeader("Accept-Encoding", "identity")
+                    .addHeader("Authorization", "Bearer $token")
+                    .apply { if (existingBytes > 0L) header("Range", "bytes=$existingBytes-") }
+                    .build()
+    val call = client.newCall(request)
+    handle.setCall(call)
+    call.enqueue(
+            object : Callback {
+              override fun onFailure(call: Call, e: IOException) {
+                AbsLogger.error(tag, "Download request failed for ${destinationFile.name}: ${e.message}")
+                progressCallback.onComplete(true)
+              }
+
+              override fun onResponse(call: Call, response: Response) {
+                response.use {
+                  try {
+                    if (response.code == 401) {
+                      AbsLogger.error(tag, "Download unauthorized (401) for ${destinationFile.name}")
+                      progressCallback.onAuthError()
+                      return
+                    }
+                    if (response.code == 416) {
+                      val serverSize =
+                              response.header("Content-Range")
+                                      ?.removePrefix("bytes */")
+                                      ?.toLongOrNull()
+                      if (serverSize != null) progressCallback.onSizeResolved(serverSize)
+                      if (serverSize != null && existingBytes == serverSize) {
+                        progressCallback.onProgress(existingBytes, 100L)
+                        AbsLogger.info(tag, "Download completed for ${destinationFile.name} ($existingBytes bytes)")
+                        progressCallback.onComplete(false)
+                      } else if (allowRestart && destinationFile.delete()) {
+                        AbsLogger.info(tag, "Restarting stale range from byte zero for ${destinationFile.name}")
+                        startRequest(url, token, handle, allowRestart = false)
+                      } else {
+                        AbsLogger.error(tag, "Could not recover invalid range for ${destinationFile.name} at byte $existingBytes")
+                        progressCallback.onComplete(true)
+                      }
+                      return
+                    }
+                    val append =
+                            existingBytes > 0L &&
+                                    response.code == 206 &&
+                                    hasExpectedRange(response, existingBytes)
+                    if (existingBytes > 0L && !append && response.code != 200) {
+                      AbsLogger.error(
+                              tag,
+                              "Invalid resume response ${response.code} for ${destinationFile.name} at byte $existingBytes"
+                      )
+                      progressCallback.onComplete(true)
+                      return
+                    }
+                    if (!response.isSuccessful || response.body == null) {
+                      AbsLogger.error(tag, "Download HTTP failure ${response.code} for ${destinationFile.name}")
+                      progressCallback.onComplete(true)
+                      return
+                    }
+
+                    val startingBytes = if (append) existingBytes else 0L
+                    val responseLength = response.body!!.contentLength()
+                    val serverSize =
+                            if (append) contentRangeTotal(response)
+                            else responseLength.takeIf { it >= 0L }
+                    if (serverSize != null) progressCallback.onSizeResolved(serverSize)
+                    val totalLength =
+                            serverSize ?: if (expectedSize > 0L) expectedSize else 0L
+
+                    FileOutputStream(destinationFile, append).use { output ->
+                      response.body!!.byteStream().use { input ->
+                        val buffer = ByteArray(CHUNK_SIZE)
+                        var totalBytes = startingBytes
+                        while (true) {
+                          val read = input.read(buffer)
+                          if (read < 0) break
+                          if (!hasAvailableSpace())
+                                  throw IOException("Download paused to preserve free storage")
+                          output.write(buffer, 0, read)
+                          totalBytes += read
+                          val progress =
+                                  if (totalLength > 0L) (totalBytes * 100L) / totalLength else 0L
+                          progressCallback.onProgress(totalBytes, progress.coerceAtMost(100L))
+                        }
+                      }
+                    }
+
+                    val downloadedSize = destinationFile.length()
+                    if (serverSize != null && downloadedSize != serverSize) {
+                      AbsLogger.error(
+                              tag,
+                              "Downloaded size for ${destinationFile.name} was $downloadedSize, expected server size $serverSize"
+                      )
+                      progressCallback.onComplete(true)
+                    } else {
+                      AbsLogger.info(
+                              tag,
+                              "Download completed for ${destinationFile.name} ($downloadedSize bytes)"
+                      )
+                      progressCallback.onComplete(false)
+                    }
+                  } catch (e: IOException) {
+                    AbsLogger.error(tag, "Could not write staging file ${destinationFile.name}: ${e.message}")
+                    progressCallback.onComplete(true)
+                  }
+                }
+              }
+            }
+    )
+  }
+
+  private fun hasExpectedRange(response: Response, offset: Long): Boolean {
+    val range = response.header("Content-Range") ?: return false
+    val match = CONTENT_RANGE.matchEntire(range) ?: return false
+    return match.groupValues[1].toLongOrNull() == offset &&
+            match.groupValues[2].toLongOrNull()?.let { it >= offset } == true
+  }
+
+  private fun contentRangeTotal(response: Response): Long? =
+          CONTENT_RANGE.matchEntire(response.header("Content-Range") ?: "")
+                  ?.groupValues
+                  ?.get(3)
+                  ?.takeUnless { it == "*" }
+                  ?.toLongOrNull()
+
+  private companion object {
+    const val CHUNK_SIZE = 512 * 1024 // 512 KB
+    val CONTENT_RANGE = Regex("bytes (\\d+)-(\\d+)/(\\d+|\\*)")
+    val client =
+            OkHttpClient.Builder()
+                    .connectTimeout(30, TimeUnit.SECONDS)
+                    .readTimeout(60, TimeUnit.SECONDS)
+                    .writeTimeout(60, TimeUnit.SECONDS)
+                    .build()
  }
 }
@@ -0,0 +1,124 @@
+package com.audiobookshelf.app.managers
+
+import android.content.Context
+import android.security.keystore.KeyGenParameterSpec
+import android.security.keystore.KeyProperties
+import android.util.Base64
+import android.util.Log
+import java.security.KeyStore
+import javax.crypto.Cipher
+import javax.crypto.KeyGenerator
+import javax.crypto.SecretKey
+import javax.crypto.spec.GCMParameterSpec
+
+class SecureStorage(private val context: Context) {
+    companion object {
+        private const val TAG = "SecureStorage"
+        private const val KEYSTORE_PROVIDER = "AndroidKeyStore"
+        private const val KEY_ALIAS = "AudiobookshelfRefreshTokens"
+        private const val TRANSFORMATION = "AES/GCM/NoPadding"
+        private const val IV_LENGTH = 12
+        private const val TAG_LENGTH = 128
+    }
+
+    private val keyStore = KeyStore.getInstance(KEYSTORE_PROVIDER).apply {
+        load(null)
+    }
+
+    /**
+     * Encrypts and stores a refresh token for a specific server connection
+     */
+    fun storeRefreshToken(serverConnectionId: String, refreshToken: String): Boolean {
+        return try {
+            val key = getOrCreateKey()
+            val cipher = Cipher.getInstance(TRANSFORMATION)
+            cipher.init(Cipher.ENCRYPT_MODE, key)
+
+            val encryptedBytes = cipher.doFinal(refreshToken.toByteArray(Charsets.UTF_8))
+            val combined = cipher.iv + encryptedBytes
+
+            val encoded = Base64.encodeToString(combined, Base64.DEFAULT)
+
+            val sharedPrefs = context.getSharedPreferences("SecureStorage", Context.MODE_PRIVATE)
+            sharedPrefs.edit().putString("refresh_token_$serverConnectionId", encoded).apply()
+
+            Log.d(TAG, "Successfully stored encrypted refresh token for server: $serverConnectionId")
+            true
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to store refresh token for server: $serverConnectionId", e)
+            false
+        }
+    }
+
+    /**
+     * Retrieves and decrypts a refresh token for a specific server connection
+     */
+    fun getRefreshToken(serverConnectionId: String): String? {
+        return try {
+            val sharedPrefs = context.getSharedPreferences("SecureStorage", Context.MODE_PRIVATE)
+            val encoded = sharedPrefs.getString("refresh_token_$serverConnectionId", null) ?: return null
+
+            val combined = Base64.decode(encoded, Base64.DEFAULT)
+            val iv = combined.copyOfRange(0, IV_LENGTH)
+            val encryptedBytes = combined.copyOfRange(IV_LENGTH, combined.size)
+
+            val key = getOrCreateKey()
+            val cipher = Cipher.getInstance(TRANSFORMATION)
+            val spec = GCMParameterSpec(TAG_LENGTH, iv)
+            cipher.init(Cipher.DECRYPT_MODE, key, spec)
+
+            val decryptedBytes = cipher.doFinal(encryptedBytes)
+            String(decryptedBytes, Charsets.UTF_8)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to retrieve refresh token for server: $serverConnectionId", e)
+            null
+        }
+    }
+
+    /**
+     * Removes a refresh token for a specific server connection
+     */
+    fun removeRefreshToken(serverConnectionId: String): Boolean {
+        return try {
+            val sharedPrefs = context.getSharedPreferences("SecureStorage", Context.MODE_PRIVATE)
+            sharedPrefs.edit().remove("refresh_token_$serverConnectionId").apply()
+            Log.d(TAG, "Successfully removed refresh token for server: $serverConnectionId")
+            true
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to remove refresh token for server: $serverConnectionId", e)
+            false
+        }
+    }
+
+    /**
+     * Checks if a refresh token exists for a specific server connection
+     */
+    fun hasRefreshToken(serverConnectionId: String): Boolean {
+        val sharedPrefs = context.getSharedPreferences("SecureStorage", Context.MODE_PRIVATE)
+        return sharedPrefs.contains("refresh_token_$serverConnectionId")
+    }
+
+    private fun getOrCreateKey(): SecretKey {
+        return if (keyStore.containsAlias(KEY_ALIAS)) {
+            keyStore.getKey(KEY_ALIAS, null) as SecretKey
+        } else {
+            createKey()
+        }
+    }
+
+    private fun createKey(): SecretKey {
+        val keyGenerator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, KEYSTORE_PROVIDER)
+        val keyGenSpec = KeyGenParameterSpec.Builder(
+            KEY_ALIAS,
+            KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
+        )
+            .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
+            .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
+            .setUserAuthenticationRequired(false)
+            .setRandomizedEncryptionRequired(true)
+            .build()
+
+        keyGenerator.init(keyGenSpec)
+        return keyGenerator.generateKey()
+    }
+}
@@ -1,133 +1,221 @@
 package com.audiobookshelf.app.managers

 import android.content.Context
-import android.media.metrics.PlaybackSession
+import android.media.MediaPlayer
 import android.os.*
 import android.util.Log
+import com.audiobookshelf.app.R
 import com.audiobookshelf.app.device.DeviceManager
 import com.audiobookshelf.app.player.PlayerNotificationService
 import com.audiobookshelf.app.player.SLEEP_TIMER_WAKE_UP_EXPIRATION
-import java.text.SimpleDateFormat
+import com.audiobookshelf.app.plugins.AbsLogger
 import java.util.*
 import kotlin.concurrent.schedule
 import kotlin.math.roundToInt

-class SleepTimerManager constructor(private val playerNotificationService: PlayerNotificationService) {
+const val SLEEP_TIMER_CHIME_SOUND_VOLUME = 0.7f
+
+class SleepTimerManager
+constructor(private val playerNotificationService: PlayerNotificationService) {
  private val tag = "SleepTimerManager"

-  private var sleepTimerTask:TimerTask? = null
-  private var sleepTimerRunning:Boolean = false
-  private var sleepTimerEndTime:Long = 0L
-  private var sleepTimerLength:Long = 0L
-  private var sleepTimerElapsed:Long = 0L
-  private var sleepTimerFinishedAt:Long = 0L
-  private var isAutoSleepTimer:Boolean = false // When timer was auto-set
-  private var isFirstAutoSleepTimer: Boolean = true
-  private var sleepTimerSessionId:String = ""
+  private var sleepTimerTask: TimerTask? = null
+  private var sleepTimerRunning: Boolean = false
+  private var sleepTimerEndTime: Long = 0L
+  private var sleepTimerLength: Long = 0L
+  private var sleepTimerElapsed: Long = 0L
+  private var sleepTimerFinishedAt: Long = 0L
+  private var isAutoSleepTimer: Boolean = false // When timer was auto-set
+  private var autoTimerDisabled: Boolean = false // Disable until out of auto timer period
+  private var sleepTimerSessionId: String = ""

-  private fun getCurrentTime():Long {
+  /**
+   * Gets the current time from the player notification service.
+   * @return Long - the current time in milliseconds.
+   */
+  private fun getCurrentTime(): Long {
    return playerNotificationService.getCurrentTime()
  }

-  private fun getDuration():Long {
+  /**
+   * Gets the duration of the current playback.
+   * @return Long - the duration in milliseconds.
+   */
+  private fun getDuration(): Long {
    return playerNotificationService.getDuration()
  }

-  private fun getIsPlaying():Boolean {
+  /**
+   * Checks if the player is currently playing.
+   * @return Boolean - true if the player is playing, false otherwise.
+   */
+  private fun getIsPlaying(): Boolean {
    return playerNotificationService.currentPlayer.isPlaying
  }

-  private fun setVolume(volume:Float) {
+  /**
+   * Gets the playback speed of the player.
+   * @return Float - the playback speed.
+   */
+  private fun getPlaybackSpeed(): Float {
+    return playerNotificationService.currentPlayer.playbackParameters.speed
+  }
+
+  /**
+   * Sets the volume of the player.
+   * @param volume Float - the volume level to set.
+   */
+  private fun setVolume(volume: Float) {
    playerNotificationService.currentPlayer.volume = volume
  }

+  /** Pauses the player. */
  private fun pause() {
    playerNotificationService.currentPlayer.pause()
  }

+  /** Plays the player. */
  private fun play() {
    playerNotificationService.currentPlayer.play()
  }

-  private fun getSleepTimerTimeRemainingSeconds():Int {
+  /**
+   * Gets the remaining time of the sleep timer in seconds.
+   * @param speed Float - the playback speed of the player, default value is 1.
+   * @return Int - the remaining time in seconds.
+   */
+  private fun getSleepTimerTimeRemainingSeconds(speed: Float = 1f): Int {
    if (sleepTimerEndTime == 0L && sleepTimerLength > 0) { // For regular timer
      return ((sleepTimerLength - sleepTimerElapsed) / 1000).toDouble().roundToInt()
    }
    // For chapter end timer
    if (sleepTimerEndTime <= 0) return 0
-    return (((sleepTimerEndTime - getCurrentTime()) / 1000).toDouble()).roundToInt()
+    return (((sleepTimerEndTime - getCurrentTime()) / 1000).toDouble() / speed).roundToInt()
  }

-  private fun setSleepTimer(time: Long, isChapterTime: Boolean) : Boolean {
-    Log.d(tag, "Setting Sleep Timer for $time is chapter time $isChapterTime")
+  /**
+   * Sets the sleep timer.
+   * @param time Long - the time to set the sleep timer for. When 0L, use end of chapter/track time.
+   * @return Boolean - true if the sleep timer was set successfully, false otherwise.
+   */
+  private fun setSleepTimer(time: Long): Boolean {
+    Log.d(tag, "Setting Sleep Timer for $time")
    sleepTimerTask?.cancel()
    sleepTimerRunning = true
    sleepTimerFinishedAt = 0L
    sleepTimerElapsed = 0L
    setVolume(1f)

-    // Register shake sensor
-    playerNotificationService.registerSensor()
+    if (time == 0L) {
+      // Get the current chapter time and set the sleep timer to the end of the chapter
+      val chapterEndTime = this.getChapterEndTime()

-    val currentTime = getCurrentTime()
-    if (isChapterTime) {
-      if (currentTime > time) {
-        Log.d(tag, "Invalid sleep timer - current time is already passed chapter time $time")
+      if (chapterEndTime == null) {
+        Log.e(tag, "Setting sleep timer to end of chapter/track but there is no current session")
        return false
      }
-      sleepTimerEndTime = time
-      sleepTimerLength = 0
+
+      val currentTime = getCurrentTime()
+      if (currentTime > chapterEndTime) {
+        Log.d(tag, "Invalid sleep timer - time is already past chapter time $chapterEndTime")
+        return false
+      }
+
+      sleepTimerEndTime = chapterEndTime

      if (sleepTimerEndTime > getDuration()) {
        sleepTimerEndTime = getDuration()
      }
    } else {
-      sleepTimerLength = time
      sleepTimerEndTime = 0L
    }

-    playerNotificationService.clientEventEmitter?.onSleepTimerSet(getSleepTimerTimeRemainingSeconds(), isAutoSleepTimer)
+    // Set sleep timer length. Will be 0L if using chapter end time
+    sleepTimerLength = time

-    sleepTimerTask = Timer("SleepTimer", false).schedule(0L, 1000L) {
-      Handler(Looper.getMainLooper()).post {
-        if (getIsPlaying()) {
-          sleepTimerElapsed += 1000L
+    // Register shake sensor
+    playerNotificationService.registerSensor()

-          val sleepTimeSecondsRemaining = getSleepTimerTimeRemainingSeconds()
-          Log.d(tag, "Timer Elapsed $sleepTimerElapsed | Sleep TIMER time remaining $sleepTimeSecondsRemaining s")
+    playerNotificationService.clientEventEmitter?.onSleepTimerSet(
+            getSleepTimerTimeRemainingSeconds(getPlaybackSpeed()),
+            isAutoSleepTimer
+    )

-          if (sleepTimeSecondsRemaining > 0) {
-            playerNotificationService.clientEventEmitter?.onSleepTimerSet(sleepTimeSecondsRemaining, isAutoSleepTimer)
-          }
+    sleepTimerTask =
+            Timer("SleepTimer", false).schedule(0L, 1000L) {
+              Handler(Looper.getMainLooper()).post {
+                if (getIsPlaying()) {
+                  sleepTimerElapsed += 1000L

-          if (sleepTimeSecondsRemaining <= 0) {
-            Log.d(tag, "Sleep Timer Pausing Player on Chapter")
-            pause()
+                  val sleepTimeSecondsRemaining =
+                          getSleepTimerTimeRemainingSeconds(getPlaybackSpeed())
+                  Log.d(
+                          tag,
+                          "Timer Elapsed $sleepTimerElapsed | Sleep TIMER time remaining $sleepTimeSecondsRemaining s"
+                  )

-            playerNotificationService.clientEventEmitter?.onSleepTimerEnded(getCurrentTime())
-            clearSleepTimer()
-            sleepTimerFinishedAt = System.currentTimeMillis()
-          } else if (sleepTimeSecondsRemaining <= 60 && DeviceManager.deviceData.deviceSettings?.disableSleepTimerFadeOut != true) {
-            // Start fading out audio down to 10% volume
-            val percentToReduce = 1 - (sleepTimeSecondsRemaining / 60F)
-            val volume =  1f - (percentToReduce * 0.9f)
-            Log.d(tag, "SLEEP VOLUME FADE $volume | ${sleepTimeSecondsRemaining}s remaining")
-            setVolume(volume)
-          } else {
-            setVolume(1f)
-          }
-        }
-      }
-    }
+                  if (sleepTimeSecondsRemaining > 0) {
+                    playerNotificationService.clientEventEmitter?.onSleepTimerSet(
+                            sleepTimeSecondsRemaining,
+                            isAutoSleepTimer
+                    )
+                  }
+
+                  if (sleepTimeSecondsRemaining == 30 && sleepTimerElapsed > 1 && DeviceManager.deviceData.deviceSettings?.enableSleepTimerAlmostDoneChime == true) {
+                    playChimeSound()
+                  }
+
+                  if (sleepTimeSecondsRemaining <= 0) {
+                    Log.d(tag, "Sleep Timer Pausing Player on Chapter")
+                    pause()
+
+                    playerNotificationService.clientEventEmitter?.onSleepTimerEnded(
+                            getCurrentTime()
+                    )
+                    clearSleepTimer()
+                    sleepTimerFinishedAt = System.currentTimeMillis()
+                  } else if (sleepTimeSecondsRemaining <= 60 &&
+                                  DeviceManager.deviceData
+                                          .deviceSettings
+                                          ?.disableSleepTimerFadeOut != true
+                  ) {
+                    // Start fading out audio down to 10% volume
+                    val percentToReduce = 1 - (sleepTimeSecondsRemaining / 60F)
+                    val volume = 1f - (percentToReduce * 0.9f)
+                    Log.d(
+                            tag,
+                            "SLEEP VOLUME FADE $volume | ${sleepTimeSecondsRemaining}s remaining"
+                    )
+                    setVolume(volume)
+                  } else {
+                    setVolume(1f)
+                  }
+                }
+              }
+            }
    return true
  }

-  fun setManualSleepTimer(playbackSessionId:String, time: Long, isChapterTime:Boolean):Boolean {
+  /**
+   * Sets a manual sleep timer.
+   * @param playbackSessionId String - the playback session ID.
+   * @param time Long - the time to set the sleep timer for.
+   * @param isChapterTime Boolean - true if the time is for the end of a chapter, false otherwise.
+   * @return Boolean - true if the sleep timer was set successfully, false otherwise.
+   */
+  fun setManualSleepTimer(playbackSessionId: String, time: Long, isChapterTime: Boolean): Boolean {
    sleepTimerSessionId = playbackSessionId
    isAutoSleepTimer = false
-    return setSleepTimer(time, isChapterTime)
+    if (isChapterTime) {
+      Log.d(tag, "Setting manual sleep timer for end of chapter")
+      return setSleepTimer(0L)
+    } else {
+      Log.d(tag, "Setting manual sleep timer for $time")
+      return setSleepTimer(time)
+    }
  }

+  /** Clears the sleep timer. */
  private fun clearSleepTimer() {
    sleepTimerTask?.cancel()
    sleepTimerTask = null
@@ -138,32 +226,36 @@ class SleepTimerManager constructor(private val playerNotificationService: Playe
    setVolume(1f)
  }

-  fun getSleepTimerTime():Long {
+  /**
+   * Gets the sleep timer end time.
+   * @return Long - the sleep timer end time in milliseconds.
+   */
+  fun getSleepTimerTime(): Long {
    return sleepTimerEndTime
  }

+  /** Cancels the sleep timer. */
  fun cancelSleepTimer() {
    Log.d(tag, "Canceling Sleep Timer")

    if (isAutoSleepTimer) {
-      Log.i(tag, "Disabling auto sleep timer")
-      DeviceManager.deviceData.deviceSettings?.autoSleepTimer = false
-      DeviceManager.dbManager.saveDeviceData(DeviceManager.deviceData)
+      Log.i(tag, "Disabling auto sleep timer for this time period")
+      autoTimerDisabled = true
    }

    clearSleepTimer()
    playerNotificationService.clientEventEmitter?.onSleepTimerSet(0, false)
  }

-  // Vibrate when resetting sleep timer
+  /** Provides vibration feedback when resetting the sleep timer. */
  private fun vibrateFeedback() {
    if (DeviceManager.deviceData.deviceSettings?.disableSleepTimerResetFeedback == true) return

    val context = playerNotificationService.getContext()
-    val vibrator:Vibrator
+    val vibrator: Vibrator
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
      val vibratorManager =
-        context.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as VibratorManager
+              context.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as VibratorManager
      vibrator = vibratorManager.defaultVibrator
    } else {
      @Suppress("DEPRECATION")
@@ -172,18 +264,32 @@ class SleepTimerManager constructor(private val playerNotificationService: Playe

    vibrator.let {
      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-        val vibrationEffect = VibrationEffect.createWaveform(longArrayOf(0, 150, 150, 150),-1)
+        val vibrationEffect = VibrationEffect.createWaveform(longArrayOf(0, 150, 150, 150), -1)
        it.vibrate(vibrationEffect)
      } else {
-        @Suppress("DEPRECATION")
-        it.vibrate(10)
+        @Suppress("DEPRECATION") it.vibrate(10)
      }
    }
  }

-  // Get the chapter end time for use in End of Chapter timers
-  //   if less than 2s remain in chapter then use the next chapter
-  private fun getChapterEndTime():Long? {
+  /** Plays chime sound */
+  private fun playChimeSound() {
+    AbsLogger.info(tag, "playChimeSound: Playing sleep timer chime sound")
+    val ctx = playerNotificationService.getContext()
+    val mediaPlayer = MediaPlayer.create(ctx, R.raw.bell)
+    mediaPlayer.setVolume(SLEEP_TIMER_CHIME_SOUND_VOLUME, SLEEP_TIMER_CHIME_SOUND_VOLUME)
+    mediaPlayer.start()
+    mediaPlayer.setOnCompletionListener {
+      mediaPlayer.release()
+    }
+  }
+
+  /**
+   * Gets the chapter end time for use in End of Chapter timers. If less than 10 seconds remain in
+   * the chapter, then use the next chapter.
+   * @return Long? - the chapter end time in milliseconds, or null if there is no current session.
+   */
+  private fun getChapterEndTime(): Long? {
    val currentChapterEndTimeMs = playerNotificationService.getEndTimeOfChapterOrTrack()
    if (currentChapterEndTimeMs == null) {
      Log.e(tag, "Getting chapter sleep timer end of chapter/track but there is no current session")
@@ -191,11 +297,17 @@ class SleepTimerManager constructor(private val playerNotificationService: Playe
    }

    val timeLeftInChapter = currentChapterEndTimeMs - getCurrentTime()
-    return if (timeLeftInChapter < 2000L) {
-      Log.i(tag, "Getting chapter sleep timer time and current chapter has less than 2s remaining")
+    // If less than 10 seconds remain in the chapter, set the timer to the next chapter or track
+    // This handles the auto-rewind from not playing media for a little bit to select the next
+    // chapter
+    return if (timeLeftInChapter < 10000L) {
+      Log.i(tag, "Getting chapter sleep timer time and current chapter has less than 10s remaining")
      val nextChapterEndTimeMs = playerNotificationService.getEndTimeOfNextChapterOrTrack()
      if (nextChapterEndTimeMs == null || currentChapterEndTimeMs == nextChapterEndTimeMs) {
-        Log.e(tag, "Invalid next chapter time. No current session or equal to current chapter. $nextChapterEndTimeMs")
+        Log.e(
+                tag,
+                "Invalid next chapter time. No current session or equal to current chapter. $nextChapterEndTimeMs"
+        )
        null
      } else {
        nextChapterEndTimeMs
@@ -205,17 +317,35 @@ class SleepTimerManager constructor(private val playerNotificationService: Playe
    }
  }

-  private fun resetChapterTimer() {
-    this.getChapterEndTime()?.let { chapterEndTime ->
-      Log.d(tag, "Resetting stopped sleep timer to end of chapter $chapterEndTime")
-      vibrateFeedback()
-      setSleepTimer(chapterEndTime, true)
-      play()
+  /**
+   * Rewind auto sleep timer if setting enabled. To ensure the first rewind of the time period does
+   * not take place, make sure to set `isAutoSleepTimer` after calling this function.
+   */
+  private fun tryRewindAutoSleepTimer() {
+    DeviceManager.deviceData.deviceSettings?.let { deviceSettings ->
+      if (isAutoSleepTimer && deviceSettings.autoSleepTimerAutoRewind) {
+        Log.i(
+                tag,
+                "Auto sleep timer auto rewind seeking back ${deviceSettings.autoSleepTimerAutoRewindTime}ms"
+        )
+        playerNotificationService.seekBackward(deviceSettings.autoSleepTimerAutoRewindTime)
+      }
    }
  }

+  /** Checks if the sleep timer should be reset. */
  private fun checkShouldResetSleepTimer() {
-    if (!sleepTimerRunning) {
+    if (sleepTimerRunning) {
+      // Reset the sleep timer if it has been running for at least 3 seconds or it is an end of
+      // chapter/track timer
+      if (sleepTimerLength == 0L || sleepTimerElapsed > 3000L) {
+        Log.d(tag, "Resetting running sleep timer")
+        vibrateFeedback()
+        setSleepTimer(sleepTimerLength)
+        play()
+      }
+    } else {
+
      if (sleepTimerFinishedAt <= 0L) return

      val finishedAtDistance = System.currentTimeMillis() - sleepTimerFinishedAt
@@ -226,51 +356,31 @@ class SleepTimerManager constructor(private val playerNotificationService: Playe
        return
      }

-      // Automatically Rewind in the book if settings is enabled
-      if (isAutoSleepTimer) {
-        DeviceManager.deviceData.deviceSettings?.let { deviceSettings ->
-          if (deviceSettings.autoSleepTimerAutoRewind && !isFirstAutoSleepTimer) {
-            Log.i(tag, "Auto sleep timer auto rewind seeking back ${deviceSettings.autoSleepTimerAutoRewindTime}ms")
-            playerNotificationService.seekBackward(deviceSettings.autoSleepTimerAutoRewindTime)
-          }
-          isFirstAutoSleepTimer = false
-        }
+      // If timer was cleared by going negative on time, clear the sleep timer length so pressing
+      // play allows playback to continue without the sleep timer continuously setting for 1 second.
+      if (sleepTimerLength == 1000L) {
+        Log.d(tag, "Sleep timer cleared by manually subtracting time, clearing sleep timer")
+        sleepTimerFinishedAt = 0L
+        return
      }

+      // Automatically rewind in the book if settings are enabled
+      tryRewindAutoSleepTimer()
+
      // Set sleep timer
-      //   When sleepTimerLength is 0 then use end of chapter/track time
-      if (sleepTimerLength == 0L) {
-        Log.d(tag, "Resetting stopped chapter sleep timer")
-        resetChapterTimer()
-      } else {
-        Log.d(tag, "Resetting stopped sleep timer to length $sleepTimerLength")
-        vibrateFeedback()
-        setSleepTimer(sleepTimerLength, false)
-        play()
-      }
-      return
-    }
-
-    // Does not apply to chapter sleep timers and timer must be running for at least 3 seconds
-    if (sleepTimerLength > 0L && sleepTimerElapsed > 3000L) {
-      Log.d(tag, "Resetting running sleep timer to length $sleepTimerLength")
+      Log.d(tag, "Resetting stopped sleep timer")
      vibrateFeedback()
-      setSleepTimer(sleepTimerLength, false)
-    } else if (sleepTimerLength == 0L) {
-      // When navigating to previous chapters make sure this is still the end of the current chapter
-      this.getChapterEndTime()?.let { chapterEndTime ->
-        if (chapterEndTime != sleepTimerEndTime) {
-          Log.d(tag, "Resetting chapter sleep timer to end of chapter $chapterEndTime from $sleepTimerEndTime")
-          vibrateFeedback()
-          setSleepTimer(chapterEndTime, true)
-          play()
-        }
-      }
+      setSleepTimer(sleepTimerLength)
+      play()
    }
  }

+  /**
+   * Handles the shake event to reset the sleep timer. Shaking to reset only works during the 2
+   * minute grace period after the timer ends or while media is playing.
+   */
  fun handleShake() {
-    if (sleepTimerRunning || sleepTimerFinishedAt > 0L) {
+    if ((sleepTimerRunning && getIsPlaying()) || sleepTimerFinishedAt > 0L) {
      if (DeviceManager.deviceData.deviceSettings?.disableShakeToResetSleepTimer == true) {
        Log.d(tag, "Shake to reset sleep timer is disabled")
        return
@@ -279,48 +389,63 @@ class SleepTimerManager constructor(private val playerNotificationService: Playe
    }
  }

+  /**
+   * Increases the sleep timer time.
+   * @param time Long - the time to increase the sleep timer by.
+   */
  fun increaseSleepTime(time: Long) {
    Log.d(tag, "Increase Sleep time $time")
    if (!sleepTimerRunning) return

+    // Increase the sleep timer time (if using fixed length) or end time (if using chapter end time)
+    // and ensure it doesn't go over the duration of the current playback item
    if (sleepTimerEndTime == 0L) {
+      // Fixed length
      sleepTimerLength += time
-      if (sleepTimerLength + getCurrentTime() > getDuration()) sleepTimerLength = getDuration() - getCurrentTime()
+      sleepTimerLength = minOf(sleepTimerLength, getDuration() - getCurrentTime())
    } else {
-      val newSleepEndTime = sleepTimerEndTime + time
-      sleepTimerEndTime = if (newSleepEndTime >= getDuration()) {
-        getDuration()
-      } else {
-        newSleepEndTime
-      }
+      // Chapter end time
+      sleepTimerEndTime =
+              minOf(sleepTimerEndTime + (time * getPlaybackSpeed()).roundToInt(), getDuration())
    }

    setVolume(1F)
-    playerNotificationService.clientEventEmitter?.onSleepTimerSet(getSleepTimerTimeRemainingSeconds(), isAutoSleepTimer)
+    playerNotificationService.clientEventEmitter?.onSleepTimerSet(
+            getSleepTimerTimeRemainingSeconds(getPlaybackSpeed()),
+            isAutoSleepTimer
+    )
  }

+  /**
+   * Decreases the sleep timer time.
+   * @param time Long - the time to decrease the sleep timer by.
+   */
  fun decreaseSleepTime(time: Long) {
    Log.d(tag, "Decrease Sleep time $time")
    if (!sleepTimerRunning) return

-
+    // Decrease the sleep timer time (if using fixed length) or end time (if using chapter end time)
+    // and ensure it doesn't go below 1 second
    if (sleepTimerEndTime == 0L) {
-      sleepTimerLength -= time
-      if (sleepTimerLength <= 0) sleepTimerLength = 1000L
+      // Fixed length
+      sleepTimerLength = maxOf(sleepTimerLength - time, 1000L)
    } else {
-      val newSleepEndTime = sleepTimerEndTime - time
-      sleepTimerEndTime = if (newSleepEndTime <= 1000) {
-        // End sleep timer in 1 second
-        getCurrentTime() + 1000
-      } else {
-        newSleepEndTime
-      }
+      // Chapter end time
+      sleepTimerEndTime =
+              maxOf(
+                      sleepTimerEndTime - (time * getPlaybackSpeed()).roundToInt(),
+                      getCurrentTime() + 1000
+              )
    }

    setVolume(1F)
-    playerNotificationService.clientEventEmitter?.onSleepTimerSet(getSleepTimerTimeRemainingSeconds(), isAutoSleepTimer)
+    playerNotificationService.clientEventEmitter?.onSleepTimerSet(
+            getSleepTimerTimeRemainingSeconds(getPlaybackSpeed()),
+            isAutoSleepTimer
+    )
  }

+  /** Checks whether the auto sleep timer should be set, and set up auto sleep timer if so. */
  fun checkAutoSleepTimer() {
    if (sleepTimerRunning) { // Sleep timer already running
      return
@@ -337,10 +462,13 @@ class SleepTimerManager constructor(private val playerNotificationService: Playe

      val currentCalendar = Calendar.getInstance()

-      // In cases where end time is before start time then we shift the time window forward or backward based on the current time.
+      // In cases where end time is before start time then we shift the time window forward or
+      // backward based on the current time.
      //   e.g. start time 22:00 and end time 06:00.
-      //          If current time is less than start time (e.g. 00:30) then start time will be the previous day.
-      //          If current time is greater than start time (e.g. 23:00) then end time will be the next day.
+      //          If current time is less than start time (e.g. 00:30) then start time will be the
+      // previous day.
+      //          If current time is greater than start time (e.g. 23:00) then end time will be the
+      // next day.
      if (endCalendar.before(startCalendar)) {
        if (currentCalendar.before(startCalendar)) { // Shift start back a day
          startCalendar.add(Calendar.DAY_OF_MONTH, -1)
@@ -349,49 +477,68 @@ class SleepTimerManager constructor(private val playerNotificationService: Playe
        }
      }

-      val currentHour = SimpleDateFormat("HH:mm", Locale.getDefault()).format(currentCalendar.time)
-      if (currentCalendar.after(startCalendar) && currentCalendar.before(endCalendar)) {
-        Log.i(tag, "Current hour $currentHour is between ${deviceSettings.autoSleepTimerStartTime} and ${deviceSettings.autoSleepTimerEndTime} - starting sleep timer")
+      val isDuringAutoTime =
+              currentCalendar.after(startCalendar) && currentCalendar.before(endCalendar)

-        // Automatically Rewind in the book if settings is enabled
-        if (deviceSettings.autoSleepTimerAutoRewind && !isFirstAutoSleepTimer) {
-          Log.i(tag, "Auto sleep timer auto rewind seeking back ${deviceSettings.autoSleepTimerAutoRewindTime}ms")
-          playerNotificationService.seekBackward(deviceSettings.autoSleepTimerAutoRewindTime)
-        }
-        isFirstAutoSleepTimer = false
-
-        // Set sleep timer
-        //   When sleepTimerLength is 0 then use end of chapter/track time
-        if (deviceSettings.sleepTimerLength == 0L) {
-          val chapterEndTimeMs = this.getChapterEndTime()
-          if (chapterEndTimeMs == null) {
-            Log.e(tag, "Setting auto sleep timer to end of chapter/track but there is no current session")
-          } else {
-            isAutoSleepTimer = true
-            setSleepTimer(chapterEndTimeMs, true)
-          }
+      // Determine whether to set the auto sleep timer or not
+      if (autoTimerDisabled) {
+        if (!isDuringAutoTime) {
+          // Check if sleep timer was disabled during the previous period and enable again
+          Log.i(tag, "Leaving disabled auto sleep time period, enabling for next time period")
+          autoTimerDisabled = false
        } else {
-          isAutoSleepTimer = true
-          setSleepTimer(deviceSettings.sleepTimerLength, false)
+          // Auto time is disabled, do not set sleep timer
+          Log.i(tag, "Auto sleep timer is disabled for this time period")
        }
      } else {
-        isFirstAutoSleepTimer = true
-        Log.d(tag, "Current hour $currentHour is NOT between ${deviceSettings.autoSleepTimerStartTime} and ${deviceSettings.autoSleepTimerEndTime}")
+        if (isDuringAutoTime) {
+          // Start an auto sleep timer
+          val currentHour = currentCalendar.get(Calendar.HOUR_OF_DAY)
+          val currentMin = currentCalendar.get(Calendar.MINUTE)
+          Log.i(tag, "Starting auto sleep timer at $currentHour:$currentMin")
+
+          // Automatically rewind in the book if settings is enabled
+          tryRewindAutoSleepTimer()
+
+          // Set `isAutoSleepTimer` to true to indicate that the timer was set automatically
+          // and to not cause the timer to rewind
+          isAutoSleepTimer = true
+          setSleepTimer(deviceSettings.sleepTimerLength)
+        } else {
+          Log.d(tag, "Not in auto sleep time period")
+        }
      }
    }
  }

-  fun handleMediaPlayEvent(playbackSessionId:String) {
+  /**
+   * Handles the media play event and checks if the sleep timer should be reset or set.
+   * @param playbackSessionId String - the playback session ID.
+   */
+  fun handleMediaPlayEvent(playbackSessionId: String) {
    // Check if the playback session has changed
    // If it hasn't changed OR the sleep timer is running then check reset the timer
-    //   e.g. You set a manual sleep timer for 10 mins, then decide to change books, the sleep timer will stay on and reset to 10 mins
+    //   e.g. You set a manual sleep timer for 10 mins, then decide to change books, the sleep timer
+    // will stay on and reset to 10 mins
    if (sleepTimerSessionId == playbackSessionId || sleepTimerRunning) {
      checkShouldResetSleepTimer()
-    } else {
-      isFirstAutoSleepTimer = true
-    }
+    } else {}
    sleepTimerSessionId = playbackSessionId

    checkAutoSleepTimer()
  }
+
+  /**
+   * Sends the current sleep timer state to the client.
+   * Called when app resumes from background to sync UI state.
+   */
+  fun sendCurrentSleepTimerState() {
+    if (sleepTimerRunning) {
+      val timeRemaining = getSleepTimerTimeRemainingSeconds(getPlaybackSpeed())
+      playerNotificationService.clientEventEmitter?.onSleepTimerSet(timeRemaining, isAutoSleepTimer)
+    } else {
+      // No timer running - send 0 to clear any stale UI state
+      playerNotificationService.clientEventEmitter?.onSleepTimerSet(0, false)
+    }
+  }
 }
@@ -36,76 +36,97 @@ object MediaEventManager {
  }

  fun seekEvent(playbackSession: PlaybackSession, syncResult: SyncResult?) {
-    Log.i(tag, "Seek Event for media \"${playbackSession.displayTitle}\", currentTime=${playbackSession.currentTime}")
+    Log.i(
+            tag,
+            "Seek Event for media \"${playbackSession.displayTitle}\", currentTime=${playbackSession.currentTime}"
+    )
    addPlaybackEvent("Seek", playbackSession, syncResult)
  }

  fun syncEvent(mediaProgress: MediaProgressWrapper, description: String) {
-    Log.i(tag, "Sync Event for media item id \"${mediaProgress.mediaItemId}\", currentTime=${mediaProgress.currentTime}")
+    Log.i(
+            tag,
+            "Sync Event for media item id \"${mediaProgress.mediaItemId}\", currentTime=${mediaProgress.currentTime}"
+    )
    addSyncEvent("Sync", mediaProgress, description)
  }

-  private fun addSyncEvent(eventName:String, mediaProgress:MediaProgressWrapper, description: String) {
+  private fun addSyncEvent(
+          eventName: String,
+          mediaProgress: MediaProgressWrapper,
+          description: String
+  ) {
    val mediaItemHistory = getMediaItemHistoryMediaItem(mediaProgress.mediaItemId)
    if (mediaItemHistory == null) {
-      Log.w(tag, "addSyncEvent: Media Item History not created yet for media item id ${mediaProgress.mediaItemId}")
+      Log.w(
+              tag,
+              "addSyncEvent: Media Item History not created yet for media item id ${mediaProgress.mediaItemId}"
+      )
      return
    }

-    val mediaItemEvent = MediaItemEvent(
-      name = eventName,
-      type = "Sync",
-      description = description,
-      currentTime = mediaProgress.currentTime,
-      serverSyncAttempted = false,
-      serverSyncSuccess = null,
-      serverSyncMessage = null,
-      timestamp = System.currentTimeMillis()
-    )
+    val mediaItemEvent =
+            MediaItemEvent(
+                    name = eventName,
+                    type = "Sync",
+                    description = description,
+                    currentTime = mediaProgress.currentTime,
+                    serverSyncAttempted = false,
+                    serverSyncSuccess = null,
+                    serverSyncMessage = null,
+                    timestamp = System.currentTimeMillis()
+            )
    mediaItemHistory.events.add(mediaItemEvent)
    DeviceManager.dbManager.saveMediaItemHistory(mediaItemHistory)

    clientEventEmitter?.onMediaItemHistoryUpdated(mediaItemHistory)
  }

-  private fun addPlaybackEvent(eventName:String, playbackSession:PlaybackSession, syncResult: SyncResult?) {
-    val mediaItemHistory = getMediaItemHistoryMediaItem(playbackSession.mediaItemId) ?: createMediaItemHistoryForSession(playbackSession)
+  private fun addPlaybackEvent(
+          eventName: String,
+          playbackSession: PlaybackSession,
+          syncResult: SyncResult?
+  ) {
+    val mediaItemHistory =
+            getMediaItemHistoryMediaItem(playbackSession.mediaItemId)
+                    ?: createMediaItemHistoryForSession(playbackSession)

-    val mediaItemEvent = MediaItemEvent(
-      name = eventName,
-      type = "Playback",
-      description = "",
-      currentTime = playbackSession.currentTime,
-      serverSyncAttempted = syncResult?.serverSyncAttempted ?: false,
-      serverSyncSuccess = syncResult?.serverSyncSuccess,
-      serverSyncMessage = syncResult?.serverSyncMessage,
-      timestamp = System.currentTimeMillis()
-    )
+    val mediaItemEvent =
+            MediaItemEvent(
+                    name = eventName,
+                    type = "Playback",
+                    description = "",
+                    currentTime = playbackSession.currentTime,
+                    serverSyncAttempted = syncResult?.serverSyncAttempted ?: false,
+                    serverSyncSuccess = syncResult?.serverSyncSuccess,
+                    serverSyncMessage = syncResult?.serverSyncMessage,
+                    timestamp = System.currentTimeMillis()
+            )
    mediaItemHistory.events.add(mediaItemEvent)
    DeviceManager.dbManager.saveMediaItemHistory(mediaItemHistory)

    clientEventEmitter?.onMediaItemHistoryUpdated(mediaItemHistory)
  }

-  private fun getMediaItemHistoryMediaItem(mediaItemId: String) : MediaItemHistory? {
+  private fun getMediaItemHistoryMediaItem(mediaItemId: String): MediaItemHistory? {
    return DeviceManager.dbManager.getMediaItemHistory(mediaItemId)
  }

-  private fun createMediaItemHistoryForSession(playbackSession: PlaybackSession):MediaItemHistory {
+  private fun createMediaItemHistoryForSession(playbackSession: PlaybackSession): MediaItemHistory {
    Log.i(tag, "Creating new media item history for media \"${playbackSession.displayTitle}\"")
-    val isLocalOnly = playbackSession.isLocalLibraryItemOnly
-    val libraryItemId = if (isLocalOnly) playbackSession.localLibraryItemId else playbackSession.libraryItemId ?: ""
-    val episodeId:String? = if (isLocalOnly && playbackSession.localEpisodeId != null) playbackSession.localEpisodeId else playbackSession.episodeId
+    val libraryItemId = playbackSession.libraryItemId ?: ""
+    val episodeId: String? = playbackSession.episodeId
    return MediaItemHistory(
-      id = playbackSession.mediaItemId,
-      mediaDisplayTitle = playbackSession.displayTitle ?: "Unset",
-      libraryItemId,
-      episodeId,
-      isLocalOnly,
-      playbackSession.serverConnectionConfigId,
-      playbackSession.serverAddress,
-      playbackSession.userId,
-      createdAt = System.currentTimeMillis(),
-      events = mutableListOf())
+            id = playbackSession.mediaItemId,
+            mediaDisplayTitle = playbackSession.displayTitle ?: "Unset",
+            libraryItemId,
+            episodeId,
+            false, // local-only items are not supported
+            playbackSession.serverConnectionConfigId,
+            playbackSession.serverAddress,
+            playbackSession.userId,
+            createdAt = System.currentTimeMillis(),
+            events = mutableListOf()
+    )
  }
 }
@@ -9,24 +9,38 @@ import com.audiobookshelf.app.device.DeviceManager
 import com.audiobookshelf.app.server.ApiHandler
 import com.getcapacitor.JSObject
 import java.util.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.launch
 import org.json.JSONException
 import org.json.JSONObject
 import kotlin.coroutines.resume
 import kotlin.coroutines.suspendCoroutine
+import java.util.concurrent.atomic.AtomicInteger

 class MediaManager(private var apiHandler: ApiHandler, var ctx: Context) {
  val tag = "MediaManager"

  private var serverLibraryItems = mutableListOf<LibraryItem>() // Store all items here
-  private var selectedLibraryItems = mutableListOf<LibraryItem>()
-  private var selectedLibraryId = ""
+
+  private var cachedLibraryAuthors : MutableMap<String, MutableMap<String, LibraryAuthorItem>> = hashMapOf()
+  private var cachedLibraryAuthorItems : MutableMap<String, MutableMap<String, List<LibraryItem>>> = hashMapOf()
+  private var cachedLibraryAuthorSeriesItems : MutableMap<String, MutableMap<String, List<LibraryItem>>> = hashMapOf()
+  private var cachedLibrarySeries : MutableMap<String, List<LibrarySeriesItem>> = hashMapOf()
+  private var cachedLibrarySeriesItem : MutableMap<String, MutableMap<String, List<LibraryItem>>> = hashMapOf()
+  private var cachedLibraryCollections : MutableMap<String, MutableMap<String, LibraryCollection>> = hashMapOf()
+  private var cachedLibraryRecentShelves : MutableMap<String, MutableList<LibraryShelfType>> = hashMapOf()
+  private var cachedLibraryDiscovery : MutableMap<String, MutableList<LibraryItem>> = hashMapOf()
+  private var cachedLibraryPodcasts : MutableMap<String, MutableMap<String, LibraryItem>> = hashMapOf()
+  private var isLibraryPodcastsCached : MutableMap<String, Boolean> = hashMapOf()
+  var allLibraryPersonalizationsDone : Boolean = false
+  private var libraryPersonalizationsDone : Int = 0

  private var selectedPodcast:Podcast? = null
  private var selectedLibraryItemId:String? = null
  private var podcastEpisodeLibraryItemMap = mutableMapOf<String, LibraryItemWithEpisode>()
-  private var serverLibraryCategories = listOf<LibraryCategory>()
  private var serverConfigIdUsed:String? = null
  private var serverConfigLastPing:Long = 0L
  var serverUserMediaProgress:MutableList<MediaProgress> = mutableListOf()
@@ -35,10 +49,49 @@ class MediaManager(private var apiHandler: ApiHandler, var ctx: Context) {

  var userSettingsPlaybackRate:Float? = null

+  // Android Auto browses on the media browser service main thread, so the server pings
+  // and authorize call must not run there or they block it and trigger an ANR
+  private val androidAutoIOScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+
+  // Android Auto re-requests the browse root every ~2s and multiple clients do so at once,
+  // so overlapping loads are coalesced into one to avoid racing on the shared server state
+  private var isLoadingAndroidAutoItems = false
+  private val pendingAndroidAutoLoadCallbacks = mutableListOf<() -> Unit>()
+  private val androidAutoLoadLock = Any()
+
  fun getIsLibrary(id:String) : Boolean {
    return serverLibraries.find { it.id == id } != null
  }

+  /**
+   * Check if there is discovery shelf for [libraryId]
+   * If personalized shelves are not yet populated for library then populate
+   *
+   */
+  fun getHasDiscovery(libraryId: String) : Boolean {
+    if (cachedLibraryDiscovery.containsKey(libraryId)) {
+      if (cachedLibraryDiscovery[libraryId]!!.isNotEmpty()) {
+        return true
+      }
+    } else {
+      populatePersonalizedDataForLibrary(libraryId){}
+    }
+    return false
+  }
+
+  fun getLibrary(id:String) : Library? {
+    return serverLibraries.find { it.id == id }
+  }
+
+  /**
+   * Add [libraryItem] to [serverLibraryItems] if it is not already added
+   */
+  private fun addServerLibrary(libraryItem: LibraryItem) {
+    if (serverLibraryItems.find { li -> li.id == libraryItem.id } == null) {
+      serverLibraryItems.add(libraryItem)
+    }
+  }
+
  fun getSavedPlaybackRate():Float {
    if (userSettingsPlaybackRate != null) {
      return userSettingsPlaybackRate ?: 1f
@@ -91,19 +144,31 @@ class MediaManager(private var apiHandler: ApiHandler, var ctx: Context) {
    }
  }

-  fun checkResetServerItems() {
+  fun checkResetServerItems():Boolean {
    // When opening android auto need to check if still connected to server
    //   and reset any server data already set
    val serverConnConfig = if (DeviceManager.isConnectedToServer) DeviceManager.serverConnectionConfig else DeviceManager.deviceData.getLastServerConnectionConfig()

-    if (!DeviceManager.isConnectedToServer || !DeviceManager.checkConnectivity(ctx) || serverConnConfig == null || serverConnConfig.id !== serverConfigIdUsed) {
+    if (!DeviceManager.isConnectedToServer || !DeviceManager.checkConnectivity(ctx) || serverConnConfig == null || serverConnConfig.id != serverConfigIdUsed) {
      podcastEpisodeLibraryItemMap = mutableMapOf()
-      serverLibraryCategories = listOf()
      serverLibraries = listOf()
      serverLibraryItems = mutableListOf()
-      selectedLibraryItems = mutableListOf()
-      selectedLibraryId = ""
+      cachedLibraryAuthors = hashMapOf()
+      cachedLibraryAuthorItems = hashMapOf()
+      cachedLibraryAuthorSeriesItems = hashMapOf()
+      cachedLibrarySeries = hashMapOf()
+      cachedLibrarySeriesItem = hashMapOf()
+      cachedLibraryCollections = hashMapOf()
+      cachedLibraryRecentShelves = hashMapOf()
+      cachedLibraryDiscovery = hashMapOf()
+      cachedLibraryPodcasts = hashMapOf()
+      isLibraryPodcastsCached = hashMapOf()
+      serverItemsInProgress = listOf()
+      allLibraryPersonalizationsDone = false
+      libraryPersonalizationsDone = 0
+      return true
    }
+    return false
  }

  private fun loadItemsInProgressForAllLibraries(cb: (List<ItemInProgress>) -> Unit) {
@@ -120,28 +185,457 @@ class MediaManager(private var apiHandler: ApiHandler, var ctx: Context) {
    }
  }

-  fun loadLibraryItemsWithAudio(libraryId:String, cb: (List<LibraryItem>) -> Unit) {
-    if (selectedLibraryItems.isNotEmpty() && selectedLibraryId == libraryId) {
-      cb(selectedLibraryItems)
+  /**
+   * Load personalized shelves from server for all libraries.
+   * [cb] resolves when all libraries are processed
+   */
+  fun populatePersonalizedDataForAllLibraries(cb: () -> Unit) {
+    val remaining = AtomicInteger(serverLibraries.size)
+
+    serverLibraries.forEach { lib ->
+      Log.d(tag, "Loading personalization for library ${lib.name}")
+      populatePersonalizedDataForLibrary(lib.id) {
+        Log.d(tag, "Loaded personalization for library ${lib.name}")
+        if (remaining.decrementAndGet() == 0) {
+          Log.d(tag, "Finished loading all library personalization data")
+          allLibraryPersonalizationsDone = true
+          cb()
+        }
+      }
+    }
+  }
+
+  /**
+   * Get personalized shelves from server for selected [libraryId].
+   * Populates [cachedLibraryRecentShelves] and [cachedLibraryDiscovery].
+   */
+  private fun populatePersonalizedDataForLibrary(libraryId: String, cb: () -> Unit) {
+    apiHandler.getLibraryPersonalized(libraryId) { shelves ->
+      Log.d(tag, "populatePersonalizedDataForLibrary $libraryId")
+      if (shelves === null) return@getLibraryPersonalized
+      shelves.map { shelf ->
+        Log.d(tag, "$shelf")
+        if (shelf.type == "book") {
+          if (shelf.id == "continue-listening") return@map
+          else if (shelf.id == "listen-again") return@map
+          else if (shelf.id == "recently-added") {
+            if (!cachedLibraryRecentShelves.containsKey(libraryId)) {
+              cachedLibraryRecentShelves[libraryId] = mutableListOf()
+            }
+            if (cachedLibraryRecentShelves[libraryId]?.find { it.id == shelf.id } == null) {
+              cachedLibraryRecentShelves[libraryId]!!.add(shelf)
+            }
+          }
+          else if (shelf.id == "discover") {
+            if (!cachedLibraryDiscovery.containsKey(libraryId)) {
+              cachedLibraryDiscovery[libraryId] = mutableListOf()
+            }
+            (shelf as LibraryShelfBookEntity).entities?.map {
+              cachedLibraryDiscovery[libraryId]!!.add(it)
+            }
+          }
+          else if (shelf.id == "continue-reading") return@map
+          else if (shelf.id == "continue-series") return@map
+          shelf as LibraryShelfBookEntity
+        } else if (shelf.type == "series") {
+          if (shelf.id == "recent-series") {
+            if (!cachedLibraryRecentShelves.containsKey(libraryId)) {
+              cachedLibraryRecentShelves[libraryId] = mutableListOf()
+            }
+            if (cachedLibraryRecentShelves[libraryId]?.find { it.id == shelf.id } == null) {
+              cachedLibraryRecentShelves[libraryId]!!.add(shelf)
+            }
+          }
+        } else if (shelf.type == "episode") {
+          if (shelf.id == "continue-listening") return@map
+          else if (shelf.id == "listen-again") return@map
+          else if (shelf.id == "newest-episodes") {
+            if (!cachedLibraryRecentShelves.containsKey(libraryId)) {
+              cachedLibraryRecentShelves[libraryId] = mutableListOf()
+            }
+            if (cachedLibraryRecentShelves[libraryId]?.find { it.id == shelf.id } == null) {
+              cachedLibraryRecentShelves[libraryId]!!.add(shelf)
+            }
+
+            val podcastLibraryItemIds = mutableListOf<String>()
+            (shelf as LibraryShelfEpisodeEntity).entities?.forEach { libraryItem ->
+              if (!podcastLibraryItemIds.contains(libraryItem.id)) {
+                podcastLibraryItemIds.add(libraryItem.id)
+                loadPodcastItem(libraryItem.libraryId, libraryItem.id) {}
+              }
+            }
+          }
+        } else if (shelf.type == "podcast") {
+          if (shelf.id == "recently-added"){
+            if (!cachedLibraryRecentShelves.containsKey(libraryId)) {
+              cachedLibraryRecentShelves[libraryId] = mutableListOf()
+            }
+            if (cachedLibraryRecentShelves[libraryId]?.find { it.id == shelf.id } == null) {
+              cachedLibraryRecentShelves[libraryId]!!.add(shelf)
+            }
+          }
+          else if (shelf.id == "discover"){
+            return@map
+          }
+        } else if (shelf.type =="authors") {
+          if (shelf.id == "newest-authors") {
+            if (!cachedLibraryRecentShelves.containsKey(libraryId)) {
+              cachedLibraryRecentShelves[libraryId] = mutableListOf()
+            }
+            if (cachedLibraryRecentShelves[libraryId]?.find { it.id == shelf.id } == null) {
+              cachedLibraryRecentShelves[libraryId]!!.add(shelf)
+            }
+          }
+        }
+
+      }
+      Log.d(tag, "populatePersonalizedDataForLibrary $libraryId DONE")
+      cb()
+    }
+  }
+
+  /**
+   * Returns podcasts for selected library.
+   * If data is not found from local cache it is loaded from server
+   */
+  fun loadLibraryPodcasts(libraryId:String, cb: (List<LibraryItem>?) -> Unit) {
+    // Without this there is possibility that only recent podcasts get loaded
+    // Loading recent podcasts will also create cachedLibraryPodcasts entry for library
+    if (!isLibraryPodcastsCached.containsKey(libraryId)) {
+      isLibraryPodcastsCached[libraryId] = false
+    }
+    // Ensure that there is map for library
+    if (!cachedLibraryPodcasts.containsKey(libraryId)) {
+      cachedLibraryPodcasts[libraryId] = mutableMapOf()
+    }
+    if (isLibraryPodcastsCached.getOrElse(libraryId) {false}) {
+      Log.d(tag, "loadLibraryPodcasts: Found from cache: $libraryId")
+      cb(cachedLibraryPodcasts[libraryId]?.values?.sortedBy { libraryItem -> (libraryItem.media as Podcast).metadata.title })
    } else {
      apiHandler.getLibraryItems(libraryId) { libraryItems ->
        val libraryItemsWithAudio = libraryItems.filter { li -> li.checkHasTracks() }
-        if (libraryItemsWithAudio.isNotEmpty()) {
-          selectedLibraryId = libraryId
-        }

-        selectedLibraryItems = mutableListOf()
        libraryItemsWithAudio.forEach { libraryItem ->
-          selectedLibraryItems.add(libraryItem)
+          cachedLibraryPodcasts[libraryId]?.set(libraryItem.id, libraryItem)
          if (serverLibraryItems.find { li -> li.id == libraryItem.id } == null) {
            serverLibraryItems.add(libraryItem)
          }
        }
+        isLibraryPodcastsCached[libraryId] = true
+        Log.d(tag, "loadLibraryPodcasts: loaded from server: $libraryId")
+        cb(libraryItemsWithAudio.sortedBy { libraryItem -> (libraryItem.media as Podcast).metadata.title })
+      }
+    }
+  }
+
+  /**
+   *  Returns series with audio books from selected library.
+   *  If data is not found from local cache then it will be fetched from server
+   */
+  fun loadLibrarySeriesWithAudio(libraryId:String, cb: (List<LibrarySeriesItem>) -> Unit) {
+    // Check "cache" first
+    if (cachedLibrarySeries.containsKey(libraryId)) {
+      Log.d(tag, "Series with audio found from cache | Library $libraryId ")
+      cb(cachedLibrarySeries[libraryId] as List<LibrarySeriesItem>)
+    } else {
+      apiHandler.getLibrarySeries(libraryId) { seriesItems ->
+        Log.d(tag, "Series with audio loaded from server | Library $libraryId")
+        val seriesItemsWithAudio = seriesItems.filter { si -> si.audiobookCount > 0 }
+
+        cachedLibrarySeries[libraryId] = seriesItemsWithAudio
+
+        cb(seriesItemsWithAudio)
+      }
+    }
+  }
+
+  /**
+   * Returns series with audiobooks from selected library using filter for paging.
+   * If data is not found from local cache then it will be fetched from server
+   */
+  fun loadLibrarySeriesWithAudio(libraryId:String, seriesFilter:String, cb: (List<LibrarySeriesItem>) -> Unit) {
+    // Check "cache" first
+    if (!cachedLibrarySeries.containsKey(libraryId)) {
+      loadLibrarySeriesWithAudio(libraryId) {}
+    } else {
+      Log.d(tag, "Series with audio found from cache | Library $libraryId ")
+    }
+    val seriesWithBooks = cachedLibrarySeries[libraryId]!!.filter { ls -> ls.title.uppercase().startsWith(seriesFilter) }.toList()
+    cb(seriesWithBooks)
+  }
+
+  /**
+   * Sorts books in series. Assumes that sequence is main.minor
+   */
+  private fun sortSeriesBooks(seriesBooks: List<LibraryItem>) : List<LibraryItem> {
+    val sortingLogic = compareBy<LibraryItem> { it.seriesSequenceParts[0].length }
+      .thenBy { it.seriesSequenceParts[0].ifEmpty { "" } }
+      .thenBy { it.seriesSequenceParts.getOrElse(1) { "" }.length }
+      .thenBy { it.seriesSequenceParts.getOrElse(1) { "" } }
+    return seriesBooks.sortedWith(sortingLogic)
+  }
+
+  /**
+   * Returns books for series from library.
+   * If data is not found from local cache then it will be fetched from server
+   */
+  fun loadLibrarySeriesItemsWithAudio(libraryId:String, seriesId:String, cb: (List<LibraryItem>) -> Unit) {
+    // Check "cache" first
+    if (!cachedLibrarySeriesItem.containsKey(libraryId)) {
+      cachedLibrarySeriesItem[libraryId] = hashMapOf()
+    }
+    if (cachedLibrarySeriesItem[libraryId]!!.containsKey(seriesId)) {
+      Log.d(tag, "Items for series $seriesId found from cache | Library $libraryId")
+      cachedLibrarySeriesItem[libraryId]!![seriesId]?.let { cb(it) }
+    } else {
+      apiHandler.getLibrarySeriesItems(libraryId, seriesId) { libraryItems ->
+        Log.d(tag, "Items for series $seriesId loaded from server | Library $libraryId")
+        val libraryItemsWithAudio = libraryItems.filter { li -> li.checkHasTracks() }
+
+        val sortedLibraryItemsWithAudio = sortSeriesBooks(libraryItemsWithAudio)
+        cachedLibrarySeriesItem[libraryId]!![seriesId] = sortedLibraryItemsWithAudio
+
+        sortedLibraryItemsWithAudio.forEach { libraryItem ->
+          if (serverLibraryItems.find { li -> li.id == libraryItem.id } == null) {
+            serverLibraryItems.add(libraryItem)
+          }
+        }
+        cb(sortedLibraryItemsWithAudio)
+      }
+    }
+  }
+
+  /**
+   * Returns authors with books from library.
+   * If data is not found from local cache then it will be fetched from server
+   */
+  fun loadAuthorsWithBooks(libraryId:String, cb: (List<LibraryAuthorItem>) -> Unit) {
+    // Check "cache" first
+    if (cachedLibraryAuthors.containsKey(libraryId)) {
+      Log.d(tag, "Authors with books found from cache | Library $libraryId ")
+      cb(cachedLibraryAuthors[libraryId]!!.values.toList())
+    } else {
+      // Fetch data from server and add it to local "cache"
+      apiHandler.getLibraryAuthors(libraryId) { authorItems ->
+        Log.d(tag, "Authors with books loaded from server | Library $libraryId ")
+        // TO-DO: This check won't ensure that there is audiobooks. Current API won't offer ability to do so
+        var authorItemsWithBooks = authorItems.filter { li -> li.bookCount != null && li.bookCount!! > 0 }
+        authorItemsWithBooks = authorItemsWithBooks.sortedBy { it.name }
+        // Ensure that there is map for library
+        cachedLibraryAuthors[libraryId] = mutableMapOf()
+        // Cache authors
+        authorItemsWithBooks.forEach {
+          if (!cachedLibraryAuthors[libraryId]!!.containsKey(it.id)) {
+            cachedLibraryAuthors[libraryId]!![it.id] = it
+          }
+        }
+        cb(authorItemsWithBooks)
+      }
+    }
+  }
+
+  /**
+   * Returns authors with books from selected library using filter for paging.
+   * If data is not found from local cache then it will be fetched from server
+   */
+  fun loadAuthorsWithBooks(libraryId:String, authorFilter: String, cb: (List<LibraryAuthorItem>) -> Unit) {
+    // Check "cache" first
+    if (cachedLibraryAuthors.containsKey(libraryId)) {
+      Log.d(tag, "Authors with books found from cache | Library $libraryId ")
+    } else {
+      loadAuthorsWithBooks(libraryId) {}
+    }
+    val authorsWithBooks = cachedLibraryAuthors[libraryId]!!.values.filter { lai -> lai.name.uppercase().startsWith(authorFilter) }.toList()
+    cb(authorsWithBooks)
+  }
+
+  /**
+   * Returns audiobooks for author from library
+   * If data is not found from local cache then it will be fetched from server
+   */
+  fun loadAuthorBooksWithAudio(libraryId:String, authorId:String, cb: (List<LibraryItem>) -> Unit) {
+    // Ensure that there is map for library
+    if (!cachedLibraryAuthorItems.containsKey(libraryId)) {
+        cachedLibraryAuthorItems[libraryId] = mutableMapOf()
+    }
+    // Check "cache" first
+    if (cachedLibraryAuthorItems[libraryId]!!.containsKey(authorId)) {
+      Log.d(tag, "Items for author $authorId found from cache | Library $libraryId")
+      cachedLibraryAuthorItems[libraryId]!![authorId]?.let { cb(it) }
+    } else {
+      apiHandler.getLibraryItemsFromAuthor(libraryId, authorId) { libraryItems ->
+        Log.d(tag, "Items for author $authorId loaded from server | Library $libraryId")
+        val libraryItemsWithAudio = libraryItems.filter { li -> li.checkHasTracks() }
+
+        cachedLibraryAuthorItems[libraryId]!![authorId]  = libraryItemsWithAudio
+
+        libraryItemsWithAudio.forEach { libraryItem ->
+          if (serverLibraryItems.find { li -> li.id == libraryItem.id } == null) {
+            serverLibraryItems.add(libraryItem)
+          }
+        }
+
        cb(libraryItemsWithAudio)
      }
    }
  }

+  /**
+   * Returns audiobooks for author from specified series within library
+   * If data is not found from local cache then it will be fetched from server
+   */
+  fun loadAuthorSeriesBooksWithAudio(libraryId:String, authorId:String, seriesId: String, cb: (List<LibraryItem>) -> Unit) {
+    val authorSeriesKey = "$authorId|$seriesId"
+    // Ensure that there is map for library
+    if (!cachedLibraryAuthorSeriesItems.containsKey(libraryId)) {
+      cachedLibraryAuthorSeriesItems[libraryId] = mutableMapOf()
+    }
+    // Check "cache" first
+    if (cachedLibraryAuthorSeriesItems[libraryId]!!.containsKey(authorSeriesKey)) {
+      Log.d(tag, "Items for series $seriesId with author $authorId found from cache | Library $libraryId")
+      cachedLibraryAuthorSeriesItems[libraryId]!![authorSeriesKey]?.let { cb(it) }
+    } else {
+      apiHandler.getLibrarySeriesItems(libraryId, seriesId) { libraryItems ->
+        Log.d(tag, "Items for series $seriesId with author $authorId loaded from server | Library $libraryId")
+        val libraryItemsWithAudio = libraryItems.filter { li -> li.checkHasTracks() }
+        if (!cachedLibraryAuthors[libraryId]!!.containsKey(authorId)) {
+          Log.d(tag, "Author data is missing")
+        }
+        val authorName = cachedLibraryAuthors[libraryId]!![authorId]?.name ?: ""
+        Log.d(tag, "Using author name: $authorName")
+        val libraryItemsFromAuthorWithAudio = libraryItemsWithAudio.filter { li -> li.authorName.indexOf(authorName, ignoreCase = true) >= 0 }
+
+        val sortedLibraryItemsWithAudio = sortSeriesBooks(libraryItemsFromAuthorWithAudio)
+        cachedLibraryAuthorSeriesItems[libraryId]!![authorId] = sortedLibraryItemsWithAudio
+
+        sortedLibraryItemsWithAudio.forEach { libraryItem ->
+          if (serverLibraryItems.find { li -> li.id == libraryItem.id } == null) {
+            serverLibraryItems.add(libraryItem)
+          }
+        }
+
+        cb(sortedLibraryItemsWithAudio)
+      }
+    }
+  }
+
+  /**
+   * Returns collections with audiobooks from library
+   * If data is not found from local cache then it will be fetched from server
+   */
+  fun loadLibraryCollectionsWithAudio(libraryId:String, cb: (List<LibraryCollection>) -> Unit) {
+    if (cachedLibraryCollections.containsKey(libraryId)) {
+      Log.d(tag, "Collections with books found from cache | Library $libraryId ")
+      cb(cachedLibraryCollections[libraryId]!!.values.toList())
+    } else {
+      apiHandler.getLibraryCollections(libraryId) { libraryCollections ->
+        Log.d(tag, "Collections with books loaded from server | Library $libraryId ")
+        val libraryCollectionsWithAudio = libraryCollections.filter { lc -> lc.audiobookCount > 0 }
+
+        // Cache collections
+        cachedLibraryCollections[libraryId] = hashMapOf()
+        libraryCollectionsWithAudio.forEach {
+          if (!cachedLibraryCollections[libraryId]!!.containsKey(it.id)) {
+            cachedLibraryCollections[libraryId]!![it.id] = it
+          }
+        }
+        cb(libraryCollectionsWithAudio)
+      }
+    }
+  }
+
+  /**
+   * Returns audiobooks for collection from library
+   * If data is not found from local cache then it will be fetched from server
+   */
+  fun loadLibraryCollectionBooksWithAudio(libraryId: String, collectionId: String, cb: (List<LibraryItem>) -> Unit) {
+    if (!cachedLibraryCollections.containsKey(libraryId)) {
+      loadLibraryCollectionsWithAudio(libraryId) {}
+    }
+    Log.d(tag, "Trying to find collection $collectionId items from from cache | Library $libraryId ")
+    if ( cachedLibraryCollections[libraryId]!!.containsKey(collectionId)) {
+      val libraryCollectionBookswithAudio = cachedLibraryCollections[libraryId]!![collectionId]?.books
+      libraryCollectionBookswithAudio?.forEach { libraryItem ->
+        if (serverLibraryItems.find { li -> li.id == libraryItem.id } == null) {
+          serverLibraryItems.add(libraryItem)
+        }
+      }
+      cb(libraryCollectionBookswithAudio as List<LibraryItem>)
+    }
+  }
+
+  /**
+   * Returns audiobooks from discovery shelf for [libraryId]
+   * If data is not found from local cache then it will be fetched from server
+   */
+  fun loadLibraryDiscoveryBooksWithAudio(libraryId: String, cb: (List<LibraryItem>) -> Unit) {
+    if (!cachedLibraryDiscovery.containsKey(libraryId)) {
+      cb(listOf())
+    }
+    val libraryItemsWithAudio = cachedLibraryDiscovery[libraryId]?.filter { li -> li.checkHasTracks() }
+    libraryItemsWithAudio?.forEach { libraryItem -> addServerLibrary(libraryItem) }
+    cb(libraryItemsWithAudio as List<LibraryItem>)
+  }
+
+  /**
+   * Returns recent shelves for [libraryId]
+   * If data is not shelves are found returns empty list
+   */
+  fun getLibraryRecentShelfs(libraryId: String, cb: (List<LibraryShelfType>) -> Unit) {
+    if (!cachedLibraryRecentShelves.containsKey(libraryId)) {
+      Log.d(tag, "getLibraryRecentShelfs: No shelves $libraryId")
+      cb(listOf())
+      return
+    }
+    cb(cachedLibraryRecentShelves[libraryId] as List<LibraryShelfType>)
+  }
+
+  /**
+   * Returns recent shelf by [type] for [libraryId]
+   * If shelf is not found returns null
+   */
+  fun getLibraryRecentShelfByType(libraryId: String, type:String, cb: (LibraryShelfType?) -> Unit) {
+    Log.d(tag, "getLibraryRecentShelfByType: $libraryId | $type")
+    if (!cachedLibraryRecentShelves.containsKey(libraryId)) {
+      cb(null)
+      return
+    }
+    for (shelf in cachedLibraryRecentShelves[libraryId]!!) {
+      if (shelf.type == type.lowercase()) {
+        cb(shelf)
+        return
+      }
+    }
+    cb(null)
+  }
+
+  /**
+   * Loads podcasts for newest episodes shelf
+   */
+  private fun loadPodcastItem(libraryId: String, libraryItemId: String, cb: (LibraryItem?) -> Unit) {
+    // Ensure that there is map for library
+    if (!cachedLibraryPodcasts.containsKey(libraryId)) {
+      cachedLibraryPodcasts[libraryId] = mutableMapOf()
+    }
+    if (cachedLibraryPodcasts[libraryId]!!.containsKey(libraryItemId)) {
+      Log.d(tag, "loadPodcastItem: Podcast found from cache | Library $libraryItemId ")
+      cb(cachedLibraryPodcasts[libraryId]?.get(libraryItemId))
+    } else {
+      Log.d(tag, "loadPodcastItem: Calling getLibraryItem $libraryItemId")
+      apiHandler.getLibraryItem(libraryItemId) { libraryItem ->
+        if (libraryItem !== null) {
+          Log.d(tag, "loadPodcastItem: Got library item ${libraryItem.id} ${libraryItem.media.metadata.title}")
+          val podcast = libraryItem.media as Podcast
+          podcast.episodes?.forEach { podcastEpisode ->
+            podcastEpisodeLibraryItemMap[podcastEpisode.id] = LibraryItemWithEpisode(libraryItem, podcastEpisode)
+          }
+          cachedLibraryPodcasts[libraryId]?.set(libraryItemId, libraryItem)
+          cb(libraryItem)
+        }
+      }
+    }
+  }
+
  private fun loadLibraryItem(libraryItemId:String, cb: (LibraryItemWrapper?) -> Unit) {
    if (libraryItemId.startsWith("local")) {
      cb(DeviceManager.dbManager.getLocalLibraryItem(libraryItemId))
@@ -187,8 +681,8 @@ class MediaManager(private var apiHandler: ApiHandler, var ctx: Context) {
              }
              selectedLibraryItemId = libraryItemWrapper.id
              selectedPodcast = podcast
-
-              val children = podcast.episodes?.map { podcastEpisode ->
+              val episodes = podcast.episodes?.sortedByDescending { it.publishedAt }
+              val children = episodes?.map { podcastEpisode ->

                val progress = serverUserMediaProgress.find { it.libraryItemId == libraryItemWrapper.id && it.episodeId == podcastEpisode.id }

@@ -209,13 +703,16 @@ class MediaManager(private var apiHandler: ApiHandler, var ctx: Context) {
      }
  }

+  /**
+   * Loads libraries for selected server with stats
+   */
  private fun loadLibraries(cb: (List<Library>) -> Unit) {
    if (serverLibraries.isNotEmpty()) {
      cb(serverLibraries)
    } else {
-      apiHandler.getLibraries {
-        serverLibraries = it
-        cb(it)
+      apiHandler.getLibraries { loadedLibraries ->
+        serverLibraries = loadedLibraries
+        cb(serverLibraries)
      }
    }
  }
@@ -246,15 +743,20 @@ class MediaManager(private var apiHandler: ApiHandler, var ctx: Context) {
    return mediaProgress
  }

-  private fun checkSetValidServerConnectionConfig(cb: (Boolean) -> Unit) = runBlocking {
-    Log.d(tag, "checkSetValidServerConnectionConfig | $serverConfigIdUsed")
+  // Runs on [androidAutoIOScope] rather than blocking the caller: this is reached from
+  // onLoadChildren on the media browser service main thread, and the pings/authorize below
+  // are network calls, so runBlocking here caused ANRs while browsing in Android Auto
+  private fun checkSetValidServerConnectionConfig(cb: (Boolean) -> Unit) = androidAutoIOScope.launch {
+    Log.d(tag, "checkSetValidServerConnectionConfig | serverConfigIdUsed=$serverConfigIdUsed | lastServerConnectionConfigId=${DeviceManager.deviceData.lastServerConnectionConfigId}")

    coroutineScope {
      if (!DeviceManager.checkConnectivity(ctx)) {
        serverUserMediaProgress = mutableListOf()
+        Log.d(tag, "checkSetValidServerConnectionConfig: No connectivity")
        cb(false)
-      } else if (DeviceManager.serverConnectionConfigId == "") { // If in offline mode server connection config is unset
+      } else if (DeviceManager.deviceData.lastServerConnectionConfigId.isNullOrBlank()) { // If in offline mode last server connection config is unset
        serverUserMediaProgress = mutableListOf()
+        Log.d(tag, "checkSetValidServerConnectionConfig: No last server connection config")
        cb(false)
      } else {
        var hasValidConn = false
@@ -327,40 +829,124 @@ class MediaManager(private var apiHandler: ApiHandler, var ctx: Context) {
    }
  }

+  fun initializeInProgressItems(cb: () -> Unit) {
+    Log.d(tag, "Initializing inprogress items")
+
+    loadItemsInProgressForAllLibraries { itemsInProgress ->
+      itemsInProgress.forEach {
+        val libraryItem = it.libraryItemWrapper as LibraryItem
+        if (serverLibraryItems.find { li -> li.id == libraryItem.id } == null) {
+          serverLibraryItems.add(libraryItem)
+        }
+
+        if (it.episode != null) {
+          podcastEpisodeLibraryItemMap[it.episode.id] = LibraryItemWithEpisode(it.libraryItemWrapper, it.episode)
+        }
+      }
+      Log.d(tag, "Initializing inprogress items done")
+      cb()
+    }
+  }
+
  fun loadAndroidAutoItems(cb: () -> Unit) {
    Log.d(tag, "Load android auto items")

+    // Coalesce overlapping calls into a single load, every caller still gets its callback
+    synchronized(androidAutoLoadLock) {
+      pendingAndroidAutoLoadCallbacks.add(cb)
+      if (isLoadingAndroidAutoItems) {
+        Log.d(tag, "loadAndroidAutoItems: Load already in progress, queued callback")
+        return
+      }
+      isLoadingAndroidAutoItems = true
+    }
+
+    val onLoadFinished = {
+      val callbacks: List<() -> Unit>
+      synchronized(androidAutoLoadLock) {
+        isLoadingAndroidAutoItems = false
+        callbacks = pendingAndroidAutoLoadCallbacks.toList()
+        pendingAndroidAutoLoadCallbacks.clear()
+      }
+      callbacks.forEach { it() }
+    }
+
    // Check if any valid server connection if not use locally downloaded books
    checkSetValidServerConnectionConfig { isConnected ->
      if (isConnected) {
        serverConfigIdUsed = DeviceManager.serverConnectionConfigId
+        Log.d(tag, "loadAndroidAutoItems: Connected to server config id=$serverConfigIdUsed")

        loadLibraries { libraries ->
          if (libraries.isEmpty()) {
            Log.w(tag, "No libraries returned from server request")
-            cb()
+            onLoadFinished()
          } else {
-            val library = libraries[0]
-            Log.d(tag, "Loading categories for library ${library.name} - ${library.id} - ${library.mediaType}")
-
-            loadItemsInProgressForAllLibraries { itemsInProgress ->
-              itemsInProgress.forEach {
-                val libraryItem = it.libraryItemWrapper as LibraryItem
-                if (serverLibraryItems.find { li -> li.id == libraryItem.id } == null) {
-                  serverLibraryItems.add(libraryItem)
-                }
-
-                if (it.episode != null) {
-                  podcastEpisodeLibraryItemMap[it.episode.id] = LibraryItemWithEpisode(it.libraryItemWrapper, it.episode)
-                }
-              }
-
-              cb() // Fully loaded
-            }
+            onLoadFinished() // Fully loaded
          }
        }
      } else { // Not connected to server
-        cb()
+        Log.d(tag, "loadAndroidAutoItems: Not connected to server")
+        onLoadFinished()
+      }
+    }
+  }
+
+  /**
+   * Handles search requests.
+   * Searches from books, series and authors
+   */
+  suspend fun doSearch(libraryId: String, queryString: String) : Map<String, List<MediaBrowserCompat.MediaItem>> {
+    return suspendCoroutine {
+      apiHandler.getSearchResults(libraryId, queryString) { searchResult ->
+        Log.d(tag, "searchLocalCache: $searchResult")
+        // Nothing found from server
+        if (searchResult === null) {
+          it.resume(mapOf())
+          return@getSearchResults
+        }
+
+        val foundItems: MutableMap<String, List<MediaBrowserCompat.MediaItem>> = mutableMapOf()
+
+        val serverLibrary = serverLibraries.find { sl -> sl.id == libraryId }
+
+        // Books
+        if (searchResult.book !== null && searchResult.book!!.isNotEmpty()) {
+          Log.d(tag, "searchLocalCache: found ${searchResult.book!!.size} books")
+          val children = searchResult.book!!.filter { it.libraryItem.checkHasTracks() }.map { bookResult ->
+            val libraryItem = bookResult.libraryItem
+
+            if (serverLibraryItems.find { li -> li.id == libraryItem.id } == null) {
+              serverLibraryItems.add(libraryItem)
+            }
+            val progress = serverUserMediaProgress.find { it.libraryItemId == libraryItem.id }
+            val localLibraryItem = DeviceManager.dbManager.getLocalLibraryItemByLId(libraryItem.id)
+            libraryItem.localLibraryItemId = localLibraryItem?.id
+            val description = libraryItem.getMediaDescription(progress, ctx, null, null, "Books (${serverLibrary?.name})")
+            MediaBrowserCompat.MediaItem(description, MediaBrowserCompat.MediaItem.FLAG_PLAYABLE)
+          }
+          foundItems["book"] = children
+        }
+        if (searchResult.series !== null && searchResult.series!!.isNotEmpty()) {
+          Log.d(tag, "onSearch: found ${searchResult.series!!.size} series")
+          val children = searchResult.series!!.map { seriesResult ->
+            val seriesItem = seriesResult.series
+            seriesItem.books = seriesResult.books as MutableList<LibraryItem>
+            val description = seriesItem.getMediaDescription(null, ctx, "Series (${serverLibrary?.name})")
+            MediaBrowserCompat.MediaItem(description, MediaBrowserCompat.MediaItem.FLAG_BROWSABLE)
+          }
+          foundItems["series"] = children
+        }
+        if (searchResult.authors !== null && searchResult.authors!!.isNotEmpty()) {
+          Log.d(tag, "onSearch: found ${searchResult.authors!!.size} authors")
+          val children = searchResult.authors!!.map { authorItem ->
+            val description = authorItem.getMediaDescription(null, ctx, "Authors (${serverLibrary?.name})")
+            MediaBrowserCompat.MediaItem(description, MediaBrowserCompat.MediaItem.FLAG_BROWSABLE)
+          }
+          foundItems["authors"] = children
+        }
+
+        it.resume(foundItems)
      }
    }
  }
@@ -8,41 +8,49 @@ import com.audiobookshelf.app.data.MediaProgress
 import com.audiobookshelf.app.data.PlaybackSession
 import com.audiobookshelf.app.device.DeviceManager
 import com.audiobookshelf.app.player.PlayerNotificationService
+import com.audiobookshelf.app.plugins.AbsLogger
 import com.audiobookshelf.app.server.ApiHandler
 import java.util.*
 import kotlin.concurrent.schedule

 data class MediaProgressSyncData(
-  var timeListened:Long, // seconds
-  var duration:Double, // seconds
-  var currentTime:Double // seconds
+        var timeListened: Long, // seconds
+        var duration: Double, // seconds
+        var currentTime: Double // seconds
 )

 data class SyncResult(
-  var serverSyncAttempted:Boolean,
-  var serverSyncSuccess:Boolean?,
-  var serverSyncMessage:String?
+        var serverSyncAttempted: Boolean,
+        var serverSyncSuccess: Boolean?,
+        var serverSyncMessage: String?
 )

-class MediaProgressSyncer(val playerNotificationService: PlayerNotificationService, private val apiHandler: ApiHandler) {
+class MediaProgressSyncer(
+        val playerNotificationService: PlayerNotificationService,
+        private val apiHandler: ApiHandler
+) {
  private val tag = "MediaProgressSync"
  private val METERED_CONNECTION_SYNC_INTERVAL = 60000

  private var listeningTimerTask: TimerTask? = null
-  var listeningTimerRunning:Boolean = false
+  var listeningTimerRunning: Boolean = false

-  private var lastSyncTime:Long = 0
-  private var failedSyncs:Int = 0
+  private var lastSyncTime: Long = 0
+  private var failedSyncs: Int = 0

  var currentPlaybackSession: PlaybackSession? = null // copy of pb session currently syncing
  var currentLocalMediaProgress: LocalMediaProgress? = null

-  private val currentDisplayTitle get() = currentPlaybackSession?.displayTitle ?: "Unset"
-  val currentIsLocal get() = currentPlaybackSession?.isLocal == true
-  val currentSessionId get() = currentPlaybackSession?.id ?: ""
-  private val currentPlaybackDuration get() = currentPlaybackSession?.duration ?: 0.0
+  private val currentDisplayTitle
+    get() = currentPlaybackSession?.displayTitle ?: "Unset"
+  val currentIsLocal
+    get() = currentPlaybackSession?.isLocal == true
+  val currentSessionId
+    get() = currentPlaybackSession?.id ?: ""
+  private val currentPlaybackDuration
+    get() = currentPlaybackSession?.duration ?: 0.0

-  fun start(playbackSession:PlaybackSession) {
+  fun start(playbackSession: PlaybackSession) {
    if (listeningTimerRunning) {
      Log.d(tag, "start: Timer already running for $currentDisplayTitle")
      if (playbackSession.id != currentSessionId) {
@@ -62,40 +70,48 @@ class MediaProgressSyncer(val playerNotificationService: PlayerNotificationServi
    listeningTimerRunning = true
    lastSyncTime = System.currentTimeMillis()
    currentPlaybackSession = playbackSession.clone()
-    Log.d(tag, "start: init last sync time $lastSyncTime with playback session id=${currentPlaybackSession?.id}")
+    Log.d(
+            tag,
+            "start: init last sync time $lastSyncTime with playback session id=${currentPlaybackSession?.id}"
+    )

-    listeningTimerTask = Timer("ListeningTimer", false).schedule(15000L, 15000L) {
-      Handler(Looper.getMainLooper()).post() {
-        if (playerNotificationService.currentPlayer.isPlaying) {
-          // Set auto sleep timer if enabled and within start/end time
-          playerNotificationService.sleepTimerManager.checkAutoSleepTimer()
+    listeningTimerTask =
+            Timer("ListeningTimer", false).schedule(15000L, 15000L) {
+              Handler(Looper.getMainLooper()).post() {
+                if (playerNotificationService.currentPlayer.isPlaying) {
+                  // Set auto sleep timer if enabled and within start/end time
+                  playerNotificationService.sleepTimerManager.checkAutoSleepTimer()

-          // Only sync with server on unmetered connection every 15s OR sync with server if last sync time is >= 60s
-          val shouldSyncServer = PlayerNotificationService.isUnmeteredNetwork || System.currentTimeMillis() - lastSyncTime >= METERED_CONNECTION_SYNC_INTERVAL
+                  // Only sync with server on unmetered connection every 15s OR sync with server if
+                  // last sync time is >= 60s
+                  val shouldSyncServer =
+                          PlayerNotificationService.isUnmeteredNetwork ||
+                                  System.currentTimeMillis() - lastSyncTime >=
+                                          METERED_CONNECTION_SYNC_INTERVAL

-          val currentTime = playerNotificationService.getCurrentTimeSeconds()
-          if (currentTime > 0) {
-            sync(shouldSyncServer, currentTime) { syncResult ->
-              Log.d(tag, "Sync complete")
+                  val currentTime = playerNotificationService.getCurrentTimeSeconds()
+                  if (currentTime > 0) {
+                    sync(shouldSyncServer, currentTime) { syncResult ->
+                      Log.d(tag, "Sync complete")

-              currentPlaybackSession?.let { playbackSession ->
-                MediaEventManager.saveEvent(playbackSession, syncResult)
+                      currentPlaybackSession?.let { playbackSession ->
+                        MediaEventManager.saveEvent(playbackSession, syncResult)
+                      }
+                    }
+                  }
+                }
              }
            }
-          }
-        }
-      }
-    }
  }

-  fun play(playbackSession:PlaybackSession) {
+  fun play(playbackSession: PlaybackSession) {
    Log.d(tag, "play ${playbackSession.displayTitle}")
    MediaEventManager.playEvent(playbackSession)

    start(playbackSession)
  }

-  fun stop(shouldSync:Boolean? = true, cb: () -> Unit) {
+  fun stop(shouldSync: Boolean? = true, cb: () -> Unit) {
    if (!listeningTimerRunning) {
      reset()
      return cb()
@@ -106,7 +122,8 @@ class MediaProgressSyncer(val playerNotificationService: PlayerNotificationServi
    listeningTimerRunning = false
    Log.d(tag, "stop: Stopping listening for $currentDisplayTitle")

-    val currentTime = if (shouldSync == true) playerNotificationService.getCurrentTimeSeconds() else 0.0
+    val currentTime =
+            if (shouldSync == true) playerNotificationService.getCurrentTimeSeconds() else 0.0
    if (currentTime > 0) { // Current time should always be > 0 on stop
      sync(true, currentTime) { syncResult ->
        currentPlaybackSession?.let { playbackSession ->
@@ -192,17 +209,21 @@ class MediaProgressSyncer(val playerNotificationService: PlayerNotificationServi
    MediaEventManager.seekEvent(currentPlaybackSession!!, null)
  }

+  // Currently unused
  fun syncFromServerProgress(mediaProgress: MediaProgress) {
    currentPlaybackSession?.let {
      it.updatedAt = mediaProgress.lastUpdate
      it.currentTime = mediaProgress.currentTime

-      MediaEventManager.syncEvent(mediaProgress, "Received from server get media progress request while playback session open")
+      MediaEventManager.syncEvent(
+              mediaProgress,
+              "Received from server get media progress request while playback session open"
+      )
      saveLocalProgress(it)
    }
  }

-  fun sync(shouldSyncServer:Boolean, currentTime:Double, cb: (SyncResult?) -> Unit) {
+  fun sync(shouldSyncServer: Boolean, currentTime: Double, cb: (SyncResult?) -> Unit) {
    if (lastSyncTime <= 0) {
      Log.e(tag, "Last sync time is not set $lastSyncTime")
      return cb(null)
@@ -214,11 +235,14 @@ class MediaProgressSyncer(val playerNotificationService: PlayerNotificationServi
    }
    val listeningTimeToAdd = diffSinceLastSync / 1000L

-    val syncData = MediaProgressSyncData(listeningTimeToAdd,currentPlaybackDuration,currentTime)
+    val syncData = MediaProgressSyncData(listeningTimeToAdd, currentPlaybackDuration, currentTime)
    currentPlaybackSession?.syncData(syncData)

    if (currentPlaybackSession?.progress?.isNaN() == true) {
-      Log.e(tag, "Current Playback Session invalid progress ${currentPlaybackSession?.progress} | Current Time: ${currentPlaybackSession?.currentTime} | Duration: ${currentPlaybackSession?.getTotalDuration()}")
+      Log.e(
+              tag,
+              "Current Playback Session invalid progress ${currentPlaybackSession?.progress} | Current Time: ${currentPlaybackSession?.currentTime} | Duration: ${currentPlaybackSession?.getTotalDuration()}"
+      )
      return cb(null)
    }

@@ -226,11 +250,7 @@ class MediaProgressSyncer(val playerNotificationService: PlayerNotificationServi

    // Save playback session to db (server linked sessions only)
    //   Sessions are removed once successfully synced with the server
-    currentPlaybackSession?.let {
-      if (!it.isLocalLibraryItemOnly) {
-        DeviceManager.dbManager.savePlaybackSession(it)
-      }
-    }
+    currentPlaybackSession?.let { DeviceManager.dbManager.savePlaybackSession(it) }

    if (currentIsLocal) {
      // Save local progress sync
@@ -238,36 +258,50 @@ class MediaProgressSyncer(val playerNotificationService: PlayerNotificationServi
        saveLocalProgress(it)
        lastSyncTime = System.currentTimeMillis()

-        Log.d(tag, "Sync local device current serverConnectionConfigId=${DeviceManager.serverConnectionConfig?.id}")
+        Log.d(
+                tag,
+                "Sync local device current serverConnectionConfigId=${DeviceManager.serverConnectionConfig?.id}"
+        )
+        AbsLogger.info("MediaProgressSyncer", "sync: Saved local progress (title: \"$currentDisplayTitle\") (currentTime: $currentTime) (session id: ${it.id})")

        // Local library item is linked to a server library item
-        // Send sync to server also if connected to this server and local item belongs to this server
-        if (hasNetworkConnection && shouldSyncServer && !it.libraryItemId.isNullOrEmpty() && it.serverConnectionConfigId != null && DeviceManager.serverConnectionConfig?.id == it.serverConnectionConfigId) {
+        // Send sync to server also if connected to this server and local item belongs to this
+        // server
+        val isConnectedToSameServer = it.serverConnectionConfigId != null && DeviceManager.serverConnectionConfig?.id == it.serverConnectionConfigId
+        if (hasNetworkConnection &&
+                        shouldSyncServer &&
+                        !it.libraryItemId.isNullOrEmpty() &&
+                        isConnectedToSameServer
+        ) {
          apiHandler.sendLocalProgressSync(it) { syncSuccess, errorMsg ->
            if (syncSuccess) {
              failedSyncs = 0
              playerNotificationService.alertSyncSuccess()
              DeviceManager.dbManager.removePlaybackSession(it.id) // Remove session from db
+              AbsLogger.info("MediaProgressSyncer", "sync: Successfully synced local progress (title: \"$currentDisplayTitle\") (currentTime: $currentTime) (session id: ${it.id})")
            } else {
              failedSyncs++
              if (failedSyncs == 2) {
                playerNotificationService.alertSyncFailing() // Show alert in client
                failedSyncs = 0
              }
-              Log.e(tag, "Local Progress sync failed ($failedSyncs) to send to server $currentDisplayTitle for time $currentTime with session id=${it.id}")
+              AbsLogger.error("MediaProgressSyncer", "sync: Local progress sync failed (count: $failedSyncs) (title: \"$currentDisplayTitle\") (currentTime: $currentTime) (session id: ${it.id}) (${DeviceManager.serverConnectionConfigName})")
            }

            cb(SyncResult(true, syncSuccess, errorMsg))
          }
        } else {
+          AbsLogger.info("MediaProgressSyncer", "sync: Not sending local progress to server (title: \"$currentDisplayTitle\") (currentTime: $currentTime) (session id: ${it.id}) (hasNetworkConnection: $hasNetworkConnection) (isConnectedToSameServer: $isConnectedToSameServer)")
          cb(SyncResult(false, null, null))
        }
      }
    } else if (hasNetworkConnection && shouldSyncServer) {
-      Log.d(tag, "sync: currentSessionId=$currentSessionId")
+      AbsLogger.info("MediaProgressSyncer", "sync: Sending progress sync to server (title: \"$currentDisplayTitle\") (currentTime: $currentTime) (session id: ${currentSessionId}) (${DeviceManager.serverConnectionConfigName})")
+
      apiHandler.sendProgressSync(currentSessionId, syncData) { syncSuccess, errorMsg ->
        if (syncSuccess) {
-          Log.d(tag, "Progress sync data sent to server $currentDisplayTitle for time $currentTime")
+          AbsLogger.info("MediaProgressSyncer", "sync: Successfully synced progress (title: \"$currentDisplayTitle\") (currentTime: $currentTime) (session id: ${currentSessionId}) (${DeviceManager.serverConnectionConfigName})")
+
          failedSyncs = 0
          playerNotificationService.alertSyncSuccess()
          lastSyncTime = System.currentTimeMillis()
@@ -278,18 +312,20 @@ class MediaProgressSyncer(val playerNotificationService: PlayerNotificationServi
            playerNotificationService.alertSyncFailing() // Show alert in client
            failedSyncs = 0
          }
-          Log.e(tag, "Progress sync failed ($failedSyncs) to send to server $currentDisplayTitle for time $currentTime with session id=${currentSessionId}")
+          AbsLogger.error("MediaProgressSyncer", "sync: Progress sync failed (count: $failedSyncs) (title: \"$currentDisplayTitle\") (currentTime: $currentTime) (session id: $currentSessionId) (${DeviceManager.serverConnectionConfigName})")
        }
        cb(SyncResult(true, syncSuccess, errorMsg))
      }
    } else {
+      AbsLogger.info("MediaProgressSyncer", "sync: Not sending progress to server (title: \"$currentDisplayTitle\") (currentTime: $currentTime) (session id: $currentSessionId) (${DeviceManager.serverConnectionConfigName}) (hasNetworkConnection: $hasNetworkConnection)")
      cb(SyncResult(false, null, null))
    }
  }

-  private fun saveLocalProgress(playbackSession:PlaybackSession) {
+  private fun saveLocalProgress(playbackSession: PlaybackSession) {
    if (currentLocalMediaProgress == null) {
-      val mediaProgress = DeviceManager.dbManager.getLocalMediaProgress(playbackSession.localMediaProgressId)
+      val mediaProgress =
+              DeviceManager.dbManager.getLocalMediaProgress(playbackSession.localMediaProgressId)
      if (mediaProgress == null) {
        currentLocalMediaProgress = playbackSession.getNewLocalMediaProgress()
      } else {
@@ -306,12 +342,14 @@ class MediaProgressSyncer(val playerNotificationService: PlayerNotificationServi
      } else {
        DeviceManager.dbManager.saveLocalMediaProgress(it)
        playerNotificationService.clientEventEmitter?.onLocalMediaProgressUpdate(it)
-        Log.d(tag, "Saved Local Progress Current Time: ID ${it.id} | ${it.currentTime} | Duration ${it.duration} | Progress ${it.progressPercent}%")
+        Log.d(
+                tag,
+                "Saved Local Progress Current Time: ID ${it.id} | ${it.currentTime} | Duration ${it.duration} | Progress ${it.progressPercent}%"
+        )
      }
    }
  }

-
  fun reset() {
    currentPlaybackSession = null
    currentLocalMediaProgress = null
@@ -0,0 +1,55 @@
+package com.audiobookshelf.app.media
+
+import android.content.ContentResolver
+import android.content.Context
+import android.net.Uri
+import androidx.annotation.AnyRes
+import com.audiobookshelf.app.R
+
+/**
+ * get uri to drawable or any other resource type if u wish
+ * @param drawableId - drawable res id
+ * @return - uri
+ */
+fun getUriToDrawable(context: Context, @AnyRes drawableId: Int): Uri {
+  return Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE
+    + "://" + context.resources.getResourcePackageName(drawableId)
+    + '/' + context.resources.getResourceTypeName(drawableId)
+    + '/' + context.resources.getResourceEntryName(drawableId))
+}
+
+
+/**
+ * get uri to drawable or any other resource type if u wish
+ * @param drawableId - drawable res id
+ * @return - uri
+ */
+fun getUriToAbsIconDrawable(context: Context, absIconName: String): Uri {
+  val drawableId = when(absIconName) {
+    "audiobookshelf" -> R.drawable.abs_audiobookshelf
+    "authors" -> R.drawable.abs_authors
+    "book-1" -> R.drawable.abs_book_1
+    "books-1" -> R.drawable.abs_books_1
+    "books-2" -> R.drawable.abs_books_2
+    "columns" -> R.drawable.abs_columns
+    "database" -> R.drawable.abs_database
+    "file-picture" -> R.drawable.abs_file_picture
+    "headphones" -> R.drawable.abs_headphones
+    "heart" -> R.drawable.abs_heart
+    "microphone_1" -> R.drawable.abs_microphone_1
+    "microphone_2" -> R.drawable.abs_microphone_2
+    "microphone_3" -> R.drawable.abs_microphone_3
+    "music" -> R.drawable.abs_music
+    "podcast" -> R.drawable.abs_podcast
+    "radio" -> R.drawable.abs_radio
+    "rocket" -> R.drawable.abs_rocket
+    "rss" -> R.drawable.abs_rss
+    "star" -> R.drawable.abs_star
+    else -> R.drawable.icon_library_folder
+  }
+  return Uri.parse(
+    ContentResolver.SCHEME_ANDROID_RESOURCE
+      + "://" + context.resources.getResourcePackageName(drawableId)
+      + '/' + context.resources.getResourceTypeName(drawableId)
+      + '/' + context.resources.getResourceEntryName(drawableId))
+}
@@ -6,34 +6,40 @@ import com.audiobookshelf.app.data.MediaType
 import com.fasterxml.jackson.annotation.JsonIgnore

 data class DownloadItem(
-  val id: String,
-  val libraryItemId:String,
-  val episodeId:String?,
-  val userMediaProgress: MediaProgress?,
-  val serverConnectionConfigId:String,
-  val serverAddress:String,
-  val serverUserId:String,
-  val mediaType: String,
-  val itemFolderPath:String,
-  val localFolder: LocalFolder,
-  val itemTitle: String,
-  val itemSubfolder: String,
-  val media: MediaType,
-  val downloadItemParts: MutableList<DownloadItemPart>
+        val id: String,
+        val libraryItemId: String,
+        val episodeId: String?,
+        val userMediaProgress: MediaProgress?,
+        val serverConnectionConfigId: String,
+        val serverAddress: String,
+        val serverUserId: String,
+        val mediaType: String,
+        val itemFolderPath: String,
+        val localFolder: LocalFolder,
+        val itemTitle: String,
+        val itemSubfolder: String,
+        val media: MediaType,
+        val downloadItemParts: MutableList<DownloadItemPart>,
+        @JsonIgnore var terminalFailureAt: Long? = null,
+        @JsonIgnore var stagingCleanupAt: Long? = null
 ) {
  @get:JsonIgnore
-  val isInternalStorage get() = localFolder.id.startsWith("internal-")
+  val isInternalStorage
+    get() = localFolder.id.startsWith("internal-")

  @get:JsonIgnore
-  val isDownloadFinished get() = !downloadItemParts.any { !it.completed || it.isMoving }
+  val isDownloadFinished
+    get() = downloadItemParts.isNotEmpty() && downloadItemParts.all {
+      it.completed && it.moved && !it.isMoving && !it.failed
+    }

  @JsonIgnore
-  fun getNextDownloadItemParts(limit:Int): MutableList<DownloadItemPart> {
+  fun getNextDownloadItemParts(limit: Int): MutableList<DownloadItemPart> {
    val itemParts = mutableListOf<DownloadItemPart>()
    if (limit == 0) return itemParts

    for (it in downloadItemParts) {
-      if (!it.completed && it.downloadId == null) {
+      if (!it.completed && !it.failed && it.downloadId == null) {
        itemParts.add(it)
        if (itemParts.size >= limit) break
      }
@@ -1,6 +1,5 @@
 package com.audiobookshelf.app.models

-import android.app.DownloadManager
 import android.net.Uri
 import android.util.Log
 import com.audiobookshelf.app.data.AudioTrack
@@ -15,7 +14,8 @@ data class DownloadItemPart(
  val id: String,
  val downloadItemId: String,
  val filename: String,
-  val fileSize: Long,
+  var fileSize: Long,
+  @JsonIgnore val destinationPath: String,
  val finalDestinationPath:String,
  val serverPath: String,
  val localFolderName: String,
@@ -31,25 +31,31 @@ data class DownloadItemPart(
  @JsonIgnore val uri: Uri,
  @JsonIgnore val destinationUri: Uri,
  @JsonIgnore val finalDestinationUri: Uri,
+  @JsonIgnore var completedDestinationUri: String?,
  val finalDestinationSubfolder: String,
  var downloadId: Long?,
+  @JsonIgnore var lastUpdateTime: Long?,
  var progress: Long,
-  var bytesDownloaded: Long
+  var bytesDownloaded: Long,
+  @JsonIgnore var retryCount: Int = 0,
+  @JsonIgnore var authRetryCount: Int = 0,
+  @JsonIgnore var waitingForSpace: Boolean = false,
+  @JsonIgnore var reusedExistingFile: Boolean = false
 ) {
  companion object {
    fun make(downloadItemId:String, filename:String, fileSize: Long, destinationFile: File, finalDestinationFile: File, subfolder:String, serverPath:String, localFolder: LocalFolder, ebookFile: EBookFile?, audioTrack: AudioTrack?, episode: PodcastEpisode?) :DownloadItemPart {
      val destinationUri = Uri.fromFile(destinationFile)
      val finalDestinationUri = Uri.fromFile(finalDestinationFile)
+      val rawCover = if (serverPath.endsWith("/cover")) "?raw=1" else ""
+      val downloadUri = Uri.parse("${DeviceManager.serverAddress}${serverPath}$rawCover")

-      var downloadUrl = "${DeviceManager.serverAddress}${serverPath}?token=${DeviceManager.token}"
-      if (serverPath.endsWith("/cover")) downloadUrl += "&format=jpeg&raw=1" // For cover images force to jpeg
-      val downloadUri = Uri.parse(downloadUrl)
-      Log.d("DownloadItemPart", "Audio File Destination Uri: $destinationUri | Final Destination Uri: $finalDestinationUri | Download URI $downloadUri")
+      Log.d("DownloadItemPart", "Audio File Destination Uri: $destinationUri | Final Destination Uri: $finalDestinationUri | Server Path $serverPath")
      return DownloadItemPart(
        id = DeviceManager.getBase64Id(finalDestinationFile.absolutePath),
        downloadItemId,
        filename = filename,
        fileSize = fileSize,
+        destinationPath = destinationFile.absolutePath,
        finalDestinationPath = finalDestinationFile.absolutePath,
        serverPath = serverPath,
        localFolderName = localFolder.name,
@@ -65,10 +71,13 @@ data class DownloadItemPart(
        uri = downloadUri,
        destinationUri = destinationUri,
        finalDestinationUri = finalDestinationUri,
+        completedDestinationUri = null,
        finalDestinationSubfolder = subfolder,
        downloadId = null,
+        lastUpdateTime = null,
        progress = 0,
-        bytesDownloaded = 0
+        bytesDownloaded = 0,
+        reusedExistingFile = false
      )
    }
  }
@@ -76,16 +85,4 @@ data class DownloadItemPart(
  @get:JsonIgnore
  val isInternalStorage get() = localFolderId.startsWith("internal-")

-  @get:JsonIgnore
-  val serverUrl get() = "${DeviceManager.serverAddress}${serverPath}?token=${DeviceManager.token}"
-
-  @JsonIgnore
-  fun getDownloadRequest(): DownloadManager.Request {
-    val dlRequest = DownloadManager.Request(uri)
-    dlRequest.setTitle(filename)
-    dlRequest.setDescription("Downloading to $localFolderName with filename $filename")
-    dlRequest.setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE)
-    dlRequest.setDestinationUri(destinationUri)
-    return dlRequest
-  }
 }
@@ -6,18 +6,13 @@ import android.graphics.ImageDecoder
 import android.net.Uri
 import android.os.Build
 import android.provider.MediaStore
+import android.support.v4.media.MediaMetadataCompat
 import android.support.v4.media.session.MediaControllerCompat
-import android.util.Log
-import com.audiobookshelf.app.BuildConfig
-import com.audiobookshelf.app.R
-import com.bumptech.glide.Glide
 import com.google.android.exoplayer2.Player
 import com.google.android.exoplayer2.ui.PlayerNotificationManager
 import kotlinx.coroutines.*

-const val NOTIFICATION_LARGE_ICON_SIZE = 144 // px
-
-class AbMediaDescriptionAdapter constructor(private val controller: MediaControllerCompat, private val playerNotificationService: PlayerNotificationService) : PlayerNotificationManager.MediaDescriptionAdapter {
+class AbMediaDescriptionAdapter (private val controller: MediaControllerCompat, private val playerNotificationService: PlayerNotificationService) : PlayerNotificationManager.MediaDescriptionAdapter {
  private val tag = "MediaDescriptionAdapter"

  private var currentIconUri: Uri? = null
@@ -38,12 +33,19 @@ class AbMediaDescriptionAdapter constructor(private val controller: MediaControl
    callback: PlayerNotificationManager.BitmapCallback
  ): Bitmap? {
    val albumArtUri = controller.metadata.description.iconUri
+    val albumBitmap = controller.metadata.description.iconBitmap
+      ?: controller.metadata.getBitmap(MediaMetadataCompat.METADATA_KEY_ALBUM_ART)
+
+    // Reuse bitmap from queue navigator (local) or PlaybackSession.resolveCoverBitmapAsync (streaming)
+    // For local cover images, bitmap is set in PlayerNotificationService TimelineQueueNavigator.getMediaDescription
+    if (albumBitmap != null) {
+      return albumBitmap
+    }

    return if (currentIconUri != albumArtUri || currentBitmap == null) {
      // Cache the bitmap for the current audiobook so that successive calls to
      // `getCurrentLargeIcon` don't cause the bitmap to be recreated.
      currentIconUri = albumArtUri
-      Log.d(tag, "ART $currentIconUri")

      if (currentIconUri.toString().startsWith("content://")) {
        currentBitmap = if (Build.VERSION.SDK_INT < 28) {
@@ -57,37 +59,14 @@ class AbMediaDescriptionAdapter constructor(private val controller: MediaControl
      } else {
        serviceScope.launch {
          currentBitmap = albumArtUri?.let {
-            resolveUriAsBitmap(it)
+            resolveUriAsBitmap(playerNotificationService, it)
          }
          currentBitmap?.let { callback.onBitmap(it) }
        }
        null
      }
-
    } else {
      currentBitmap
    }
  }
-
-  private suspend fun resolveUriAsBitmap(uri: Uri): Bitmap? {
-    return withContext(Dispatchers.IO) {
-      try {
-        Glide.with(playerNotificationService)
-          .asBitmap()
-          .load(uri)
-          .placeholder(R.drawable.icon)
-          .error(R.drawable.icon)
-          .submit(NOTIFICATION_LARGE_ICON_SIZE, NOTIFICATION_LARGE_ICON_SIZE)
-          .get()
-      } catch (e: Exception) {
-        e.printStackTrace()
-
-        Glide.with(playerNotificationService)
-          .asBitmap()
-          .load(Uri.parse("android.resource://${BuildConfig.APPLICATION_ID}/" + R.drawable.icon))
-          .submit(NOTIFICATION_LARGE_ICON_SIZE, NOTIFICATION_LARGE_ICON_SIZE)
-          .get()
-      }
-    }
-  }
 }
@@ -1,51 +1,45 @@
 package com.audiobookshelf.app.player

-import android.content.ContentResolver
 import android.content.Context
-import android.net.Uri
 import android.support.v4.media.MediaMetadataCompat
-import androidx.annotation.AnyRes
+import android.util.Log
 import com.audiobookshelf.app.R
 import com.audiobookshelf.app.data.*
+import com.audiobookshelf.app.media.getUriToDrawable

 class BrowseTree(
  val context: Context,
  itemsInProgress: List<ItemInProgress>,
-  libraries: List<Library>
+  libraries: List<Library>,
+  recentsLoaded: Boolean
 ) {
  private val mediaIdToChildren = mutableMapOf<String, MutableList<MediaMetadataCompat>>()

-  /**
-   * get uri to drawable or any other resource type if u wish
-   * @param drawableId - drawable res id
-   * @return - uri
-   */
-  private fun getUriToDrawable(@AnyRes drawableId: Int): Uri {
-    return Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE
-      + "://" + context.resources.getResourcePackageName(drawableId)
-      + '/' + context.resources.getResourceTypeName(drawableId)
-      + '/' + context.resources.getResourceEntryName(drawableId))
-  }
-
  init {
    val rootList = mediaIdToChildren[AUTO_BROWSE_ROOT] ?: mutableListOf()

    val continueListeningMetadata = MediaMetadataCompat.Builder().apply {
      putString(MediaMetadataCompat.METADATA_KEY_MEDIA_ID, CONTINUE_ROOT)
-      putString(MediaMetadataCompat.METADATA_KEY_TITLE, "Listening")
-      putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI, getUriToDrawable(R.drawable.exo_icon_localaudio).toString())
+      putString(MediaMetadataCompat.METADATA_KEY_TITLE, "Continue")
+      putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI, getUriToDrawable(context, R.drawable.exo_icon_localaudio).toString())
+    }.build()
+
+    val recentMetadata = MediaMetadataCompat.Builder().apply {
+      putString(MediaMetadataCompat.METADATA_KEY_MEDIA_ID, RECENTLY_ROOT)
+      putString(MediaMetadataCompat.METADATA_KEY_TITLE, "Recent")
+      putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI, getUriToDrawable(context, R.drawable.md_clock_outline).toString())
    }.build()

    val downloadsMetadata = MediaMetadataCompat.Builder().apply {
      putString(MediaMetadataCompat.METADATA_KEY_MEDIA_ID, DOWNLOADS_ROOT)
      putString(MediaMetadataCompat.METADATA_KEY_TITLE, "Downloads")
-      putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI, getUriToDrawable(R.drawable.exo_icon_downloaddone).toString())
+      putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI, getUriToDrawable(context, R.drawable.exo_icon_downloaddone).toString())
    }.build()

    val librariesMetadata = MediaMetadataCompat.Builder().apply {
      putString(MediaMetadataCompat.METADATA_KEY_MEDIA_ID, LIBRARIES_ROOT)
      putString(MediaMetadataCompat.METADATA_KEY_TITLE, "Libraries")
-      putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI, getUriToDrawable(R.drawable.icon_library_folder).toString())
+      putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI, getUriToDrawable(context, R.drawable.icon_library_folder).toString())
    }.build()

    if (itemsInProgress.isNotEmpty()) {
@@ -53,13 +47,28 @@ class BrowseTree(
    }

    if (libraries.isNotEmpty()) {
+      if (recentsLoaded) {
+        rootList += recentMetadata
+      }
      rootList += librariesMetadata

      libraries.forEach { library ->
-        val libraryMediaMetadata = library.getMediaMetadata()
+        // Skip libraries without audio content
+        if (library.stats?.numAudioFiles == 0) return@forEach
+        Log.d("BrowseTree", "Library $library | ${library.icon}")
+        // Generate library list items for Libraries menu
+        val libraryMediaMetadata = library.getMediaMetadata(context)
        val children = mediaIdToChildren[LIBRARIES_ROOT] ?: mutableListOf()
        children += libraryMediaMetadata
        mediaIdToChildren[LIBRARIES_ROOT] = children
+
+        if (recentsLoaded) {
+          // Generate library list items for Recent menu
+          val recentlyMediaMetadata = library.getMediaMetadata(context,"recently")
+          val childrenRecently = mediaIdToChildren[RECENTLY_ROOT] ?: mutableListOf()
+          childrenRecently += recentlyMediaMetadata
+          mediaIdToChildren[RECENTLY_ROOT] = childrenRecently
+        }
      }
    }

@@ -75,3 +84,4 @@ const val AUTO_BROWSE_ROOT = "/"
 const val CONTINUE_ROOT = "__CONTINUE__"
 const val DOWNLOADS_ROOT = "__DOWNLOADS__"
 const val LIBRARIES_ROOT = "__LIBRARIES__"
+const val RECENTLY_ROOT = "__RECENTLY__"
@@ -21,6 +21,31 @@ class CastManager constructor(val mainActivity:Activity) {

  private var playerNotificationService:PlayerNotificationService? = null
  private var newConnectionListener: SessionListener? = null
+  private var castStateListener: CastStateListener? = null
+
+  /**
+   * The framework reports NO_DEVICES_AVAILABLE when a session ends, because it stops discovering -
+   * taken at face value that hides the cast button. The media router is the second opinion.
+   */
+  private fun isReceiverAvailable(castState: Int): Boolean {
+    if (castState != CastState.NO_DEVICES_AVAILABLE) return true
+
+    // The framework's own selector, which carries the receiver id this app is configured with -
+    // building one by hand here would ask about a different receiver than the one being cast to
+    val selector = getContext().mergedSelector ?: return false
+
+    return getMediaRouter()?.isRouteAvailable(
+      selector,
+      MediaRouter.AVAILABILITY_FLAG_IGNORE_DEFAULT_ROUTE or
+        MediaRouter.AVAILABILITY_FLAG_REQUIRE_MATCH
+    ) == true
+  }
+
+  /** Drops what this manager registered for the activity, which does not outlive it. */
+  fun detach() {
+    castStateListener?.let { getContext().removeCastStateListener(it) }
+    castStateListener = null
+  }

  private fun switchToPlayer(useCastPlayer:Boolean) {
    Handler(Looper.getMainLooper()).post() {
@@ -123,6 +148,13 @@ class CastManager constructor(val mainActivity:Activity) {
  }

  fun startRouteScan(connListener:ChromecastListener) {
+    // ChromecastListener has always implemented CastStateListener, but nothing registered it, so
+    // availability hung entirely on the media router callback below - which does not always fire
+    val stateListener = CastStateListener { state -> connListener.onReceiverAvailableUpdate(isReceiverAvailable(state)) }
+    castStateListener = stateListener
+    getContext().addCastStateListener(stateListener)
+    connListener.onReceiverAvailableUpdate(isReceiverAvailable(getContext().castState))
+
    val callback = object : ScanCallback() {
      override fun onRouteUpdate(routes: List<MediaRouter.RouteInfo>?) {
        Log.d(tag, "CAST On ROUTE UPDATED ${routes?.size} | ${getContext().castState}")
@@ -3,6 +3,7 @@ package com.audiobookshelf.app.player
 import android.annotation.SuppressLint
 import android.os.Looper
 import android.util.Log
+import kotlin.math.roundToInt
 import android.view.Surface
 import android.view.SurfaceHolder
 import android.view.SurfaceView
@@ -53,6 +54,10 @@ class CastPlayer(var castContext: CastContext) : BasePlayer() {
  private var myCurrentTrackGroups: TrackGroupArray
  private var myCurrentTrackSelections: TrackSelectionArray

+  // Cache for pending volume to handle async setVolume
+  private var pendingVolume: Int? = null
+  private var pendingVolumeSetAt: Long = 0L
+
  var currentMediaItems:List<MediaItem> = mutableListOf()
  var remoteMediaClient:RemoteMediaClient? = null
  var sessionAvailabilityListener:SessionAvailabilityListener? = null
@@ -76,7 +81,10 @@ class CastPlayer(var castContext: CastContext) : BasePlayer() {
      COMMAND_GET_MEDIA_ITEMS_METADATA,
      COMMAND_SET_MEDIA_ITEMS_METADATA,
      COMMAND_CHANGE_MEDIA_ITEMS,
-      COMMAND_GET_TRACKS)
+      COMMAND_GET_TRACKS,
+      COMMAND_GET_DEVICE_VOLUME,
+      COMMAND_SET_DEVICE_VOLUME,
+      COMMAND_ADJUST_DEVICE_VOLUME)
    .build()

  var currentPlaybackState = Player.STATE_IDLE
@@ -807,12 +815,21 @@ class CastPlayer(var castContext: CastContext) : BasePlayer() {
   return AudioAttributes.DEFAULT
  }

+  /**
+   * The volume of the media stream, which is what the sleep timer fades - not the volume of the
+   * receiver. The device volume stays where the user put it, and on a cast group the balance
+   * between its members is left alone, because the receiver applies this to the group's output.
+   */
  override fun setVolume(audioVolume: Float) {
-
+    try {
+      remoteMediaClient?.setStreamVolume(audioVolume.toDouble().coerceIn(0.0, 1.0))
+    } catch (e: Exception) {
+      Log.e(tag, "Failed to set the cast stream volume", e)
+    }
  }

  override fun getVolume(): Float {
-    return 0F
+    return remoteMediaClient?.mediaStatus?.streamVolume?.toFloat() ?: 1F
  }

  override fun clearVideoSurface() {
@@ -861,27 +878,66 @@ class CastPlayer(var castContext: CastContext) : BasePlayer() {
  }

  override fun getDeviceVolume(): Int {
-   return 0
+    // Short-lived cache without even-value quantization
+    val now = System.currentTimeMillis()
+    if (pendingVolume != null && (now - pendingVolumeSetAt) < 100) {
+      return pendingVolume!!
+    }
+
+    val session = castContext.sessionManager.currentCastSession
+    val vol = if (session != null && !session.isMute) {
+      (session.volume * 100).roundToInt().coerceIn(0, 100)
+    } else {
+      0
+    }
+
+    if (pendingVolume != null && vol == pendingVolume) {
+      pendingVolume = null
+    }
+
+    return vol
  }

  override fun isDeviceMuted(): Boolean {
-   return false
+    val session = castContext.sessionManager.currentCastSession
+    return session?.isMute ?: false
  }

  override fun setDeviceVolume(volume: Int) {
+    val session = castContext.sessionManager.currentCastSession
+    try {
+      val clamped = volume.coerceIn(0, 100)
+      val target = (clamped / 100.0).let { kotlin.math.round(it * 100.0) / 100.0 }

+      // Cache for 100ms to return in getDeviceVolume during async period
+      pendingVolume = clamped
+      pendingVolumeSetAt = System.currentTimeMillis()
+
+      session?.setVolume(target)
+    } catch (e: Exception) {
+      Log.e(tag, "Failed to set cast device volume", e)
+    }
  }

  override fun increaseDeviceVolume() {
-
+    val current = getDeviceVolume()
+    val next = current + 1
+    setDeviceVolume(next.coerceAtMost(100))
  }

  override fun decreaseDeviceVolume() {
-
+    val current = getDeviceVolume()
+    val next = current - 1
+    setDeviceVolume(next.coerceAtLeast(0))
  }

  override fun setDeviceMuted(muted: Boolean) {
-
+    val session = castContext.sessionManager.currentCastSession
+    try {
+      session?.isMute = muted
+    } catch (e: Exception) {
+      Log.e(tag, "Failed to set cast device mute state", e)
+    }
  }

  inner class StatusListener() : RemoteMediaClient.Callback(), SessionManagerListener<CastSession>, RemoteMediaClient.ProgressListener {
@@ -0,0 +1,36 @@
+package com.audiobookshelf.app.player
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.net.Uri
+import android.util.Log
+import com.audiobookshelf.app.BuildConfig
+import com.audiobookshelf.app.R
+import com.bumptech.glide.Glide
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+private const val TAG = "CoverImageLoader"
+
+/** Loads [uri] as a bitmap via Glide, falling back to the app icon if the load fails. */
+suspend fun resolveUriAsBitmap(context: Context, uri: Uri): Bitmap? {
+  return withContext(Dispatchers.IO) {
+    try {
+      Glide.with(context)
+        .asBitmap()
+        .load(uri)
+        .placeholder(R.drawable.icon)
+        .error(R.drawable.icon)
+        .submit()
+        .get()
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to load cover bitmap for uri: $uri", e)
+
+      Glide.with(context)
+        .asBitmap()
+        .load(Uri.parse("android.resource://${BuildConfig.APPLICATION_ID}/" + R.drawable.icon))
+        .submit()
+        .get()
+    }
+  }
+}
@@ -8,7 +8,6 @@ import android.util.Log
 import android.view.KeyEvent
 import com.audiobookshelf.app.data.LibraryItemWrapper
 import com.audiobookshelf.app.data.PodcastEpisode
-import com.audiobookshelf.app.device.DeviceManager
 import java.util.*
 import kotlin.concurrent.schedule

@@ -235,7 +234,7 @@ class MediaSessionCallback(var playerNotificationService:PlayerNotificationServi
            playerNotificationService.jumpBackward()
          }
          KeyEvent.KEYCODE_MEDIA_STOP -> {
-            playerNotificationService.closePlayback()
+            playerNotificationService.pause()
          }
          else -> {
            Log.d(tag, "KeyCode:${keyEvent.keyCode}")
@@ -5,6 +5,7 @@ import android.hardware.SensorEvent
 import android.hardware.SensorEventListener
 import android.hardware.SensorManager
 import com.audiobookshelf.app.device.DeviceManager
+import com.audiobookshelf.app.plugins.AbsLogger
 import kotlin.math.sqrt

 class ShakeDetector : SensorEventListener {
@@ -46,6 +47,7 @@ class ShakeDetector : SensorEventListener {
        if (mShakeTimestamp + SHAKE_COUNT_RESET_TIME_MS < now) {
          mShakeCount = 0
        }
+        AbsLogger.info("ShakeDetector", "Device shake above threshold ($gForce > $shakeThreshold)")
        mShakeTimestamp = now
        mShakeCount++
        mListener!!.onShake(mShakeCount)
@@ -33,6 +33,9 @@ class AbsAudioPlayer : Plugin() {

  private var isCastAvailable:Boolean = false

+  // Track foreground state to avoid flooding WebView with events while backgrounded
+  private var isInForeground: Boolean = true
+
  override fun load() {
    mainActivity = (activity as MainActivity)
    apiHandler = ApiHandler(mainActivity)
@@ -60,6 +63,8 @@ class AbsAudioPlayer : Plugin() {
        }

        override fun onMetadata(metadata: PlaybackMetadata) {
+          // Skip frequent metadata updates when app is backgrounded to prevent event queue buildup
+          if (!isInForeground) return
          notifyListeners("onMetadata", JSObject(jacksonMapper.writeValueAsString(metadata)))
        }

@@ -68,6 +73,8 @@ class AbsAudioPlayer : Plugin() {
        }

        override fun onSleepTimerSet(sleepTimeRemaining: Int, isAutoSleepTimer:Boolean) {
+          // Skip sleep timer updates when app is backgrounded to prevent event queue buildup
+          if (!isInForeground) return
          val ret = JSObject()
          ret.put("value", sleepTimeRemaining)
          ret.put("isAuto", isAutoSleepTimer)
@@ -75,6 +82,8 @@ class AbsAudioPlayer : Plugin() {
        }

        override fun onLocalMediaProgressUpdate(localMediaProgress: LocalMediaProgress) {
+          // Skip progress updates when app is backgrounded to prevent event queue buildup
+          if (!isInForeground) return
          notifyListeners("onLocalMediaProgressUpdate", JSObject(jacksonMapper.writeValueAsString(localMediaProgress)))
        }

@@ -118,6 +127,32 @@ class AbsAudioPlayer : Plugin() {
    notifyListeners(evtName, ret)
  }

+  override fun handleOnDestroy() {
+    castManager?.detach()
+    super.handleOnDestroy()
+  }
+
+  override fun handleOnPause() {
+    super.handleOnPause()
+    isInForeground = false
+  }
+
+  override fun handleOnResume() {
+    super.handleOnResume()
+    isInForeground = true
+
+    // Send current state to UI after resume to sync up (with small delay to let WebView fully resume)
+    if (::playerNotificationService.isInitialized && playerNotificationService.currentPlaybackSession != null) {
+      Handler(Looper.getMainLooper()).postDelayed({
+        playerNotificationService.sendClientMetadata(PlayerState.READY)
+        playerNotificationService.sleepTimerManager.sendCurrentSleepTimerState()
+        playerNotificationService.mediaProgressSyncer.currentLocalMediaProgress?.let {
+          playerNotificationService.clientEventEmitter?.onLocalMediaProgressUpdate(it)
+        }
+      }, 100)
+    }
+  }
+
  private fun initCastManager() {
    val googleApi = GoogleApiAvailability.getInstance()
    val statusCode = googleApi.isGooglePlayServicesAvailable(mainActivity)
@@ -180,7 +215,8 @@ class AbsAudioPlayer : Plugin() {
    val playWhenReady = call.getBoolean("playWhenReady") == true
    val playbackRate = call.getFloat("playbackRate",1f) ?: 1f
    val startTimeOverride = call.getDouble("startTime")
-    Log.d(tag, "prepareLibraryItem lid=$libraryItemId, startTimeOverride=$startTimeOverride, playbackRate=$playbackRate")
+
+    AbsLogger.info("AbsAudioPlayer", "prepareLibraryItem: lid=$libraryItemId, startTimeOverride=$startTimeOverride, playbackRate=$playbackRate")

    if (libraryItemId.isEmpty()) {
      Log.e(tag, "Invalid call to play library item no library item id")
@@ -198,6 +234,9 @@ class AbsAudioPlayer : Plugin() {
            return call.resolve(JSObject("{\"error\":\"Podcast episode not found\"}"))
          }
        }
+        if (!it.hasTracks(mainActivity, episode)) {
+          return call.resolve(JSObject("{\"error\":\"No audio files found on device. Download book again to fix.\"}"))
+        }

        Handler(Looper.getMainLooper()).post {
          Log.d(tag, "prepareLibraryItem: Preparing Local Media item ${jacksonMapper.writeValueAsString(it)}")
@@ -291,10 +330,10 @@ class AbsAudioPlayer : Plugin() {

  @PluginMethod
  fun seek(call: PluginCall) {
-    val time:Int = call.getInt("value", 0) ?: 0 // Value in seconds
+    val time: Double = call.getDouble("value", 0.0) ?: 0.0 // Value in seconds, fractional
    Log.d(tag, "seek action to $time")
    Handler(Looper.getMainLooper()).post {
-      playerNotificationService.seekPlayer(time * 1000L) // convert to ms
+      playerNotificationService.seekPlayer((time * 1000L).toLong())
      call.resolve()
    }
  }
@@ -1,11 +1,14 @@
 package com.audiobookshelf.app.plugins

+import android.os.Handler
+import android.os.Looper
 import android.util.Log
 import com.audiobookshelf.app.MainActivity
 import com.audiobookshelf.app.data.*
 import com.audiobookshelf.app.device.DeviceManager
 import com.audiobookshelf.app.media.MediaEventManager
 import com.audiobookshelf.app.server.ApiHandler
+import com.audiobookshelf.app.managers.SecureStorage
 import com.fasterxml.jackson.core.json.JsonReadFeature
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import com.fasterxml.jackson.module.kotlin.readValue
@@ -20,20 +23,25 @@ class AbsDatabase : Plugin() {
  val tag = "AbsDatabase"
  private var jacksonMapper = jacksonObjectMapper().enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature())

-  lateinit var mainActivity: MainActivity
-  lateinit var apiHandler: ApiHandler
+  private lateinit var mainActivity: MainActivity
+  private lateinit var apiHandler: ApiHandler
+  private lateinit var secureStorage: SecureStorage

  data class LocalMediaProgressPayload(val value:List<LocalMediaProgress>)
  data class LocalLibraryItemsPayload(val value:List<LocalLibraryItem>)
  data class LocalFoldersPayload(val value:List<LocalFolder>)
-  data class ServerConnConfigPayload(val id:String?, val index:Int, val name:String?, val userId:String, val username:String, val token:String, val address:String?, val customHeaders:Map<String,String>?)
+  data class ServerConnConfigPayload(val id:String?, val index:Int, val name:String?, val userId:String, val username:String, var version:String, val token:String, val refreshToken:String?, val address:String?, val customHeaders:Map<String,String>?)

  override fun load() {
    mainActivity = (activity as MainActivity)
    apiHandler = ApiHandler(mainActivity)
+    ApiHandler.absDatabaseNotifyListeners = ::notifyListeners
+
+    secureStorage = SecureStorage(mainActivity)

    DeviceManager.dbManager.cleanLocalMediaProgress()
-    DeviceManager.dbManager.cleanLocalLibraryItems()
+    DeviceManager.dbManager.cleanLocalLibraryItems(mainActivity)
+    DeviceManager.dbManager.cleanLogs()
  }

  @PluginMethod
@@ -111,13 +119,15 @@ class AbsDatabase : Plugin() {

  @PluginMethod
  fun setCurrentServerConnectionConfig(call:PluginCall) {
-    Log.d(tag, "setCurrentServerConnectionConfig ${call.data}")
+    Log.d(tag, "setCurrentServerConnectionConfig called")
    val serverConfigPayload = jacksonMapper.readValue<ServerConnConfigPayload>(call.data.toString())
    var serverConnectionConfig = DeviceManager.deviceData.serverConnectionConfigs.find { it.id == serverConfigPayload.id }

    val userId =  serverConfigPayload.userId
    val username = serverConfigPayload.username
-    val token = serverConfigPayload.token
+    val serverVersion = serverConfigPayload.version
+    val accessToken = serverConfigPayload.token
+    val refreshToken = serverConfigPayload.refreshToken // Refresh only sent after login or refresh

    GlobalScope.launch(Dispatchers.IO) {
      if (serverConnectionConfig == null) { // New Server Connection
@@ -126,7 +136,16 @@ class AbsDatabase : Plugin() {
        // Create new server connection config
        val sscId = DeviceManager.getBase64Id("$serverAddress@$username")
        val sscIndex = DeviceManager.deviceData.serverConnectionConfigs.size
-        serverConnectionConfig = ServerConnectionConfig(sscId, sscIndex, "$serverAddress ($username)", serverAddress, userId, username, token, serverConfigPayload.customHeaders)
+
+        // Store refresh token securely if provided
+        val hasRefreshToken = if (!refreshToken.isNullOrEmpty()) {
+          secureStorage.storeRefreshToken(sscId, refreshToken)
+        } else {
+          false
+        }
+        Log.d(tag, "Refresh token secured = $hasRefreshToken")
+
+        serverConnectionConfig = ServerConnectionConfig(sscId, sscIndex, "$serverAddress ($username)", serverAddress, serverVersion, userId, username, accessToken, serverConfigPayload.customHeaders)

        // Add and save
        DeviceManager.deviceData.serverConnectionConfigs.add(serverConnectionConfig!!)
@@ -134,14 +153,21 @@ class AbsDatabase : Plugin() {
        DeviceManager.dbManager.saveDeviceData(DeviceManager.deviceData)
      } else {
        var shouldSave = false
-        if (serverConnectionConfig?.username != username || serverConnectionConfig?.token != token) {
+        if (serverConnectionConfig?.username != username || serverConnectionConfig?.token != accessToken || serverConnectionConfig?.version != serverVersion) {
          serverConnectionConfig?.userId = userId
          serverConnectionConfig?.username = username
          serverConnectionConfig?.name = "${serverConnectionConfig?.address} (${serverConnectionConfig?.username})"
-          serverConnectionConfig?.token = token
+          serverConnectionConfig?.version = serverVersion
+          serverConnectionConfig?.token = accessToken
          shouldSave = true
        }

+        // Update refresh token if provided
+        if (!refreshToken.isNullOrEmpty()) {
+          val stored = secureStorage.storeRefreshToken(serverConnectionConfig!!.id, refreshToken)
+          Log.d(tag, "Refresh token secured = $stored")
+        }
+
        // Set last connection config
        if (DeviceManager.deviceData.lastServerConnectionConfigId != serverConfigPayload.id) {
          DeviceManager.deviceData.lastServerConnectionConfigId = serverConfigPayload.id
@@ -160,6 +186,10 @@ class AbsDatabase : Plugin() {
  fun removeServerConnectionConfig(call:PluginCall) {
    GlobalScope.launch(Dispatchers.IO) {
      val serverConnectionConfigId = call.getString("serverConnectionConfigId", "").toString()
+
+      // Remove refresh token if it exists
+      secureStorage.removeRefreshToken(serverConnectionConfigId)
+
      DeviceManager.deviceData.serverConnectionConfigs = DeviceManager.deviceData.serverConnectionConfigs.filter { it.id != serverConnectionConfigId } as MutableList<ServerConnectionConfig>
      if (DeviceManager.deviceData.lastServerConnectionConfigId == serverConnectionConfigId) {
        DeviceManager.deviceData.lastServerConnectionConfigId = null
@@ -172,6 +202,42 @@ class AbsDatabase : Plugin() {
    }
  }

+  @PluginMethod
+  fun getRefreshToken(call:PluginCall) {
+    val serverConnectionConfigId = call.getString("serverConnectionConfigId", "").toString()
+
+    GlobalScope.launch(Dispatchers.IO) {
+      val refreshToken = secureStorage.getRefreshToken(serverConnectionConfigId)
+      if (refreshToken != null) {
+        val result = JSObject()
+        result.put("refreshToken", refreshToken)
+        call.resolve(result)
+      } else {
+        call.resolve()
+      }
+    }
+  }
+
+  @PluginMethod
+  fun clearRefreshToken(call:PluginCall) {
+    val serverConnectionConfigId = call.getString("serverConnectionConfigId", "").toString()
+
+    val refreshToken = secureStorage.removeRefreshToken(serverConnectionConfigId)
+    val result = JSObject()
+    result.put("success", refreshToken)
+    call.resolve(result)
+  }
+
+  @PluginMethod
+  fun getAccessToken(call:PluginCall) {
+    val serverConnectionConfigId = call.getString("serverConnectionConfigId", "").toString()
+    val serverConnectionConfig = DeviceManager.deviceData.serverConnectionConfigs.find { it.id == serverConnectionConfigId }
+    val token = serverConnectionConfig?.token ?: ""
+    val ret = JSObject()
+    ret.put("token", token)
+    call.resolve(ret)
+  }
+
  @PluginMethod
  fun logout(call:PluginCall) {
    GlobalScope.launch(Dispatchers.IO) {
@@ -218,12 +284,11 @@ class AbsDatabase : Plugin() {
  @PluginMethod
  fun syncLocalSessionsWithServer(call:PluginCall) {
    if (DeviceManager.serverConnectionConfig == null) {
-      Log.e(tag, "syncLocalSessionsWithServer not connected to server")
+      AbsLogger.error("AbsDatabase", "syncLocalSessionsWithServer: not connected to server")
      return call.resolve()
    }

    apiHandler.syncLocalMediaProgressForUser {
-      Log.d(tag, "Finished syncing local media progress for user")
      val savedSessions = DeviceManager.dbManager.getPlaybackSessions().filter { it.serverConnectionConfigId == DeviceManager.serverConnectionConfigId }

      if (savedSessions.isNotEmpty()) {
@@ -231,6 +296,7 @@ class AbsDatabase : Plugin() {
          if (!success) {
            call.resolve(JSObject("{\"error\":\"$errorMsg\"}"))
          } else {
+            AbsLogger.info("AbsDatabase", "syncLocalSessionsWithServer: Finished sending local playback sessions to server. Removing ${savedSessions.size} saved sessions.")
            // Remove all local sessions
            savedSessions.forEach {
              DeviceManager.dbManager.removePlaybackSession(it.id)
@@ -239,6 +305,7 @@ class AbsDatabase : Plugin() {
          }
        }
      } else {
+        AbsLogger.info("AbsDatabase", "syncLocalSessionsWithServer: No saved local playback sessions to send to server.")
        call.resolve()
      }
    }
@@ -491,18 +558,25 @@ class AbsDatabase : Plugin() {

  @PluginMethod
  fun updateDeviceSettings(call:PluginCall) { // Returns device data
-    Log.d(tag, "updateDeviceSettings ${call.data}")
+    Log.d(tag, "updateDeviceSettings called")
    val newDeviceSettings = jacksonMapper.readValue<DeviceSettings>(call.data.toString())
-    GlobalScope.launch(Dispatchers.IO) {
+
+    Handler(Looper.getMainLooper()).post {
      DeviceManager.deviceData.deviceSettings = newDeviceSettings
      DeviceManager.dbManager.saveDeviceData(DeviceManager.deviceData)
+
+      // Updates playback actions for media notification (handles media control seek locking setting)
+      if (mainActivity.isPlayerNotificationServiceInitialized()) {
+        mainActivity.foregroundService.setMediaSessionConnectorPlaybackActions()
+      }
+
      call.resolve(JSObject(jacksonMapper.writeValueAsString(DeviceManager.deviceData)))
    }
  }

  @PluginMethod
  fun getMediaItemHistory(call:PluginCall) { // Returns device data
-    Log.d(tag, "getMediaItemHistory ${call.data}")
+    Log.d(tag, "getMediaItemHistory called")
    val mediaId = call.getString("mediaId") ?: ""

    GlobalScope.launch(Dispatchers.IO) {
@@ -1,17 +1,14 @@
 package com.audiobookshelf.app.plugins

-import android.app.DownloadManager
-import android.content.Context
 import android.os.Environment
-import android.util.Log
 import com.audiobookshelf.app.MainActivity
 import com.audiobookshelf.app.data.*
 import com.audiobookshelf.app.device.DeviceManager
-import com.audiobookshelf.app.device.FolderScanner
 import com.audiobookshelf.app.models.DownloadItem
 import com.audiobookshelf.app.models.DownloadItemPart
 import com.audiobookshelf.app.server.ApiHandler
 import com.audiobookshelf.app.managers.DownloadItemManager
+import com.audiobookshelf.app.services.DownloadServiceHost
 import com.fasterxml.jackson.core.json.JsonReadFeature
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import com.getcapacitor.JSObject
@@ -27,9 +24,7 @@ class AbsDownloader : Plugin() {
  private var jacksonMapper = jacksonObjectMapper().enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature())

  lateinit var mainActivity: MainActivity
-  lateinit var downloadManager: DownloadManager
  lateinit var apiHandler: ApiHandler
-  lateinit var folderScanner: FolderScanner
  lateinit var downloadItemManager: DownloadItemManager

  private val clientEventEmitter = (object : DownloadItemManager.DownloadEventEmitter {
@@ -42,14 +37,44 @@ class AbsDownloader : Plugin() {
    override fun onDownloadItemComplete(jsobj:JSObject) {
      notifyListeners("onItemDownloadComplete", jsobj)
    }
+    override fun onQueueChanged(hasWork: Boolean) {
+      notifyListeners("onQueueChanged", JSObject().put("hasWork", hasWork))
+    }
  })

  override fun load() {
    mainActivity = (activity as MainActivity)
-    downloadManager = activity.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager
-    folderScanner = FolderScanner(mainActivity)
    apiHandler = ApiHandler(mainActivity)
-    downloadItemManager = DownloadItemManager(downloadManager, folderScanner, mainActivity, clientEventEmitter)
+    downloadItemManager = DownloadServiceHost.ensure(mainActivity)
+    DownloadServiceHost.attachBridge(mainActivity, clientEventEmitter)
+  }
+
+  override fun handleOnDestroy() {
+    DownloadServiceHost.detachBridge()
+    super.handleOnDestroy()
+  }
+
+  @PluginMethod
+  fun setDownloadNotificationStrings(call: PluginCall) {
+    DownloadServiceHost.setNotificationStrings(
+            mainActivity,
+            call.getString("preparing") ?: "Preparing downloads",
+            call.getString("downloadingFile") ?: "Downloading {0}",
+            call.getString("waitingForStorage") ?: "Waiting for available storage",
+            call.getString("downloads") ?: "Downloads",
+            call.getString("cancel") ?: "Cancel")
+    call.resolve()
+  }
+
+  /** Replays restored queue items when the frontend subscribes to download events. */
+  @PluginMethod(returnType = PluginMethod.RETURN_NONE)
+  override fun addListener(call: PluginCall) {
+    super.addListener(call)
+    if (call.getString("eventName") == "onDownloadItem" && ::downloadItemManager.isInitialized) {
+      downloadItemManager.downloadItemQueue.forEach { item ->
+        notifyListeners("onDownloadItem", JSObject(jacksonMapper.writeValueAsString(item)))
+      }
+    }
  }

  @PluginMethod
@@ -58,57 +83,60 @@ class AbsDownloader : Plugin() {
    var episodeId = call.data.getString("episodeId").toString()
    if (episodeId == "null") episodeId = ""
    var localFolderId = call.data.getString("localFolderId", "").toString()
-    Log.d(tag, "Download library item $libraryItemId to folder $localFolderId / episode: $episodeId")
+    AbsLogger.info(tag, "Requested download for item $libraryItemId${if (episodeId.isEmpty()) "" else " / episode $episodeId"}")

    val downloadId = if (episodeId.isEmpty()) libraryItemId else "$libraryItemId-$episodeId"
-    if (downloadItemManager.downloadItemQueue.find { it.id == downloadId } != null) {
-      Log.d(tag, "Download already started for this media entity $downloadId")
-      return call.resolve(JSObject("{\"error\":\"Download already started for this media entity\"}"))
-    }
-
-    apiHandler.getLibraryItemWithProgress(libraryItemId, episodeId) { libraryItem ->
-      if (libraryItem == null) {
-        call.resolve(JSObject("{\"error\":\"Server request failed\"}"))
-      } else {
-        Log.d(tag, "Got library item from server ${libraryItem.id}")
-
-        if (localFolderId == "") {
-          localFolderId = "internal-${libraryItem.mediaType}"
+    DownloadServiceHost.retryExisting(mainActivity, downloadId) { result ->
+      when (result) {
+        DownloadServiceHost.ExistingDownloadResult.RETRIED -> call.resolve()
+        DownloadServiceHost.ExistingDownloadResult.ACTIVE -> {
+          AbsLogger.info(tag, "Download already active for $downloadId")
+          call.resolve(JSObject("{\"error\":\"Download already started for this media entity\"}"))
        }
-        var localFolder = DeviceManager.dbManager.getLocalFolder(localFolderId)
-
-        if (localFolder == null && localFolderId.startsWith("internal-")) {
-          Log.d(tag, "Creating new App Storage internal LocalFolder $localFolderId")
-          localFolder = LocalFolder(localFolderId, "Internal App Storage", "", "", "", "", "internal", libraryItem.mediaType)
-          DeviceManager.dbManager.saveLocalFolder(localFolder)
-        }
-
-        if (localFolder != null) {
-          if (episodeId.isNotEmpty() && libraryItem.mediaType != "podcast") {
-            Log.e(tag, "Library item is not a podcast but episode was requested")
-            call.resolve(JSObject("{\"error\":\"Invalid library item not a podcast\"}"))
-          } else if (episodeId.isNotEmpty()) {
-            val podcast = libraryItem.media as Podcast
-            val episode = podcast.episodes?.find { podcastEpisode ->
-              podcastEpisode.id == episodeId
-            }
-            if (episode == null) {
-              call.resolve(JSObject("{\"error\":\"Invalid podcast episode not found\"}"))
+        DownloadServiceHost.ExistingDownloadResult.SERVICE_START_FAILED ->
+                call.resolve(JSObject("{\"error\":\"Unable to start the Android download service\"}"))
+        DownloadServiceHost.ExistingDownloadResult.NOT_FOUND -> {
+          apiHandler.getLibraryItemWithProgress(libraryItemId, episodeId) { libraryItem ->
+            if (libraryItem == null) {
+              call.resolve(JSObject("{\"error\":\"Server request failed\"}"))
            } else {
-              startLibraryItemDownload(libraryItem, localFolder, episode)
-              call.resolve()
+              AbsLogger.info(tag, "Preparing download for ${libraryItem.id}")
+
+              if (localFolderId == "") localFolderId = "internal-${libraryItem.mediaType}"
+              var localFolder = DeviceManager.dbManager.getLocalFolder(localFolderId)
+              if (localFolder == null && localFolderId.startsWith("internal-")) {
+                AbsLogger.info(tag, "Creating internal download folder $localFolderId")
+                localFolder = LocalFolder(localFolderId, "Internal App Storage", "", "", "", "internal", libraryItem.mediaType)
+                DeviceManager.dbManager.saveLocalFolder(localFolder)
+              }
+
+              if (localFolder == null) {
+                call.resolve(JSObject("{\"error\":\"Local Folder Not Found\"}"))
+              } else if (episodeId.isNotEmpty() && libraryItem.mediaType != "podcast") {
+                call.resolve(JSObject("{\"error\":\"Invalid library item not a podcast\"}"))
+              } else if (episodeId.isNotEmpty()) {
+                val podcast = libraryItem.media as Podcast
+                val episode = podcast.episodes?.find { it.id == episodeId }
+                if (episode == null) {
+                  call.resolve(JSObject("{\"error\":\"Invalid podcast episode not found\"}"))
+                } else {
+                  startLibraryItemDownload(libraryItem, localFolder, episode) { error -> resolveDownloadCall(call, error) }
+                }
+              } else {
+                startLibraryItemDownload(libraryItem, localFolder, null) { error -> resolveDownloadCall(call, error) }
+              }
            }
-          } else {
-            startLibraryItemDownload(libraryItem, localFolder, null)
-            call.resolve()
          }
-        } else {
-          call.resolve(JSObject("{\"error\":\"Local Folder Not Found\"}"))
        }
      }
    }
  }

+  private fun resolveDownloadCall(call: PluginCall, error: String?) {
+    if (error == null) call.resolve()
+    else call.resolve(JSObject().put("error", error))
+  }
+
  // Item filenames could be the same if they are in sub-folders, this will make them unique
  private fun getFilenameFromRelPath(relPath: String): String {
    var cleanedRelPath = relPath.replace("\\", "_").replace("/", "_")
@@ -129,21 +157,31 @@ class AbsDownloader : Plugin() {
    return newTitle
  }

-  private fun startLibraryItemDownload(libraryItem: LibraryItem, localFolder: LocalFolder, episode:PodcastEpisode?) {
+  private fun startLibraryItemDownload(
+          libraryItem: LibraryItem,
+          localFolder: LocalFolder,
+          episode: PodcastEpisode?,
+          callback: (String?) -> Unit
+  ) {
    val isInternal = localFolder.id.startsWith("internal-")

-    val tempFolderPath = if (isInternal) "${mainActivity.filesDir}/downloads/${libraryItem.id}" else mainActivity.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS)
+    val finalInternalFolderPath = "${mainActivity.filesDir}/downloads/${libraryItem.id}"
+    val tempFolderPath =
+            if (isInternal) {
+              "${mainActivity.filesDir}/download-staging/${libraryItem.id}"
+            } else {
+              "${mainActivity.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS) ?: mainActivity.filesDir}/download-staging/${libraryItem.id}"
+            }

-    Log.d(tag, "downloadCacheDirectory=$tempFolderPath")

    if (libraryItem.mediaType == "book") {
      val bookTitle = cleanStringForFileSystem(libraryItem.media.metadata.title)
      val bookAuthor = cleanStringForFileSystem(libraryItem.media.metadata.getAuthorDisplayName())

      val tracks = libraryItem.media.getAudioTracks()
-      Log.d(tag, "Starting library item download with ${tracks.size} tracks")
+      AbsLogger.info(tag, "Queueing library item download with ${tracks.size} files")
      val itemSubfolder = "$bookAuthor/$bookTitle"
-      val itemFolderPath = if (isInternal) "$tempFolderPath" else "${localFolder.absolutePath}/$itemSubfolder"
+      val itemFolderPath = if (isInternal) finalInternalFolderPath else "${localFolder.absolutePath}/$itemSubfolder"
      val downloadItem = DownloadItem(libraryItem.id, libraryItem.id, null, libraryItem.userMediaProgress,DeviceManager.serverConnectionConfig?.id ?: "", DeviceManager.serverAddress, DeviceManager.serverUserId, libraryItem.mediaType, itemFolderPath, localFolder, bookTitle, itemSubfolder, libraryItem.media, mutableListOf())

      val book = libraryItem.media as Book
@@ -152,17 +190,7 @@ class AbsDownloader : Plugin() {
        val serverPath = "/api/items/${libraryItem.id}/file/${ebookFile.ino}/download"
        val destinationFilename = getFilenameFromRelPath(ebookFile.metadata?.relPath ?: "")
        val finalDestinationFile = File("$itemFolderPath/$destinationFilename")
-        val destinationFile = File("$tempFolderPath/$destinationFilename")
-
-        if (destinationFile.exists()) {
-          Log.d(tag, "TEMP ebook file already exists, removing it from ${destinationFile.absolutePath}")
-          destinationFile.delete()
-        }
-
-        if (finalDestinationFile.exists()) {
-          Log.d(tag, "ebook file already exists, removing it from ${finalDestinationFile.absolutePath}")
-          finalDestinationFile.delete()
-        }
+        val destinationFile = File("$tempFolderPath/$destinationFilename.part")

        val downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename, fileSize, destinationFile,finalDestinationFile,itemSubfolder,serverPath,localFolder,ebookFile,null,null)
        downloadItem.downloadItemParts.add(downloadItemPart)
@@ -178,20 +206,9 @@ class AbsDownloader : Plugin() {

        val serverPath = "/api/items/${libraryItem.id}/file/${audioFileIno}/download"
        val destinationFilename = getFilenameFromRelPath(audioTrack.relPath)
-        Log.d(tag, "Audio File Server Path $serverPath | AF RelPath ${audioTrack.relPath} | LocalFolder Path ${localFolder.absolutePath} | DestName $destinationFilename")

        val finalDestinationFile = File("$itemFolderPath/$destinationFilename")
-        val destinationFile = File("$tempFolderPath/$destinationFilename")
-
-        if (destinationFile.exists()) {
-          Log.d(tag, "TEMP Audio file already exists, removing it from ${destinationFile.absolutePath}")
-          destinationFile.delete()
-        }
-
-        if (finalDestinationFile.exists()) {
-          Log.d(tag, "Audio file already exists, removing it from ${finalDestinationFile.absolutePath}")
-          finalDestinationFile.delete()
-        }
+        val destinationFile = File("$tempFolderPath/$destinationFilename.part")

        val downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename, fileSize, destinationFile,finalDestinationFile,itemSubfolder,serverPath,localFolder,null,audioTrack,null)
        downloadItem.downloadItemParts.add(downloadItemPart)
@@ -205,25 +222,15 @@ class AbsDownloader : Plugin() {

          val serverPath = "/api/items/${libraryItem.id}/cover"
          val destinationFilename = "cover-${libraryItem.id}.jpg"
-          val destinationFile = File("$tempFolderPath/$destinationFilename")
+          val destinationFile = File("$tempFolderPath/$destinationFilename.part")
          val finalDestinationFile = File("$itemFolderPath/$destinationFilename")

-          if (destinationFile.exists()) {
-            Log.d(tag, "TEMP Audio file already exists, removing it from ${destinationFile.absolutePath}")
-            destinationFile.delete()
-          }
-
-          if (finalDestinationFile.exists()) {
-            Log.d(tag, "Cover already exists, removing it from ${finalDestinationFile.absolutePath}")
-            finalDestinationFile.delete()
-          }
-
          val downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename, coverFileSize,  destinationFile,finalDestinationFile,itemSubfolder,serverPath,localFolder,null,null,null)
          downloadItem.downloadItemParts.add(downloadItemPart)
        }

-        downloadItemManager.addDownloadItem(downloadItem)
-      }
+        DownloadServiceHost.enqueue(mainActivity, downloadItem, callback)
+      } else callback("No downloadable files found")
    } else {
      // Podcast episode download
      val podcastTitle = cleanStringForFileSystem(libraryItem.media.metadata.title)
@@ -232,22 +239,16 @@ class AbsDownloader : Plugin() {
      val audioFileIno = episode?.audioFile?.ino
      val fileSize = audioTrack?.metadata?.size ?: 0

-      Log.d(tag, "Starting podcast episode download")
-      val itemFolderPath = if (isInternal) "$tempFolderPath" else "${localFolder.absolutePath}/$podcastTitle"
+      AbsLogger.info(tag, "Queueing podcast episode download")
+      val itemFolderPath = if (isInternal) finalInternalFolderPath else "${localFolder.absolutePath}/$podcastTitle"
      val downloadItemId = "${libraryItem.id}-${episode?.id}"
      val downloadItem = DownloadItem(downloadItemId, libraryItem.id, episode?.id, libraryItem.userMediaProgress, DeviceManager.serverConnectionConfig?.id ?: "", DeviceManager.serverAddress, DeviceManager.serverUserId, libraryItem.mediaType, itemFolderPath, localFolder, podcastTitle, podcastTitle, libraryItem.media, mutableListOf())

      var serverPath = "/api/items/${libraryItem.id}/file/${audioFileIno}/download"
      var destinationFilename = getFilenameFromRelPath(audioTrack?.relPath ?: "")
-      Log.d(tag, "Audio File Server Path $serverPath | AF RelPath ${audioTrack?.relPath} | LocalFolder Path ${localFolder.absolutePath} | DestName $destinationFilename")

-      var destinationFile = File("$tempFolderPath/$destinationFilename")
+      var destinationFile = File("$tempFolderPath/$destinationFilename.part")
      var finalDestinationFile = File("$itemFolderPath/$destinationFilename")
-      if (finalDestinationFile.exists()) {
-        Log.d(tag, "Audio file already exists, removing it from ${finalDestinationFile.absolutePath}")
-        finalDestinationFile.delete()
-      }
-
      var downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename,fileSize, destinationFile,finalDestinationFile,podcastTitle,serverPath,localFolder,null,audioTrack,episode)
      downloadItem.downloadItemParts.add(downloadItemPart)

@@ -258,18 +259,14 @@ class AbsDownloader : Plugin() {
        serverPath = "/api/items/${libraryItem.id}/cover"
        destinationFilename = "cover.jpg"

-        destinationFile = File("$tempFolderPath/$destinationFilename")
+        destinationFile = File("$tempFolderPath/$destinationFilename.part")
        finalDestinationFile = File("$itemFolderPath/$destinationFilename")

-        if (finalDestinationFile.exists()) {
-          Log.d(tag, "Podcast cover already exists - not downloading cover again")
-        } else {
-          downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename,coverFileSize,destinationFile,finalDestinationFile,podcastTitle,serverPath,localFolder,null,null,null)
-          downloadItem.downloadItemParts.add(downloadItemPart)
-        }
+        downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename,coverFileSize,destinationFile,finalDestinationFile,podcastTitle,serverPath,localFolder,null,null,null)
+        downloadItem.downloadItemParts.add(downloadItemPart)
      }

-      downloadItemManager.addDownloadItem(downloadItem)
+        DownloadServiceHost.enqueue(mainActivity, downloadItem, callback)
    }
  }
 }
@@ -1,6 +1,7 @@
 package com.audiobookshelf.app.plugins

 import android.app.AlertDialog
+import android.content.Context
 import android.net.Uri
 import android.os.Build
 import android.util.Log
@@ -23,40 +24,62 @@ import java.io.File
 class AbsFileSystem : Plugin() {
  private val TAG = "AbsFileSystem"
  private val tag = "AbsFileSystem"
-  private var jacksonMapper = jacksonObjectMapper().enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature())
+  private var jacksonMapper =
+          jacksonObjectMapper()
+                  .enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature())

  lateinit var mainActivity: MainActivity

  override fun load() {
    mainActivity = (activity as MainActivity)

-    mainActivity.storage.storageAccessCallback = object : StorageAccessCallback {
-      override fun onRootPathNotSelected(
-        requestCode: Int,
-        rootPath: String,
-        uri: Uri,
-        selectedStorageType: StorageType,
-        expectedStorageType: StorageType
-      ) {
-        Log.d(TAG, "STORAGE ACCESS CALLBACK")
-      }
+    mainActivity.storage.storageAccessCallback =
+            object : StorageAccessCallback {
+              override fun onRootPathNotSelected(
+                      requestCode: Int,
+                      rootPath: String,
+                      uri: Uri,
+                      selectedStorageType: StorageType,
+                      expectedStorageType: StorageType
+              ) {
+                Log.d(TAG, "STORAGE ACCESS CALLBACK")
+              }

-      override fun onCanceledByUser(requestCode: Int) {
-        Log.d(TAG, "STORAGE ACCESS CALLBACK")
-      }
+              override fun onCanceledByUser(requestCode: Int) {
+                Log.d(TAG, "STORAGE ACCESS CALLBACK")
+              }

-      override fun onExpectedStorageNotSelected(requestCode: Int, selectedFolder: DocumentFile, selectedStorageType: StorageType, expectedBasePath: String, expectedStorageType: StorageType) {
-        Log.d(TAG, "STORAGE ACCESS CALLBACK")
-      }
+              override fun onExpectedStorageNotSelected(
+                      requestCode: Int,
+                      selectedFolder: DocumentFile,
+                      selectedStorageType: StorageType,
+                      expectedBasePath: String,
+                      expectedStorageType: StorageType
+              ) {
+                Log.d(TAG, "STORAGE ACCESS CALLBACK")
+              }

-      override fun onStoragePermissionDenied(requestCode: Int) {
-        Log.d(TAG, "STORAGE ACCESS CALLBACK")
-      }
+              override fun onStoragePermissionDenied(requestCode: Int) {
+                Log.d(TAG, "STORAGE ACCESS CALLBACK")
+              }

-      override fun onRootPathPermissionGranted(requestCode: Int, root: DocumentFile) {
-        Log.d(TAG, "STORAGE ACCESS CALLBACK")
-      }
-    }
+              override fun onRootPathPermissionGranted(requestCode: Int, root: DocumentFile) {
+                Log.d(TAG, "STORAGE ACCESS CALLBACK")
+              }
+            }
+  }
+
+  @PluginMethod
+  fun setFolderPickerStrings(call: PluginCall) {
+    mainActivity.getSharedPreferences(FOLDER_PICKER_PREFERENCES, Context.MODE_PRIVATE)
+            .edit()
+            .putString(KEY_WRITE_ACCESS_REQUIRED, call.getString("writeAccessRequired"))
+            .putString(KEY_ALLOW, call.getString("allow"))
+            .putString(KEY_CANCEL, call.getString("cancel"))
+            .putString(KEY_ACCESS_DENIED, call.getString("accessDenied"))
+            .putString(KEY_PERMISSION_DENIED, call.getString("permissionDenied"))
+            .apply()
+    call.resolve()
  }

  @PluginMethod
@@ -65,60 +88,74 @@ class AbsFileSystem : Plugin() {
    val REQUEST_CODE_SELECT_FOLDER = 6
    val REQUEST_CODE_SDCARD_ACCESS = 7

-    mainActivity.storage.folderPickerCallback = object : FolderPickerCallback {
-      override fun onFolderSelected(requestCode: Int, folder: DocumentFile) {
-        Log.d(TAG, "ON FOLDER SELECTED ${folder.uri} ${folder.name}")
-        val absolutePath = folder.getAbsolutePath(activity)
-        val storageType = folder.getStorageType(activity)
-        val simplePath = folder.getSimplePath(activity)
-        val basePath = folder.getBasePath(activity)
-        val folderId = android.util.Base64.encodeToString(folder.id.toByteArray(), android.util.Base64.DEFAULT)
+    mainActivity.storage.folderPickerCallback =
+            object : FolderPickerCallback {
+              override fun onFolderSelected(requestCode: Int, folder: DocumentFile) {
+                Log.d(TAG, "ON FOLDER SELECTED ${folder.uri} ${folder.name}")
+                val absolutePath = folder.getAbsolutePath(activity)
+                val storageType = folder.getStorageType(activity)
+                val basePath = folder.getBasePath(activity)
+                val folderId =
+                        android.util.Base64.encodeToString(
+                                folder.id.toByteArray(),
+                                android.util.Base64.DEFAULT
+                        )

-        val localFolder = LocalFolder(folderId, folder.name ?: "", folder.uri.toString(),basePath,absolutePath, simplePath, storageType.toString(), mediaType)
+                val localFolder =
+                        LocalFolder(
+                                folderId,
+                                folder.name ?: "",
+                                folder.uri.toString(),
+                                basePath,
+                                absolutePath,
+                                storageType.toString(),
+                                mediaType
+                        )

-        DeviceManager.dbManager.saveLocalFolder(localFolder)
-        call.resolve(JSObject(jacksonMapper.writeValueAsString(localFolder)))
-      }
+                DeviceManager.dbManager.saveLocalFolder(localFolder)
+                call.resolve(JSObject(jacksonMapper.writeValueAsString(localFolder)))
+              }

-      override fun onStorageAccessDenied(
-        requestCode: Int,
-        folder: DocumentFile?,
-        storageType: StorageType,
-        storageId: String
-      ) {
-        Log.e(tag, "Storage Access Denied ${folder?.getAbsolutePath(mainActivity)}")
+              override fun onStorageAccessDenied(
+                      requestCode: Int,
+                      folder: DocumentFile?,
+                      storageType: StorageType,
+                      storageId: String
+              ) {
+                Log.e(tag, "Storage Access Denied ${folder?.getAbsolutePath(mainActivity)}")

-        val jsobj = JSObject()
-        if (requestCode == REQUEST_CODE_SELECT_FOLDER) {
+                val jsobj = JSObject()
+                if (requestCode == REQUEST_CODE_SELECT_FOLDER) {

-          val builder: AlertDialog.Builder = AlertDialog.Builder(mainActivity)
-          builder.setMessage(
-            "You have no write access to this storage, thus selecting this folder is useless." +
-              "\nWould you like to grant access to this folder?")
-          builder.setNegativeButton("Dont Allow") { _, _ ->
-            run {
-              jsobj.put("error", "User Canceled, Access Denied")
-              call.resolve(jsobj)
+                  val builder: AlertDialog.Builder = AlertDialog.Builder(mainActivity)
+                  builder.setMessage(folderPickerString(KEY_WRITE_ACCESS_REQUIRED, DEFAULT_WRITE_ACCESS_REQUIRED))
+                  builder.setNegativeButton(folderPickerString(KEY_CANCEL, DEFAULT_CANCEL)) { _, _ ->
+                    run {
+                      jsobj.put("error", folderPickerString(KEY_ACCESS_DENIED, DEFAULT_ACCESS_DENIED))
+                      call.resolve(jsobj)
+                    }
+                  }
+                  builder.setPositiveButton(folderPickerString(KEY_ALLOW, DEFAULT_ALLOW)) { _, _ ->
+                    mainActivity.storageHelper.requestStorageAccess(
+                            REQUEST_CODE_SDCARD_ACCESS,
+                            initialPath = FileFullPath(mainActivity, storageId, "")
+                    )
+                  }
+                  builder.show()
+                } else {
+                  Log.d(TAG, "STORAGE ACCESS DENIED $requestCode")
+                  jsobj.put("error", folderPickerString(KEY_ACCESS_DENIED, DEFAULT_ACCESS_DENIED))
+                  call.resolve(jsobj)
+                }
+              }
+
+              override fun onStoragePermissionDenied(requestCode: Int) {
+                Log.d(TAG, "STORAGE PERMISSION DENIED $requestCode")
+                val jsobj = JSObject()
+                jsobj.put("error", folderPickerString(KEY_PERMISSION_DENIED, DEFAULT_PERMISSION_DENIED))
+                call.resolve(jsobj)
+              }
            }
-          }
-          builder.setPositiveButton("Allow.") { _, _ -> mainActivity.storageHelper.requestStorageAccess(REQUEST_CODE_SDCARD_ACCESS, initialPath = FileFullPath(mainActivity, storageId, "")) }
-          builder.show()
-        } else {
-          Log.d(TAG, "STORAGE ACCESS DENIED $requestCode")
-          jsobj.put("error", "Access Denied")
-          call.resolve(jsobj)
-        }
-      }
-
-
-      override fun onStoragePermissionDenied(requestCode: Int) {
-        Log.d(TAG, "STORAGE PERMISSION DENIED $requestCode")
-        val jsobj = JSObject()
-        jsobj.put("error", "Permission Denied")
-        call.resolve(jsobj)
-      }
-
-    }

    mainActivity.storage.openFolderPicker(REQUEST_CODE_SELECT_FOLDER)
  }
@@ -152,7 +189,7 @@ class AbsFileSystem : Plugin() {
    val folderUrl = call.data.getString("folderUrl", "").toString()
    Log.d(TAG, "Check Folder Permissions for $folderUrl")

-    val hasAccess = SimpleStorage.hasStorageAccess(context,folderUrl,true)
+    val hasAccess = SimpleStorage.hasStorageAccess(context, folderUrl, true)

    val jsobj = JSObject()
    jsobj.put("value", hasAccess)
@@ -196,29 +233,41 @@ class AbsFileSystem : Plugin() {
    if (localLibraryItem?.folderId?.startsWith("internal-") == true) {
      Log.d(tag, "Deleting internal library item at absolutePath $absolutePath")
      val file = File(absolutePath)
-      success = file.deleteRecursively()
+      success =
+              if (file.exists()) {
+                file.deleteRecursively()
+              } else {
+                true
+              }
    } else {
      var subfolderPathToDelete = ""
      localLibraryItem?.folderId?.let { folderId ->
        val folder = DeviceManager.dbManager.getLocalFolder(folderId)
        folder?.absolutePath?.let { folderPath ->
          val splitAbsolutePath = absolutePath.split("/")
-          val fullSubDir = splitAbsolutePath.subList(0, splitAbsolutePath.size - 1).joinToString("/")
+          val fullSubDir =
+                  splitAbsolutePath.subList(0, splitAbsolutePath.size - 1).joinToString("/")
          if (fullSubDir != folderPath) {
-            val subdirHasAnItem = DeviceManager.dbManager.getLocalLibraryItems().any { _localLibraryItem ->
-              if (_localLibraryItem.id == localLibraryItemId) {
-                false
-              } else {
-                _localLibraryItem.absolutePath.startsWith(fullSubDir)
-              }
-            }
+            val subdirHasAnItem =
+                    DeviceManager.dbManager.getLocalLibraryItems().any { _localLibraryItem ->
+                      if (_localLibraryItem.id == localLibraryItemId) {
+                        false
+                      } else {
+                        _localLibraryItem.absolutePath.startsWith(fullSubDir)
+                      }
+                    }
            subfolderPathToDelete = if (subdirHasAnItem) "" else fullSubDir
          }
        }
      }

      val docfile = DocumentFileCompat.fromUri(mainActivity, Uri.parse(contentUrl))
-      success = docfile?.delete() == true
+      if (docfile?.exists() == true) {
+        success = docfile.delete() == true
+      } else {
+        Log.d(tag, "Folder $contentUrl doesn't exist")
+        success = true
+      }

      if (subfolderPathToDelete != "") {
        Log.d(tag, "Deleting empty subfolder at $subfolderPathToDelete")
@@ -257,4 +306,23 @@ class AbsFileSystem : Plugin() {
      call.resolve(JSObject("{\"success\":false}"))
    }
  }
+
+  private fun folderPickerString(key: String, defaultValue: String): String =
+          mainActivity.getSharedPreferences(FOLDER_PICKER_PREFERENCES, Context.MODE_PRIVATE)
+                  .getString(key, defaultValue) ?: defaultValue
+
+  private companion object {
+    const val FOLDER_PICKER_PREFERENCES = "folder_picker"
+    const val KEY_WRITE_ACCESS_REQUIRED = "write_access_required"
+    const val KEY_ALLOW = "allow"
+    const val KEY_CANCEL = "cancel"
+    const val KEY_ACCESS_DENIED = "access_denied"
+    const val KEY_PERMISSION_DENIED = "permission_denied"
+    const val DEFAULT_WRITE_ACCESS_REQUIRED =
+            "You do not have write access to this folder. Would you like to grant access?"
+    const val DEFAULT_ALLOW = "Allow"
+    const val DEFAULT_CANCEL = "Cancel"
+    const val DEFAULT_ACCESS_DENIED = "Access denied"
+    const val DEFAULT_PERMISSION_DENIED = "Permission denied"
+  }
 }
@@ -0,0 +1,80 @@
+package com.audiobookshelf.app.plugins
+
+import android.util.Log
+import com.audiobookshelf.app.device.DeviceManager
+import com.fasterxml.jackson.core.json.JsonReadFeature
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import java.util.UUID
+
+data class AbsLog(
+  var id:String,
+  var tag:String,
+  var level:String,
+  var message:String,
+  var timestamp:Long
+)
+
+data class AbsLogList(val value:List<AbsLog>)
+
+@CapacitorPlugin(name = "AbsLogger")
+class AbsLogger : Plugin() {
+  private var jacksonMapper = jacksonObjectMapper().enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature())
+
+  override fun load() {
+    onLogEmitter = { log:AbsLog ->
+      notifyListeners("onLog", JSObject(jacksonMapper.writeValueAsString(log)))
+    }
+    info("AbsLogger", "load: AbsLogger plugin initialized")
+  }
+
+  companion object {
+    var onLogEmitter:((log:AbsLog) -> Unit)? = null
+
+    fun log(level:String, tag:String, message:String) {
+      val absLog = AbsLog(id = UUID.randomUUID().toString(), tag, level, message, timestamp = System.currentTimeMillis())
+      DeviceManager.dbManager.saveLog(absLog)
+      onLogEmitter?.let { it(absLog) }
+    }
+    fun info(tag:String, message:String) {
+      Log.i("AbsLogger", message)
+      log("info", tag, message)
+    }
+    fun error(tag:String, message:String) {
+      Log.e("AbsLogger", message)
+      log("error", tag, message)
+    }
+  }
+
+  @PluginMethod
+  fun info(call: PluginCall) {
+    val msg = call.getString("message") ?: return call.reject("No message")
+    val tag = call.getString("tag") ?: ""
+    info(tag, msg)
+    call.resolve()
+  }
+
+  @PluginMethod
+  fun error(call: PluginCall) {
+    val msg = call.getString("message") ?: return call.reject("No message")
+    val tag = call.getString("tag") ?: ""
+    error(tag, msg)
+    call.resolve()
+  }
+
+  @PluginMethod
+  fun getAllLogs(call: PluginCall) {
+    val absLogs = DeviceManager.dbManager.getAllLogs()
+    call.resolve(JSObject(jacksonMapper.writeValueAsString(AbsLogList(absLogs))))
+  }
+
+  @PluginMethod
+  fun clearLogs(call: PluginCall) {
+    DeviceManager.dbManager.removeAllLogs()
+    call.resolve()
+  }
+}
@@ -4,6 +4,7 @@ import android.annotation.SuppressLint
 import android.content.Context
 import android.os.Build
 import android.provider.Settings
+import android.util.Base64
 import android.util.Log
 import com.audiobookshelf.app.data.*
 import com.audiobookshelf.app.device.DeviceManager
@@ -11,8 +12,12 @@ import com.audiobookshelf.app.media.MediaEventManager
 import com.audiobookshelf.app.media.MediaProgressSyncData
 import com.audiobookshelf.app.media.SyncResult
 import com.audiobookshelf.app.models.User
+import com.audiobookshelf.app.BuildConfig
+import com.audiobookshelf.app.plugins.AbsLogger
+import com.audiobookshelf.app.managers.SecureStorage
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties
 import com.fasterxml.jackson.core.json.JsonReadFeature
+import com.fasterxml.jackson.databind.node.ObjectNode
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import com.fasterxml.jackson.module.kotlin.readValue
 import com.getcapacitor.JSArray
@@ -30,11 +35,20 @@ import java.util.concurrent.TimeUnit
 class ApiHandler(var ctx:Context) {
  val tag = "ApiHandler"

+  companion object {
+    // For sending data back to the Webview frontend
+    lateinit var absDatabaseNotifyListeners:(String, JSObject) -> Unit
+
+    fun checkAbsDatabaseNotifyListenersInitted():Boolean {
+      return ::absDatabaseNotifyListeners.isInitialized
+    }
+  }
+
  private var defaultClient = OkHttpClient()
  private var pingClient = OkHttpClient.Builder().callTimeout(3, TimeUnit.SECONDS).build()
  private var jacksonMapper = jacksonObjectMapper().enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature())
+  private var secureStorage = SecureStorage(ctx)

-  data class LocalSessionsSyncRequestPayload(val sessions:List<PlaybackSession>, val deviceInfo:DeviceInfo)
  @JsonIgnoreProperties(ignoreUnknown = true)
  data class LocalSessionSyncResult(val id:String, val success:Boolean, val progressSynced:Boolean?, val error:String?)
  data class LocalSessionsSyncResponsePayload(val results:List<LocalSessionSyncResult>)
@@ -43,10 +57,17 @@ class ApiHandler(var ctx:Context) {
    val address = config?.address ?: DeviceManager.serverAddress
    val token = config?.token ?: DeviceManager.token

-    val request = Request.Builder()
-      .url("${address}$endpoint").addHeader("Authorization", "Bearer $token")
-      .build()
-    makeRequest(request, httpClient, cb)
+    try {
+      val request = Request.Builder()
+        .url("${address}$endpoint").addHeader("Authorization", "Bearer $token")
+        .build()
+      makeRequest(request, httpClient, cb)
+    } catch(e: Exception) {
+      e.printStackTrace()
+      val jsobj = JSObject()
+      jsobj.put("error", "Request failed: ${e.message}")
+      cb(jsobj)
+    }
  }

  private fun postRequest(endpoint:String, payload: JSObject?, config:ServerConnectionConfig?, cb: (JSObject) -> Unit) {
@@ -56,23 +77,38 @@ class ApiHandler(var ctx:Context) {
    val requestBody = payload?.toString()?.toRequestBody(mediaType) ?: EMPTY_REQUEST
    val requestUrl = "${address}$endpoint"
    Log.d(tag, "postRequest to $requestUrl")
-    val request = Request.Builder().post(requestBody)
-      .url(requestUrl).addHeader("Authorization", "Bearer ${token}")
-      .build()
-    makeRequest(request, null, cb)
+    try {
+      val request = Request.Builder().post(requestBody)
+        .url(requestUrl).addHeader("Authorization", "Bearer ${token}")
+        .build()
+      makeRequest(request, null, cb)
+    } catch(e: Exception) {
+      e.printStackTrace()
+      val jsobj = JSObject()
+      jsobj.put("error", "Request failed: ${e.message}")
+      cb(jsobj)
+    }
  }

  private fun patchRequest(endpoint:String, payload: JSObject, cb: (JSObject) -> Unit) {
    val mediaType = "application/json; charset=utf-8".toMediaType()
    val requestBody = payload.toString().toRequestBody(mediaType)
-    val request = Request.Builder().patch(requestBody)
-      .url("${DeviceManager.serverAddress}$endpoint").addHeader("Authorization", "Bearer ${DeviceManager.token}")
-      .build()
-    makeRequest(request, null, cb)
+    try {
+      val request = Request.Builder().patch(requestBody)
+        .url("${DeviceManager.serverAddress}$endpoint").addHeader("Authorization", "Bearer ${DeviceManager.token}")
+        .build()
+      makeRequest(request, null, cb)
+    } catch(e: Exception) {
+      e.printStackTrace()
+      val jsobj = JSObject()
+      jsobj.put("error", "Request failed: ${e.message}")
+      cb(jsobj)
+    }
  }

  private fun makeRequest(request:Request, httpClient:OkHttpClient?, cb: (JSObject) -> Unit) {
    val client = httpClient ?: defaultClient
+
    client.newCall(request).enqueue(object : Callback {
      override fun onFailure(call: Call, e: IOException) {
        Log.d(tag, "FAILURE TO CONNECT")
@@ -85,6 +121,13 @@ class ApiHandler(var ctx:Context) {

      override fun onResponse(call: Call, response: Response) {
        response.use {
+          if (it.code == 401) {
+            // Handle 401 Unauthorized by attempting token refresh
+            AbsLogger.info(tag, "makeRequest: 401 Unauthorized for request to \"${request.url}\" - attempt token refresh")
+            handleTokenRefresh(request, httpClient, cb)
+            return
+          }
+
          if (!it.isSuccessful) {
            val jsobj = JSObject()
            jsobj.put("error", "Unexpected code $response")
@@ -117,6 +160,236 @@ class ApiHandler(var ctx:Context) {
    })
  }

+  /**
+   * Handles token refresh when a 401 Unauthorized response is received
+   * This function will:
+   * 1. Get the refresh token from secure storage for the current server connection
+   * 2. Make a request to /auth/refresh endpoint with the refresh token
+   * 3. Update the stored tokens with the new access token
+   * 4. Retry the original request with the new access token
+   * 5. If refresh fails, fail the request ([refreshAuthTokens] owns clearing the session)
+   *
+   * @param originalRequest The original request that failed with 401
+   * @param httpClient The HTTP client to use for the request
+   * @param callback The callback to return the response
+   */
+  private fun handleTokenRefresh(originalRequest: Request, httpClient: OkHttpClient?, callback: (JSObject) -> Unit) {
+    val serverConnectionConfigId = DeviceManager.serverConnectionConfigId
+    refreshAuthTokens(serverConnectionConfigId, httpClient) { result ->
+      if (result is RefreshResult.Success) {
+        retryOriginalRequest(originalRequest, result.accessToken, httpClient, callback)
+      } else {
+        callback(JSObject().put("error", "Authentication failed - login again"))
+      }
+    }
+  }
+
+  sealed interface RefreshResult {
+    data class Success(val accessToken: String) : RefreshResult
+
+    /** The server rejected the refresh token, so the session has already been cleared. */
+    data object Rejected : RefreshResult
+
+    /** The refresh could not be completed. Credentials are untouched and the caller may retry. */
+    data object Transient : RefreshResult
+  }
+
+  /** Refreshes tokens for a specific saved server, including downloads queued while another server is active. */
+  fun refreshAuthTokens(
+          serverConnectionConfigId: String,
+          httpClient: OkHttpClient? = null,
+          onResult: (RefreshResult) -> Unit
+  ) {
+    val config = DeviceManager.getServerConnectionConfig(serverConnectionConfigId)
+    val refreshToken = secureStorage.getRefreshToken(serverConnectionConfigId)
+    if (config == null || refreshToken.isNullOrEmpty()) {
+      AbsLogger.error(tag, "No refresh token or server configuration for $serverConnectionConfigId")
+      handleRefreshRejected(serverConnectionConfigId)
+      onResult(RefreshResult.Rejected)
+      return
+    }
+    val request = try {
+      Request.Builder()
+              .url("${config.address}/auth/refresh")
+              .addHeader("x-refresh-token", refreshToken)
+              .addHeader("Content-Type", "application/json")
+              .post(EMPTY_REQUEST)
+              .build()
+    } catch (e: Exception) {
+      AbsLogger.error(tag, "Could not create refresh request for ${config.name}: ${e.message}")
+      onResult(RefreshResult.Transient)
+      return
+    }
+    (httpClient ?: defaultClient).newCall(request).enqueue(object : Callback {
+      override fun onFailure(call: Call, e: IOException) {
+        AbsLogger.error(tag, "Token refresh failed for ${config.name}: ${e.message}")
+        onResult(RefreshResult.Transient)
+      }
+
+      override fun onResponse(call: Call, response: Response) {
+        response.use {
+          if (!it.isSuccessful) {
+            AbsLogger.error(tag, "Token refresh returned ${it.code} for ${config.name}")
+            if (it.code != 401 && it.code != 403) {
+              onResult(RefreshResult.Transient)
+              return
+            }
+            handleRefreshRejected(serverConnectionConfigId)
+            onResult(RefreshResult.Rejected)
+            return
+          }
+          try {
+            val user = JSONObject(it.body!!.string()).optJSONObject("user")
+            val accessToken = user?.optString("accessToken").orEmpty()
+            if (accessToken.isEmpty()) {
+              AbsLogger.error(tag, "Refresh response had no access token for ${config.name}")
+              onResult(RefreshResult.Transient)
+              return
+            }
+            updateTokens(accessToken, user?.optString("refreshToken").orEmpty().ifEmpty { refreshToken }, serverConnectionConfigId)
+            onResult(RefreshResult.Success(accessToken))
+          } catch (e: Exception) {
+            AbsLogger.error(tag, "Could not parse refresh response for ${config.name}: ${e.message}")
+            onResult(RefreshResult.Transient)
+          }
+        }
+      }
+    })
+  }
+
+  /**
+   * Clears only the server that rejected the refresh token; queued downloads can target a non-active server.
+   *
+   * Only call this when the server explicitly rejected the refresh token. Transient failures should not log the user out
+   */
+  private fun handleRefreshRejected(serverConnectionConfigId: String) {
+    // Must not throw: callers still have to report the refresh result to an in-flight request or download.
+    try {
+      secureStorage.removeRefreshToken(serverConnectionConfigId)
+      if (DeviceManager.serverConnectionConfigId != serverConnectionConfigId) return
+      DeviceManager.serverConnectionConfig = null
+      DeviceManager.deviceData.lastServerConnectionConfigId = null
+      DeviceManager.dbManager.saveDeviceData(DeviceManager.deviceData)
+      if (checkAbsDatabaseNotifyListenersInitted()) {
+        absDatabaseNotifyListeners(
+                "onTokenRefreshFailure",
+                JSObject().put("error", "Token refresh failed").put("serverConnectionConfigId", serverConnectionConfigId))
+      }
+    } catch (e: Exception) {
+      AbsLogger.error(tag, "Could not clear session for $serverConnectionConfigId: ${e.message}")
+    }
+  }
+
+  /**
+   * Updates the stored tokens with new access and refresh tokens
+   *
+   * @param newAccessToken The new access token
+   * @param newRefreshToken The new refresh token (or existing one if not provided)
+   */
+  private fun updateTokens(newAccessToken: String, newRefreshToken: String, serverConnectionConfigId: String) {
+    try {
+      // Update the refresh token in secure storage if it's new
+      if (newRefreshToken != secureStorage.getRefreshToken(serverConnectionConfigId)) {
+        secureStorage.storeRefreshToken(serverConnectionConfigId, newRefreshToken)
+        Log.d(tag, "updateTokens: Updated refresh token in secure storage")
+      }
+
+      // The refreshed connection may be queued in the downloader rather than currently active.
+      DeviceManager.getServerConnectionConfig(serverConnectionConfigId)?.let { config ->
+        config.token = newAccessToken
+        DeviceManager.dbManager.saveDeviceData(DeviceManager.deviceData)
+        Log.d(tag, "updateTokens: Updated access token in server connection config")
+      }
+
+      // Send access token to Webview frontend
+      if (DeviceManager.serverConnectionConfigId == serverConnectionConfigId && checkAbsDatabaseNotifyListenersInitted()) {
+        val tokenJsObject = JSObject()
+        tokenJsObject.put("accessToken", newAccessToken)
+        absDatabaseNotifyListeners("onTokenRefresh", tokenJsObject)
+      } else {
+        // Can happen if Webview is never run
+        Log.i(tag, "AbsDatabaseNotifyListeners is not initialized so cannot send new access token")
+      }
+      AbsLogger.info(tag, "updateTokens: Successfully refreshed auth tokens for server ${DeviceManager.serverConnectionConfigString}")
+    } catch (e: Exception) {
+      Log.e(tag, "updateTokens: Failed to update tokens", e)
+      AbsLogger.error(tag, "updateTokens: Failed to refresh auth tokens for server ${DeviceManager.serverConnectionConfigString} (error: ${e.message})")
+    }
+  }
+
+  /**
+   * Retries the original request with the new access token
+   *
+   * @param originalRequest The original request to retry
+   * @param newAccessToken The new access token to use
+   * @param httpClient The HTTP client to use
+   * @param callback The callback to return the response
+   */
+  private fun retryOriginalRequest(originalRequest: Request, newAccessToken: String, httpClient: OkHttpClient?, callback: (JSObject) -> Unit) {
+    try {
+      // Create a new request with the updated authorization header
+      val newRequest = originalRequest.newBuilder()
+        .removeHeader("Authorization")
+        .addHeader("Authorization", "Bearer $newAccessToken")
+        .build()
+
+      Log.d(tag, "retryOriginalRequest: Retrying request to ${newRequest.url}")
+
+      // Make the retry request
+      val client = httpClient ?: defaultClient
+      client.newCall(newRequest).enqueue(object : Callback {
+        override fun onFailure(call: Call, e: IOException) {
+          Log.e(tag, "retryOriginalRequest: Failed to retry request", e)
+          AbsLogger.error(tag, "retryOriginalRequest: Failed to retry request after token refresh for server ${DeviceManager.serverConnectionConfigString} (error: ${e.message})")
+          val errorObj = JSObject()
+          errorObj.put("error", "Failed to retry request after token refresh")
+          callback(errorObj)
+        }
+
+        override fun onResponse(call: Call, response: Response) {
+          response.use {
+            if (!it.isSuccessful) {
+              Log.e(tag, "retryOriginalRequest: Retry request failed with status ${it.code}")
+              AbsLogger.error(tag, "retryOriginalRequest: Retry request failed with status ${it.code} for server ${DeviceManager.serverConnectionConfigString}")
+              val errorObj = JSObject()
+              errorObj.put("error", "Retry request failed with status ${it.code}")
+              callback(errorObj)
+              return
+            }
+
+            val bodyString = it.body!!.string()
+            if (bodyString == "OK") {
+              callback(JSObject())
+            } else {
+              try {
+                var jsonObj = JSObject()
+                if (bodyString.startsWith("[")) {
+                  val array = JSArray(bodyString)
+                  jsonObj.put("value", array)
+                } else {
+                  jsonObj = JSObject(bodyString)
+                }
+                callback(jsonObj)
+              } catch(je:JSONException) {
+                Log.e(tag, "retryOriginalRequest: Invalid JSON response ${je.localizedMessage} from body $bodyString")
+                val errorObj = JSObject()
+                errorObj.put("error", "Invalid response body")
+                callback(errorObj)
+              }
+            }
+          }
+        }
+      })
+
+    } catch (e: Exception) {
+      Log.e(tag, "retryOriginalRequest: Unexpected error during retry", e)
+      AbsLogger.error(tag, "retryOriginalRequest: Unexpected error during retry for server ${DeviceManager.serverConnectionConfigString}")
+      val errorObj = JSObject()
+      errorObj.put("error", "Failed to retry request")
+      callback(errorObj)
+    }
+  }
+
  fun getCurrentUser(cb: (User?) -> Unit) {
    getRequest("/api/me", null, null) {
      if (it.has("error")) {
@@ -131,7 +404,7 @@ class ApiHandler(var ctx:Context) {

  fun getLibraries(cb: (List<Library>) -> Unit) {
    val mapper = jacksonMapper
-    getRequest("/api/libraries", null,null) {
+    getRequest("/api/libraries?include=stats", null,null) {
      val libraries = mutableListOf<Library>()

      var array = JSONArray()
@@ -148,6 +421,23 @@ class ApiHandler(var ctx:Context) {
    }
  }

+  fun getLibraryPersonalized(libraryItemId:String, cb: (List<LibraryShelfType>?) -> Unit) {
+    getRequest("/api/libraries/$libraryItemId/personalized", null, null) {
+      if (it.has("error")) {
+        Log.e(tag, it.getString("error") ?: "getLibraryStats Failed")
+        cb(null)
+      } else {
+        val items = mutableListOf<LibraryShelfType>()
+        val array = it.getJSONArray("value")
+        for (i in 0 until array.length()) {
+          val item = jacksonMapper.readValue<LibraryShelfType>(array.get(i).toString())
+          items.add(item)
+        }
+        cb(items)
+      }
+    }
+  }
+
  fun getLibraryItem(libraryItemId:String, cb: (LibraryItem?) -> Unit) {
    getRequest("/api/items/$libraryItemId?expanded=1", null, null) {
      if (it.has("error")) {
@@ -188,6 +478,103 @@ class ApiHandler(var ctx:Context) {
    }
  }

+  fun getLibrarySeries(libraryId:String, cb: (List<LibrarySeriesItem>) -> Unit) {
+    Log.d(tag, "Getting series")
+    getRequest("/api/libraries/$libraryId/series?minified=1&sort=name&limit=10000", null, null) {
+      val items = mutableListOf<LibrarySeriesItem>()
+      if (it.has("results")) {
+        val array = it.getJSONArray("results")
+        for (i in 0 until array.length()) {
+          val item = jacksonMapper.readValue<LibrarySeriesItem>(array.get(i).toString())
+          items.add(item)
+        }
+      }
+      cb(items)
+    }
+  }
+
+  fun getLibrarySeriesItems(libraryId:String, seriesId:String, cb: (List<LibraryItem>) -> Unit) {
+    Log.d(tag, "Getting items for series")
+    val seriesIdBase64 = Base64.encodeToString(seriesId.toByteArray(), Base64.DEFAULT)
+    getRequest("/api/libraries/$libraryId/items?minified=1&sort=media.metadata.title&filter=series.${seriesIdBase64}&limit=1000", null, null) {
+      val items = mutableListOf<LibraryItem>()
+      if (it.has("results")) {
+        val array = it.getJSONArray("results")
+        for (i in 0 until array.length()) {
+          val item = jacksonMapper.readValue<LibraryItem>(array.get(i).toString())
+          items.add(item)
+        }
+      }
+      cb(items)
+    }
+  }
+
+  fun getLibraryAuthors(libraryId:String, cb: (List<LibraryAuthorItem>) -> Unit) {
+    Log.d(tag, "Getting series")
+    getRequest("/api/libraries/$libraryId/authors", null, null) {
+      val items = mutableListOf<LibraryAuthorItem>()
+      if (it.has("authors")) {
+        val array = it.getJSONArray("authors")
+        for (i in 0 until array.length()) {
+          val item = jacksonMapper.readValue<LibraryAuthorItem>(array.get(i).toString())
+          items.add(item)
+        }
+      }else{
+        Log.e(tag, "No results")
+      }
+      cb(items)
+    }
+  }
+
+  fun getLibraryItemsFromAuthor(libraryId:String, authorId:String, cb: (List<LibraryItem>) -> Unit) {
+    Log.d(tag, "Getting author items")
+    val authorIdBase64 = Base64.encodeToString(authorId.toByteArray(), Base64.DEFAULT)
+    getRequest("/api/libraries/$libraryId/items?limit=1000&minified=1&filter=authors.${authorIdBase64}&sort=media.metadata.title&collapseseries=1", null, null) {
+      val items = mutableListOf<LibraryItem>()
+      if (it.has("results")) {
+        val array = it.getJSONArray("results")
+        for (i in 0 until array.length()) {
+          val item = jacksonMapper.readValue<LibraryItem>(array.get(i).toString())
+          if (item.collapsedSeries != null) {
+            item.collapsedSeries?.libraryId = libraryId
+          }
+          items.add(item)
+        }
+      }else{
+        Log.e(tag, "No results")
+      }
+      cb(items)
+    }
+  }
+
+  fun getLibraryCollections(libraryId:String, cb: (List<LibraryCollection>) -> Unit) {
+    Log.d(tag, "Getting collections")
+    getRequest("/api/libraries/$libraryId/collections?minified=1&sort=name&limit=1000", null, null) {
+      val items = mutableListOf<LibraryCollection>()
+      if (it.has("results")) {
+        val array = it.getJSONArray("results")
+        for (i in 0 until array.length()) {
+          val item = jacksonMapper.readValue<LibraryCollection>(array.get(i).toString())
+          items.add(item)
+        }
+      }
+      cb(items)
+    }
+  }
+
+  fun getSearchResults(libraryId:String, queryString:String, cb: (LibraryItemSearchResultType?) -> Unit) {
+    Log.d(tag, "Doing search for library $libraryId")
+    getRequest("/api/libraries/$libraryId/search?q=$queryString", null, null) {
+      if (it.has("error")) {
+        Log.e(tag, it.getString("error") ?: "getSearchResults Failed")
+        cb(null)
+      } else {
+        val librarySearchResults = jacksonMapper.readValue<LibraryItemSearchResultType>(it.toString())
+        cb(librarySearchResults)
+      }
+    }
+  }
+
  fun getAllItemsInProgress(cb: (List<ItemInProgress>) -> Unit) {
    getRequest("/api/me/items-in-progress", null, null) {
      val items = mutableListOf<ItemInProgress>()
@@ -195,8 +582,7 @@ class ApiHandler(var ctx:Context) {
        val array = it.getJSONArray("libraryItems")
        for (i in 0 until array.length()) {
          val jsobj = array.get(i) as JSONObject
-
-          val itemInProgress = ItemInProgress.makeFromServerObject(jsobj)
+          val itemInProgress = ItemInProgress.makeFromServerObject(jsobj, jacksonMapper)
          items.add(itemInProgress)
        }
      }
@@ -233,10 +619,29 @@ class ApiHandler(var ctx:Context) {
    }
  }

-  fun sendLocalProgressSync(playbackSession:PlaybackSession, cb: (Boolean, String?) -> Unit) {
-    val payload = JSObject(jacksonMapper.writeValueAsString(playbackSession))
+  private fun createPartialPlaybackSession(playbackSession: PlaybackSession): ObjectNode {
+    val json = jacksonMapper.createObjectNode()
+    json.put("id", playbackSession.id)
+    json.put("userId", playbackSession.userId)
+    json.put("libraryItemId", playbackSession.libraryItemId)
+    json.put("episodeId", playbackSession.episodeId)
+    json.put("mediaType", playbackSession.mediaType)
+    json.put("displayTitle", playbackSession.displayTitle)
+    json.put("displayAuthor", playbackSession.displayAuthor)
+    json.put("duration", playbackSession.duration)
+    json.put("playMethod", playbackSession.playMethod)
+    json.put("startedAt", playbackSession.startedAt)
+    json.put("updatedAt", playbackSession.updatedAt)
+    json.put("timeListening", playbackSession.timeListening)
+    json.put("currentTime", playbackSession.currentTime)
+    json.put("mediaPlayer", playbackSession.mediaPlayer)
+    return json
+  }

-    postRequest("/api/session/local", payload, null) {
+  fun sendLocalProgressSync(playbackSession:PlaybackSession, cb: (Boolean, String?) -> Unit) {
+    val partialSession = createPartialPlaybackSession(playbackSession)
+    partialSession.set<ObjectNode>("deviceInfo", jacksonMapper.valueToTree(playbackSession.deviceInfo))
+    postRequest("/api/session/local", JSObject(partialSession.toString()), null) {
      if (!it.getString("error").isNullOrEmpty()) {
        cb(false, it.getString("error"))
      } else {
@@ -296,9 +701,9 @@ class ApiHandler(var ctx:Context) {
    }
  }

-  fun closePlaybackSession(playbackSessionId:String, cb: (Boolean) -> Unit) {
+  fun closePlaybackSession(playbackSessionId:String, config:ServerConnectionConfig?, cb: (Boolean) -> Unit) {
    Log.d(tag, "closePlaybackSession: playbackSessionId=$playbackSessionId")
-    postRequest("/api/session/$playbackSessionId/close", null, null) {
+    postRequest("/api/session/$playbackSessionId/close", null, config) {
      cb(true)
    }
  }
@@ -327,25 +732,32 @@ class ApiHandler(var ctx:Context) {
  fun sendSyncLocalSessions(playbackSessions:List<PlaybackSession>, cb: (Boolean, String?) -> Unit) {
    @SuppressLint("HardwareIds")
    val deviceId = Settings.Secure.getString(ctx.contentResolver, Settings.Secure.ANDROID_ID)
-    val deviceInfo = DeviceInfo(deviceId, Build.MANUFACTURER, Build.MODEL, Build.VERSION.SDK_INT, Build.VERSION.RELEASE)
+    val deviceInfo = DeviceInfo(deviceId, Build.MANUFACTURER, Build.MODEL, Build.VERSION.SDK_INT, BuildConfig.VERSION_NAME)

-    val payload = JSObject(jacksonMapper.writeValueAsString(LocalSessionsSyncRequestPayload(playbackSessions, deviceInfo)))
-    Log.d(tag, "Sending ${playbackSessions.size} saved local playback sessions to server")
-    postRequest("/api/session/local-all", payload, null) {
+    val json = jacksonMapper.createObjectNode();
+    json.putArray("sessions").addAll(playbackSessions.map(::createPartialPlaybackSession))
+    json.set<ObjectNode>("deviceInfo", jacksonMapper.valueToTree(deviceInfo))
+    AbsLogger.info("ApiHandler", "sendSyncLocalSessions: Sending ${playbackSessions.size} saved local playback sessions to server (${DeviceManager.serverConnectionConfigName})")
+
+    postRequest("/api/session/local-all", JSObject(json.toString()), null) {
      if (!it.getString("error").isNullOrEmpty()) {
-        Log.e(tag, "Failed to sync local sessions")
+        AbsLogger.error("ApiHandler", "sendSyncLocalSessions: Failed to sync local sessions. (${it.getString("error")})")
        cb(false, it.getString("error"))
      } else {
        val response = jacksonMapper.readValue<LocalSessionsSyncResponsePayload>(it.toString())
        response.results.forEach { localSessionSyncResult ->
          Log.d(tag, "Synced session result ${localSessionSyncResult.id}|${localSessionSyncResult.progressSynced}|${localSessionSyncResult.success}")
+
          playbackSessions.find { ps -> ps.id == localSessionSyncResult.id }?.let { session ->
            if (localSessionSyncResult.progressSynced == true) {
              val syncResult = SyncResult(true, true, "Progress synced on server")
              MediaEventManager.saveEvent(session, syncResult)
-              Log.i(tag, "Successfully synced session ${session.displayTitle} with server")
+
+              AbsLogger.info("ApiHandler", "sendSyncLocalSessions: Synced session \"${session.displayTitle}\" with server, server progress was updated for item ${session.mediaItemId}")
            } else if (!localSessionSyncResult.success) {
-              Log.e(tag, "Failed to sync session ${session.displayTitle} with server. Error: ${localSessionSyncResult.error}")
+              AbsLogger.error("ApiHandler", "sendSyncLocalSessions: Failed to sync session \"${session.displayTitle}\" with server. Error: ${localSessionSyncResult.error}")
+            } else {
+              AbsLogger.info("ApiHandler", "sendSyncLocalSessions: Synced session \"${session.displayTitle}\" with server. Server progress was up-to-date for item ${session.mediaItemId}")
            }
          }
        }
@@ -355,37 +767,72 @@ class ApiHandler(var ctx:Context) {
  }

  fun syncLocalMediaProgressForUser(cb: () -> Unit) {
+    AbsLogger.info("ApiHandler", "[ApiHandler] syncLocalMediaProgressForUser: Server connection ${DeviceManager.serverConnectionConfigName}")
+
    // Get all local media progress for this server
    val allLocalMediaProgress = DeviceManager.dbManager.getAllLocalMediaProgress().filter { it.serverConnectionConfigId == DeviceManager.serverConnectionConfigId }
    if (allLocalMediaProgress.isEmpty()) {
-      Log.d(tag, "No local media progress to sync")
+      AbsLogger.info("ApiHandler", "[ApiHandler] syncLocalMediaProgressForUser: No local media progress to sync")
      return cb()
    }

-    getCurrentUser { _user ->
-      _user?.let { user->
+    AbsLogger.info("ApiHandler", "syncLocalMediaProgressForUser: Found ${allLocalMediaProgress.size} local media progress")
+
+    getCurrentUser { user ->
+      if (user == null) {
+        AbsLogger.error("ApiHandler", "syncLocalMediaProgressForUser: Failed to load user from server (${DeviceManager.serverConnectionConfigName})")
+      } else {
+        var numLocalMediaProgressUptToDate = 0
+        var numLocalMediaProgressUpdated = 0
+
        // Compare server user progress with local progress
        user.mediaProgress.forEach { mediaProgress ->
          // Get matching local media progress
          allLocalMediaProgress.find { it.isMatch(mediaProgress) }?.let { localMediaProgress ->
            if (mediaProgress.lastUpdate > localMediaProgress.lastUpdate) {
-              Log.d(tag, "Server progress for media item id=\"${mediaProgress.mediaItemId}\" is more recent then local. Updating local current time ${localMediaProgress.currentTime} to ${mediaProgress.currentTime}")
+              val updateLogs = mutableListOf<String>()
+              if (mediaProgress.progress != localMediaProgress.progress) {
+                updateLogs.add("Updated progress from ${localMediaProgress.progress} to ${mediaProgress.progress}")
+              }
+              if (mediaProgress.currentTime != localMediaProgress.currentTime) {
+                updateLogs.add("Updated currentTime from ${localMediaProgress.currentTime} to ${mediaProgress.currentTime}")
+              }
+              if (mediaProgress.isFinished != localMediaProgress.isFinished) {
+                updateLogs.add("Updated isFinished from ${localMediaProgress.isFinished} to ${mediaProgress.isFinished}")
+              }
+              if (mediaProgress.ebookProgress != localMediaProgress.ebookProgress) {
+                updateLogs.add("Updated ebookProgress from ${localMediaProgress.isFinished} to ${mediaProgress.isFinished}")
+              }
+              if (updateLogs.isNotEmpty()) {
+                AbsLogger.info("ApiHandler", "syncLocalMediaProgressForUser: Server progress for item \"${mediaProgress.mediaItemId}\" is more recent than local (server lastUpdate=${mediaProgress.lastUpdate}, local lastUpdate=${localMediaProgress.lastUpdate}). ${updateLogs.joinToString()}")
+              }
+
              localMediaProgress.updateFromServerMediaProgress(mediaProgress)
-              MediaEventManager.syncEvent(mediaProgress, "Sync on server connection")
+
+              // Only report sync if progress changed
+              if (updateLogs.isNotEmpty()) {
+                MediaEventManager.syncEvent(mediaProgress, "Sync on server connection")
+              }
              DeviceManager.dbManager.saveLocalMediaProgress(localMediaProgress)
+              numLocalMediaProgressUpdated++
            } else if (localMediaProgress.lastUpdate > mediaProgress.lastUpdate && localMediaProgress.ebookLocation != null && localMediaProgress.ebookLocation != mediaProgress.ebookLocation) {
              // Patch ebook progress to server
+              AbsLogger.info("ApiHandler", "syncLocalMediaProgressForUser: Local progress for ebook item \"${mediaProgress.mediaItemId}\" is more recent than server progress. Local progress last updated ${localMediaProgress.lastUpdate}, server progress last updated ${mediaProgress.lastUpdate}. Sending server request to update ebook progress from ${mediaProgress.ebookProgress} to ${localMediaProgress.ebookProgress}")
              val endpoint = "/api/me/progress/${localMediaProgress.libraryItemId}"
              val updatePayload = JSObject()
              updatePayload.put("ebookLocation", localMediaProgress.ebookLocation)
              updatePayload.put("ebookProgress", localMediaProgress.ebookProgress)
              updatePayload.put("lastUpdate", localMediaProgress.lastUpdate)
              patchRequest(endpoint,updatePayload) {
-                Log.d(tag, "syncLocalMediaProgressForUser patched ebook progress")
+                AbsLogger.info("ApiHandler", "syncLocalMediaProgressForUser: Successfully updated server ebook progress for item item \"${mediaProgress.mediaItemId}\"")
              }
+            } else {
+              numLocalMediaProgressUptToDate++
            }
          }
        }
+
+        AbsLogger.info("ApiHandler", "syncLocalMediaProgressForUser: Finishing syncing local media progress with server. $numLocalMediaProgressUptToDate up-to-date, $numLocalMediaProgressUpdated updated")
      }
      cb()
    }
@@ -0,0 +1,102 @@
+package com.audiobookshelf.app.services
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ServiceInfo
+import android.os.Build
+import android.os.IBinder
+import androidx.core.app.NotificationCompat
+import com.audiobookshelf.app.R
+import com.audiobookshelf.app.models.DownloadItemPart
+
+/** Android-owned foreground lifecycle for transfers that must outlive the WebView and Activity. */
+class DownloadService : Service() {
+  override fun onCreate() {
+    super.onCreate()
+    createChannel()
+    startForegroundWithType(DownloadServiceHost.notificationStrings(this).preparing)
+    DownloadServiceHost.attachService(this)
+  }
+
+  override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+    when (intent?.action) {
+      ACTION_CANCEL -> DownloadServiceHost.cancelAll(this)
+      else -> {
+        startForegroundWithType(DownloadServiceHost.notificationStrings(this).preparing)
+        DownloadServiceHost.startWork(this)
+      }
+    }
+    return START_STICKY
+  }
+
+  override fun onDestroy() {
+    DownloadServiceHost.detachService(this)
+    super.onDestroy()
+  }
+
+  override fun onBind(intent: Intent?): IBinder? = null
+
+  fun onPartUpdate(part: DownloadItemPart) {
+    val strings = DownloadServiceHost.notificationStrings(this)
+    val text =
+            if (part.waitingForSpace) strings.waitingForStorage
+            else strings.downloadingFile.replace("{0}", part.filename)
+    val progress = part.progress.coerceIn(0L, 100L).toInt()
+    val notification = notification(text, progress, part.fileSize > 0L)
+    (getSystemService(NOTIFICATION_SERVICE) as NotificationManager).notify(NOTIFICATION_ID, notification)
+  }
+
+  fun onQueueChanged(hasWork: Boolean) {
+    if (!hasWork) {
+      stopForeground(STOP_FOREGROUND_REMOVE)
+      stopSelf()
+    }
+  }
+
+  private fun startForegroundWithType(text: String) {
+    val notification = notification(text)
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      startForeground(NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC)
+    } else {
+      startForeground(NOTIFICATION_ID, notification)
+    }
+  }
+
+  private fun notification(text: String, progress: Int = 0, determinate: Boolean = false): Notification {
+    val cancelIntent = PendingIntent.getService(
+            this, 1, Intent(this, DownloadService::class.java).setAction(ACTION_CANCEL), pendingIntentFlags())
+    return NotificationCompat.Builder(this, CHANNEL_ID)
+            .setSmallIcon(R.drawable.icon)
+            .setContentTitle(DownloadServiceHost.notificationStrings(this).downloads)
+            .setContentText(text)
+            .setOnlyAlertOnce(true)
+            .setOngoing(true)
+            .setProgress(100, progress, !determinate)
+            .addAction(0, DownloadServiceHost.notificationStrings(this).cancel, cancelIntent)
+            .build()
+  }
+
+  private fun createChannel() {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+    val manager = getSystemService(NOTIFICATION_SERVICE) as NotificationManager
+    manager.createNotificationChannel(
+            NotificationChannel(
+                    CHANNEL_ID,
+                    DownloadServiceHost.notificationStrings(this).downloads,
+                    NotificationManager.IMPORTANCE_LOW))
+  }
+
+  private fun pendingIntentFlags(): Int = PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+
+  companion object {
+    private const val CHANNEL_ID = "downloads"
+    private const val NOTIFICATION_ID = 11
+    private const val ACTION_CANCEL = "com.audiobookshelf.app.download.CANCEL"
+    fun intent(context: Context) = Intent(context, DownloadService::class.java)
+  }
+}
@@ -0,0 +1,225 @@
+package com.audiobookshelf.app.services
+
+import android.content.Context
+import androidx.core.content.ContextCompat
+import com.audiobookshelf.app.device.DeviceManager
+import com.audiobookshelf.app.device.FolderScanner
+import com.audiobookshelf.app.managers.DbManager
+import com.audiobookshelf.app.managers.DownloadItemManager
+import com.audiobookshelf.app.managers.IncompleteDownloadCleanup
+import com.audiobookshelf.app.models.DownloadItem
+import com.audiobookshelf.app.plugins.AbsLogger
+import com.getcapacitor.JSObject
+import java.util.Collections
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+/** Shared process owner used by the foreground service and the Capacitor bridge. */
+object DownloadServiceHost {
+  enum class ExistingDownloadResult { NOT_FOUND, ACTIVE, RETRIED, SERVICE_START_FAILED }
+
+  data class NotificationStrings(
+          val preparing: String,
+          val downloadingFile: String,
+          val waitingForStorage: String,
+          val downloads: String,
+          val cancel: String
+  )
+
+  private var manager: DownloadItemManager? = null
+  private var bridgeEmitter: DownloadItemManager.DownloadEventEmitter = NoopEmitter
+  @Volatile private var service: DownloadService? = null
+  @Volatile private var bridgeReady = false
+  private val deferredCompletions = Collections.synchronizedList(mutableListOf<JSObject>())
+  private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+  private var restoreJob: Job? = null
+
+  @Synchronized
+  fun ensure(context: Context): DownloadItemManager {
+    if (manager == null) {
+      val appContext = context.applicationContext
+      DbManager.initialize(appContext)
+      manager = DownloadItemManager(FolderScanner(appContext), appContext, ForwardingEmitter)
+      restoreJob = scope.launch {
+        try {
+          if (DeviceManager.dbManager.ensureValidDownloadQueue()) {
+            IncompleteDownloadCleanup.cleanupExpired(appContext)
+            manager!!.restoreQueue()
+          } else {
+            AbsLogger.error(TAG, "Skipping invalid download queue because it could not be cleared")
+          }
+          onRestoreComplete(appContext)
+        } catch (restoreError: Exception) {
+          AbsLogger.error(
+                  TAG,
+                  "Could not restore download queue (${restoreError.javaClass.simpleName}: ${restoreError.message})"
+          )
+        }
+      }
+    }
+    return manager!!
+  }
+
+  /** Attaches the frontend after restored queue items have been emitted. */
+  @Synchronized
+  fun attachBridge(context: Context, emitter: DownloadItemManager.DownloadEventEmitter) {
+    bridgeReady = false
+    bridgeEmitter = emitter
+    ensure(context).setEventEmitter(ForwardingEmitter)
+    bridgeReady = true
+    val completions = synchronized(deferredCompletions) {
+      deferredCompletions.toList().also { deferredCompletions.clear() }
+    }
+    completions.forEach(bridgeEmitter::onDownloadItemComplete)
+  }
+
+  @Synchronized
+  fun detachBridge() {
+    bridgeReady = false
+    bridgeEmitter = NoopEmitter
+  }
+
+  fun enqueue(context: Context, item: DownloadItem, callback: (String?) -> Unit) {
+    val queue = ensure(context)
+    scope.launch {
+      restoreJob?.join()
+      queue.addDownloadItem(item)
+      if (startService(context)) callback(null)
+      else callback("Unable to start the Android download service")
+    }
+  }
+
+  fun retryExisting(
+          context: Context,
+          downloadItemId: String,
+          callback: (ExistingDownloadResult) -> Unit
+  ) {
+    val queue = ensure(context)
+    scope.launch {
+      restoreJob?.join()
+      val existing = queue.downloadItemQueue.find { it.id == downloadItemId }
+      if (existing == null) {
+        callback(ExistingDownloadResult.NOT_FOUND)
+      } else if (!queue.retryDownloadItem(downloadItemId)) {
+        callback(ExistingDownloadResult.ACTIVE)
+      } else if (startService(context)) {
+        callback(ExistingDownloadResult.RETRIED)
+      } else {
+        callback(ExistingDownloadResult.SERVICE_START_FAILED)
+      }
+    }
+  }
+
+  fun cancelAll(context: Context) {
+    val queue = ensure(context)
+    scope.launch {
+      restoreJob?.join()
+      queue.cancelAll()
+    }
+  }
+
+  fun setNotificationStrings(
+          context: Context,
+          preparing: String,
+          downloadingFile: String,
+          waitingForStorage: String,
+          downloads: String,
+          cancel: String
+  ) {
+    context.getSharedPreferences(NOTIFICATION_PREFERENCES, Context.MODE_PRIVATE)
+            .edit()
+            .putString(KEY_PREPARING, preparing)
+            .putString(KEY_DOWNLOADING_FILE, downloadingFile)
+            .putString(KEY_WAITING_FOR_STORAGE, waitingForStorage)
+            .putString(KEY_DOWNLOADS, downloads)
+            .putString(KEY_CANCEL, cancel)
+            .apply()
+  }
+
+  fun notificationStrings(context: Context): NotificationStrings {
+    val preferences = context.getSharedPreferences(NOTIFICATION_PREFERENCES, Context.MODE_PRIVATE)
+    return NotificationStrings(
+            preferences.getString(KEY_PREPARING, DEFAULT_PREPARING) ?: DEFAULT_PREPARING,
+            preferences.getString(KEY_DOWNLOADING_FILE, DEFAULT_DOWNLOADING_FILE)
+                    ?: DEFAULT_DOWNLOADING_FILE,
+            preferences.getString(KEY_WAITING_FOR_STORAGE, DEFAULT_WAITING_FOR_STORAGE)
+                    ?: DEFAULT_WAITING_FOR_STORAGE,
+            preferences.getString(KEY_DOWNLOADS, DEFAULT_DOWNLOADS) ?: DEFAULT_DOWNLOADS,
+            preferences.getString(KEY_CANCEL, DEFAULT_CANCEL) ?: DEFAULT_CANCEL)
+  }
+
+  fun attachService(downloadService: DownloadService) {
+    synchronized(this) { service = downloadService }
+    startWork(downloadService)
+  }
+
+  @Synchronized
+  fun detachService(downloadService: DownloadService) {
+    if (service === downloadService) service = null
+  }
+
+  fun startWork(context: Context) {
+    val queue = ensure(context)
+    scope.launch {
+      restoreJob?.join()
+      queue.resumeWork()
+    }
+  }
+
+  private fun onRestoreComplete(context: Context) {
+    val attachedService = synchronized(this) { service }
+    if (attachedService != null) {
+      manager?.resumeWork()
+    } else if (bridgeReady && manager?.hasWork() == true) {
+      startService(context)
+    }
+  }
+
+  private fun startService(context: Context): Boolean {
+    return try {
+      ContextCompat.startForegroundService(context, DownloadService.intent(context))
+      true
+    } catch (e: RuntimeException) {
+      AbsLogger.error(TAG, "Could not start download foreground service: ${e.message}")
+      false
+    }
+  }
+
+  private object ForwardingEmitter : DownloadItemManager.DownloadEventEmitter {
+    override fun onDownloadItem(downloadItem: DownloadItem) { bridgeEmitter.onDownloadItem(downloadItem) }
+    override fun onDownloadItemPartUpdate(downloadItemPart: com.audiobookshelf.app.models.DownloadItemPart) {
+      if (bridgeReady) bridgeEmitter.onDownloadItemPartUpdate(downloadItemPart)
+      service?.onPartUpdate(downloadItemPart)
+    }
+    override fun onDownloadItemComplete(jsobj: JSObject) {
+      if (bridgeReady) bridgeEmitter.onDownloadItemComplete(jsobj) else deferredCompletions.add(jsobj)
+    }
+    override fun onQueueChanged(hasWork: Boolean) {
+      bridgeEmitter.onQueueChanged(hasWork)
+      service?.onQueueChanged(hasWork)
+    }
+  }
+
+  private object NoopEmitter : DownloadItemManager.DownloadEventEmitter {
+    override fun onDownloadItem(downloadItem: DownloadItem) = Unit
+    override fun onDownloadItemPartUpdate(downloadItemPart: com.audiobookshelf.app.models.DownloadItemPart) = Unit
+    override fun onDownloadItemComplete(jsobj: JSObject) = Unit
+    override fun onQueueChanged(hasWork: Boolean) = Unit
+  }
+
+  private const val NOTIFICATION_PREFERENCES = "download_notifications"
+  private const val KEY_PREPARING = "preparing"
+  private const val KEY_DOWNLOADING_FILE = "downloading_file"
+  private const val KEY_WAITING_FOR_STORAGE = "waiting_for_storage"
+  private const val KEY_DOWNLOADS = "downloads"
+  private const val KEY_CANCEL = "cancel"
+  private const val DEFAULT_PREPARING = "Preparing downloads"
+  private const val DEFAULT_DOWNLOADING_FILE = "Downloading {0}"
+  private const val DEFAULT_WAITING_FOR_STORAGE = "Waiting for available storage"
+  private const val DEFAULT_DOWNLOADS = "Downloads"
+  private const val DEFAULT_CANCEL = "Cancel"
+  private const val TAG = "DownloadServiceHost"
+}
@@ -0,0 +1 @@
+<!-- drawable/clock_outline.xml --><vector xmlns:android="http://schemas.android.com/apk/res/android" android:height="24dp" android:width="24dp" android:viewportWidth="24" android:viewportHeight="24"><path android:fillColor="#FFFFFF" android:pathData="M12,20A8,8 0 0,0 20,12A8,8 0 0,0 12,4A8,8 0 0,0 4,12A8,8 0 0,0 12,20M12,2A10,10 0 0,1 22,12A10,10 0 0,1 12,22C6.47,22 2,17.5 2,12A10,10 0 0,1 12,2M12.5,7V12.25L17,14.92L16.25,16.15L11,13V7H12.5Z" /></vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="27dp"
+    android:height="32dp"
+    android:viewportWidth="27"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M26.719,15.761c-0.165,-0.138 -0.422,-0.341 -0.77,-0.581v-2.703c0,-6.891 -5.586,-12.477 -12.478,-12.477v0c-6.891,0 -12.477,5.586 -12.477,12.477v2.703c-0.348,0.241 -0.605,0.443 -0.77,0.581 -0.137,0.114 -0.223,0.285 -0.223,0.476 0,0 0,0 0,0.001v-0,3.238c0,0 0,0.001 0,0.001 0,0.191 0.086,0.361 0.222,0.475l0.001,0.001c0.385,0.321 1.269,0.993 2.645,1.683v0.315c0,0.849 0.548,1.537 1.223,1.537v0c0.675,0 1.223,-0.688 1.223,-1.537v-7.767c0,-0.849 -0.548,-1.537 -1.223,-1.537v0c-0.647,0 -1.177,0.632 -1.22,1.431l-0.003,0.002v-1.601c0,-5.856 4.747,-10.602 10.603,-10.602v0c5.856,0 10.603,4.747 10.603,10.602v1.601l-0.003,-0.002c-0.043,-0.799 -0.573,-1.431 -1.22,-1.431v0c-0.675,0 -1.223,0.688 -1.223,1.537v7.766c0,0.849 0.548,1.537 1.223,1.537v0c0.676,0 1.223,-0.688 1.223,-1.537v-0.315c1.376,-0.69 2.26,-1.362 2.645,-1.683 0.137,-0.114 0.223,-0.285 0.223,-0.476 0,-0 0,-0.001 0,-0.001v0,-3.237c0,-0 0,-0 0,-0 0,-0.191 -0.086,-0.361 -0.222,-0.475l-0.001,-0.001zM9.12,29.262c0.816,0 1.477,-0.661 1.477,-1.477v0,-16.543c0,-0 0,-0 0,-0 0,-0.816 -0.661,-1.477 -1.477,-1.477h-1.526c-0.816,0 -1.478,0.662 -1.478,1.478v0,16.543c0,0.816 0.661,1.477 1.477,1.477 0,0 0,0 0,0v0zM6.673,13.731h3.368v0.352h-3.368zM14.234,29.262c0.816,0 1.477,-0.661 1.477,-1.477v0,-16.543c0,-0 0,-0 0,-0 0,-0.816 -0.661,-1.477 -1.477,-1.477h-1.526c-0.816,0 -1.478,0.662 -1.478,1.478v0,16.543c0,0.816 0.661,1.477 1.477,1.477 0,0 0,0 0,0v0zM11.787,13.731h3.367v0.352h-3.367zM19.348,29.262c0.816,0 1.477,-0.661 1.477,-1.477v0,-16.543c0,-0 0,-0 0,-0 0,-0.816 -0.661,-1.477 -1.477,-1.477h-1.526c-0.816,0 -1.478,0.662 -1.478,1.478v0,16.543c0,0.816 0.661,1.477 1.477,1.477 0,0 0,0 0,0v0zM16.901,13.731h3.367v0.352h-3.367zM3.566,29.773h19.81c0.615,0 1.113,0.498 1.113,1.113v0c0,0.615 -0.498,1.113 -1.113,1.113h-19.81c-0.615,0 -1.113,-0.498 -1.113,-1.113v-0c0,-0.615 0.498,-1.113 1.113,-1.113z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="32dp"
+    android:height="32dp"
+    android:viewportWidth="32"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M16,7.333c2.577,0 4.667,2.089 4.667,4.667v0c0,2.577 -2.089,4.667 -4.667,4.667v0c-2.577,0 -4.667,-2.089 -4.667,-4.667v0c0,-2.577 2.089,-4.667 4.667,-4.667v0zM6.667,10.667c0.747,0 1.44,0.2 2.04,0.56 -0.2,1.907 0.36,3.8 1.507,5.28 -0.667,1.28 -2,2.16 -3.547,2.16 -2.209,0 -4,-1.791 -4,-4v0c0,-2.209 1.791,-4 4,-4v0zM25.333,10.667c2.209,0 4,1.791 4,4v0c0,2.209 -1.791,4 -4,4v0c-1.547,0 -2.88,-0.88 -3.547,-2.16 1.147,-1.48 1.707,-3.373 1.507,-5.28 0.6,-0.36 1.293,-0.56 2.04,-0.56zM7.333,24.333c0,-2.76 3.88,-5 8.667,-5s8.667,2.24 8.667,5v2.333h-17.333v-2.333zM0,26.667v-2c0,-1.853 2.52,-3.413 5.933,-3.867 -0.787,0.907 -1.267,2.16 -1.267,3.533v2.333h-4.667zM32,26.667h-4.667v-2.333c0,-1.373 -0.48,-2.627 -1.267,-3.533 3.413,0.453 5.933,2.013 5.933,3.867v2z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="32dp"
+    android:height="32dp"
+    android:viewportWidth="32"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M28,4v26h-21c-1.657,0 -3,-1.343 -3,-3s1.343,-3 3,-3h19v-24h-20c-2.2,0 -4,1.8 -4,4v24c0,2.2 1.8,4 4,4h24v-28h-2zM7.002,26v0c-0.001,0 -0.001,0 -0.002,0 -0.552,0 -1,0.448 -1,1s0.448,1 1,1c0.001,0 0.001,-0 0.002,-0v0h18.997v-2h-18.997z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="32dp"
+    android:height="32dp"
+    android:viewportWidth="32"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M12,4v20h4v-20h-4zM16,6.667l5.333,17.333 4,-1.333 -5.333,-17.333 -4,1.333zM6.667,6.667v17.333h4v-17.333h-4zM4,25.333v2.667h24v-2.667h-24z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="36dp"
+    android:height="32dp"
+    android:viewportWidth="36"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M7,4h-6c-0.55,0 -1,0.45 -1,1v22c0,0.55 0.45,1 1,1h6c0.55,0 1,-0.45 1,-1v-22c0,-0.55 -0.45,-1 -1,-1zM6,10h-4v-2h4v2zM17,4h-6c-0.55,0 -1,0.45 -1,1v22c0,0.55 0.45,1 1,1h6c0.55,0 1,-0.45 1,-1v-22c0,-0.55 -0.45,-1 -1,-1zM16,10h-4v-2h4v2zM23.909,5.546l-5.358,2.7c-0.491,0.247 -0.691,0.852 -0.443,1.343l8.999,17.861c0.247,0.491 0.852,0.691 1.343,0.443l5.358,-2.7c0.491,-0.247 0.691,-0.852 0.443,-1.343l-8.999,-17.861c-0.247,-0.491 -0.852,-0.691 -1.343,-0.443z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="32dp"
+    android:height="32dp"
+    android:viewportWidth="32"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M19.2,6h-6.4v19.2h6.4v-19.2zM22.4,6v19.2h6.4v-19.2h-6.4zM9.6,6h-6.4v19.2h6.4v-19.2zM0,2.8h32v25.6h-32v-25.6z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="27dp"
+    android:height="32dp"
+    android:viewportWidth="27"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M13.68,0c7.518,0 13.612,2.854 13.612,6.37 0,3.518 -6.096,6.37 -13.612,6.37s-13.612,-2.854 -13.612,-6.37c0,-3.516 6.096,-6.37 13.612,-6.37v0zM0.068,21.31v4.891c2.422,8.602 26.349,6.94 27.227,-0.44v-4.885c-1.195,8.102 -25.313,8.685 -27.227,0.435v0,0zM0,8.578v4.776c2.422,8.401 26.482,7.266 27.362,0.06v-4.773c-1.198,7.914 -25.448,7.995 -27.362,-0.063v0zM0,14.75v4.891c2.422,8.602 26.482,7.44 27.362,0.06v-4.885c-1.198,8.102 -25.448,8.185 -27.362,-0.065v0z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="32dp"
+    android:height="32dp"
+    android:viewportWidth="32"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M26,28h-20v-4l6,-10 8.219,10 5.781,-4v8zM26,15c0,1.657 -1.343,3 -3,3s-3,-1.343 -3,-3 1.343,-3 3,-3c1.657,0 3,1.343 3,3zM28.681,7.159c-0.694,-0.947 -1.662,-2.053 -2.724,-3.116s-2.169,-2.03 -3.116,-2.724c-1.612,-1.182 -2.393,-1.319 -2.841,-1.319h-15.5c-1.378,0 -2.5,1.121 -2.5,2.5v27c0,1.378 1.122,2.5 2.5,2.5h23c1.378,0 2.5,-1.122 2.5,-2.5v-19.5c0,-0.448 -0.137,-1.23 -1.319,-2.841zM24.543,5.457c0.959,0.959 1.712,1.825 2.268,2.543h-4.811v-4.811c0.718,0.556 1.584,1.309 2.543,2.268zM28,29.5c0,0.271 -0.229,0.5 -0.5,0.5h-23c-0.271,0 -0.5,-0.229 -0.5,-0.5v-27c0,-0.271 0.229,-0.5 0.5,-0.5 0,0 15.499,-0 15.5,0v7c0,0.552 0.448,1 1,1h7v19.5z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="32dp"
+    android:height="32dp"
+    android:viewportWidth="32"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M9,18h-2v14h2c0.55,0 1,-0.45 1,-1v-12c0,-0.55 -0.45,-1 -1,-1zM23,18c-0.55,0 -1,0.45 -1,1v12c0,0.55 0.45,1 1,1h2v-14h-2zM32,16c0,-8.837 -7.163,-16 -16,-16s-16,7.163 -16,16c0,1.919 0.338,3.759 0.958,5.464 -0.609,1.038 -0.958,2.246 -0.958,3.536 0,3.526 2.608,6.443 6,6.929v-13.857c-0.997,0.143 -1.927,0.495 -2.742,1.012 -0.168,-0.835 -0.258,-1.699 -0.258,-2.584 0,-7.18 5.82,-13 13,-13s13,5.82 13,13c0,0.885 -0.088,1.749 -0.257,2.584 -0.816,-0.517 -1.745,-0.87 -2.743,-1.013v13.858c3.392,-0.485 6,-3.402 6,-6.929 0,-1.29 -0.349,-2.498 -0.958,-3.536 0.62,-1.705 0.958,-3.545 0.958,-5.465z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="32dp"
+    android:height="32dp"
+    android:viewportWidth="32"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M23.6,2c-3.363,0 -6.258,2.736 -7.599,5.594 -1.342,-2.858 -4.237,-5.594 -7.601,-5.594 -4.637,0 -8.4,3.764 -8.4,8.401 0,9.433 9.516,11.906 16.001,21.232 6.13,-9.268 15.999,-12.1 15.999,-21.232 0,-4.637 -3.763,-8.401 -8.4,-8.401z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="32dp"
+    android:viewportWidth="24"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M6,6v10c0,3.313 2.688,6 6,6s6,-2.688 6,-6h-5c-0.55,0 -1,-0.45 -1,-1s0.45,-1 1,-1h5v-2h-5c-0.55,0 -1,-0.45 -1,-1s0.45,-1 1,-1h5v-2h-5c-0.55,0 -1,-0.45 -1,-1s0.45,-1 1,-1h5c0,-3.313 -2.688,-6 -6,-6s-6,2.688 -6,6zM20,15v1c0,4.419 -3.581,8 -8,8s-8,-3.581 -8,-8v-2.5c0,-0.831 -0.669,-1.5 -1.5,-1.5s-1.5,0.669 -1.5,1.5v2.5c0,5.569 4.138,10.169 9.5,10.9v2.1h-3c-0.831,0 -1.5,0.669 -1.5,1.5s0.669,1.5 1.5,1.5h9c0.831,0 1.5,-0.669 1.5,-1.5s-0.669,-1.5 -1.5,-1.5h-3v-2.1c5.363,-0.731 9.5,-5.331 9.5,-10.9v-2.5c0,-0.831 -0.669,-1.5 -1.5,-1.5s-1.5,0.669 -1.5,1.5v1.5z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="22dp"
+    android:height="32dp"
+    android:viewportWidth="22"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M22.292,14.872c0,-0.836 -0.677,-1.51 -1.51,-1.51 -0.836,0 -1.51,0.677 -1.51,1.51 0,2.977 -0.714,5.435 -2.159,7.076 -1.31,1.484 -3.289,2.341 -5.964,2.341s-4.654,-0.854 -5.964,-2.339c-1.448,-1.641 -2.159,-4.099 -2.159,-7.078 0,-0.836 -0.677,-1.51 -1.51,-1.51 -0.836,0 -1.51,0.677 -1.51,1.51 0,3.711 0.961,6.857 2.914,9.073 1.438,1.63 3.375,2.734 5.815,3.164v2.479h-3.703c-0.661,0 -1.203,0.542 -1.203,1.203v1.206h14.646v-1.206c0,-0.661 -0.542,-1.203 -1.203,-1.203h-3.711v-2.479c2.44,-0.432 4.375,-1.534 5.815,-3.167 1.953,-2.214 2.917,-5.359 2.917,-9.07v0,0zM11.146,0c3.083,0 5.604,2.523 5.604,5.604v0.146h-3.013v3.57h3.016v1.818h-3.016v3.57h3.016v1.284c0,3.083 -2.523,5.604 -5.604,5.604 -3.083,0 -5.604,-2.523 -5.604,-5.604v-1.284h3.016v-3.57h-3.018v-1.818h3.016v-3.57h-3.016v-0.146c0,-3.081 2.521,-5.604 5.604,-5.604v0z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="32dp"
+    android:height="32dp"
+    android:viewportWidth="32"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M15,22c2.761,0 5,-2.239 5,-5v-12c0,-2.761 -2.239,-5 -5,-5s-5,2.239 -5,5v12c0,2.761 2.239,5 5,5zM22,14v3c0,3.866 -3.134,7 -7,7s-7,-3.134 -7,-7v-3h-2v3c0,4.632 3.5,8.447 8,8.944v4.056h-4v2h10v-2h-4v-4.056c4.5,-0.497 8,-4.312 8,-8.944v-3h-2z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="32dp"
+    android:height="32dp"
+    android:viewportWidth="32"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M30,0h2v23c0,2.761 -3.134,5 -7,5s-7,-2.239 -7,-5c0,-2.761 3.134,-5 7,-5 1.959,0 3.729,0.575 5,1.501v-11.501l-16,3.556v15.444c0,2.761 -3.134,5 -7,5s-7,-2.239 -7,-5c0,-2.761 3.134,-5 7,-5 1.959,0 3.729,0.575 5,1.501v-19.501l18,-4z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="33dp"
+    android:height="32dp"
+    android:viewportWidth="33"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M18.289,18.549v13.45h-3.973v-13.45c-1.305,-0.706 -2.191,-2.087 -2.191,-3.676 0,-2.307 1.871,-4.178 4.178,-4.178s4.178,1.871 4.178,4.178c0,1.589 -0.887,2.97 -2.192,3.676v0zM10.434,2.963c0.774,-0.382 1.091,-1.319 0.709,-2.091s-1.318,-1.091 -2.091,-0.71c-3.158,1.558 -5.613,4.134 -7.165,7.169 -1.146,2.241 -1.8,4.734 -1.879,7.251 -0.079,2.538 0.421,5.101 1.585,7.46 1.433,2.906 3.863,5.491 7.44,7.322 0.767,0.392 1.706,0.088 2.098,-0.679s0.088,-1.706 -0.679,-2.097c-2.929,-1.498 -4.905,-3.589 -6.059,-5.926 -0.93,-1.887 -1.33,-3.942 -1.267,-5.981 0.064,-2.058 0.599,-4.098 1.536,-5.93 1.256,-2.455 3.234,-4.536 5.771,-5.786v0zM23.554,0.161c-0.773,-0.382 -1.71,-0.064 -2.091,0.71s-0.064,1.71 0.71,2.091c2.537,1.251 4.515,3.332 5.771,5.787 0.937,1.832 1.472,3.871 1.536,5.93 0.064,2.038 -0.336,4.094 -1.267,5.981 -1.153,2.337 -3.13,4.428 -6.059,5.926 -0.767,0.392 -1.07,1.331 -0.679,2.097s1.331,1.071 2.098,0.679c3.577,-1.83 6.007,-4.415 7.44,-7.322 1.164,-2.359 1.664,-4.922 1.585,-7.46 -0.079,-2.516 -0.732,-5.01 -1.878,-7.251 -1.552,-3.034 -4.008,-5.611 -7.165,-7.169v0zM21.968,7.033c-0.582,-0.42 -1.395,-0.287 -1.814,0.295s-0.287,1.395 0.295,1.814c0.235,0.169 0.465,0.359 0.691,0.566 1.319,1.216 2.101,2.838 2.266,4.553 0.166,1.731 -0.295,3.566 -1.464,5.188 -0.198,0.276 -0.427,0.555 -0.686,0.836 -0.487,0.529 -0.453,1.353 0.076,1.839s1.353,0.452 1.84,-0.076c0.313,-0.339 0.607,-0.701 0.88,-1.081 1.555,-2.16 2.167,-4.617 1.943,-6.951 -0.225,-2.349 -1.293,-4.566 -3.091,-6.224 -0.283,-0.261 -0.595,-0.514 -0.935,-0.76v0zM12.156,9.143c0.582,-0.42 0.715,-1.232 0.295,-1.814s-1.232,-0.715 -1.814,-0.296c-0.341,0.246 -0.652,0.499 -0.935,0.76 -1.799,1.658 -2.866,3.875 -3.091,6.224 -0.224,2.334 0.387,4.792 1.943,6.952 0.274,0.379 0.567,0.741 0.88,1.08 0.487,0.529 1.311,0.563 1.839,0.076s0.563,-1.311 0.076,-1.839c-0.259,-0.281 -0.487,-0.56 -0.686,-0.836 -1.169,-1.623 -1.63,-3.457 -1.464,-5.188 0.164,-1.715 0.947,-3.337 2.266,-4.553 0.226,-0.207 0.456,-0.397 0.691,-0.566v0z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="32dp"
+    android:height="32dp"
+    android:viewportWidth="32"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M30.925,2.938c0.794,-0.231 1.25,-1.069 1.019,-1.863s-1.069,-1.25 -1.869,-1.012l-26.844,7.869c-0.587,0.169 -1.119,0.456 -1.569,0.825 -1.006,0.725 -1.663,1.906 -1.663,3.244v16c0,2.206 1.794,4 4,4h24c2.206,0 4,-1.794 4,-4v-16c0,-2.206 -1.794,-4 -4,-4h-14.344l17.269,-5.063zM23,25c-2.762,0 -5,-2.238 -5,-5s2.238,-5 5,-5 5,2.238 5,5 -2.238,5 -5,5zM5,16c0,-0.55 0.45,-1 1,-1h6c0.55,0 1,0.45 1,1s-0.45,1 -1,1h-6c-0.55,0 -1,-0.45 -1,-1zM4,20c0,-0.55 0.45,-1 1,-1h8c0.55,0 1,0.45 1,1s-0.45,1 -1,1h-8c-0.55,0 -1,-0.45 -1,-1zM5,24c0,-0.55 0.45,-1 1,-1h6c0.55,0 1,0.45 1,1s-0.45,1 -1,1h-6c-0.55,0 -1,-0.45 -1,-1z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="32dp"
+    android:height="32dp"
+    android:viewportWidth="32"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M22,2l-10,10h-6l-6,8c0,0 6.357,-1.77 10.065,-0.94l-10.065,12.94 13.184,-10.255c1.839,4.208 -1.184,10.255 -1.184,10.255l8,-6v-6l10,-10 2,-10 -10,2z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="32dp"
+    android:height="32dp"
+    android:viewportWidth="32"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M4.259,23.467c-2.35,0 -4.259,1.917 -4.259,4.252 0,2.349 1.909,4.244 4.259,4.244 2.358,0 4.265,-1.895 4.265,-4.244 -0,-2.336 -1.907,-4.252 -4.265,-4.252zM0.005,10.873v6.133c3.993,0 7.749,1.562 10.577,4.391 2.825,2.822 4.384,6.595 4.384,10.603h6.16c-0,-11.651 -9.478,-21.127 -21.121,-21.127zM0.012,0v6.136c14.243,0 25.836,11.604 25.836,25.864h6.152c0,-17.64 -14.352,-32 -31.988,-32z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="32dp"
+    android:height="32dp"
+    android:viewportWidth="32"
+    android:viewportHeight="32">
+  <path
+      android:pathData="M32,12.408l-11.056,-1.607 -4.944,-10.018 -4.944,10.018 -11.056,1.607 8,7.798 -1.889,11.011 9.889,-5.199 9.889,5.199 -1.889,-11.011 8,-7.798z"
+      android:fillColor="#fff"/>
+</vector>
@@ -0,0 +1 @@
+<!-- drawable/account_outline.xml --><vector xmlns:android="http://schemas.android.com/apk/res/android" android:height="24dp" android:width="24dp" android:viewportWidth="24" android:viewportHeight="24"><path android:fillColor="#FFFFFF" android:pathData="M12,4A4,4 0 0,1 16,8A4,4 0 0,1 12,12A4,4 0 0,1 8,8A4,4 0 0,1 12,4M12,6A2,2 0 0,0 10,8A2,2 0 0,0 12,10A2,2 0 0,0 14,8A2,2 0 0,0 12,6M12,13C14.67,13 20,14.33 20,17V20H4V17C4,14.33 9.33,13 12,13M12,14.9C9.03,14.9 5.9,16.36 5.9,17V18.1H18.1V17C18.1,16.36 14.97,14.9 12,14.9Z" /></vector>
@@ -0,0 +1 @@
+<!-- drawable/book_multiple_outline.xml --><vector xmlns:android="http://schemas.android.com/apk/res/android" android:height="24dp" android:width="24dp" android:viewportWidth="24" android:viewportHeight="24"><path android:fillColor="#FFFFFF" android:pathData="M19 2A2 2 0 0 1 21 4V16A2 2 0 0 1 19 18H9A2 2 0 0 1 7 16V4A2 2 0 0 1 9 2H19M19 4H16V10L13.5 7.75L11 10V4H9V16H19M3 20A2 2 0 0 0 5 22H17V20H5V6H3Z" /></vector>
				`@@ -0,0 +1 @@`
				`<!-- drawable/clock_outline.xml --><vector xmlns:android="http://schemas.android.com/apk/res/android" android:height="24dp" android:width="24dp" android:viewportWidth="24" android:viewportHeight="24"><path android:fillColor="#FFFFFF" android:pathData="M12,20A8,8 0 0,0 20,12A8,8 0 0,0 12,4A8,8 0 0,0 4,12A8,8 0 0,0 12,20M12,2A10,10 0 0,1 22,12A10,10 0 0,1 12,22C6.47,22 2,17.5 2,12A10,10 0 0,1 12,2M12.5,7V12.25L17,14.92L16.25,16.15L11,13V7H12.5Z" /></vector>`
				`@@ -0,0 +1 @@`
				<!-- drawable/account_outline.xml --><vector xmlns:android="http://schemas.android.com/apk/res/android" android:height="24dp" android:width="24dp" android:viewportWidth="24" android:viewportHeight="24"><path android:fillColor="#FFFFFF" android:pathData="M12,4A4,4 0 0,1 16,8A4,4 0 0,1 12,12A4,4 0 0,1 8,8A4,4 0 0,1 12,4M12,6A2,2 0 0,0 10,8A2,2 0 0,0 12,10A2,2 0 0,0 14,8A2,2 0 0,0 12,6M12,13C14.67,13 20,14.33 20,17V20H4V17C4,14.33 9.33,13 12,13M12,14.9C9.03,14.9 5.9,16.36 5.9,17V18.1H18.1V17C18.1,16.36 14.97,14.9 12,14.9Z" /></vector>
				`@@ -0,0 +1 @@`
				`<!-- drawable/book_multiple_outline.xml --><vector xmlns:android="http://schemas.android.com/apk/res/android" android:height="24dp" android:width="24dp" android:viewportWidth="24" android:viewportHeight="24"><path android:fillColor="#FFFFFF" android:pathData="M19 2A2 2 0 0 1 21 4V16A2 2 0 0 1 19 18H9A2 2 0 0 1 7 16V4A2 2 0 0 1 9 2H19M19 4H16V10L13.5 7.75L11 10V4H9V16H19M3 20A2 2 0 0 0 5 22H17V20H5V6H3Z" /></vector>`