Bump iOS build number

Fix crash on cleanExpiredLogs for iOS
Merge pull request #2019 from nichwall/ios-workflow
2026-11-13 12:23:47 +01:00 · 2026-09-11 16:06:49 -05:00 · 2026-09-11 15:57:59 -05:00 · 2026-09-11 15:00:22 -05:00 · 2026-09-11 06:43:42 -07:00 · 2026-09-11 06:38:58 -07:00
558 changed files with 63945 additions and 19463 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.0'
+        - 'iOS App - 0.14.0'
+        - 'Android App - 0.13.0'
+        - 'iOS App - 0.13.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.0'
+        - 'iOS App - 0.14.0'
+        - 'Android App - 0.13.0'
+        - 'iOS App - 0.13.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. -->
@@ -0,0 +1,81 @@
+<!DOCTYPE html>
+<html lang=en>
+<head>
+<meta http-equiv=content-type content="text/html; charset=utf-8" />
+<meta name=viewport content="width=device-width, initial-scale=1">
+<title>Audiobookshelf :: Testers</title>
+<style>
+body {
+  background-color: rgb(55, 56, 56);
+  font-family: Sans;
+  margin: 40px auto;
+  max-width: 500px;
+  color: #ddd;
+  text-align: center;
+  padding: 5px;
+}
+img {
+    width: 100px;
+}
+h1 {
+  font-weight: 100;
+}
+a {
+  color: #fff;
+}
+#apk {
+  display: grid;
+  grid-template-columns: auto auto;
+  justify-content: center;
+  column-gap: 15px;
+  text-align: left;
+  font-family: monospace;
+  background-color: #222;
+  padding: 20px;
+  border-radius: 5px;
+}
+</style>
+</head>
+<body>
+
+  <a href="https://audiobookshelf.org">
+    <img src=logo.png />
+  </a>
+	<h1>Audiobookshelf :: Testers</h1>
+
+  <p>
+  Here you can download the latest version of Audiobookshelf for Android for <b>testing</b>.
+  The app is automatically built for every new patch added to the project.
+  </p>
+
+  <div id=apk>
+    <div>Built on</div>
+    <div>__DATE__</div>
+
+    <div>Git commit</div>
+    <a href="https://github.com/advplyr/audiobookshelf-app/commit/__COMMIT__">__COMMIT__</a>
+
+    <div>Download</div>
+    <a href="__APK__">__APK__</a>
+  </div>
+
+  <p>
+  Using this requires some technical knowledge to install the APK manually.
+  Regular users should use the releases published on the <a href="https://play.google.com/store/apps/details?id=com.audiobookshelf.app">Play Store</a>.
+  </p>
+
+  <hr />
+
+  <p>Report bugs, request features, provide feedback, and contribute on <a href="https://github.com/advplyr/audiobookshelf-app/issues">GitHub</a></p>
+  <p>
+    <a href="https://github.com/advplyr/audiobookshelf-app/issues">
+      <svg xmlns="http://www.w3.org/2000/svg" fill="currentColor" width=32 height=32 viewBox="0 0 24 24">
+        <path
+          d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.23.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"
+        />
+      </svg>
+    </a>
+  </div>
+
+</body>
+</html>
@@ -0,0 +1,53 @@
+name: Build APK
+
+on:
+  push:
+    paths-ignore:
+      - 'ios/**'
+      - 'readme.md'
+  pull_request:
+    paths-ignore:
+      - 'ios/**'
+      - 'readme.md'
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout sources
+        uses: actions/checkout@v3
+
+      - 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: 21
+
+      - name: install dependencies
+        run: npm ci --omit=optional
+
+      - name: build Nuxt project
+        run: npm run generate
+
+      - name: copy to Android project
+        run: npx cap sync
+
+      - 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: 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"
+              });
+            }
@@ -0,0 +1,82 @@
+name: Publish Test App
+
+on:
+  push:
+    branches:
+      - master
+    paths-ignore:
+      - 'ios/**'
+      - 'readme.md'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout sources
+        uses: actions/checkout@v3
+
+      - 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: 21
+
+      - name: install dependencies
+        run: npm ci --omit=optional
+
+      - name: build Nuxt project
+        run: npm run generate
+
+      - name: copy to Android project
+        run: npx cap sync
+
+      - 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: 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: upload test page artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: ./ghpages
+
+  deploy:
+    needs: build
+
+    permissions:
+      pages: write
+      id-token: write
+
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+
+    runs-on: ubuntu-latest
+    steps:
+      - name: deploy to GitHub Pages
+        id: deployment
+        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,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,71 +18,82 @@ 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 {
-    kotlinOptions {
-      freeCompilerArgs = ['-Xjvm-default=all']
+  namespace 'com.audiobookshelf.app'
+  buildFeatures {
+    viewBinding true
+    buildConfig true
+  }
+  kotlinOptions {
+    freeCompilerArgs = ['-Xjvm-default=all']
+  }
+  compileSdk rootProject.ext.compileSdkVersion
+  defaultConfig {
+    applicationId "com.audiobookshelf.app"
+    minSdkVersion rootProject.ext.minSdkVersion
+    targetSdkVersion rootProject.ext.targetSdkVersion
+    versionCode 120
+    versionName "0.14.1-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 73
-        versionName "0.9.44-beta"
-        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
-        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 {
-        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()
 }

-configurations.all {
+configurations.configureEach {
  resolutionStrategy {
    force("com.google.android.gms:play-services-base:18.0.1")
    force("androidx.appcompat:appcompat:$androidxAppCompatVersion")
    force("androidx.core:core-ktx:$androidx_core_ktx_version")
-    force("org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version")
    force("androidx.media:media:$androidx_media_version")
    force("org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version")
    force("org.jetbrains.kotlinx:kotlinx-coroutines-android:$kotlin_coroutines_version")
-
-//    failOnVersionConflict()
  }
 }

 dependencies {
+  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.3'
+  implementation 'androidx.constraintlayout:constraintlayout:2.2.1'
  implementation "androidx.coordinatorlayout:coordinatorlayout:$androidxCoordinatorLayoutVersion"

-//  testImplementation "junit:junit:$junitVersion"
-//  androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
-//  androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
  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"

@@ -105,22 +116,18 @@ dependencies {

  // Glide for images
  implementation "com.github.bumptech.glide:glide:$glide_version"
-  kapt "com.github.bumptech.glide:compiler:$glide_version"

  // Paper NoSQL Db
  implementation 'io.github.pilgr:paperdb:2.7.2'

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

  // OK HTTP
  implementation 'com.squareup.okhttp3:okhttp:4.9.2'

  // Jackson for JSON
-  implementation 'com.fasterxml.jackson.module:jackson-module-kotlin:2.12.1'
-
-  // FFMPEG-Kit
-  implementation 'com.arthenica:ffmpeg-kit-min:4.5.1'
+  implementation 'com.fasterxml.jackson.module:jackson-module-kotlin:2.12.2'
 }

 apply from: 'capacitor.build.gradle'
@@ -2,20 +2,24 @@

 android {
  compileOptions {
-      sourceCompatibility JavaVersion.VERSION_1_8
-      targetCompatibility JavaVersion.VERSION_1_8
+      sourceCompatibility JavaVersion.VERSION_17
+      targetCompatibility JavaVersion.VERSION_17
  }
 }

 apply from: "../capacitor-cordova-android-plugins/cordova.variables.gradle"
 dependencies {
+    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')
    implementation project(':capacitor-dialog')
    implementation project(':capacitor-haptics')
    implementation project(':capacitor-network')
+    implementation project(':capacitor-preferences')
    implementation project(':capacitor-status-bar')
-    implementation project(':capacitor-storage')
-    implementation project(':robingenz-capacitor-app-update')

 }

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@mipmap/ic_launcher_background"/>
+    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+    <monochrome android:drawable="@mipmap/ic_launcher_foreground"/>
+</adaptive-icon>
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@mipmap/ic_launcher_background"/>
+    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+    <monochrome android:drawable="@mipmap/ic_launcher_foreground"/>
+</adaptive-icon>
@@ -0,0 +1,14 @@
+<?xml version='1.0' encoding='utf-8'?>
+<resources>
+    <string name="app_name">Audiobookshelf</string>
+    <string name="title_activity_main">Audiobookshelf</string>
+    <string name="package_name">com.audiobookshelf.app</string>
+    <string name="custom_url_scheme">audiobookshelf</string>
+    <string name="add_widget">Add widget</string>
+    <string name="app_widget_description">Simple widget for audiobookshelf playback</string>
+    <string name="action_jump_forward">Jump Forward</string>
+    <string name="action_jump_backward">Jump Backward</string>
+    <string name="action_skip_forward">Skip Forward</string>
+    <string name="action_skip_backward">Skip Backward</string>
+    <string name="action_change_speed">Change Playback Speed</string>
+</resources>
@@ -1,82 +1,120 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-  xmlns:dist="http://schemas.android.com/apk/distribution"
-  xmlns:tools="http://schemas.android.com/tools"
-  package="com.audiobookshelf.app">
+    xmlns:dist="http://schemas.android.com/apk/distribution"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:installLocation="preferExternal" >

    <!-- 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.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"
        android:icon="@mipmap/ic_launcher"
-        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
+        android:label="@string/app_name"
+        android:networkSecurityConfig="@xml/network_security_config"
+        android:requestLegacyExternalStorage="true"
        android:supportsRtl="true"
        android:theme="@style/AppTheme"
        android:usesCleartextTraffic="true"
-        android:networkSecurityConfig="@xml/network_security_config"
-        android:requestLegacyExternalStorage="true">
+        android:largeHeap="true" >

+        <!-- Android app widget -->
+        <receiver
+          android:name="MediaPlayerWidget"
+          android:exported="false">
+          <intent-filter>
+            <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
+          </intent-filter>

-        <!--Used by Android Auto-->
-        <meta-data android:name="com.google.android.gms.car.notification.SmallIcon"
-          android:resource="@drawable/icon" />
+          <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 -->
        <meta-data
-          android:name="com.google.android.gms.car.application"
-          android:resource="@xml/automotive_app_desc"/>
-
-        <!-- Support for Cast -->
-        <meta-data android:name="com.google.android.gms.cast.framework.OPTIONS_PROVIDER_CLASS_NAME"
-          android:value="com.audiobookshelf.app.CastOptionsProvider"/>
+            android:name="com.google.android.gms.car.notification.SmallIcon"
+            android:resource="@drawable/icon" />
+        <meta-data
+            android:name="com.google.android.gms.car.application"
+            android:resource="@xml/automotive_app_desc" /> <!-- Support for Cast -->
+        <meta-data
+            android:name="com.google.android.gms.cast.framework.OPTIONS_PROVIDER_CLASS_NAME"
+            android:value="com.audiobookshelf.app.CastOptionsProvider" />

        <activity
-            android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|smallestScreenSize|screenLayout|uiMode"
-            android:name="com.audiobookshelf.app.MainActivity"
-            android:label="@string/title_activity_main"
+            android:name=".MainActivity"
+            android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|smallestScreenSize|screenLayout|uiMode|navigation"
            android:exported="true"
-            android:theme="@style/AppTheme.NoActionBarLaunch"
-            android:launchMode="singleTask">
+            android:label="@string/title_activity_main"
+            android:launchMode="singleTask"
+            android:theme="@style/AppTheme.NoActionBarLaunch" >
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />

-          <intent-filter>
-              <action android:name="android.intent.action.MAIN" />
-              <category android:name="android.intent.category.LAUNCHER" />
-          </intent-filter>
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.media.action.MEDIA_PLAY_FROM_SEARCH" />

-          <intent-filter>
-            <action android:name="android.media.action.MEDIA_PLAY_FROM_SEARCH" />
-            <category android:name="android.intent.category.DEFAULT" />
-          </intent-filter>
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>

-          <!-- Register URL scheme -->
-          <intent-filter>
-            <action android:name="android.intent.action.VIEW" />
-            <category android:name="android.intent.category.DEFAULT" />
-            <category android:name="android.intent.category.BROWSABLE" />
-            <data android:scheme="@string/custom_url_scheme" />
-          </intent-filter>
+            <!-- Register URL scheme -->
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data android:scheme="@string/custom_url_scheme" />
+            </intent-filter>
        </activity>

+        <receiver android:name="androidx.media.session.MediaButtonReceiver" android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MEDIA_BUTTON" />
+            </intent-filter>
+        </receiver>

-      <receiver android:name="androidx.media.session.MediaButtonReceiver" >
-        <intent-filter>
-          <action android:name="android.intent.action.MEDIA_BUTTON" />
-        </intent-filter>
-      </receiver>
+        <service
+            android:name=".player.PlayerNotificationService"
+            android:enabled="true"
+            android:exported="true"
+            android:foregroundServiceType="mediaPlayback">
+            <intent-filter>
+                <action android:name="android.media.browse.MediaBrowserService" />
+            </intent-filter>
+        </service>

-      <service
-        android:exported="true"
-        android:enabled="true"
-        android:name=".player.PlayerNotificationService">
-        <intent-filter>
-          <action android:name="android.media.browse.MediaBrowserService"/>
-        </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"
+          android:grantUriPermissions="true"
+          android:exported="false">
+          <meta-data
+            android:name="android.support.FILE_PROVIDER_PATHS"
+            android:resource="@xml/file_paths" />
+        </provider>
    </application>

 </manifest>
@@ -2,5 +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,28 @@
 [
+	{
+		"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"
 	},
+	{
+		"pkg": "@capacitor/browser",
+		"classpath": "com.capacitorjs.plugins.browser.BrowserPlugin"
+	},
+	{
+		"pkg": "@capacitor/clipboard",
+		"classpath": "com.capacitorjs.plugins.clipboard.ClipboardPlugin"
+	},
 	{
 		"pkg": "@capacitor/dialog",
 		"classpath": "com.capacitorjs.plugins.dialog.DialogPlugin"
@@ -15,16 +35,12 @@
 		"pkg": "@capacitor/network",
 		"classpath": "com.capacitorjs.plugins.network.NetworkPlugin"
 	},
+	{
+		"pkg": "@capacitor/preferences",
+		"classpath": "com.capacitorjs.plugins.preferences.PreferencesPlugin"
+	},
 	{
 		"pkg": "@capacitor/status-bar",
 		"classpath": "com.capacitorjs.plugins.statusbar.StatusBarPlugin"
-	},
-	{
-		"pkg": "@capacitor/storage",
-		"classpath": "com.capacitorjs.plugins.storage.StoragePlugin"
-	},
-	{
-		"pkg": "@robingenz/capacitor-app-update",
-		"classpath": "dev.robingenz.capacitor.appupdate.AppUpdatePlugin"
 	}
 ]
@@ -1,21 +1,30 @@
 package com.audiobookshelf.app

 import android.Manifest
-import android.app.DownloadManager
-import android.content.*
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
 import android.content.pm.PackageManager
-import android.os.*
+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.data.AbsDatabase
+import com.audiobookshelf.app.managers.DbManager
 import com.audiobookshelf.app.player.PlayerNotificationService
 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
-import io.paperdb.Paper


 class MainActivity : BridgeActivity() {
@@ -31,45 +40,76 @@ 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())
-
-    super.onCreate(savedInstanceState)
-
-    Log.d(tag, "onCreate")
-
-    // Grant full storage access for testing
-    // var ss = SimpleStorage(this)
-    // ss.requestFullStorageAccess()
-
-    var permission = ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE)
-    if (permission != PackageManager.PERMISSION_GRANTED) {
-      ActivityCompat.requestPermissions(this,
-        PERMISSIONS_ALL,
-        REQUEST_PERMISSIONS)
-    }
+    DbManager.initialize(applicationContext)

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

-    Paper.init(applicationContext)
+    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)
+
+      // 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)
+    }
  }

  override fun onDestroy() {
@@ -94,9 +134,7 @@ class MainActivity : BridgeActivity() {
        foregroundService = mLocalBinder.getService()

        // Let NativeAudio know foreground service is ready and setup event listener
-        if (pluginCallback != null) {
-          pluginCallback()
-        }
+        pluginCallback()
      }
    }

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

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

  fun stopMyService() {
    if (mBounded) {
@@ -119,6 +160,7 @@ class MainActivity : BridgeActivity() {
  override fun onSaveInstanceState(outState: Bundle) {
    storageHelper.onSaveInstanceState(outState)
    super.onSaveInstanceState(outState)
+    outState.clear()
  }

  override fun onRestoreInstanceState(savedInstanceState: Bundle) {
@@ -140,9 +182,4 @@ class MainActivity : BridgeActivity() {
    // Mandatory for Activity, but not for Fragment & ComponentActivity
    storageHelper.onRequestPermissionsResult(requestCode, permissions, grantResults)
  }
-
-//  override fun onUserInteraction() {
-//    super.onUserInteraction()
-//    Log.d(tag, "USER INTERACTION")
-//  }
 }
@@ -0,0 +1,103 @@
+package com.audiobookshelf.app
+
+import android.app.PendingIntent
+import android.appwidget.AppWidgetManager
+import android.appwidget.AppWidgetProvider
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.net.Uri
+import android.support.v4.media.session.PlaybackStateCompat
+import android.util.Log
+import android.view.View
+import android.widget.RemoteViews
+import androidx.media.session.MediaButtonReceiver
+import com.audiobookshelf.app.data.PlaybackSession
+import com.audiobookshelf.app.device.DeviceManager
+import com.audiobookshelf.app.managers.DbManager
+import com.bumptech.glide.Glide
+import com.bumptech.glide.request.RequestOptions
+import com.bumptech.glide.request.target.AppWidgetTarget
+import com.bumptech.glide.request.transition.Transition
+
+/**
+ * Implementation of App Widget functionality.
+ */
+class MediaPlayerWidget : AppWidgetProvider() {
+  val tag = "MediaPlayerWidget"
+  override fun onUpdate(context: Context, appWidgetManager: AppWidgetManager, appWidgetIds: IntArray) {
+    Log.d(tag, "onUpdate $appWidgetIds")
+  }
+
+  override fun onEnabled(context: Context) {
+    Log.i(tag, "onEnabled check context ${context.packageName}")
+
+    DbManager.initialize(context)
+
+    DeviceManager.deviceData.lastPlaybackSession?.let {
+      val appWidgetManager = AppWidgetManager.getInstance(context)
+      val componentName = ComponentName(context, MediaPlayerWidget::class.java)
+      val ids = appWidgetManager.getAppWidgetIds(componentName)
+      Log.d(tag, "Setting initial widget state with last playback session ${it.displayTitle}")
+      for (widgetId in ids) {
+        updateAppWidget(context, appWidgetManager, widgetId, it, false, true)
+      }
+    }
+
+    // Enter relevant functionality for when the first widget is created
+    DeviceManager.initializeWidgetUpdater(context)
+  }
+}
+
+internal fun updateAppWidget(context: Context, appWidgetManager: AppWidgetManager, appWidgetId: Int, playbackSession: PlaybackSession?, isPlaying:Boolean, isAppClosed:Boolean) {
+  val tag = "MediaPlayerWidget"
+  val views = RemoteViews(context.packageName, R.layout.media_player_widget)
+  Log.i(tag, "updateAppWidget ${playbackSession?.displayTitle ?: "No Title"} isPlaying=$isPlaying isAppClosed=$isAppClosed")
+  val wholeWidgetClickI = Intent(context, MainActivity::class.java)
+  wholeWidgetClickI.flags = Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_NEW_TASK
+  val wholeWidgetClickPI = PendingIntent.getActivity(
+    context,
+    System.currentTimeMillis().toInt(),
+    wholeWidgetClickI,
+    PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+  )
+
+  val playPausePI = MediaButtonReceiver.buildMediaButtonPendingIntent(context, PlaybackStateCompat.ACTION_PLAY_PAUSE)
+  views.setOnClickPendingIntent(R.id.widgetPlayPauseButton, playPausePI)
+
+  val fastForwardPI = MediaButtonReceiver.buildMediaButtonPendingIntent(context, PlaybackStateCompat.ACTION_FAST_FORWARD)
+  views.setOnClickPendingIntent(R.id.widgetFastForwardButton, fastForwardPI)
+
+  val rewindPI = MediaButtonReceiver.buildMediaButtonPendingIntent(context, PlaybackStateCompat.ACTION_REWIND)
+  views.setOnClickPendingIntent(R.id.widgetRewindButton, rewindPI)
+
+  // Show/Hide button container
+  views.setViewVisibility(R.id.widgetButtonContainer, if (isAppClosed) View.GONE else View.VISIBLE)
+
+  views.setOnClickPendingIntent(R.id.widgetBackground, wholeWidgetClickPI)
+
+  val imageUri = playbackSession?.getCoverUri(context) ?: Uri.parse("android.resource://${BuildConfig.APPLICATION_ID}/" + R.drawable.icon)
+  val awt: AppWidgetTarget = object : AppWidgetTarget(context.applicationContext, R.id.widgetAlbumArt, views, appWidgetId) {
+    override fun onResourceReady(resource: Bitmap, transition: Transition<in Bitmap>?) {
+      super.onResourceReady(resource, transition)
+    }
+  }
+
+  val artist = playbackSession?.displayAuthor ?: "Unknown"
+  views.setTextViewText(R.id.widgetArtistText, artist)
+
+  val title = playbackSession?.displayTitle ?: "Unknown"
+  views.setTextViewText(R.id.widgetMediaTitle, title)
+
+  val options = RequestOptions().override(300, 300).placeholder(R.drawable.icon).error(R.drawable.icon)
+  Glide.with(context.applicationContext).asBitmap().load(imageUri).apply(options).into(awt)
+
+  Log.i(tag, "Update App Widget | Is Playing=$isPlaying | isAppClosed=$isAppClosed")
+
+  val playPauseResource = if (isPlaying) androidx.mediarouter.R.drawable.ic_media_pause_dark else androidx.mediarouter.R.drawable.ic_media_play_dark
+  views.setImageViewResource(R.id.widgetPlayPauseButton, playPauseResource)
+
+  // Instruct the widget manager to update the widget
+  appWidgetManager.updateAppWidget(appWidgetId, views)
+}
@@ -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() }
-  }
-}
@@ -0,0 +1,38 @@
+package com.audiobookshelf.app.data
+
+import com.fasterxml.jackson.annotation.JsonIgnore
+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?,
+        // 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()
+  @get:JsonIgnore
+  val durationMs
+    get() = (duration * 1000L).toLong()
+  @get:JsonIgnore
+  val endOffsetMs
+    get() = startOffsetMs + durationMs
+  @get:JsonIgnore
+  val relPath
+    get() = metadata?.relPath ?: ""
+
+  @JsonIgnore
+  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,61 +1,15 @@
 package com.audiobookshelf.app.data

-import android.net.Uri
+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 com.audiobookshelf.app.R
-import com.audiobookshelf.app.device.DeviceManager
+import androidx.media.utils.MediaConstants
+import com.audiobookshelf.app.media.MediaManager
 import com.fasterxml.jackson.annotation.*
-
-@JsonIgnoreProperties(ignoreUnknown = true)
-data class LibraryItem(
-  var id:String,
-  var ino:String,
-  var libraryId:String,
-  var folderId:String,
-  var path:String,
-  var relPath:String,
-  var mtimeMs:Long,
-  var ctimeMs:Long,
-  var birthtimeMs:Long,
-  var addedAt:Long,
-  var updatedAt:Long,
-  var lastScan:Long?,
-  var scanVersion:String?,
-  var isMissing:Boolean,
-  var isInvalid:Boolean,
-  var mediaType:String,
-  var media:MediaType,
-  var libraryFiles:MutableList<LibraryFile>?,
-  var userMediaProgress:MediaProgress? // Only included when requesting library item with progress (for downloads)
-) : LibraryItemWrapper() {
-  @get:JsonIgnore
-  val title get() = media.metadata.title
-  @get:JsonIgnore
-  val authorName get() = media.metadata.getAuthorDisplayName()
-
-  @JsonIgnore
-  fun getCoverUri():Uri {
-    if (media.coverPath == null) {
-      return Uri.parse("android.resource://com.audiobookshelf.app/" + R.drawable.icon)
-    }
-
-    return Uri.parse("${DeviceManager.serverAddress}/api/items/$id/cover?token=${DeviceManager.token}")
-  }
-
-  @JsonIgnore
-  fun getMediaMetadata(): MediaMetadataCompat {
-    return MediaMetadataCompat.Builder().apply {
-      putString(MediaMetadataCompat.METADATA_KEY_MEDIA_ID, id)
-      putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_TITLE, title)
-      putString(MediaMetadataCompat.METADATA_KEY_TITLE, title)
-      putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_SUBTITLE, authorName)
-      putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_ICON_URI, getCoverUri().toString())
-      putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI, getCoverUri().toString())
-      putString(MediaMetadataCompat.METADATA_KEY_ART_URI, getCoverUri().toString())
-      putString(MediaMetadataCompat.METADATA_KEY_AUTHOR, authorName)
-    }.build()
-  }
-}
+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)
@@ -73,7 +27,9 @@ open class MediaType(var metadata:MediaTypeMetadata, var coverPath:String?) {
  @JsonIgnore
  open fun removeAudioTrack(localFileId:String) { }
  @JsonIgnore
-  open fun getLocalCopy():MediaType { return MediaType(MediaTypeMetadata(""),null) }
+  open fun getLocalCopy():MediaType { return MediaType(MediaTypeMetadata("", false),null) }
+  @JsonIgnore
+  open fun checkHasTracks():Boolean { return false }
 }

@JsonIgnoreProperties(ignoreUnknown = true)
@@ -82,7 +38,8 @@ class Podcast(
  coverPath:String?,
  var tags:MutableList<String>,
  var episodes:MutableList<PodcastEpisode>?,
-  var autoDownloadEpisodes:Boolean
+  var autoDownloadEpisodes:Boolean,
+  var numEpisodes:Int?
 ) : MediaType(metadata, coverPath) {
  @JsonIgnore
  override fun getAudioTracks():List<AudioTrack> {
@@ -99,7 +56,8 @@ class Podcast(
    // Add new episodes
    audioTracks.forEach { at ->
      if (episodes?.find{ it.audioTrack?.localFileId == at.localFileId } == null) {
-        val newEpisode = PodcastEpisode("local_" + at.localFileId,episodes?.size ?: 0 + 1,null,null,at.title,null,null,null,at,at.duration,0, null)
+        val localEpisodeId = "local_ep_" + at.localFileId
+        val newEpisode = PodcastEpisode(localEpisodeId,(episodes?.size ?: 0) + 1,null,null,at.title,null,null,null, null, null, at,null,at.duration,0, null, localEpisodeId)
        episodes?.add(newEpisode)
      }
    }
@@ -112,7 +70,8 @@ class Podcast(
  }
  @JsonIgnore
  override fun addAudioTrack(audioTrack:AudioTrack) {
-    val newEpisode = PodcastEpisode("local_" + audioTrack.localFileId,episodes?.size ?: 0 + 1,null,null,audioTrack.title,null,null,null,audioTrack,audioTrack.duration,0, null)
+    val localEpisodeId = "local_ep_" + audioTrack.localFileId
+    val newEpisode = PodcastEpisode(localEpisodeId,(episodes?.size ?: 0) + 1,null,null,audioTrack.title,null,null,null, null, null,audioTrack,null,audioTrack.duration,0, null, localEpisodeId)
    episodes?.add(newEpisode)

    var index = 1
@@ -131,9 +90,22 @@ class Podcast(
      index++
    }
  }
+
+  // Used for FolderScanner local podcast item to get copy of Podcast excluding episodes
+  @JsonIgnore
+  override fun getLocalCopy(): 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 newEpisode = PodcastEpisode("local_" + episode.id,episodes?.size ?: 0 + 1,episode.episode,episode.episodeType,episode.title,episode.subtitle,episode.description,null,audioTrack,audioTrack.duration,0, episode.id)
+    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,episode.size, episode.id, localEpisodeId)
    episodes?.add(newEpisode)

    var index = 1
@@ -144,10 +116,14 @@ class Podcast(
    return newEpisode
  }

-  // Used for FolderScanner local podcast item to get copy of Podcast excluding episodes
  @JsonIgnore
-  override fun getLocalCopy(): Podcast {
-    return Podcast(metadata as PodcastMetadata,coverPath,tags, mutableListOf(),autoDownloadEpisodes)
+  fun getNextUnfinishedEpisode(libraryItemId:String, mediaManager: MediaManager):PodcastEpisode? {
+    val sortedEpisodes = episodes?.sortedByDescending { it.publishedAt }
+    val podcastEpisode = sortedEpisodes?.find { episode ->
+      val progress = mediaManager.serverUserMediaProgress.find { it.libraryItemId == libraryItemId && it.episodeId == episode.id }
+      progress == null || !progress.isFinished
+    }
+    return podcastEpisode
  }
 }

@@ -159,8 +135,10 @@ class Book(
  var audioFiles:List<AudioFile>?,
  var chapters:List<BookChapter>?,
  var tracks:MutableList<AudioTrack>?,
+  var ebookFile: EBookFile?,
  var size:Long?,
-  var duration:Double?
+  var duration:Double?,
+  var numTracks:Int?
 ) : MediaType(metadata, coverPath) {
  @JsonIgnore
  override fun getAudioTracks():List<AudioTrack> {
@@ -170,10 +148,13 @@ class Book(
  override fun setAudioTracks(audioTracks:MutableList<AudioTrack>) {
    tracks = audioTracks
    tracks?.sortBy { it.index }
-    // TODO: Is it necessary to calculate this each time? check if can remove safely
+
    var totalDuration = 0.0
+    var currentStartOffset = 0.0
    tracks?.forEach {
      totalDuration += it.duration
+      it.startOffset = currentStartOffset
+      currentStartOffset += it.duration
    }
    duration = totalDuration
  }
@@ -206,10 +187,14 @@ class Book(
    }
    duration = totalDuration
  }
-
  @JsonIgnore
  override fun getLocalCopy(): Book {
-    return Book(metadata as BookMetadata,coverPath,tags, mutableListOf(),chapters,mutableListOf(),null,null)
+    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
  }
 }

@@ -219,7 +204,7 @@ class Book(
  JsonSubTypes.Type(BookMetadata::class),
  JsonSubTypes.Type(PodcastMetadata::class)
 )
-open class MediaTypeMetadata(var title:String) {
+open class MediaTypeMetadata(var title:String, var explicit:Boolean) {
  @JsonIgnore
  open fun getAuthorDisplayName():String { return "Unknown" }
 }
@@ -238,13 +223,15 @@ class BookMetadata(
  var isbn:String?,
  var asin:String?,
  var language:String?,
-  var explicit:Boolean,
+  explicit:Boolean,
  // In toJSONExpanded
  var authorName:String?,
  var authorNameLF:String?,
  var narratorName:String?,
-  var seriesName:String?
-) : MediaTypeMetadata(title) {
+  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" }
 }
@@ -254,8 +241,9 @@ class PodcastMetadata(
  title:String,
  var author:String?,
  var feedUrl:String?,
-  var genres:MutableList<String>
-) : MediaTypeMetadata(title) {
+  var genres:MutableList<String>,
+  explicit:Boolean
+) : MediaTypeMetadata(title, explicit) {
  @JsonIgnore
  override fun getAuthorDisplayName():String { return author ?: "Unknown" }
 }
@@ -276,12 +264,78 @@ data class PodcastEpisode(
  var title:String?,
  var subtitle:String?,
  var description:String?,
+  var pubDate:String?,
+  var publishedAt:Long?,
  var audioFile:AudioFile?,
  var audioTrack:AudioTrack?,
+  var chapters:List<BookChapter>?,
  var duration:Double?,
  var size:Long?,
-  var serverEpisodeId:String? // For local podcasts to match with server podcasts
-)
+  var serverEpisodeId:String?, // For local podcasts to match with server podcasts
+  var localEpisodeId:String? // For Android Auto server episodes with local copy
+) {
+  @JsonIgnore
+  fun getMediaDescription(libraryItem:LibraryItemWrapper, progress:MediaProgressWrapper?, ctx: Context): MediaDescriptionCompat {
+    val coverUri = if (libraryItem is LocalLibraryItem) {
+      libraryItem.getCoverUri(ctx)
+    } else {
+      (libraryItem as LibraryItem).getCoverUri()
+    }
+
+    val extras = Bundle()
+
+    if (localEpisodeId != 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 {
+      extras.putInt(
+        MediaConstants.DESCRIPTION_EXTRAS_KEY_COMPLETION_STATUS,
+        MediaConstants.DESCRIPTION_EXTRAS_VALUE_COMPLETION_STATUS_NOT_PLAYED
+      )
+    }
+
+    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(subtitle)
+      .setExtras(extras)
+
+    libraryItemDescription.iconBitmap?.let {
+      mediaDescriptionBuilder.setIconBitmap(it)
+    }
+
+    return mediaDescriptionBuilder.build()
+  }
+}

@JsonIgnoreProperties(ignoreUnknown = true)
 data class LibraryFile(
@@ -311,7 +365,37 @@ 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(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, 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)
@@ -320,54 +404,111 @@ data class Folder(
  var fullPath:String
 )

-@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
-) {
-
-  @get:JsonIgnore
-  val startOffsetMs get() = (startOffset * 1000L).toLong()
-  @get:JsonIgnore
-  val durationMs get() = (duration * 1000L).toLong()
-  @get:JsonIgnore
-  val endOffsetMs get() = startOffsetMs + durationMs
-  @get:JsonIgnore
-  val relPath get() = metadata?.relPath ?: ""
-
-  @JsonIgnore
-  fun getBookChapter():BookChapter {
-    return BookChapter(index + 1,startOffset, startOffset + duration, title)
-  }
-}
-
@JsonIgnoreProperties(ignoreUnknown = true)
 data class BookChapter(
  var id:Int,
  var start:Double,
  var end:Double,
  var title:String?
+) {
+  @get:JsonIgnore
+  val startMs get() = (start * 1000L).toLong()
+  @get:JsonIgnore
+  val endMs get() = (end * 1000L).toLong()
+}
+
+@JsonTypeInfo(use= JsonTypeInfo.Id.DEDUCTION, defaultImpl = MediaProgress::class)
+@JsonSubTypes(
+  JsonSubTypes.Type(MediaProgress::class),
+  JsonSubTypes.Type(LocalMediaProgress::class)
+)
+open class MediaProgressWrapper(var isFinished:Boolean, var currentTime:Double, var progress:Double) {
+  open val mediaItemId get() = ""
+}
+
+// Helper class
+data class LibraryItemWithEpisode(
+  var libraryItemWrapper:LibraryItemWrapper,
+  var episode:PodcastEpisode
 )

@JsonIgnoreProperties(ignoreUnknown = true)
-data class MediaProgress(
-  var id:String,
-  var libraryItemId:String,
-  var episodeId:String?,
-  var duration:Double, // seconds
-  var progress:Double, // 0 to 1
-  var currentTime:Double,
-  var isFinished:Boolean,
-  var lastUpdate:Long,
-  var startedAt:Long,
-  var finishedAt:Long?
+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,215 +0,0 @@
-package com.audiobookshelf.app.data
-
-import android.util.Log
-import com.audiobookshelf.app.plugins.AbsDownloader
-import io.paperdb.Paper
-import org.json.JSONObject
-import java.io.File
-
-class DbManager {
-  val tag = "DbManager"
-
-  fun getDeviceData(): DeviceData {
-    return Paper.book("device").read("data") ?: DeviceData(mutableListOf(), null, null)
-  }
-  fun saveDeviceData(deviceData:DeviceData) {
-    Paper.book("device").write("data", deviceData)
-  }
-
-  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)) {
-        localLibraryItems.add(localLibraryItem)
-      }
-    }
-    return localLibraryItems
-  }
-
-  fun getLocalLibraryItemsInFolder(folderId:String):List<LocalLibraryItem> {
-    val localLibraryItems = getLocalLibraryItems()
-    return localLibraryItems.filter {
-      it.folderId == folderId
-    }
-  }
-
-  fun getLocalLibraryItemByLLId(libraryItemId:String):LocalLibraryItem? {
-    return getLocalLibraryItems().find { it.libraryItemId == libraryItemId }
-  }
-
-  fun getLocalLibraryItem(localLibraryItemId:String):LocalLibraryItem? {
-    return Paper.book("localLibraryItems").read(localLibraryItemId)
-  }
-
-  fun removeLocalLibraryItem(localLibraryItemId:String) {
-    Paper.book("localLibraryItems").delete(localLibraryItemId)
-  }
-
-  fun saveLocalLibraryItems(localLibraryItems:List<LocalLibraryItem>) {
-    localLibraryItems.map {
-        Paper.book("localLibraryItems").write(it.id, it)
-      }
-  }
-
-  fun saveLocalLibraryItem(localLibraryItem:LocalLibraryItem) {
-    Paper.book("localLibraryItems").write(localLibraryItem.id, localLibraryItem)
-  }
-
-  fun saveLocalFolder(localFolder:LocalFolder) {
-    Paper.book("localFolders").write(localFolder.id,localFolder)
-  }
-
-  fun getLocalFolder(folderId:String):LocalFolder? {
-    return Paper.book("localFolders").read(folderId)
-  }
-
-  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)
-      }
-    }
-    return localFolders
-  }
-
-  fun removeLocalFolder(folderId:String) {
-    val localLibraryItems = getLocalLibraryItemsInFolder(folderId)
-    localLibraryItems.forEach {
-      Paper.book("localLibraryItems").delete(it.id)
-    }
-    Paper.book("localFolders").delete(folderId)
-  }
-
-  fun saveDownloadItem(downloadItem: AbsDownloader.DownloadItem) {
-    Paper.book("downloadItems").write(downloadItem.id, downloadItem)
-  }
-
-  fun removeDownloadItem(downloadItemId:String) {
-    Paper.book("downloadItems").delete(downloadItemId)
-  }
-
-  fun getDownloadItems():List<AbsDownloader.DownloadItem> {
-    val downloadItems:MutableList<AbsDownloader.DownloadItem> = mutableListOf()
-    Paper.book("downloadItems").allKeys.forEach { downloadItemId ->
-      Paper.book("downloadItems").read<AbsDownloader.DownloadItem>(downloadItemId)?.let {
-        downloadItems.add(it)
-      }
-    }
-    return downloadItems
-  }
-
-  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()
-    Paper.book("localMediaProgress").allKeys.forEach { localMediaProgressId ->
-      Paper.book("localMediaProgress").read<LocalMediaProgress>(localMediaProgressId)?.let {
-        mediaProgress.add(it)
-      }
-    }
-    return mediaProgress
-  }
-  fun removeLocalMediaProgress(localMediaProgressId:String) {
-    Paper.book("localMediaProgress").delete(localMediaProgressId)
-  }
-
-  fun removeAllLocalMediaProgress() {
-    Paper.book("localMediaProgress").destroy()
-  }
-
-  // Make sure all local file ids still exist
-  fun cleanLocalLibraryItems() {
-    val localLibraryItems = getLocalLibraryItems()
-
-    localLibraryItems.forEach { lli ->
-      var hasUpates = 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}")
-          hasUpates = true
-        }
-        file.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}")
-            hasUpates = 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}")
-            hasUpates = 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}")
-          lli.coverAbsolutePath = null
-          lli.coverContentUrl = null
-          hasUpates = true
-        }
-      }
-
-      if (hasUpates) {
-        Log.d(tag, "cleanLocalLibraryItems: Saving local library item ${lli.id}")
-        Paper.book("localLibraryItems").write(lli.id, lli)
-      }
-    }
-  }
-
-  // Remove any local media progress where the local media item is not found
-  fun cleanLocalMediaProgress() {
-    val localMediaProgress = getAllLocalMediaProgress()
-    val localLibraryItems = getLocalLibraryItems()
-    localMediaProgress.forEach {
-      val matchingLLI = localLibraryItems.find { lli -> lli.id == it.localLibraryItemId }
-      if (matchingLLI == null) {
-        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()) {
-          Log.d(tag, "cleanLocalMediaProgress: Podcast media progress has no episode id - removing")
-          Paper.book("localMediaProgress").delete(it.id)
-        } else {
-          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")
-            Paper.book("localMediaProgress").delete(it.id)
-          }
-        }
-      }
-    }
-  }
-
-  fun saveLocalPlaybackSession(playbackSession:PlaybackSession) {
-    Paper.book("localPlaybackSession").write(playbackSession.id,playbackSession)
-  }
-  fun getLocalPlaybackSession(playbackSessionId:String):PlaybackSession? {
-    return Paper.book("localPlaybackSession").read(playbackSessionId)
-  }
-}
@@ -1,66 +1,254 @@
 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.util.*
+import java.io.File

-data class ServerConnectionConfig(
-  var id:String,
-  var index:Int,
-  var name:String,
-  var address:String,
-  var userId:String,
-  var username:String,
-  var token:String
-)
+enum class LockOrientationSetting {
+  NONE,
+  PORTRAIT,
+  LANDSCAPE
+}

-data class DeviceData(
-  var serverConnectionConfigs:MutableList<ServerConnectionConfig>,
-  var lastServerConnectionConfigId:String?,
-  var currentLocalPlaybackSession:PlaybackSession? // Stored to open up where left off for local media
-) {
-  @JsonIgnore
-  fun getLastServerConnectionConfig():ServerConnectionConfig? {
-    return lastServerConnectionConfigId?.let { lsccid ->
-      return serverConnectionConfigs.find { it.id == lsccid }
-    }
-  }
+enum class HapticFeedbackSetting {
+  OFF,
+  LIGHT,
+  MEDIUM,
+  HEAVY
+}
+
+enum class ShakeSensitivitySetting {
+  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,
+        // 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 {
+    return getEBookFormat() != null
+  }
+  @JsonIgnore
+  fun getEBookFormat(): String? {
+    if (mimeType == "application/epub+zip") return "epub"
+    if (mimeType == "application/pdf") return "pdf"
+    if (mimeType == "application/x-mobipocket-ebook") return "mobi"
+    if (mimeType == "application/vnd.comicbook+zip") return "cbz"
+    if (mimeType == "application/vnd.comicbook-rar") return "cbr"
+    if (mimeType == "application/vnd.amazon.mobi8-ebook") return "azw3"
+    return null
+  }
 }

@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)
+@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()
+  }
+}
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class DeviceInfo(
+        var deviceId: String,
+        var manufacturer: String,
+        var model: String,
+        var sdkVersion: Int,
+        var clientVersion: String
 )
-open class LibraryItemWrapper()
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class PlayItemRequestPayload(
+        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 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 {
+      return DeviceSettings(
+              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
+  @get:JsonIgnore
+  val jumpForwardTimeMs
+    get() = jumpForwardTime * 1000L
+  @get:JsonIgnore
+  val autoSleepTimerStartHour
+    get() = autoSleepTimerStartTime.split(":")[0].toInt()
+  @get:JsonIgnore
+  val autoSleepTimerStartMinute
+    get() = autoSleepTimerStartTime.split(":")[1].toInt()
+  @get:JsonIgnore
+  val autoSleepTimerEndHour
+    get() = autoSleepTimerEndTime.split(":")[0].toInt()
+  @get:JsonIgnore
+  val autoSleepTimerEndMinute
+    get() = autoSleepTimerEndTime.split(":")[1].toInt()
+
+  @JsonIgnore
+  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 {
+      Log.e("DeviceSetting", "Invalid ShakeSensitivitySetting $shakeSensitivity")
+      1.6f
+    }
+  }
+}
+
+data class DeviceData(
+        var serverConnectionConfigs: MutableList<ServerConnectionConfig>,
+        var lastServerConnectionConfigId: String?,
+        var deviceSettings: DeviceSettings?,
+        var lastPlaybackSession: PlaybackSession?
+) {
+  @JsonIgnore
+  fun getLastServerConnectionConfig(): ServerConnectionConfig? {
+    return lastServerConnectionConfigId?.let { lsccid ->
+      return serverConnectionConfigs.find { it.id == lsccid }
+    }
+  }
+}
@@ -0,0 +1,13 @@
+package com.audiobookshelf.app.data
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class EBookFile(
+  var ino:String,
+  var metadata:FileMetadata?,
+  var ebookFormat:String,
+  var isLocal:Boolean,
+  var localFileId:String?,
+  var contentUrl:String?
+)
@@ -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,
-)
@@ -0,0 +1,32 @@
+/*
+    Used in Android Auto to represent a podcast episode or an audiobook in progress
+ */
+
+package com.audiobookshelf.app.data
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.module.kotlin.readValue
+import org.json.JSONObject
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class ItemInProgress(
+  val libraryItemWrapper: LibraryItemWrapper,
+  val episode: PodcastEpisode?,
+  val progressLastUpdate: Long,
+  val isLocal: Boolean
+) {
+  companion object {
+    fun makeFromServerObject(serverItem: JSONObject, jacksonMapper: ObjectMapper):ItemInProgress {
+      val libraryItem = jacksonMapper.readValue<LibraryItem>(serverItem.toString())
+
+      var episode:PodcastEpisode? = null
+      if (serverItem.has("recentEpisode")) {
+        episode = jacksonMapper.readValue<PodcastEpisode>(serverItem.get("recentEpisode").toString())
+      }
+
+      val progressLastUpdate:Long = serverItem.getLong("progressLastUpdate")
+      return ItemInProgress(libraryItem, episode, progressLastUpdate, false)
+    }
+  }
+}
@@ -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()
+  }
+}
@@ -0,0 +1,178 @@
+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 LibraryItem(
+  id:String,
+  var ino:String,
+  var libraryId:String,
+  var folderId:String,
+  var path:String,
+  var relPath:String,
+  var mtimeMs:Long,
+  var ctimeMs:Long,
+  var birthtimeMs:Long,
+  var addedAt:Long,
+  var updatedAt:Long,
+  var lastScan:Long?,
+  var scanVersion:String?,
+  var isMissing:Boolean,
+  var isInvalid:Boolean,
+  var mediaType:String,
+  var media:MediaType,
+  var libraryFiles:MutableList<LibraryFile>?,
+  var userMediaProgress:MediaProgress?, // Only included when requesting library item with progress (for downloads)
+  var collapsedSeries: CollapsedSeries?,
+  var localLibraryItemId:String?, // For Android Auto
+  val recentEpisode: PodcastEpisode?  // Podcast episode shelf uses this
+) : LibraryItemWrapper(id) {
+  @get:JsonIgnore
+  val title: String
+    get() {
+      if (collapsedSeries != null) {
+        return collapsedSeries!!.title
+      }
+      return media.metadata.title
+    }
+  @get:JsonIgnore
+  val authorName get() = media.metadata.getAuthorDisplayName()
+
+  @JsonIgnore
+  fun getCoverUri(): Uri {
+    if (media.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 (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 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 {
+    /*
+    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)
+  }
+}
@@ -1,17 +1,29 @@
 package com.audiobookshelf.app.data

+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.ImageDecoder
 import android.net.Uri
-import android.support.v4.media.MediaMetadataCompat
+import android.os.Build
+import android.os.Bundle
+import android.provider.MediaStore
+import android.support.v4.media.MediaDescriptionCompat
 import android.util.Log
+import androidx.core.content.FileProvider
+import androidx.core.net.toFile
+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
+import com.audiobookshelf.app.player.PLAYMETHOD_LOCAL
+import java.io.File
 import java.util.*

@JsonIgnoreProperties(ignoreUnknown = true)
-data class LocalLibraryItem(
-  var id:String,
+class LocalLibraryItem(
+  id:String,
  var folderId:String,
  var basePath:String,
  var absolutePath:String,
@@ -28,7 +40,7 @@ data class LocalLibraryItem(
  var serverAddress:String?,
  var serverUserId:String?,
  var libraryItemId:String?
-  ) : LibraryItemWrapper() {
+  ) : LibraryItemWrapper(id) {
  @get:JsonIgnore
  val title get() = media.metadata.title
  @get:JsonIgnore
@@ -37,14 +49,17 @@ data class LocalLibraryItem(
  val isPodcast get() = mediaType == "podcast"

  @JsonIgnore
-  fun getCoverUri(): Uri {
-    return if (coverContentUrl != null) Uri.parse(coverContentUrl) else Uri.parse("android.resource://com.audiobookshelf.app/" + R.drawable.icon)
+  fun getCoverUri(ctx:Context): Uri {
+    if (coverContentUrl?.startsWith("file:") == true) {
+      return FileProvider.getUriForFile(ctx, "${BuildConfig.APPLICATION_ID}.fileprovider", Uri.parse(coverContentUrl).toFile())
+    }
+    return if (coverContentUrl != null) Uri.parse(coverContentUrl) else Uri.parse("android.resource://${BuildConfig.APPLICATION_ID}/" + R.drawable.icon)
  }

  @JsonIgnore
  fun getDuration():Double {
    var total = 0.0
-    var audioTracks = media.getAudioTracks()
+    val audioTracks = media.getAudioTracks()
    audioTracks.forEach{ total += it.duration }
    return total
  }
@@ -65,27 +80,55 @@ data class LocalLibraryItem(
  }

  @JsonIgnore
-  fun getPlaybackSession(episode:PodcastEpisode?):PlaybackSession {
+  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
-    val sessionId = "play_local_${UUID.randomUUID()}"
+    val sessionId = "${UUID.randomUUID()}"

    // 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
+

-    // TODO: Clean up add mediaType methods for displayTitle and displayAuthor
    val mediaMetadata = media.metadata
-    val chapters = if (mediaType == "book") (media as Book).chapters else mutableListOf()
+    var chapters = if (mediaType == "book") (media as Book).chapters else mutableListOf()
    var audioTracks = media.getAudioTracks() as MutableList<AudioTrack>
    val authorName = mediaMetadata.getAuthorDisplayName()
+    val displayTitle = episode?.title ?: mediaMetadata.title
+    var duration = getDuration()
    if (episode != null) { // Get podcast episode audio track
      episode.audioTrack?.let { at -> mutableListOf(at) }?.let { tracks -> audioTracks = tracks }
+      chapters = episode.chapters
+      duration = episode.audioTrack?.duration ?: 0.0
      Log.d("LocalLibraryItem", "getPlaybackSession: Got podcast episode audio track ${audioTracks.size}")
    }

    val dateNow = System.currentTimeMillis()
-    return PlaybackSession(sessionId,serverUserId,libraryItemId,episode?.serverEpisodeId, mediaType, mediaMetadata, chapters ?: mutableListOf(), mediaMetadata.title, authorName,null,getDuration(),PLAYMETHOD_LOCAL,dateNow,0L,0L, audioTracks,currentTime,null,this,localEpisodeId,serverConnectionConfigId, serverAddress, "exo-player")
+    return PlaybackSession(sessionId,serverUserId,libraryItemId,episode?.serverEpisodeId, mediaType, mediaMetadata, deviceInfo,chapters ?: mutableListOf(), displayTitle, authorName,null,duration,PLAYMETHOD_LOCAL,dateNow,0L,0L, audioTracks,currentTime,null,this,localEpisodeId,serverConnectionConfigId, serverAddress, "exo-player")
  }

  @JsonIgnore
@@ -94,16 +137,61 @@ data class LocalLibraryItem(
  }

  @JsonIgnore
-  fun getMediaMetadata(): MediaMetadataCompat {
-    return MediaMetadataCompat.Builder().apply {
-      putString(MediaMetadataCompat.METADATA_KEY_MEDIA_ID, id)
-      putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_TITLE, title)
-      putString(MediaMetadataCompat.METADATA_KEY_TITLE, title)
-      putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_SUBTITLE, authorName)
-      putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_ICON_URI, getCoverUri().toString())
-      putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI, getCoverUri().toString())
-      putString(MediaMetadataCompat.METADATA_KEY_ART_URI, getCoverUri().toString())
-      putString(MediaMetadataCompat.METADATA_KEY_AUTHOR, authorName)
-    }.build()
+  override fun getMediaDescription(progress:MediaProgressWrapper?, ctx:Context): MediaDescriptionCompat {
+    val coverUri = getCoverUri(ctx)
+
+    var bitmap:Bitmap? = null
+    if (coverContentUrl != null) {
+      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)
+      }
+    }
+
+    val extras = Bundle()
+    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 mediaDescriptionBuilder = MediaDescriptionCompat.Builder()
+      .setMediaId(id)
+      .setTitle(title)
+      .setIconUri(coverUri)
+      .setSubtitle(authorName)
+      .setExtras(extras)
+
+    bitmap?.let {
+      mediaDescriptionBuilder.setIconBitmap(bitmap)
+    }
+
+    return mediaDescriptionBuilder.build()
  }
 }
@@ -4,69 +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 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())
-    }
-  }
-
-  @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 {
-    var mediaMetadata = getMediaMetadata()
-    if (mediaType == "book") {
-      var chapters = getAudiobookChapters()
-      var book = Book(mediaMetadata as BookMetadata, coverAbsolutePath, mutableListOf(), mutableListOf(), chapters,audioTracks,getTotalSize(),getDuration())
-      return LocalLibraryItem(id, folderId, basePath,absolutePath, contentUrl,  false,mediaType, book, localFiles, coverContentUrl, coverAbsolutePath,true,null,null,null,null)
-    } else {
-      var podcast = Podcast(mediaMetadata as PodcastMetadata, coverAbsolutePath, mutableListOf(), mutableListOf(), false)
-      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)
    }
  }
 }
@@ -2,16 +2,19 @@ package com.audiobookshelf.app.data

 import com.fasterxml.jackson.annotation.JsonIgnore
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+import kotlin.math.roundToInt

@JsonIgnoreProperties(ignoreUnknown = true)
-data class LocalMediaProgress(
+class LocalMediaProgress(
  var id:String,
  var localLibraryItemId:String,
  var localEpisodeId:String?,
  var duration:Double,
-  var progress:Double, // 0 to 1
-  var currentTime:Double,
-  var isFinished:Boolean,
+  progress:Double, // 0 to 1
+  currentTime:Double,
+  isFinished:Boolean,
+  var ebookLocation:String?, // cfi tag
+  var ebookProgress:Double?, // 0 to 1
  var lastUpdate:Long,
  var startedAt:Long,
  var finishedAt:Long?,
@@ -21,13 +24,32 @@ data class LocalMediaProgress(
  var serverUserId:String?,
  var libraryItemId:String?,
  var episodeId:String?
-) {
+) : MediaProgressWrapper(isFinished, currentTime, progress) {
+  @get:JsonIgnore
+  val progressPercent get() = if (progress.isNaN()) 0 else (progress * 100).roundToInt()
+  @get:JsonIgnore
+  override val mediaItemId get() = if (libraryItemId != null) {
+        if (episodeId.isNullOrEmpty()) libraryItemId ?: "" else "$libraryItemId-$episodeId"
+    } else {
+        if (localEpisodeId.isNullOrEmpty()) localLibraryItemId else "$localLibraryItemId-$localEpisodeId"
+    }
+
+  @JsonIgnore
+  fun isMatch(mediaProgress:MediaProgress):Boolean {
+    if (episodeId != null) return libraryItemId == mediaProgress.libraryItemId && episodeId == mediaProgress.episodeId
+    return libraryItemId == mediaProgress.libraryItemId
+  }
+
  @JsonIgnore
  fun updateIsFinished(finished:Boolean) {
    if (isFinished != finished) { // If finished changed then set progress
      progress = if (finished) 1.0 else 0.0
    }

+    if (finished) {
+      currentTime = 0.0
+    }
+
    isFinished = finished
    lastUpdate = System.currentTimeMillis()
    finishedAt = if (isFinished) lastUpdate else null
@@ -37,9 +59,28 @@ data class LocalMediaProgress(
  fun updateFromPlaybackSession(playbackSession:PlaybackSession) {
    currentTime = playbackSession.currentTime
    progress = playbackSession.progress
-    lastUpdate = System.currentTimeMillis()
-
+    lastUpdate = playbackSession.updatedAt
    isFinished = playbackSession.progress >= 0.99
    finishedAt = if (isFinished) lastUpdate else null
  }
+
+  @JsonIgnore
+  fun updateEbookProgress(ebookLocation:String, ebookProgress:Double) {
+    lastUpdate = System.currentTimeMillis()
+    this.ebookProgress = ebookProgress
+    this.ebookLocation = ebookLocation
+  }
+
+  @JsonIgnore
+  fun updateFromServerMediaProgress(serverMediaProgress:MediaProgress) {
+    isFinished = serverMediaProgress.isFinished
+    progress = serverMediaProgress.progress
+    currentTime = serverMediaProgress.currentTime
+    ebookProgress = serverMediaProgress.ebookProgress
+    ebookLocation = serverMediaProgress.ebookLocation
+    duration = serverMediaProgress.duration
+    lastUpdate = serverMediaProgress.lastUpdate
+    finishedAt = serverMediaProgress.finishedAt
+    startedAt = serverMediaProgress.startedAt
+  }
 }
@@ -0,0 +1,15 @@
+package com.audiobookshelf.app.data
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+class MediaItemEvent(
+  var name:String, // e.g. Play/Pause/Stop/Seek/Save
+  var type:String, // Playback/Info
+  var description:String?,
+  var currentTime:Number?, // Seconds
+  var serverSyncAttempted:Boolean?,
+  var serverSyncSuccess:Boolean?,
+  var serverSyncMessage:String?,
+  var timestamp: Long
+)
@@ -0,0 +1,17 @@
+package com.audiobookshelf.app.data
+
+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>,
+)
@@ -0,0 +1,24 @@
+package com.audiobookshelf.app.data
+
+import com.fasterxml.jackson.annotation.JsonIgnore
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+class MediaProgress(
+  var id:String,
+  var libraryItemId:String,
+  var episodeId:String?,
+  var duration:Double, // seconds
+  progress:Double, // 0 to 1
+  currentTime:Double,
+  isFinished:Boolean,
+  var ebookLocation:String?, // cfi tag
+  var ebookProgress:Double?, // 0 to 1
+  var lastUpdate:Long,
+  var startedAt:Long,
+  var finishedAt:Long?
+) : MediaProgressWrapper(isFinished, currentTime, progress) {
+
+  @get:JsonIgnore
+  override val mediaItemId get() = if (episodeId.isNullOrEmpty()) libraryItemId else "$libraryItemId-$episodeId"
+}
@@ -1,75 +1,96 @@
 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
+import android.provider.MediaStore
 import android.support.v4.media.MediaMetadataCompat
-import androidx.core.app.NotificationCompat
+import androidx.core.content.FileProvider
+import androidx.core.net.toFile
+import com.audiobookshelf.app.BuildConfig
 import com.audiobookshelf.app.R
 import com.audiobookshelf.app.device.DeviceManager
-import com.audiobookshelf.app.player.MediaProgressSyncData
+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.C
 import com.google.android.exoplayer2.MediaItem
 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
-
-// TODO: enum or something in kotlin?
-val PLAYMETHOD_DIRECTPLAY = 0
-val PLAYMETHOD_DIRECTSTREAM = 1
-val PLAYMETHOD_TRANSCODE = 2
-val PLAYMETHOD_LOCAL = 3
+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 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 currentTimeMs get() = (currentTime * 1000L).toLong()
+  val isPodcastEpisode
+    get() = mediaType == "podcast"
  @get:JsonIgnore
-  val totalDurationMs get() = (getTotalDuration() * 1000L).toLong()
+  val currentTimeMs
+    get() = (currentTime * 1000L).toLong()
  @get:JsonIgnore
-  val localLibraryItemId get() = localLibraryItem?.id ?: ""
+  val totalDurationMs
+    get() = (getTotalDuration() * 1000L).toLong()
  @get:JsonIgnore
-  val localMediaProgressId get() = if (episodeId.isNullOrEmpty()) localLibraryItemId else "$localLibraryItemId-$localEpisodeId"
+  val localLibraryItemId
+    get() = localLibraryItem?.id ?: ""
  @get:JsonIgnore
-  val progress get() = currentTime / getTotalDuration()
+  val localMediaProgressId
+    get() =
+            if (localEpisodeId.isNullOrEmpty()) localLibraryItemId
+            else "$localLibraryItemId-$localEpisodeId"
+  @get:JsonIgnore
+  val progress
+    get() = currentTime / getTotalDuration()
+  @get:JsonIgnore
+  val mediaItemId
+    get() = if (episodeId.isNullOrEmpty()) libraryItemId ?: "" else "$libraryItemId-$episodeId"

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

  @JsonIgnore
-  fun getCurrentTrackTimeMs():Long {
-    var currentTrack = audioTracks[this.getCurrentTrackIndex()]
-    var time = currentTime - currentTrack.startOffset
+  fun getNextTrackIndex(): Int {
+    for (i in 0 until audioTracks.size) {
+      val track = audioTracks[i]
+      if (currentTimeMs < track.startOffsetMs) {
+        return i
+      }
+    }
+    return audioTracks.size - 1
+  }
+
+  @JsonIgnore
+  fun getChapterForTime(time: Long): BookChapter? {
+    if (chapters.isEmpty()) return null
+    return chapters.find { time >= it.startMs && it.endMs > time }
+  }
+
+  @JsonIgnore
+  fun getCurrentTrackEndTime(): Long {
+    val currentTrack = audioTracks[this.getCurrentTrackIndex()]
+    return currentTrack.startOffsetMs + currentTrack.durationMs
+  }
+
+  @JsonIgnore
+  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 {
+    val currentTrack = audioTracks[this.getNextTrackIndex()]
+    return currentTrack.startOffsetMs + currentTrack.durationMs
+  }
+
+  @JsonIgnore
+  fun getCurrentTrackTimeMs(): Long {
+    val currentTrack = audioTracks[this.getCurrentTrackIndex()]
+    val time = currentTime - currentTrack.startOffset
    return (time * 1000L).toLong()
  }

  @JsonIgnore
-  fun getTrackStartOffsetMs(index:Int):Long {
-    var currentTrack = audioTracks[index]
+  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(): Uri {
-    if (localLibraryItem?.coverContentUrl != null) return Uri.parse(localLibraryItem?.coverContentUrl) ?: Uri.parse("android.resource://com.audiobookshelf.app/" + R.drawable.icon)
+  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
+    }

-    if (coverPath == null) return Uri.parse("android.resource://com.audiobookshelf.app/" + R.drawable.icon)
+    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()
+                )
+      }
+
+      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)
+
+    // 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
-  fun getMediaMetadataCompat(): MediaMetadataCompat {
-    var 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, "series")
-      .putString(MediaMetadataCompat.METADATA_KEY_MEDIA_ID, id)
+  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)
+                      .putLong(MediaMetadataCompat.METADATA_KEY_DURATION, totalDurationMs)
+                    .putString(
+                            MediaMetadataCompat.METADATA_KEY_DISPLAY_ICON_URI,
+                            coverUri.toString()
+                    )
+
+    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(audioTrack:AudioTrack): MediaMetadata {
-    var metadataBuilder = MediaMetadata.Builder()
-      .setTitle(displayTitle)
-      .setDisplayTitle(displayTitle)
-      .setArtist(displayAuthor)
-      .setAlbumArtist(displayAuthor)
-      .setSubtitle(displayAuthor)
+  fun resolveCoverBitmapAsync(
+          ctx: Context,
+          coroutineScope: CoroutineScope,
+          onArtResolved: () -> Unit
+  ): Job? {
+    val coverUri = getCoverUri(ctx)

-    var contentUri = this.getContentUri(audioTrack)
-    metadataBuilder.setMediaUri(contentUri)
+    // 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():List<MediaItem> {
-    var mediaItems:MutableList<MediaItem> = mutableListOf()
+  fun getMediaItems(ctx: Context): List<MediaItem> {
+    val mediaItems: MutableList<MediaItem> = mutableListOf()

    for (audioTrack in audioTracks) {
-      var mediaMetadata = this.getExoMediaMetadata(audioTrack)
-      var mediaUri = this.getContentUri(audioTrack)
-      var mimeType = audioTrack.mimeType
+      val mediaMetadata = this.getExoMediaMetadata(ctx)
+      val mediaUri = this.getContentUri(audioTrack)
+      val mimeType = audioTrack.mimeType

-      var queueItem = getQueueItem(audioTrack) // Queue item used in exo player CastManager
-      var mediaItem = MediaItem.Builder().setUri(mediaUri).setTag(queueItem).setMediaMetadata(mediaMetadata).setMimeType(mimeType).build()
+      val queueItem = getQueueItem(audioTrack) // Queue item used in exo player CastManager
+      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 {
-    var 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_CHAPTER_TITLE, audioTrack.title)
-    castMetadata.putInt(com.google.android.gms.cast.MediaMetadata.KEY_TRACK_NUMBER, audioTrack.index)
+    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
+    )
    return castMetadata
  }

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

-    var mediaUri = getContentUri(audioTrack)
+    val mediaUri = getContentUri(audioTrack)

-    var 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,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
-  fun syncData(syncData:MediaProgressSyncData) {
+  fun syncData(syncData: MediaProgressSyncData) {
    timeListening += syncData.timeListened
    updatedAt = System.currentTimeMillis()
    currentTime = syncData.currentTime
  }

  @JsonIgnore
-  fun getNewLocalMediaProgress():LocalMediaProgress {
-    return LocalMediaProgress(localMediaProgressId,localLibraryItemId,localEpisodeId,getTotalDuration(),progress,currentTime,false,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
+    )
  }
 }
@@ -1,29 +1,228 @@
 package com.audiobookshelf.app.device

+import android.appwidget.AppWidgetManager
+import android.content.ComponentName
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
 import android.util.Log
-import com.audiobookshelf.app.data.DbManager
-import com.audiobookshelf.app.data.DeviceData
-import com.audiobookshelf.app.data.ServerConnectionConfig
+import com.audiobookshelf.app.MediaPlayerWidget
+import com.audiobookshelf.app.data.*
+import com.audiobookshelf.app.managers.DbManager
+import com.audiobookshelf.app.player.PlayerNotificationService
+import com.audiobookshelf.app.updateAppWidget

+/** Interface for widget event handling. */
+interface WidgetEventEmitter {
+  /**
+   * 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"

-  val dbManager:DbManager = DbManager()
-  var deviceData:DeviceData = dbManager.getDeviceData()
+  val dbManager: DbManager = DbManager()
+  var deviceData: DeviceData = dbManager.getDeviceData()
  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 hasLastServerConnectionConfig get() = deviceData.getLastServerConnectionConfig() != 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

  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
+    ) {
+      deviceData.deviceSettings?.autoSleepTimerStartTime = "22:00"
+      deviceData.deviceSettings?.autoSleepTimerEndTime = "06:00"
+      deviceData.deviceSettings?.sleepTimerLength = 900000L
+    }
+    if (deviceData.deviceSettings?.shakeSensitivity == null) {
+      deviceData.deviceSettings?.shakeSensitivity = ShakeSensitivitySetting.MEDIUM
+    }
+    // Initialize auto sleep timer auto rewind added in v0.9.64
+    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.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
+    )
+  }
+
+  /**
+   * 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 } }
+  }
+
+  /**
+   * 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)) {
+        Log.i("Internet", "NetworkCapabilities.TRANSPORT_CELLULAR")
+        return true
+      } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
+        Log.i("Internet", "NetworkCapabilities.TRANSPORT_WIFI")
+        return true
+      } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET)) {
+        Log.i("Internet", "NetworkCapabilities.TRANSPORT_ETHERNET")
+        return true
+      }
+    }
+    return false
+  }
+
+  /**
+   * Sets the last playback session.
+   * @param playbackSession The playback session to set.
+   */
+  fun setLastPlaybackSession(playbackSession: PlaybackSession) {
+    deviceData.lastPlaybackSession = playbackSession
+    dbManager.saveDeviceData(deviceData)
+  }
+
+  /**
+   * 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) {
+                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()
+
+                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
+                  )
+                }
+              }
+            })
  }
 }
@@ -5,465 +5,308 @@ import android.net.Uri
 import android.util.Log
 import androidx.documentfile.provider.DocumentFile
 import com.anggrayudi.storage.file.*
-import com.arthenica.ffmpegkit.FFmpegKitConfig
-import com.arthenica.ffmpegkit.FFprobeKit
-import com.arthenica.ffmpegkit.Level
 import com.audiobookshelf.app.data.*
-import com.audiobookshelf.app.plugins.AbsDownloader
-import com.fasterxml.jackson.core.json.JsonReadFeature
-import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
-import com.fasterxml.jackson.module.kotlin.readValue
-import com.getcapacitor.JSObject
+import com.audiobookshelf.app.models.DownloadItem
+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"
-  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)}"

-  enum class ItemScanResult {
-    ADDED, REMOVED, UPDATED, UPTODATE
-  }
-
-  // TODO: CLEAN this monster! Divide into bite-size methods
-   fun scanForMediaItems(localFolder:LocalFolder, forceAudioProbe:Boolean):FolderScanResult? {
-    FFmpegKitConfig.enableLogCallback { log ->
-      if (log.level != Level.AV_LOG_STDERR) { // STDERR is filled with junk
-        Log.d(tag, "FFmpeg-Kit Log: (${log.level}) ${log.message}")
-      }
+  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 df: DocumentFile? = DocumentFileCompat.fromUri(ctx, Uri.parse(localFolder.contentUrl))
-
-     if (df == null) {
-       Log.e(tag, "Folder Doc File Invalid $localFolder.contentUrl")
-       return null
-     }
-
-     var mediaItemsUpdated = 0
-     var mediaItemsAdded = 0
-     var mediaItemsRemoved = 0
-     var mediaItemsUpToDate = 0
-
-      // Search for files in media item folder
-     val foldersFound = df.search(false, DocumentFileType.FOLDER)
-
-      // Match folders found with local library items already saved in db
-     var existingLocalLibraryItems = DeviceManager.dbManager.getLocalLibraryItemsInFolder(localFolder.id)
-
-     // Remove existing items no longer there
-    existingLocalLibraryItems = existingLocalLibraryItems.filter { lli ->
-      Log.d(tag, "scanForMediaItems Checking Existing LLI ${lli.id}")
-       val fileFound = foldersFound.find { f -> lli.id == getLocalLibraryItemId(f.id) }
-       if (fileFound == null) {
-         Log.d(tag, "Existing local library item is no longer in file system ${lli.media.metadata.title}")
-         DeviceManager.dbManager.removeLocalLibraryItem(lli.id)
-         mediaItemsRemoved++
-       }
-       fileFound != null
-     }
-
-     foldersFound.forEach { itemFolder ->
-       Log.d(tag, "Iterating over Folder Found ${itemFolder.name} | ${itemFolder.getSimplePath(ctx)} | URI: ${itemFolder.uri}")
-       val existingItem = existingLocalLibraryItems.find { emi -> emi.id == getLocalLibraryItemId(itemFolder.id) }
-
-       val result = scanLibraryItemFolder(itemFolder, localFolder, existingItem, forceAudioProbe)
-
-       if (result == ItemScanResult.REMOVED) mediaItemsRemoved++
-       else if (result == ItemScanResult.UPDATED) mediaItemsUpdated++
-       else if (result == ItemScanResult.ADDED) mediaItemsAdded++
-       else mediaItemsUpToDate++
-     }
-
-     Log.d(tag, "Folder $${localFolder.name} scan Results: $mediaItemsAdded Added | $mediaItemsUpdated Updated | $mediaItemsRemoved Removed | $mediaItemsUpToDate Up-to-date")
-
-     return if (mediaItemsAdded > 0 || mediaItemsUpdated > 0 || mediaItemsRemoved > 0) {
-       var folderLibraryItems = DeviceManager.dbManager.getLocalLibraryItemsInFolder(localFolder.id) // Get all local media items
-       FolderScanResult(mediaItemsAdded, mediaItemsUpdated, mediaItemsRemoved, mediaItemsUpToDate, localFolder, folderLibraryItems)
-     } else {
-       Log.d(tag, "No Media Items to save")
-       FolderScanResult(mediaItemsAdded, mediaItemsUpdated, mediaItemsRemoved, mediaItemsUpToDate, localFolder, mutableListOf())
-     }
-   }
-
-  fun scanLibraryItemFolder(itemFolder:DocumentFile, localFolder:LocalFolder, existingItem:LocalLibraryItem?, forceAudioProbe:Boolean):ItemScanResult {
-    val itemFolderName = itemFolder.name ?: ""
-    val itemId = getLocalLibraryItemId(itemFolder.id)
-
-    val existingLocalFiles = existingItem?.localFiles ?: mutableListOf()
-    val existingAudioTracks = existingItem?.media?.getAudioTracks() ?: mutableListOf()
-    var isNewOrUpdated = existingItem == null
-
-    val audioTracks = mutableListOf<AudioTrack>()
-    val localFiles = mutableListOf<LocalFile>()
-    var index = 1
-    var startOffset = 0.0
-    var coverContentUrl:String? = null
-    var coverAbsolutePath:String? = null
-
-    val filesInFolder = itemFolder.search(false, DocumentFileType.FILE, arrayOf("audio/*", "image/*", "video/mp4"))
-
-    val existingLocalFilesRemoved = existingLocalFiles.filter { elf ->
-      filesInFolder.find { fif -> DeviceManager.getBase64Id(fif.id) == elf.id } == null // File was not found in media item folder
-    }
-    if (existingLocalFilesRemoved.isNotEmpty()) {
-      Log.d(tag, "${existingLocalFilesRemoved.size} Local files were removed from local media item ${existingItem?.media?.metadata?.title}")
-      isNewOrUpdated = true
+    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
+      )
    }

-    filesInFolder.forEach { file ->
-      val mimeType = file.mimeType ?: ""
-      val filename = file.name ?: ""
-      val isAudio = mimeType.startsWith("audio") || mimeType == "video/mp4"
-      Log.d(tag, "Found $mimeType file $filename in folder $itemFolderName")
-
-      val localFileId = DeviceManager.getBase64Id(file.id)
-
-      val localFile = LocalFile(localFileId,filename,file.uri.toString(),file.getBasePath(ctx), file.getAbsolutePath(ctx),file.getSimplePath(ctx),mimeType,file.length())
-      localFiles.add(localFile)
-
-      Log.d(tag, "File attributes Id:${localFileId}|ContentUrl:${localFile.contentUrl}|isDownloadsDocument:${file.isDownloadsDocument}")
-
-      if (isAudio) {
-        var audioTrackToAdd:AudioTrack? = null
-
-        val existingAudioTrack = existingAudioTracks.find { eat -> eat.localFileId == localFileId }
-        if (existingAudioTrack != null) { // Update existing audio track
-          if (existingAudioTrack.index != index) {
-            Log.d(tag, "scanLibraryItemFolder Updating Audio track index from ${existingAudioTrack.index} to $index")
-            existingAudioTrack.index = index
-            isNewOrUpdated = true
-          }
-          if (existingAudioTrack.startOffset != startOffset) {
-            Log.d(tag, "scanLibraryItemFolder Updating Audio track startOffset ${existingAudioTrack.startOffset} to $startOffset")
-            existingAudioTrack.startOffset = startOffset
-            isNewOrUpdated = true
-          }
-        }
-
-        if (existingAudioTrack == null || forceAudioProbe) {
-          Log.d(tag, "scanLibraryItemFolder Scanning Audio File Path ${localFile.absolutePath} | ForceAudioProbe=${forceAudioProbe}")
-
-          // TODO: Make asynchronous
-          val audioProbeResult = probeAudioFile(localFile.absolutePath)
-
-          if (existingAudioTrack != null) {
-            // Update audio probe data on existing audio track
-            existingAudioTrack.audioProbeResult = audioProbeResult
-            audioTrackToAdd = existingAudioTrack
-          } else {
-            // Create new audio track
-            var track = AudioTrack(index, startOffset, audioProbeResult.duration, filename, localFile.contentUrl, mimeType, null, true, localFileId, audioProbeResult, null)
-            audioTrackToAdd = track
-          }
-
-          startOffset += audioProbeResult.duration
-          isNewOrUpdated = true
-        } else {
-          audioTrackToAdd = existingAudioTrack
-        }
-
-        startOffset += audioTrackToAdd.duration
-        index++
-        audioTracks.add(audioTrackToAdd)
-      } else {
-        val existingLocalFile = existingLocalFiles.find { elf -> elf.id == localFileId }
-
-        if (existingLocalFile == null) {
-          Log.d(tag, "scanLibraryItemFolder new local file found ${localFile.absolutePath}")
-          isNewOrUpdated = true
-        }
-        if (existingItem != null && existingItem.coverContentUrl == null) {
-          // Existing media item did not have a cover - cover found on scan
-          Log.d(tag, "scanLibraryItemFolder setting cover ${localFile.absolutePath}")
-          isNewOrUpdated = true
-          existingItem.coverAbsolutePath = localFile.absolutePath
-          existingItem.coverContentUrl = localFile.contentUrl
-          existingItem.media.coverPath = localFile.absolutePath
-        }
-
-        // First image file use as cover path
-        if (coverContentUrl == null) {
-          coverContentUrl = localFile.contentUrl
-          coverAbsolutePath = localFile.absolutePath
-        }
-      }
-    }
-
-    if (existingItem != null && audioTracks.isEmpty()) {
-      Log.d(tag, "Local library item ${existingItem.media.metadata.title} no longer has audio tracks - removing item")
-      DeviceManager.dbManager.removeLocalLibraryItem(existingItem.id)
-      return ItemScanResult.REMOVED
-    } else if (existingItem != null && !isNewOrUpdated) {
-      Log.d(tag, "Local library item ${existingItem.media.metadata.title} has no updates")
-      return ItemScanResult.UPTODATE
-    } else if (existingItem != null) {
-      Log.d(tag, "Updating local library item ${existingItem.media.metadata.title}")
-      existingItem.updateFromScan(audioTracks,localFiles)
-      DeviceManager.dbManager.saveLocalLibraryItem(existingItem)
-      return ItemScanResult.UPDATED
-    } else if (audioTracks.isNotEmpty()) {
-      Log.d(tag, "Found local media item named $itemFolderName with ${audioTracks.size} tracks and ${localFiles.size} local files")
-      val localMediaItem = LocalMediaItem(itemId, itemFolderName, localFolder.mediaType, localFolder.id, itemFolder.uri.toString(), itemFolder.getSimplePath(ctx), itemFolder.getBasePath(ctx), itemFolder.getAbsolutePath(ctx),audioTracks,localFiles,coverContentUrl,coverAbsolutePath)
-      val localLibraryItem = localMediaItem.getLocalLibraryItem()
-      DeviceManager.dbManager.saveLocalLibraryItem(localLibraryItem)
-      return ItemScanResult.ADDED
-    } else {
-      return ItemScanResult.UPTODATE
-    }
-  }
-
-  // Scan item after download and create local library item
-  fun scanDownloadItem(downloadItem: AbsDownloader.DownloadItem):DownloadItemScanResult? {
-    val folderDf = DocumentFileCompat.fromUri(ctx, Uri.parse(downloadItem.localFolder.contentUrl))
-    val foldersFound =  folderDf?.search(false, DocumentFileType.FOLDER) ?: mutableListOf()
-
-    var itemFolderId = ""
-    var itemFolderUrl = ""
-    var itemFolderBasePath = ""
-    var itemFolderAbsolutePath = ""
-    foldersFound.forEach {
-      if (it.name == downloadItem.itemTitle) {
-        itemFolderId = it.id
-        itemFolderUrl = it.uri.toString()
-        itemFolderBasePath = it.getBasePath(ctx)
-        itemFolderAbsolutePath = it.getAbsolutePath(ctx)
-      }
-    }
-
-    if (itemFolderUrl == "") {
-      Log.d(tag, "scanDownloadItem failed to find media folder")
+    // 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
    }
-    val df: DocumentFile? = DocumentFileCompat.fromUri(ctx, Uri.parse(itemFolderUrl))
-
-    if (df == null) {
-      Log.e(tag, "Folder Doc File Invalid ${downloadItem.itemFolderPath}")
-      return 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
-    val filesFound = df.search(false, DocumentFileType.FILE, arrayOf("audio/*", "image/*", "video/mp4"))
-    Log.d(tag, "scanDownloadItem ${filesFound.size} files found in ${downloadItem.itemFolderPath}")
-
-    var localEpisodeId:String? = null
-    var localLibraryItem:LocalLibraryItem? = null
-    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()
-
-      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)
-
-          // TODO: Make asynchronous
-          val audioProbeResult = probeAudioFile(localFile.absolutePath)
-
-          // Create new audio track
-          val track = AudioTrack(audioTrackFromServer?.index ?: -1, audioTrackFromServer?.startOffset ?: 0.0, audioProbeResult.duration, localFile.filename ?: "", localFile.contentUrl, localFile.mimeType ?: "", null, true, localFileId, audioProbeResult, audioTrackFromServer?.index ?: -1)
-          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
-            var 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 { // 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()) {
-      Log.d(tag, "scanDownloadItem did not find any audio tracks in folder for ${downloadItem.itemFolderPath}")
-      return 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 = false,
-        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)
-
-    return downloadItemScanResult
+    return LocalFile(
+            DeviceManager.getBase64Id(document.id),
+            document.name,
+            document.uri.toString(),
+            document.getBasePath(ctx),
+            document.getAbsolutePath(ctx),
+            document.mimeType,
+            document.length()
+    )
  }

-  fun scanLocalLibraryItem(localLibraryItem:LocalLibraryItem, forceAudioProbe:Boolean):LocalLibraryItemScanResult? {
-    var df: DocumentFile? = DocumentFileCompat.fromUri(ctx, Uri.parse(localLibraryItem.contentUrl))
+  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
+          )

-    if (df == null) {
-      Log.e(tag, "Item Folder Doc File Invalid ${localLibraryItem.absolutePath}")
-      return null
-    }
-    Log.d(tag, "scanLocalLibraryItem starting for ${localLibraryItem.absolutePath} | ${df.uri}")
+  private fun scanParts(
+          item: DownloadItem,
+          localItem: LocalLibraryItem,
+          externalFolder: DocumentFile? = null,
+          callback: (DownloadItemScanResult?) -> Unit
+  ) {
+    val tracks = mutableListOf<AudioTrack>()
+    var foundEbook = false
+    var localEpisodeId: String? = null

-    var wasUpdated = false
-
-    // Search for files in media item folder
-    var filesFound = df.search(false, DocumentFileType.FILE, arrayOf("audio/*", "image/*", "video/mp4"))
-    Log.d(tag, "scanLocalLibraryItem ${filesFound.size} files found in ${localLibraryItem.absolutePath}")
-
-    filesFound.forEach {
-      try {
-        Log.d(tag, "Checking file found ${it.name} | ${it.id}")
-      }catch(e:Exception) {
-        Log.d(tag, "Check file found exception", e)
-      }
-    }
-
-    var existingAudioTracks = localLibraryItem.media.getAudioTracks()
-
-    // Remove any files no longer found in library item folder
-    var existingLocalFileIds = localLibraryItem.localFiles.map { it.id }
-    existingLocalFileIds.forEach { localFileId ->
-      Log.d(tag, "Checking local file id is there $localFileId")
-      if (filesFound.find { DeviceManager.getBase64Id(it.id) == localFileId } == null) {
-        Log.d(tag, "scanLocalLibraryItem file $localFileId was removed from ${localLibraryItem.absolutePath}")
-        localLibraryItem.localFiles.removeIf { it.id == localFileId }
-
-        if (existingAudioTracks.find { it.localFileId == localFileId } != null) {
-          Log.d(tag, "scanLocalLibraryItem audio track file ${localFileId} was removed from ${localLibraryItem.absolutePath}")
-          localLibraryItem.media.removeAudioTrack(localFileId)
+    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
+          }
        }
-        wasUpdated = true
-      }
-    }
-
-    filesFound.forEach { docFile ->
-      var localFileId = DeviceManager.getBase64Id(docFile.id)
-      var existingLocalFile = localLibraryItem.localFiles.find { it.id == localFileId }
-
-      if (existingLocalFile == null || (existingLocalFile.isAudioFile() && forceAudioProbe)) {
-
-        var localFile = existingLocalFile ?: LocalFile(localFileId,docFile.name,docFile.uri.toString(),docFile.getBasePath(ctx), docFile.getAbsolutePath(ctx),docFile.getSimplePath(ctx),docFile.mimeType,docFile.length())
-        if (existingLocalFile == null) {
-          localLibraryItem.localFiles.add(localFile)
-          Log.d(tag, "scanLocalLibraryItem new file found ${localFile.filename}")
+        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
+                  )
        }
-
-        if (localFile.isAudioFile()) {
-          // TODO: Make asynchronous
-          var audioProbeResult = probeAudioFile(localFile.absolutePath)
-
-          var existingTrack = existingAudioTracks.find { audioTrack ->
-            audioTrack.localFileId == localFile.id
-          }
-
-          if (existingTrack == null) {
-            // Create new audio track
-              var lastTrack = existingAudioTracks.lastOrNull()
-            var startOffset = (lastTrack?.startOffset ?: 0.0) + (lastTrack?.duration ?: 0.0)
-            var track = AudioTrack(existingAudioTracks.size, startOffset, audioProbeResult.duration, localFile.filename ?: "", localFile.contentUrl, localFile.mimeType ?: "", null, true, localFileId, audioProbeResult, null)
-            localLibraryItem.media.addAudioTrack(track)
-            wasUpdated = true
-          } else {
-            existingTrack.audioProbeResult = audioProbeResult
-            // TODO: Update data found from probe
-            wasUpdated = true
-          }
-        } else { // Check if cover is empty
-          if (localLibraryItem.coverContentUrl == null) {
-            Log.d(tag, "scanLocalLibraryItem setting cover for ${localLibraryItem.media.metadata.title}")
-            localLibraryItem.coverContentUrl = localFile.contentUrl
-            localLibraryItem.coverAbsolutePath = localFile.absolutePath
-            wasUpdated = true
-          }
+        else -> {
+          localItem.coverAbsolutePath = localFile.absolutePath
+          localItem.coverContentUrl = localFile.contentUrl
+          localItem.localFiles.removeAll { it.id == localFile.id }
+          localItem.localFiles.add(localFile)
        }
      }
    }

-    if (wasUpdated) {
-      Log.d(tag, "Local library item was updated - saving it")
-      DeviceManager.dbManager.saveLocalLibraryItem(localLibraryItem)
-    } else {
-      Log.d(tag, "Local library item was up-to-date")
+    if (tracks.isEmpty() && !foundEbook) {
+      callback(null)
+      return
    }
-    return LocalLibraryItemScanResult(wasUpdated, localLibraryItem)
+    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
+      }
+      localItem.media.setAudioTracks(tracks)
+    }
+
+    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(localItem)
+    callback(result)
  }

-  fun probeAudioFile(absolutePath:String):AudioProbeResult {
-    var session = FFprobeKit.execute("-i \"${absolutePath}\" -print_format json -show_format -show_streams -select_streams a -show_chapters -loglevel quiet")
-    Log.d(tag, "FFprobe output ${JSObject(session.output)}")
+  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
+  }

-    val audioProbeResult = jacksonMapper.readValue<AudioProbeResult>(session.output)
-    Log.d(tag, "Probe Result DATA ${audioProbeResult.duration} | ${audioProbeResult.size} | ${audioProbeResult.title} | ${audioProbeResult.artist}")
-    return audioProbeResult
+  /**
+   * 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 root = DocumentFileCompat.fromUri(ctx, Uri.parse(item.localFolder.contentUrl))
+    if (root == null) {
+      Log.e(tag, "Invalid SAF root: ${item.localFolder.contentUrl}")
+      callback(null)
+      return
+    }
+    val itemFolder = findFolderByPath(root, item.itemSubfolder)
+    if (itemFolder == null) {
+      Log.e(tag, "SAF item folder not found: ${item.itemSubfolder}")
+      callback(null)
+      return
+    }
+    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)
  }
 }
@@ -0,0 +1,325 @@
+package com.audiobookshelf.app.managers
+
+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
+
+class DbManager {
+  val tag = "DbManager"
+
+  companion object {
+    private var isDbInitialized = false
+
+    fun initialize(ctx: Context) {
+      if (isDbInitialized) return
+      Paper.init(ctx)
+      isDbInitialized = true
+      Log.i("DbManager", "Initialized Paper db")
+    }
+  }
+
+  fun getDeviceData(): DeviceData {
+    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()
+    Paper.book("localLibraryItems").allKeys.forEach {
+      val localLibraryItem: LocalLibraryItem? = Paper.book("localLibraryItems").read(it)
+      if (localLibraryItem != null &&
+                      (mediaType.isNullOrEmpty() || mediaType == localLibraryItem.mediaType)
+      ) {
+        localLibraryItems.add(localLibraryItem)
+      }
+    }
+    return localLibraryItems
+  }
+
+  fun getLocalLibraryItemsInFolder(folderId: String): List<LocalLibraryItem> {
+    val localLibraryItems = getLocalLibraryItems()
+    return localLibraryItems.filter { it.folderId == folderId }
+  }
+
+  fun getLocalLibraryItemByLId(libraryItemId: String): LocalLibraryItem? {
+    return getLocalLibraryItems().find { it.libraryItemId == libraryItemId }
+  }
+
+  fun getLocalLibraryItem(localLibraryItemId: String): LocalLibraryItem? {
+    return Paper.book("localLibraryItems").read(localLibraryItemId)
+  }
+
+  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
+            }
+    return if (localLibraryItem != null) {
+      LibraryItemWithEpisode(localLibraryItem, podcastEpisode!!)
+    } else {
+      null
+    }
+  }
+
+  fun removeLocalLibraryItem(localLibraryItemId: String) {
+    Paper.book("localLibraryItems").delete(localLibraryItemId)
+  }
+
+  fun saveLocalLibraryItems(localLibraryItems: List<LocalLibraryItem>) {
+    localLibraryItems.map { Paper.book("localLibraryItems").write(it.id, it) }
+  }
+
+  fun saveLocalLibraryItem(localLibraryItem: LocalLibraryItem) {
+    Paper.book("localLibraryItems").write(localLibraryItem.id, localLibraryItem)
+  }
+
+  fun saveLocalFolder(localFolder: LocalFolder) {
+    Paper.book("localFolders").write(localFolder.id, localFolder)
+  }
+
+  fun getLocalFolder(folderId: String): LocalFolder? {
+    return Paper.book("localFolders").read(folderId)
+  }
+
+  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) }
+    }
+    return localFolders
+  }
+
+  fun removeLocalFolder(folderId: String) {
+    val localLibraryItems = getLocalLibraryItemsInFolder(folderId)
+    localLibraryItems.forEach { Paper.book("localLibraryItems").delete(it.id) }
+    Paper.book("localFolders").delete(folderId)
+  }
+
+  fun saveDownloadItem(downloadItem: DownloadItem) {
+    Paper.book("downloadItems").write(downloadItem.id, downloadItem)
+  }
+
+  fun removeDownloadItem(downloadItemId: String) {
+    Paper.book("downloadItems").delete(downloadItemId)
+  }
+
+  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) }
+    }
+    return downloadItems
+  }
+
+  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()
+    Paper.book("localMediaProgress").allKeys.forEach { localMediaProgressId ->
+      Paper.book("localMediaProgress").read<LocalMediaProgress>(localMediaProgressId)?.let {
+        mediaProgress.add(it)
+      }
+    }
+    return mediaProgress
+  }
+  fun removeLocalMediaProgress(localMediaProgressId: String) {
+    Paper.book("localMediaProgress").delete(localMediaProgressId)
+  }
+
+  fun removeAllLocalMediaProgress() {
+    Paper.book("localMediaProgress").destroy()
+  }
+
+  // Make sure all local file ids still exist
+  fun cleanLocalLibraryItems(context: Context) {
+    val localLibraryItems = getLocalLibraryItems()
+
+    localLibraryItems.forEach { lli ->
+      var hasUpdates = false
+
+      // Check local files
+      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>
+      } 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>
+      }
+
+      // Check cover still there
+      lli.coverAbsolutePath?.let {
+        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 (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)
+      }
+    }
+  }
+
+  // Remove any local media progress where the local media item is not found
+  fun cleanLocalMediaProgress() {
+    val localMediaProgress = getAllLocalMediaProgress()
+    val localLibraryItems = getLocalLibraryItems()
+    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)"
+        )
+        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"
+        )
+        Paper.book("localMediaProgress").delete(it.id)
+      } else if (matchingLLI.isPodcast) {
+        if (it.localEpisodeId.isNullOrEmpty()) {
+          Log.d(tag, "cleanLocalMediaProgress: Podcast media progress has no episode id - removing")
+          Paper.book("localMediaProgress").delete(it.id)
+        } else {
+          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"
+            )
+            Paper.book("localMediaProgress").delete(it.id)
+          }
+        }
+      }
+    }
+  }
+
+  fun saveMediaItemHistory(mediaItemHistory: MediaItemHistory) {
+    Paper.book("mediaItemHistory").write(mediaItemHistory.id, mediaItemHistory)
+  }
+  fun getMediaItemHistory(id: String): MediaItemHistory? {
+    return Paper.book("mediaItemHistory").read(id)
+  }
+
+  fun savePlaybackSession(playbackSession: PlaybackSession) {
+    Paper.book("playbackSession").write(playbackSession.id, playbackSession)
+  }
+  fun removePlaybackSession(playbackSessionId: String) {
+    Paper.book("playbackSession").delete(playbackSessionId)
+  }
+  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)
+      }
+    }
+    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,794 @@
+package com.audiobookshelf.app.managers
+
+import android.content.Context
+import android.net.Uri
+import android.os.StatFs
+import androidx.documentfile.provider.DocumentFile
+import com.anggrayudi.storage.file.fullName
+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.plugins.AbsLogger
+import com.audiobookshelf.app.server.ApiHandler
+import com.fasterxml.jackson.core.json.JsonReadFeature
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.getcapacitor.JSObject
+import java.io.File
+import java.io.FileInputStream
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.math.max
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+
+/** Manages the process-owned queue for app-managed downloads. */
+class DownloadItemManager(
+        private val folderScanner: FolderScanner,
+        private val context: Context,
+        private var clientEventEmitter: DownloadEventEmitter
+) {
+  private val tag = "DownloadItemManager"
+  private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+  private val activeCalls = ConcurrentHashMap<String, InternalDownloadManager.DownloadHandle>()
+  private val safFolderLocks = ConcurrentHashMap<String, Any>()
+  private val scanLocks = ConcurrentHashMap<String, Any>()
+  private val reservations = mutableMapOf<String, Long>()
+  private val lastPersistTime = mutableMapOf<String, Long>()
+  private val finalizingItems = mutableSetOf<String>()
+  private val refreshingServerIds = mutableSetOf<String>()
+  private val apiHandler = ApiHandler(context)
+  private var watcherRunning = false
+  private val jacksonMapper =
+          jacksonObjectMapper()
+                  .enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature())
+
+  var downloadItemQueue: MutableList<DownloadItem> = mutableListOf()
+    private set
+  var currentDownloadItemParts: MutableList<DownloadItemPart> = mutableListOf()
+    private set
+
+  interface DownloadEventEmitter {
+    fun onDownloadItem(downloadItem: DownloadItem)
+    fun onDownloadItemPartUpdate(downloadItemPart: DownloadItemPart)
+    fun onDownloadItemComplete(jsobj: JSObject)
+    fun onQueueChanged(hasWork: Boolean)
+  }
+
+  interface InternalProgressCallback {
+    fun onSizeResolved(totalBytes: Long)
+    fun onProgress(totalBytesWritten: Long, progress: Long)
+    fun onComplete(failed: Boolean)
+    fun onAuthError()
+  }
+
+  @Synchronized
+  fun setEventEmitter(eventEmitter: DownloadEventEmitter) {
+    clientEventEmitter = eventEmitter
+    downloadItemQueue.forEach(clientEventEmitter::onDownloadItem)
+    notifyQueueChanged()
+  }
+
+  @Synchronized
+  fun restoreQueue() {
+    if (downloadItemQueue.isNotEmpty()) return
+    DeviceManager.dbManager.getDownloadItems().forEach { item ->
+      item.downloadItemParts.filter { it.moved }.forEach { part ->
+        if (!finalizedFileExists(part)) {
+          AbsLogger.error(tag, "Finalized file is missing; resetting ${part.filename}")
+          part.moved = false
+          part.completed = false
+          part.completedDestinationUri = null
+          part.downloadId = null
+          part.reusedExistingFile = false
+        }
+      }
+      if (item.isDownloadFinished) {
+        downloadItemQueue.add(item)
+        checkDownloadItemFinished(item)
+        return@forEach
+      }
+      var resetFailed = false
+      item.downloadItemParts.forEach { part ->
+        if (part.moved) return@forEach
+        if (!resetPartForFreshDownload(part)) resetFailed = true
+      }
+      if (resetFailed) {
+        item.terminalFailureAt = item.terminalFailureAt ?: System.currentTimeMillis()
+        item.stagingCleanupAt = null
+      }
+      if (item.terminalFailureAt != null) {
+        item.downloadItemParts.filter { !it.moved }.forEach { it.failed = true }
+      }
+      downloadItemQueue.add(item)
+      if (item.terminalFailureAt != null) IncompleteDownloadCleanup.schedule(context, item)
+      clientEventEmitter.onDownloadItem(item)
+    }
+    notifyQueueChanged()
+  }
+
+  @Synchronized
+  fun addDownloadItem(downloadItem: DownloadItem) {
+    val existingItem = downloadItemQueue.find { it.id == downloadItem.id }
+    if (existingItem != null) {
+      return
+    }
+    persist(downloadItem, force = true)
+    downloadItemQueue.add(downloadItem)
+    clientEventEmitter.onDownloadItem(downloadItem)
+    notifyQueueChanged()
+  }
+
+  @Synchronized
+  fun retryDownloadItem(downloadItemId: String): Boolean {
+    val item = downloadItemQueue.find { it.id == downloadItemId } ?: return false
+    if (item.downloadItemParts.any { it in currentDownloadItemParts }) return false
+    if (item.isDownloadFinished) return false
+    synchronized(IncompleteDownloadCleanup) {
+      var resetFailed = false
+      item.downloadItemParts.filter { !it.moved }.forEach { part ->
+        if (!resetPartForFreshDownload(part)) resetFailed = true
+      }
+      if (resetFailed) {
+        item.downloadItemParts.filter { !it.moved }.forEach { it.failed = true }
+        persist(item, force = true)
+        return false
+      }
+      item.terminalFailureAt = null
+      item.stagingCleanupAt = null
+      IncompleteDownloadCleanup.cancel(context, item.id)
+      persist(item, force = true)
+    }
+    clientEventEmitter.onDownloadItem(item)
+    notifyQueueChanged()
+    return true
+  }
+
+  @Synchronized
+  fun resumeWork() {
+    checkUpdateDownloadQueue()
+    notifyQueueChanged()
+  }
+
+  @Synchronized
+  fun cancelAll() {
+    activeCalls.values.forEach(InternalDownloadManager.DownloadHandle::cancel)
+    activeCalls.clear()
+    downloadItemQueue.forEach { item ->
+      item.downloadItemParts.forEach { part ->
+        File(part.destinationPath).delete()
+        if (part.moved && !part.reusedExistingFile && part.isInternalStorage) {
+          File(part.finalDestinationPath).delete()
+        } else if (part.moved && !part.reusedExistingFile) {
+          part.completedDestinationUri?.let { uri ->
+            try {
+              DocumentFile.fromSingleUri(context, Uri.parse(uri))?.delete()
+            } catch (e: Exception) {
+              AbsLogger.error(
+                      tag,
+                      "Could not delete cancelled SAF file ${part.filename}: ${e.message}"
+              )
+            }
+          }
+        }
+      }
+      IncompleteDownloadCleanup.cancel(context, item.id)
+      DeviceManager.dbManager.removeDownloadItem(item.id)
+    }
+    currentDownloadItemParts.clear()
+    reservations.clear()
+    downloadItemQueue.clear()
+    notifyQueueChanged()
+  }
+
+  @Synchronized
+  fun hasWork(): Boolean =
+          finalizingItems.isNotEmpty() ||
+                  downloadItemQueue.any { item ->
+                    item.downloadItemParts.any { part ->
+                      (!part.moved && !part.failed) || part.isMoving
+                    }
+                  }
+
+  @Synchronized
+  private fun checkUpdateDownloadQueue() {
+    downloadItemQueue.toList().forEach { item ->
+      var slots = MAX_SIMULTANEOUS_DOWNLOADS - currentDownloadItemParts.size
+      if (slots <= 0) return@forEach
+      item.downloadItemParts
+              .filter { part ->
+                part.completed &&
+                        !part.moved &&
+                        !part.failed &&
+                        !part.isMoving &&
+                        part !in currentDownloadItemParts &&
+                        File(part.destinationPath).exists() &&
+                        !hasActiveDestinationConflict(part)
+              }
+              .take(slots)
+              .forEach { part ->
+                currentDownloadItemParts.add(part)
+                part.downloadId = APP_MANAGED_DOWNLOAD_ID
+              }
+      slots = MAX_SIMULTANEOUS_DOWNLOADS - currentDownloadItemParts.size
+      if (slots <= 0) return@forEach
+      item.getNextDownloadItemParts(slots).forEach { part ->
+        val existingFile = findSharedStorageFile(part)
+        if (existingFile != null) {
+          part.bytesDownloaded = existingFile.length()
+          part.progress = 100L
+          part.completedDestinationUri = existingFile.uri.toString()
+          part.reusedExistingFile = true
+          File(part.destinationPath).delete()
+          completePart(item, part)
+          clientEventEmitter.onDownloadItemPartUpdate(part)
+          return@forEach
+        }
+        if (completeFromExistingInternalCover(item, part)) return@forEach
+        if (hasActiveDestinationConflict(part)) {
+          leaveQueued(item, part)
+        } else if (part.fileSize <= 0L && currentDownloadItemParts.any { it.fileSize <= 0L }) {
+          leaveQueued(item, part)
+        } else if (tryReserve(part)) startDownload(item, part)
+        else {
+          part.waitingForSpace = true
+          part.lastUpdateTime = System.currentTimeMillis()
+          persist(item)
+          clientEventEmitter.onDownloadItemPartUpdate(part)
+        }
+      }
+    }
+    if (hasWork()) startWatchingDownloads() else notifyQueueChanged()
+  }
+
+  private fun startDownload(item: DownloadItem, part: DownloadItemPart) {
+    val stagingFile = File(part.destinationPath)
+    stagingFile.parentFile?.mkdirs()
+    part.downloadId = APP_MANAGED_DOWNLOAD_ID
+    part.waitingForSpace = false
+    part.lastUpdateTime = System.currentTimeMillis()
+    currentDownloadItemParts.add(part)
+    persist(item, force = true)
+    AbsLogger.info(tag, "Starting download for ${part.filename}")
+    val activeConfig = DeviceManager.serverConnectionConfig
+    val token =
+            if (activeConfig?.id == item.serverConnectionConfigId) activeConfig.token
+            else
+                    DeviceManager.getServerConnectionConfig(item.serverConnectionConfigId)?.token
+                            ?: DeviceManager.token
+    val handle =
+            InternalDownloadManager(
+                            stagingFile,
+                            part.fileSize,
+                            object : InternalProgressCallback {
+                              override fun onSizeResolved(totalBytes: Long) {
+                                synchronized(this@DownloadItemManager) {
+                                  if (part !in currentDownloadItemParts || totalBytes < 0L) return
+                                  if (part.fileSize == totalBytes) return
+                                  AbsLogger.info(
+                                          tag,
+                                          "Using server size $totalBytes instead of metadata size ${part.fileSize} for ${part.filename}"
+                                  )
+                                  part.fileSize = totalBytes
+                                  part.lastUpdateTime = System.currentTimeMillis()
+                                  persist(item, force = true)
+                                  clientEventEmitter.onDownloadItemPartUpdate(part)
+                                }
+                              }
+
+                              override fun onProgress(totalBytesWritten: Long, progress: Long) {
+                                synchronized(this@DownloadItemManager) {
+                                  if (part !in currentDownloadItemParts) return
+                                  part.bytesDownloaded = totalBytesWritten
+                                  part.progress = progress
+                                  part.lastUpdateTime = System.currentTimeMillis()
+                                  persist(item)
+                                }
+                              }
+
+                              override fun onComplete(failed: Boolean) {
+                                synchronized(this@DownloadItemManager) {
+                                  if (part !in currentDownloadItemParts) return
+                                  part.failed = failed
+                                  part.completed = !failed
+                                  part.lastUpdateTime = System.currentTimeMillis()
+                                  activeCalls.remove(part.id)
+                                  persist(item, force = true)
+                                }
+                              }
+
+                              override fun onAuthError() {
+                                synchronized(this@DownloadItemManager) {
+                                  if (part !in currentDownloadItemParts) return
+                                  handleAuthError(item, part)
+                                }
+                              }
+                            },
+                            { hasAvailableSpace(part) }
+                    )
+                    .download(serverUrl(item, part), token)
+    if (part in currentDownloadItemParts && !part.completed && !part.failed) {
+      activeCalls[part.id] = handle
+    }
+  }
+
+  @Synchronized
+  private fun startWatchingDownloads() {
+    if (watcherRunning) return
+    watcherRunning = true
+    scope.launch {
+      while (true) {
+        val activeParts =
+                synchronized(this@DownloadItemManager) { currentDownloadItemParts.toList() }
+        activeParts.forEach(::handlePartUpdate)
+        synchronized(this@DownloadItemManager) {
+          checkUpdateDownloadQueue()
+          if (!hasWork()) {
+            watcherRunning = false
+            notifyQueueChanged()
+            return@launch
+          }
+        }
+        delay(WATCH_INTERVAL_MS)
+      }
+    }
+  }
+
+  private fun handlePartUpdate(part: DownloadItemPart) {
+    clientEventEmitter.onDownloadItemPartUpdate(part)
+    val item =
+            synchronized(this) { downloadItemQueue.find { it.id == part.downloadItemId } }
+                    ?: run {
+                      removeActivePart(part)
+                      return
+                    }
+    if (!part.completed && !part.failed) {
+      val lastUpdate = part.lastUpdateTime ?: return
+      if (System.currentTimeMillis() - lastUpdate > STALL_TIMEOUT_MS) {
+        AbsLogger.error(tag, "Download stalled: ${part.filename}")
+        activeCalls.remove(part.id)?.cancel()
+        failOrRetry(item, part, "Download stalled")
+      }
+      return
+    }
+    if (part.failed) {
+      failOrRetry(item, part, "Transfer failed")
+      return
+    }
+    if (part.isInternalStorage) finalizeInternalFile(item, part) else moveDownloadedFile(item, part)
+  }
+
+  @Synchronized
+  private fun failOrRetry(item: DownloadItem, part: DownloadItemPart, reason: String) {
+    removeActivePart(part)
+    part.retryCount += 1
+    reservations.remove(part.destinationPath)
+    if (part.retryCount > MAX_RETRIES) {
+      markTerminalFailure(item, part, "$reason after $MAX_RETRIES retries")
+      return
+    }
+    part.failed = false
+    part.completed = false
+    part.downloadId = null
+    part.isMoving = false
+    persist(item, force = true)
+    clientEventEmitter.onDownloadItemPartUpdate(part)
+  }
+
+  /** A 401 refreshes the token for this queued item's server without consuming transfer retries. */
+  @Synchronized
+  private fun handleAuthError(item: DownloadItem, part: DownloadItemPart) {
+    removeActivePart(part)
+    reservations.remove(part.destinationPath)
+    part.downloadId = null
+    part.isMoving = false
+    part.failed = false
+    part.completed = false
+    part.authRetryCount += 1
+    part.lastUpdateTime = System.currentTimeMillis()
+    if (part.authRetryCount > MAX_AUTH_RETRIES) {
+      markTerminalFailure(item, part, "Unauthorized after $MAX_AUTH_RETRIES token refresh attempts")
+      return
+    }
+
+    AbsLogger.info(
+            tag,
+            "Refreshing token after 401 for ${part.filename} (attempt ${part.authRetryCount})"
+    )
+    persist(item, force = true)
+    clientEventEmitter.onDownloadItemPartUpdate(part)
+    refreshTokenThenResume(item.serverConnectionConfigId)
+  }
+
+  private fun refreshTokenThenResume(serverConnectionConfigId: String) {
+    if (!refreshingServerIds.add(serverConnectionConfigId)) return
+    apiHandler.refreshAuthTokens(serverConnectionConfigId) { result ->
+      synchronized(this@DownloadItemManager) {
+        refreshingServerIds.remove(serverConnectionConfigId)
+        when (result) {
+          is ApiHandler.RefreshResult.Success -> {
+            AbsLogger.info(
+                    tag,
+                    "Token refresh succeeded; resuming downloads for $serverConnectionConfigId"
+            )
+            checkUpdateDownloadQueue()
+          }
+          ApiHandler.RefreshResult.Rejected -> failParkedAuthParts(serverConnectionConfigId)
+          // Parked parts are still queued, so MAX_AUTH_RETRIES bounds the reattempts.
+          ApiHandler.RefreshResult.Transient -> {
+            AbsLogger.info(
+                    tag,
+                    "Token refresh could not be completed; retrying downloads for $serverConnectionConfigId"
+            )
+            checkUpdateDownloadQueue()
+          }
+        }
+      }
+    }
+  }
+
+  @Synchronized
+  private fun failParkedAuthParts(serverConnectionConfigId: String) {
+    downloadItemQueue.toList().forEach { item ->
+      if (item.serverConnectionConfigId != serverConnectionConfigId) return@forEach
+      item.downloadItemParts
+              .filter {
+                it.authRetryCount > 0 &&
+                        !it.completed &&
+                        !it.failed &&
+                        it.downloadId == null &&
+                        it !in currentDownloadItemParts
+              }
+              .forEach { part ->
+                markTerminalFailure(item, part, "Unable to refresh download authorization")
+              }
+    }
+  }
+
+  @Synchronized
+  private fun markTerminalFailure(item: DownloadItem, part: DownloadItemPart, reason: String) {
+    AbsLogger.error(tag, "$reason: ${part.filename}")
+    removeActivePart(part)
+    reservations.remove(part.destinationPath)
+    part.failed = true
+    part.completed = false
+    part.downloadId = null
+    part.isMoving = false
+    item.terminalFailureAt = item.terminalFailureAt ?: System.currentTimeMillis()
+    item.stagingCleanupAt = null
+    persist(item, force = true)
+    IncompleteDownloadCleanup.schedule(context, item)
+    clientEventEmitter.onDownloadItemPartUpdate(part)
+    notifyQueueChanged()
+  }
+
+  private fun finalizeInternalFile(item: DownloadItem, part: DownloadItemPart) {
+    if (part.moved || part.isMoving) return
+    part.isMoving = true
+    val stagingFile = File(part.destinationPath)
+    val finalFile = File(part.finalDestinationPath)
+    finalFile.parentFile?.mkdirs()
+    val backup = File(finalFile.parentFile, ".${finalFile.name}.abs-backup")
+    try {
+      if (backup.exists() && !backup.delete()) throw IllegalStateException("Could not clear backup")
+      if (finalFile.exists() && !finalFile.renameTo(backup))
+              throw IllegalStateException("Could not protect existing file")
+      if (!stagingFile.renameTo(finalFile)) {
+        if (backup.exists()) backup.renameTo(finalFile)
+        throw IllegalStateException("Could not finalize internal staging file")
+      }
+      backup.delete()
+      AbsLogger.info(tag, "Move completed for ${part.filename} to ${finalFile.absolutePath}")
+      completePart(item, part)
+    } catch (e: Exception) {
+      part.isMoving = false
+      part.failed = true
+      failOrRetry(item, part, e.message ?: "Internal finalization failed")
+    }
+  }
+
+  private fun moveDownloadedFile(item: DownloadItem, part: DownloadItemPart) {
+    if (part.moved || part.isMoving) return
+    val root =
+            DocumentFile.fromTreeUri(context, Uri.parse(part.localFolderUrl))
+                    ?: return failFinalization(item, part, "Could not resolve SAF destination")
+    part.isMoving = true
+    persist(item, force = true)
+    scope.launch {
+      try {
+        if (!hasAvailableSpace(part))
+                throw IllegalStateException("Insufficient storage for SAF copy")
+        val folderKey = "${root.uri}/${part.finalDestinationSubfolder}"
+        val folderLock = safFolderLocks.computeIfAbsent(folderKey) { Any() }
+        val folder =
+                synchronized(folderLock) { getOrCreateFolder(root, part.finalDestinationSubfolder) }
+                        ?: throw IllegalStateException("Could not create SAF destination folder")
+        val temporaryName = ".${part.filename}.${part.id.hashCode()}.part"
+        folder.findFile(temporaryName)?.delete()
+        val temporary =
+                folder.createFile(mimeTypeFor(part), temporaryName)
+                        ?: throw IllegalStateException("Could not create SAF temporary file")
+        val staging = File(part.destinationPath)
+        FileInputStream(staging).use { input ->
+          context.contentResolver.openOutputStream(temporary.uri, "w")?.use { input.copyTo(it) }
+                  ?: throw IllegalStateException("Could not open SAF output stream")
+        }
+        if (temporary.length() != staging.length())
+                throw IllegalStateException("SAF copy size mismatch")
+        val existing = findDocumentByFilename(folder, part)
+        if (existing != null && !existing.delete())
+                throw IllegalStateException("Could not replace existing file")
+        if (!temporary.renameTo(part.filename))
+                throw IllegalStateException("Could not finalize SAF temporary file")
+        val destination =
+                findDocumentByFilename(folder, part)
+                        ?: throw IllegalStateException("Could not reopen finalized SAF file")
+        if (destination.length() != staging.length())
+                throw IllegalStateException("SAF final size mismatch")
+        if (!staging.delete()) AbsLogger.error(tag, "Could not remove staging file ${staging.name}")
+        part.completedDestinationUri = destination.uri.toString()
+        AbsLogger.info(tag, "Move completed for ${part.filename} to ${destination.uri}")
+        completePart(item, part)
+      } catch (e: Exception) {
+        failFinalization(item, part, "SAF copy failed: ${e.message}")
+      }
+    }
+  }
+
+  @Synchronized
+  private fun failFinalization(item: DownloadItem, part: DownloadItemPart, message: String) {
+    AbsLogger.error(tag, message)
+    part.isMoving = false
+    part.failed = true
+    failOrRetry(item, part, message)
+  }
+
+  @Synchronized
+  private fun completePart(item: DownloadItem, part: DownloadItemPart) {
+    part.moved = true
+    part.completed = true
+    part.failed = false
+    part.isMoving = false
+    reservations.remove(part.destinationPath)
+    removeActivePart(part)
+    persist(item, force = true)
+    checkDownloadItemFinished(item)
+  }
+
+  @Synchronized
+  private fun checkDownloadItemFinished(item: DownloadItem) {
+    if (!item.isDownloadFinished || !finalizingItems.add(item.id)) return
+    IncompleteDownloadCleanup.cancel(context, item.id)
+    scope.launch {
+      try {
+        val scanLock = scanLocks.computeIfAbsent(scanDestinationKey(item)) { Any() }
+        synchronized(scanLock) {
+          folderScanner.scanDownloadItem(item) { scanResult ->
+            val event =
+                    JSObject().apply {
+                      put("libraryItemId", item.id)
+                      put("localFolderId", item.localFolder.id)
+                      scanResult?.localLibraryItem?.let {
+                        put("localLibraryItem", JSObject(jacksonMapper.writeValueAsString(it)))
+                      }
+                      scanResult?.localMediaProgress?.let {
+                        put("localMediaProgress", JSObject(jacksonMapper.writeValueAsString(it)))
+                      }
+                    }
+            clientEventEmitter.onDownloadItemComplete(event)
+            synchronized(this@DownloadItemManager) {
+              downloadItemQueue.remove(item)
+              DeviceManager.dbManager.removeDownloadItem(item.id)
+            }
+          }
+        }
+      } catch (e: Exception) {
+        // The files are already in place, so leave the item queued for restoreQueue to rescan.
+        AbsLogger.error(tag, "Could not finalize download item ${item.id}: ${e.message}")
+      } finally {
+        synchronized(this@DownloadItemManager) {
+          finalizingItems.remove(item.id)
+          notifyQueueChanged()
+        }
+      }
+    }
+  }
+
+  private fun tryReserve(part: DownloadItemPart): Boolean {
+    val staging = File(part.destinationPath)
+    staging.parentFile?.mkdirs()
+    val expectedSize = if (part.fileSize > 0L) part.fileSize else UNKNOWN_PART_RESERVATION_BYTES
+    val remaining =
+            (expectedSize - (staging.takeIf(File::exists)?.length() ?: 0L)).coerceAtLeast(0L)
+    val required = if (part.isInternalStorage) remaining else remaining + expectedSize
+    val key = storageKey(staging)
+    val fs = statFsFor(staging)
+    val headroom = max(MIN_FREE_SPACE_BYTES, fs.totalBytes / 20L)
+    val alreadyReserved = reservations.filterKeys { storageKey(File(it)) == key }.values.sum()
+    if (fs.availableBytes - alreadyReserved < required + headroom) return false
+    reservations[part.destinationPath] = required
+    return true
+  }
+
+  private fun hasAvailableSpace(part: DownloadItemPart): Boolean {
+    val staging = File(part.destinationPath)
+    val fs = statFsFor(staging)
+    return fs.availableBytes >= max(MIN_FREE_SPACE_BYTES, fs.totalBytes / 20L)
+  }
+
+  private fun statFsFor(staging: File): StatFs {
+    var directory = staging.parentFile ?: context.filesDir
+    directory.mkdirs()
+    while (!directory.exists()) directory = directory.parentFile ?: context.filesDir
+    return StatFs(directory.absolutePath)
+  }
+
+  private fun storageKey(file: File): String =
+          if (file.absolutePath.startsWith(context.filesDir.absolutePath)) "internal"
+          else "external"
+
+  @Synchronized
+  private fun removeActivePart(part: DownloadItemPart) {
+    activeCalls.remove(part.id)
+    currentDownloadItemParts.remove(part)
+  }
+
+  private fun persist(item: DownloadItem, force: Boolean = false) {
+    val now = System.currentTimeMillis()
+    if (!force && now - (lastPersistTime[item.id] ?: 0L) < PERSIST_INTERVAL_MS) return
+    lastPersistTime[item.id] = now
+    DeviceManager.dbManager.saveDownloadItem(item)
+  }
+
+  private fun notifyQueueChanged() {
+    clientEventEmitter.onQueueChanged(hasWork())
+  }
+
+  fun destroy() {
+    activeCalls.values.forEach(InternalDownloadManager.DownloadHandle::cancel)
+    activeCalls.clear()
+    scope.cancel()
+  }
+
+  private fun getOrCreateFolder(root: DocumentFile, relativePath: String): DocumentFile? {
+    var current = root
+    relativePath.split('/').filter { it.isNotBlank() }.forEach { segment ->
+      if (segment == "." || segment == "..") return null
+      current = current.findFile(segment) ?: current.createDirectory(segment) ?: return null
+    }
+    return current
+  }
+
+  private fun findSharedStorageFile(part: DownloadItemPart): DocumentFile? {
+    if (part.isInternalStorage) return null
+    val root = DocumentFile.fromTreeUri(context, Uri.parse(part.localFolderUrl)) ?: return null
+    var folder = root
+    part.finalDestinationSubfolder.split('/').filter { it.isNotBlank() }.forEach { segment ->
+      if (segment == "." || segment == "..") return null
+      folder = folder.findFile(segment) ?: return null
+    }
+    val file = findDocumentByFilename(folder, part) ?: return null
+    if (!file.isFile) return null
+    if (part.fileSize > 0L && file.length() != part.fileSize) return null
+    if (part.fileSize <= 0L && file.length() <= 0L) return null
+    return file
+  }
+
+  private fun completeFromExistingInternalCover(
+          item: DownloadItem,
+          part: DownloadItemPart
+  ): Boolean {
+    if (!part.isInternalStorage || !part.serverPath.endsWith("/cover")) return false
+    val file = File(part.finalDestinationPath)
+    if (!file.isFile || file.length() <= 0L) return false
+    if (part.fileSize > 0L && file.length() != part.fileSize) return false
+    part.bytesDownloaded = file.length()
+    part.progress = 100L
+    part.reusedExistingFile = true
+    AbsLogger.info(tag, "Reusing existing cover ${part.filename}")
+    File(part.destinationPath).delete()
+    completePart(item, part)
+    clientEventEmitter.onDownloadItemPartUpdate(part)
+    return true
+  }
+
+  private fun hasActiveDestinationConflict(part: DownloadItemPart): Boolean =
+          currentDownloadItemParts.any { activePart ->
+            activePart !== part &&
+                    activePart.localFolderId == part.localFolderId &&
+                    activePart.finalDestinationPath == part.finalDestinationPath
+          }
+
+  private fun leaveQueued(item: DownloadItem, part: DownloadItemPart) {
+    if (!part.waitingForSpace) return
+    part.waitingForSpace = false
+    part.downloadId = null
+    persist(item)
+    clientEventEmitter.onDownloadItemPartUpdate(part)
+  }
+
+  private fun scanDestinationKey(item: DownloadItem): String =
+          "${item.localFolder.id}:${item.itemFolderPath}"
+
+  private fun finalizedFileExists(part: DownloadItemPart): Boolean {
+    if (part.isInternalStorage) {
+      val file = File(part.finalDestinationPath)
+      return file.isFile &&
+              if (part.fileSize > 0L) file.length() == part.fileSize else file.length() > 0L
+    }
+    part.completedDestinationUri?.let { uri ->
+      try {
+        val file = DocumentFile.fromSingleUri(context, Uri.parse(uri))
+        if (file?.isFile == true && (part.fileSize <= 0L || file.length() == part.fileSize))
+                return true
+      } catch (e: Exception) {
+        AbsLogger.error(tag, "Could not validate SAF file ${part.filename}: ${e.message}")
+      }
+    }
+    return findSharedStorageFile(part) != null
+  }
+
+  /** Resets an unmoved part when recovery crosses a service-session boundary. */
+  private fun resetPartForFreshDownload(part: DownloadItemPart): Boolean {
+    val stagingFile = File(part.destinationPath)
+    if (stagingFile.exists() && !stagingFile.delete()) {
+      AbsLogger.error(tag, "Could not delete staging file ${part.filename}")
+      part.failed = true
+      return false
+    }
+    part.completed = false
+    part.bytesDownloaded = 0L
+    part.progress = 0L
+    part.failed = false
+    part.isMoving = false
+    part.downloadId = null
+    part.retryCount = 0
+    part.authRetryCount = 0
+    part.waitingForSpace = false
+    part.reusedExistingFile = false
+    return true
+  }
+
+  private fun findDocumentByFilename(folder: DocumentFile, part: DownloadItemPart): DocumentFile? {
+    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 ||
+                              document.fullName.substringBeforeLast('.') == expectedBaseName))
+    }
+  }
+
+  private fun mimeTypeFor(part: DownloadItemPart): String =
+          part.audioTrack?.mimeType
+                  ?: when (part.ebookFile?.ebookFormat?.lowercase()) {
+                    "epub" -> "application/epub+zip"
+                    "pdf" -> "application/pdf"
+                    else -> "image/jpeg"
+                  }
+
+  private fun serverUrl(item: DownloadItem, part: DownloadItemPart): String {
+    val rawCover = if (part.serverPath.endsWith("/cover")) "?raw=1" else ""
+    return "${item.serverAddress}${part.serverPath}$rawCover"
+  }
+
+  private companion object {
+    const val APP_MANAGED_DOWNLOAD_ID = -1L
+    const val MAX_SIMULTANEOUS_DOWNLOADS = 3
+    const val WATCH_INTERVAL_MS = 1_000L
+    const val STALL_TIMEOUT_MS = 60_000L
+    const val MAX_RETRIES = 5
+    const val MAX_AUTH_RETRIES = 2
+    const val PERSIST_INTERVAL_MS = 2_000L
+    const val MIN_FREE_SPACE_BYTES = 100L * 1024L * 1024L
+    const val UNKNOWN_PART_RESERVATION_BYTES = 100L * 1024L * 1024L
+  }
+}
@@ -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()
+  }
+}
@@ -0,0 +1,203 @@
+package com.audiobookshelf.app.managers
+
+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
+
+/** 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"
+
+  interface DownloadHandle {
+    fun cancel()
+  }
+
+  private class ActiveDownloadHandle : DownloadHandle {
+    private val cancelled = AtomicBoolean(false)
+    private val activeCall = AtomicReference<Call?>()
+
+    fun setCall(call: Call) {
+      activeCall.set(call)
+      if (cancelled.get()) call.cancel()
+    }
+
+    override fun cancel() {
+      cancelled.set(true)
+      activeCall.get()?.cancel()
+    }
+  }
+  /**
+   * 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
+  }
+
+  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()
+    }
+}
@@ -0,0 +1,544 @@
+package com.audiobookshelf.app.managers
+
+import android.content.Context
+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 com.audiobookshelf.app.plugins.AbsLogger
+import java.util.*
+import kotlin.concurrent.schedule
+import kotlin.math.roundToInt
+
+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 autoTimerDisabled: Boolean = false // Disable until out of auto timer period
+  private var sleepTimerSessionId: String = ""
+
+  /**
+   * Gets the current time from the player notification service.
+   * @return Long - the current time in milliseconds.
+   */
+  private fun getCurrentTime(): Long {
+    return playerNotificationService.getCurrentTime()
+  }
+
+  /**
+   * Gets the duration of the current playback.
+   * @return Long - the duration in milliseconds.
+   */
+  private fun getDuration(): Long {
+    return playerNotificationService.getDuration()
+  }
+
+  /**
+   * 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
+  }
+
+  /**
+   * 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()
+  }
+
+  /**
+   * 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() / speed).roundToInt()
+  }
+
+  /**
+   * 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)
+
+    if (time == 0L) {
+      // Get the current chapter time and set the sleep timer to the end of the chapter
+      val chapterEndTime = this.getChapterEndTime()
+
+      if (chapterEndTime == null) {
+        Log.e(tag, "Setting sleep timer to end of chapter/track but there is no current session")
+        return false
+      }
+
+      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 {
+      sleepTimerEndTime = 0L
+    }
+
+    // Set sleep timer length. Will be 0L if using chapter end time
+    sleepTimerLength = time
+
+    // Register shake sensor
+    playerNotificationService.registerSensor()
+
+    playerNotificationService.clientEventEmitter?.onSleepTimerSet(
+            getSleepTimerTimeRemainingSeconds(getPlaybackSpeed()),
+            isAutoSleepTimer
+    )
+
+    sleepTimerTask =
+            Timer("SleepTimer", false).schedule(0L, 1000L) {
+              Handler(Looper.getMainLooper()).post {
+                if (getIsPlaying()) {
+                  sleepTimerElapsed += 1000L
+
+                  val sleepTimeSecondsRemaining =
+                          getSleepTimerTimeRemainingSeconds(getPlaybackSpeed())
+                  Log.d(
+                          tag,
+                          "Timer Elapsed $sleepTimerElapsed | Sleep TIMER time remaining $sleepTimeSecondsRemaining s"
+                  )
+
+                  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
+  }
+
+  /**
+   * 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
+    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
+    sleepTimerEndTime = 0
+    sleepTimerRunning = false
+    playerNotificationService.unregisterSensor()
+
+    setVolume(1f)
+  }
+
+  /**
+   * 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 for this time period")
+      autoTimerDisabled = true
+    }
+
+    clearSleepTimer()
+    playerNotificationService.clientEventEmitter?.onSleepTimerSet(0, false)
+  }
+
+  /** 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
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      val vibratorManager =
+              context.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as VibratorManager
+      vibrator = vibratorManager.defaultVibrator
+    } else {
+      @Suppress("DEPRECATION")
+      vibrator = context.getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
+    }
+
+    vibrator.let {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        val vibrationEffect = VibrationEffect.createWaveform(longArrayOf(0, 150, 150, 150), -1)
+        it.vibrate(vibrationEffect)
+      } else {
+        @Suppress("DEPRECATION") it.vibrate(10)
+      }
+    }
+  }
+
+  /** 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")
+      return null
+    }
+
+    val timeLeftInChapter = currentChapterEndTimeMs - getCurrentTime()
+    // 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"
+        )
+        null
+      } else {
+        nextChapterEndTimeMs
+      }
+    } else {
+      currentChapterEndTimeMs
+    }
+  }
+
+  /**
+   * 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) {
+      // 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
+      if (finishedAtDistance > SLEEP_TIMER_WAKE_UP_EXPIRATION) // 2 minutes
+      {
+        Log.d(tag, "Sleep timer finished over 2 mins ago, clearing it")
+        sleepTimerFinishedAt = 0L
+        return
+      }
+
+      // 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
+      Log.d(tag, "Resetting stopped sleep timer")
+      vibrateFeedback()
+      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 && getIsPlaying()) || sleepTimerFinishedAt > 0L) {
+      if (DeviceManager.deviceData.deviceSettings?.disableShakeToResetSleepTimer == true) {
+        Log.d(tag, "Shake to reset sleep timer is disabled")
+        return
+      }
+      checkShouldResetSleepTimer()
+    }
+  }
+
+  /**
+   * 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
+      sleepTimerLength = minOf(sleepTimerLength, getDuration() - getCurrentTime())
+    } else {
+      // Chapter end time
+      sleepTimerEndTime =
+              minOf(sleepTimerEndTime + (time * getPlaybackSpeed()).roundToInt(), getDuration())
+    }
+
+    setVolume(1F)
+    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) {
+      // Fixed length
+      sleepTimerLength = maxOf(sleepTimerLength - time, 1000L)
+    } else {
+      // Chapter end time
+      sleepTimerEndTime =
+              maxOf(
+                      sleepTimerEndTime - (time * getPlaybackSpeed()).roundToInt(),
+                      getCurrentTime() + 1000
+              )
+    }
+
+    setVolume(1F)
+    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
+    }
+    DeviceManager.deviceData.deviceSettings?.let { deviceSettings ->
+      if (!deviceSettings.autoSleepTimer) return // Check auto sleep timer is enabled
+
+      val startCalendar = Calendar.getInstance()
+      startCalendar.set(Calendar.HOUR_OF_DAY, deviceSettings.autoSleepTimerStartHour)
+      startCalendar.set(Calendar.MINUTE, deviceSettings.autoSleepTimerStartMinute)
+      val endCalendar = Calendar.getInstance()
+      endCalendar.set(Calendar.HOUR_OF_DAY, deviceSettings.autoSleepTimerEndHour)
+      endCalendar.set(Calendar.MINUTE, deviceSettings.autoSleepTimerEndMinute)
+
+      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.
+      //   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 (endCalendar.before(startCalendar)) {
+        if (currentCalendar.before(startCalendar)) { // Shift start back a day
+          startCalendar.add(Calendar.DAY_OF_MONTH, -1)
+        } else { // Shift end forward a day
+          endCalendar.add(Calendar.DAY_OF_MONTH, 1)
+        }
+      }
+
+      val isDuringAutoTime =
+              currentCalendar.after(startCalendar) && currentCalendar.before(endCalendar)
+
+      // 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 {
+          // Auto time is disabled, do not set sleep timer
+          Log.i(tag, "Auto sleep timer is disabled for this time period")
+        }
+      } else {
+        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")
+        }
+      }
+    }
+  }
+
+  /**
+   * 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
+    if (sleepTimerSessionId == playbackSessionId || sleepTimerRunning) {
+      checkShouldResetSleepTimer()
+    } 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)
+    }
+  }
+}
@@ -0,0 +1,132 @@
+package com.audiobookshelf.app.media
+
+import android.util.Log
+import com.audiobookshelf.app.data.*
+import com.audiobookshelf.app.device.DeviceManager
+import com.audiobookshelf.app.player.PlayerNotificationService
+
+object MediaEventManager {
+  const val tag = "MediaEventManager"
+
+  var clientEventEmitter: PlayerNotificationService.ClientEventEmitter? = null
+
+  fun playEvent(playbackSession: PlaybackSession) {
+    Log.i(tag, "Play Event for media \"${playbackSession.displayTitle}\"")
+    addPlaybackEvent("Play", playbackSession, null)
+  }
+
+  fun pauseEvent(playbackSession: PlaybackSession, syncResult: SyncResult?) {
+    Log.i(tag, "Pause Event for media \"${playbackSession.displayTitle}\"")
+    addPlaybackEvent("Pause", playbackSession, syncResult)
+  }
+
+  fun stopEvent(playbackSession: PlaybackSession, syncResult: SyncResult?) {
+    Log.i(tag, "Stop Event for media \"${playbackSession.displayTitle}\"")
+    addPlaybackEvent("Stop", playbackSession, syncResult)
+  }
+
+  fun saveEvent(playbackSession: PlaybackSession, syncResult: SyncResult?) {
+    Log.i(tag, "Save Event for media \"${playbackSession.displayTitle}\"")
+    addPlaybackEvent("Save", playbackSession, syncResult)
+  }
+
+  fun finishedEvent(playbackSession: PlaybackSession, syncResult: SyncResult?) {
+    Log.i(tag, "Finished Event for media \"${playbackSession.displayTitle}\"")
+    addPlaybackEvent("Finished", playbackSession, syncResult)
+  }
+
+  fun seekEvent(playbackSession: PlaybackSession, syncResult: SyncResult?) {
+    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}"
+    )
+    addSyncEvent("Sync", mediaProgress, description)
+  }
+
+  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}"
+      )
+      return
+    }
+
+    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)
+
+    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? {
+    return DeviceManager.dbManager.getMediaItemHistory(mediaItemId)
+  }
+
+  private fun createMediaItemHistoryForSession(playbackSession: PlaybackSession): MediaItemHistory {
+    Log.i(tag, "Creating new media item history for media \"${playbackSession.displayTitle}\"")
+    val libraryItemId = playbackSession.libraryItemId ?: ""
+    val episodeId: String? = playbackSession.episodeId
+    return MediaItemHistory(
+            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()
+    )
+  }
+}
@@ -0,0 +1,360 @@
+package com.audiobookshelf.app.media
+
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.audiobookshelf.app.data.LocalMediaProgress
+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
+)
+
+data class SyncResult(
+        var serverSyncAttempted: Boolean,
+        var serverSyncSuccess: Boolean?,
+        var serverSyncMessage: String?
+)
+
+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
+
+  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
+
+  fun start(playbackSession: PlaybackSession) {
+    if (listeningTimerRunning) {
+      Log.d(tag, "start: Timer already running for $currentDisplayTitle")
+      if (playbackSession.id != currentSessionId) {
+        Log.d(tag, "Playback session changed, reset timer")
+        currentLocalMediaProgress = null
+        listeningTimerTask?.cancel()
+        lastSyncTime = 0L
+        Log.d(tag, "start: Set last sync time 0 $lastSyncTime")
+        failedSyncs = 0
+      } else {
+        return
+      }
+    } else if (playbackSession.id != currentSessionId) {
+      currentLocalMediaProgress = null
+    }
+
+    listeningTimerRunning = true
+    lastSyncTime = System.currentTimeMillis()
+    currentPlaybackSession = playbackSession.clone()
+    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()
+
+                  // 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")
+
+                      currentPlaybackSession?.let { playbackSession ->
+                        MediaEventManager.saveEvent(playbackSession, syncResult)
+                      }
+                    }
+                  }
+                }
+              }
+            }
+  }
+
+  fun play(playbackSession: PlaybackSession) {
+    Log.d(tag, "play ${playbackSession.displayTitle}")
+    MediaEventManager.playEvent(playbackSession)
+
+    start(playbackSession)
+  }
+
+  fun stop(shouldSync: Boolean? = true, cb: () -> Unit) {
+    if (!listeningTimerRunning) {
+      reset()
+      return cb()
+    }
+
+    listeningTimerTask?.cancel()
+    listeningTimerTask = null
+    listeningTimerRunning = false
+    Log.d(tag, "stop: Stopping listening for $currentDisplayTitle")
+
+    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 ->
+          MediaEventManager.stopEvent(playbackSession, syncResult)
+        }
+
+        reset()
+        cb()
+      }
+    } else {
+      currentPlaybackSession?.let { playbackSession ->
+        MediaEventManager.stopEvent(playbackSession, null)
+      }
+
+      reset()
+      cb()
+    }
+  }
+
+  fun pause(cb: () -> Unit) {
+    if (!listeningTimerRunning) return
+
+    listeningTimerTask?.cancel()
+    listeningTimerTask = null
+    listeningTimerRunning = false
+    Log.d(tag, "pause: Pausing progress syncer for $currentDisplayTitle")
+    Log.d(tag, "pause: Last sync time $lastSyncTime")
+
+    val currentTime = playerNotificationService.getCurrentTimeSeconds()
+    if (currentTime > 0) { // Current time should always be > 0 on pause
+      sync(true, currentTime) { syncResult ->
+        lastSyncTime = 0L
+        Log.d(tag, "pause: Set last sync time 0 $lastSyncTime")
+        failedSyncs = 0
+
+        currentPlaybackSession?.let { playbackSession ->
+          MediaEventManager.pauseEvent(playbackSession, syncResult)
+        }
+
+        cb()
+      }
+    } else {
+      lastSyncTime = 0L
+      Log.d(tag, "pause: Set last sync time 0 $lastSyncTime (current time < 0)")
+      failedSyncs = 0
+
+      currentPlaybackSession?.let { playbackSession ->
+        MediaEventManager.pauseEvent(playbackSession, null)
+      }
+
+      cb()
+    }
+  }
+
+  fun finished(cb: () -> Unit) {
+    if (!listeningTimerRunning) return
+
+    listeningTimerTask?.cancel()
+    listeningTimerTask = null
+    listeningTimerRunning = false
+    Log.d(tag, "finished: Stopping listening for $currentDisplayTitle")
+
+    sync(true, currentPlaybackSession?.duration ?: 0.0) { syncResult ->
+      reset()
+
+      currentPlaybackSession?.let { playbackSession ->
+        MediaEventManager.finishedEvent(playbackSession, syncResult)
+      }
+
+      cb()
+    }
+  }
+
+  fun seek() {
+    currentPlaybackSession?.currentTime = playerNotificationService.getCurrentTimeSeconds()
+    Log.d(tag, "seek: $currentDisplayTitle, currentTime=${currentPlaybackSession?.currentTime}")
+
+    if (currentPlaybackSession == null) {
+      Log.e(tag, "seek: Playback session not set")
+      return
+    }
+
+    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"
+      )
+      saveLocalProgress(it)
+    }
+  }
+
+  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)
+    }
+
+    val diffSinceLastSync = System.currentTimeMillis() - lastSyncTime
+    if (diffSinceLastSync < 1000L) {
+      return cb(null)
+    }
+    val listeningTimeToAdd = diffSinceLastSync / 1000L
+
+    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()}"
+      )
+      return cb(null)
+    }
+
+    val hasNetworkConnection = DeviceManager.checkConnectivity(playerNotificationService)
+
+    // Save playback session to db (server linked sessions only)
+    //   Sessions are removed once successfully synced with the server
+    currentPlaybackSession?.let { DeviceManager.dbManager.savePlaybackSession(it) }
+
+    if (currentIsLocal) {
+      // Save local progress sync
+      currentPlaybackSession?.let {
+        saveLocalProgress(it)
+        lastSyncTime = System.currentTimeMillis()
+
+        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
+        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
+              }
+              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) {
+      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) {
+          AbsLogger.info("MediaProgressSyncer", "sync: Successfully synced progress (title: \"$currentDisplayTitle\") (currentTime: $currentTime) (session id: ${currentSessionId}) (${DeviceManager.serverConnectionConfigName})")
+
+          failedSyncs = 0
+          playerNotificationService.alertSyncSuccess()
+          lastSyncTime = System.currentTimeMillis()
+          DeviceManager.dbManager.removePlaybackSession(currentSessionId) // Remove session from db
+        } else {
+          failedSyncs++
+          if (failedSyncs == 2) {
+            playerNotificationService.alertSyncFailing() // Show alert in client
+            failedSyncs = 0
+          }
+          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) {
+    if (currentLocalMediaProgress == null) {
+      val mediaProgress =
+              DeviceManager.dbManager.getLocalMediaProgress(playbackSession.localMediaProgressId)
+      if (mediaProgress == null) {
+        currentLocalMediaProgress = playbackSession.getNewLocalMediaProgress()
+      } else {
+        currentLocalMediaProgress = mediaProgress
+        currentLocalMediaProgress?.updateFromPlaybackSession(playbackSession)
+      }
+    } else {
+      currentLocalMediaProgress?.updateFromPlaybackSession(playbackSession)
+    }
+
+    currentLocalMediaProgress?.let {
+      if (it.progress.isNaN()) {
+        Log.e(tag, "Invalid progress on local media progress")
+      } 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}%"
+        )
+      }
+    }
+  }
+
+  fun reset() {
+    currentPlaybackSession = null
+    currentLocalMediaProgress = null
+    lastSyncTime = 0L
+    Log.d(tag, "reset: Set last sync time 0 $lastSyncTime")
+    failedSyncs = 0
+  }
+}
@@ -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))
+}
@@ -0,0 +1,50 @@
+package com.audiobookshelf.app.models
+
+import com.audiobookshelf.app.data.LocalFolder
+import com.audiobookshelf.app.data.MediaProgress
+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>,
+        @JsonIgnore var terminalFailureAt: Long? = null,
+        @JsonIgnore var stagingCleanupAt: Long? = null
+) {
+  @get:JsonIgnore
+  val isInternalStorage
+    get() = localFolder.id.startsWith("internal-")
+
+  @get:JsonIgnore
+  val isDownloadFinished
+    get() = downloadItemParts.isNotEmpty() && downloadItemParts.all {
+      it.completed && it.moved && !it.isMoving && !it.failed
+    }
+
+  @JsonIgnore
+  fun getNextDownloadItemParts(limit: Int): MutableList<DownloadItemPart> {
+    val itemParts = mutableListOf<DownloadItemPart>()
+    if (limit == 0) return itemParts
+
+    for (it in downloadItemParts) {
+      if (!it.completed && !it.failed && it.downloadId == null) {
+        itemParts.add(it)
+        if (itemParts.size >= limit) break
+      }
+    }
+
+    return itemParts
+  }
+}
@@ -0,0 +1,88 @@
+package com.audiobookshelf.app.models
+
+import android.net.Uri
+import android.util.Log
+import com.audiobookshelf.app.data.AudioTrack
+import com.audiobookshelf.app.data.EBookFile
+import com.audiobookshelf.app.data.LocalFolder
+import com.audiobookshelf.app.data.PodcastEpisode
+import com.audiobookshelf.app.device.DeviceManager
+import com.fasterxml.jackson.annotation.JsonIgnore
+import java.io.File
+
+data class DownloadItemPart(
+  val id: String,
+  val downloadItemId: String,
+  val filename: String,
+  var fileSize: Long,
+  @JsonIgnore val destinationPath: String,
+  val finalDestinationPath:String,
+  val serverPath: String,
+  val localFolderName: String,
+  val localFolderUrl: String,
+  val localFolderId: String,
+  val ebookFile: EBookFile?,
+  val audioTrack: AudioTrack?,
+  val episode: PodcastEpisode?,
+  var completed:Boolean,
+  var moved:Boolean,
+  var isMoving:Boolean,
+  var failed:Boolean,
+  @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,
+  @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")
+
+      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,
+        localFolderUrl = localFolder.contentUrl,
+        localFolderId = localFolder.id,
+        ebookFile = ebookFile,
+        audioTrack = audioTrack,
+        episode = episode,
+        completed = false,
+        moved = false,
+        isMoving = false,
+        failed = false,
+        uri = downloadUri,
+        destinationUri = destinationUri,
+        finalDestinationUri = finalDestinationUri,
+        completedDestinationUri = null,
+        finalDestinationSubfolder = subfolder,
+        downloadId = null,
+        lastUpdateTime = null,
+        progress = 0,
+        bytesDownloaded = 0,
+        reusedExistingFile = false
+      )
+    }
+  }
+
+  @get:JsonIgnore
+  val isInternalStorage get() = localFolderId.startsWith("internal-")
+
+}
@@ -0,0 +1,11 @@
+package com.audiobookshelf.app.models
+
+import com.audiobookshelf.app.data.MediaProgress
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class User(
+  val id:String,
+  val username: String,
+  val mediaProgress:List<MediaProgress>
+)
@@ -2,31 +2,22 @@ package com.audiobookshelf.app.player

 import android.app.PendingIntent
 import android.graphics.Bitmap
+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 androidx.documentfile.provider.DocumentFile
-import com.anggrayudi.storage.file.getAbsolutePath
-import com.anggrayudi.storage.file.toRawFile
-import com.audiobookshelf.app.R
-import com.bumptech.glide.Glide
-import com.bumptech.glide.load.engine.DiskCacheStrategy
-import com.bumptech.glide.request.RequestOptions
 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, val playerNotificationService: PlayerNotificationService) : PlayerNotificationManager.MediaDescriptionAdapter {
+class AbMediaDescriptionAdapter (private val controller: MediaControllerCompat, private val playerNotificationService: PlayerNotificationService) : PlayerNotificationManager.MediaDescriptionAdapter {
  private val tag = "MediaDescriptionAdapter"

-  var currentIconUri: Uri? = null
-  var currentBitmap: Bitmap? = null
+  private var currentIconUri: Uri? = null
+  private var currentBitmap: Bitmap? = null

-  private val glideOptions = RequestOptions()
-    .fallback(R.drawable.icon)
-    .diskCacheStrategy(DiskCacheStrategy.DATA)
  private val serviceJob = SupervisorJob()
  private val serviceScope = CoroutineScope(Dispatchers.Main + serviceJob)

@@ -42,59 +33,40 @@ 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")
-      serviceScope.launch {
-        currentBitmap = albumArtUri?.let {
-          resolveUriAsBitmap(it)
+
+      if (currentIconUri.toString().startsWith("content://")) {
+        currentBitmap = if (Build.VERSION.SDK_INT < 28) {
+          @Suppress("DEPRECATION")
+          MediaStore.Images.Media.getBitmap(playerNotificationService.contentResolver, currentIconUri)
+        } else {
+          val source: ImageDecoder.Source = ImageDecoder.createSource(playerNotificationService.contentResolver, currentIconUri!!)
+          ImageDecoder.decodeBitmap(source)
        }
-        currentBitmap?.let { callback.onBitmap(it) }
+        currentBitmap
+      } else {
+        serviceScope.launch {
+          currentBitmap = albumArtUri?.let {
+            resolveUriAsBitmap(playerNotificationService, it)
+          }
+          currentBitmap?.let { callback.onBitmap(it) }
+        }
+        null
      }
-      null
    } else {
      currentBitmap
    }
  }
-
-  private suspend fun resolveUriAsBitmap(uri: Uri): Bitmap? {
-    return withContext(Dispatchers.IO) {
-      // Block on downloading artwork.
-      val context = playerNotificationService.getContext()
-
-      // Fix attempt for #35 local cover crashing
-      //  Convert content uri to a file and pass to Glide
-      var urival:Any = uri
-      if (uri.toString().startsWith("content:")) {
-        val imageDocFile = DocumentFile.fromSingleUri(context, uri)
-        Log.d(tag, "Converting local content url $uri to file with path ${imageDocFile?.getAbsolutePath(context)}")
-        val file = imageDocFile?.toRawFile(context)
-        file?.let {
-          Log.d(tag, "Using local file image instead of content uri ${it.absolutePath}")
-          urival = it
-        }
-      }
-
-      try {
-        Glide.with(context).applyDefaultRequestOptions(glideOptions)
-          .asBitmap()
-          .load(urival)
-          .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(context).applyDefaultRequestOptions(glideOptions)
-          .asBitmap()
-          .load(Uri.parse("android.resource://com.audiobookshelf.app/" + R.drawable.icon))
-          .submit(NOTIFICATION_LARGE_ICON_SIZE, NOTIFICATION_LARGE_ICON_SIZE)
-          .get()
-      }
-    }
-  }
 }
@@ -1,50 +1,33 @@
 package com.audiobookshelf.app.player

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

 class BrowseTree(
  val context: Context,
-  libraryCategories: List<LibraryCategory>
+  itemsInProgress: List<ItemInProgress>,
+  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 context - context
-   * @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))
-  }
-
  init {
    val rootList = mediaIdToChildren[AUTO_BROWSE_ROOT] ?: mutableListOf()

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

-    val allMetadata = MediaMetadataCompat.Builder().apply {
-      putString(MediaMetadataCompat.METADATA_KEY_MEDIA_ID, ALL_ROOT)
-      putString(MediaMetadataCompat.METADATA_KEY_TITLE, "Library Items")
-      putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI, getUriToDrawable(context, R.drawable.exo_icon_books).toString())
+    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 {
@@ -53,50 +36,44 @@ class BrowseTree(
      putString(MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI, getUriToDrawable(context, R.drawable.exo_icon_downloaddone).toString())
    }.build()

-    // Server continue Listening cat
-    libraryCategories.find { it.id == "continue-listening" }?.let { continueListeningCategory ->
-      var continueListeningMediaMetadata = continueListeningCategory.entities.map { liw ->
-        var libraryItem = liw as LibraryItem
-        libraryItem.getMediaMetadata()
+    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(context, R.drawable.icon_library_folder).toString())
+    }.build()
+
+    if (itemsInProgress.isNotEmpty()) {
+      rootList += continueListeningMetadata
+    }
+
+    if (libraries.isNotEmpty()) {
+      if (recentsLoaded) {
+        rootList += recentMetadata
      }
-      if (continueListeningMediaMetadata.isNotEmpty()) {
-        rootList += continueReadingMetadata
-      }
-      continueListeningMediaMetadata.forEach {
-        val children = mediaIdToChildren[CONTINUE_ROOT] ?: mutableListOf()
-        children += it
-        mediaIdToChildren[CONTINUE_ROOT] = children
+      rootList += librariesMetadata
+
+      libraries.forEach { library ->
+        // 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
+        }
      }
    }

-    rootList += allMetadata
    rootList += downloadsMetadata

-    // Server library cat
-    libraryCategories.find { it.id == "library" }?.let { libraryCategory ->
-      var libraryMediaMetadata = libraryCategory.entities.map { libc ->
-        var libraryItem = libc as LibraryItem
-        libraryItem.getMediaMetadata()
-      }
-      libraryMediaMetadata.forEach {
-        val children = mediaIdToChildren[ALL_ROOT] ?: mutableListOf()
-        children += it
-        mediaIdToChildren[ALL_ROOT] = children
-      }
-    }
-
-    libraryCategories.find { it.id == "local-books" }?.let { localBooksCat ->
-      var localMediaMetadata = localBooksCat.entities.map { libc ->
-        var libraryItem = libc as LocalLibraryItem
-        libraryItem.getMediaMetadata()
-      }
-      localMediaMetadata.forEach {
-        val children = mediaIdToChildren[DOWNLOADS_ROOT] ?: mutableListOf()
-        children += it
-        mediaIdToChildren[DOWNLOADS_ROOT] = children
-      }
-    }
-
    mediaIdToChildren[AUTO_BROWSE_ROOT] = rootList
  }

@@ -104,6 +81,7 @@ class BrowseTree(
 }

 const val AUTO_BROWSE_ROOT = "/"
-const val ALL_ROOT = "__ALL__"
 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,7 +148,14 @@ class CastManager constructor(val mainActivity:Activity) {
  }

  fun startRouteScan(connListener:ChromecastListener) {
-    var callback = object : ScanCallback() {
+    // 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}")
        // if the routes have changed, we may have an available device
@@ -136,7 +168,7 @@ class CastManager constructor(val mainActivity:Activity) {
          // Let the client know a receiver is available
          connListener.onReceiverAvailableUpdate(true)
          // Since we have a receiver we may also have an active session
-          var session = getSessionManager()?.currentCastSession
+          val session = getSessionManager()?.currentCastSession
          // If we do have a session
          if (session != null) {
            // Let the client know
@@ -246,15 +278,15 @@ class CastManager constructor(val mainActivity:Activity) {
      onRouteUpdate(outRoutes)
    }

-    override fun onRouteAdded(router: MediaRouter?, route: MediaRouter.RouteInfo?) {
+    override fun onRouteAdded(router: MediaRouter, route: MediaRouter.RouteInfo) {
      onFilteredRouteUpdate()
    }

-    override fun onRouteChanged(router: MediaRouter?, route: MediaRouter.RouteInfo?) {
+    override fun onRouteChanged(router: MediaRouter, route: MediaRouter.RouteInfo) {
      onFilteredRouteUpdate()
    }

-    override fun onRouteRemoved(router: MediaRouter?, route: MediaRouter.RouteInfo?) {
+    override fun onRouteRemoved(router: MediaRouter, route: MediaRouter.RouteInfo) {
      onFilteredRouteUpdate()
    }
  }
@@ -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
@@ -11,12 +12,12 @@ import com.google.android.exoplayer2.*
 import com.google.android.exoplayer2.C.TrackType
 import com.google.android.exoplayer2.MediaMetadata
 import com.google.android.exoplayer2.Player.*
-import com.google.android.exoplayer2.TracksInfo.TrackGroupInfo
+import com.google.android.exoplayer2.Tracks.Group
 import com.google.android.exoplayer2.audio.AudioAttributes
 import com.google.android.exoplayer2.ext.cast.SessionAvailabilityListener
 import com.google.android.exoplayer2.source.TrackGroup
 import com.google.android.exoplayer2.source.TrackGroupArray
-import com.google.android.exoplayer2.text.Cue
+import com.google.android.exoplayer2.text.CueGroup
 import com.google.android.exoplayer2.trackselection.TrackSelection
 import com.google.android.exoplayer2.trackselection.TrackSelectionArray
 import com.google.android.exoplayer2.trackselection.TrackSelectionParameters
@@ -49,10 +50,14 @@ class CastPlayer(var castContext: CastContext) : BasePlayer() {
  private var myPlayWhenReady:Boolean = false
  private var playbackParameters:PlaybackParameters = PlaybackParameters.DEFAULT
  private var myAvailableCommands: Commands
-  private var myCurrentTracksInfo: TracksInfo
+  private var myCurrentTracksInfo: Tracks
  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_TRACK_INFOS)
+      COMMAND_GET_TRACKS,
+      COMMAND_GET_DEVICE_VOLUME,
+      COMMAND_SET_DEVICE_VOLUME,
+      COMMAND_ADJUST_DEVICE_VOLUME)
    .build()

  var currentPlaybackState = Player.STATE_IDLE
@@ -88,14 +96,14 @@ class CastPlayer(var castContext: CastContext) : BasePlayer() {
  private var currentMediaItemIndex = 0
  private var pendingMediaItemRemovalPosition:PositionInfo? = null
  private var pendingSeekCount = 0
-  private var pendingSeekWindowIndex = 0
+  private var pendingSeekWindowIndex = C.INDEX_UNSET
  private var pendingSeekPositionMs = 0L

  init {
    Log.d(tag, "Init CastPlayer")
    myCurrentTrackGroups = TrackGroupArray.EMPTY
    myCurrentTrackSelections = EMPTY_TRACK_SELECTION_ARRAY
-    myCurrentTracksInfo = TracksInfo.EMPTY
+    myCurrentTracksInfo = Tracks.EMPTY
    statusListener = StatusListener()
    timelineTracker = CastTimelineTracker()
    myCurrentTimeline = CastTimeline.EMPTY_CAST_TIMELINE
@@ -385,7 +393,7 @@ class CastPlayer(var castContext: CastContext) : BasePlayer() {
    }
    if (updateTracksAndSelectionsAndNotifyIfChanged()) {
      listeners.queueEvent(
-        EVENT_TRACKS_CHANGED) { listener: Listener -> listener.onTracksInfoChanged(currentTracksInfo) }
+        EVENT_TRACKS_CHANGED) { listener: Listener -> listener.onTracksChanged(currentTracks) }
    }
    updateAvailableCommandsAndNotifyIfChanged()
    listeners.flushEvents()
@@ -405,7 +413,7 @@ class CastPlayer(var castContext: CastContext) : BasePlayer() {
      val hasChanged = !myCurrentTrackGroups.isEmpty
      myCurrentTrackGroups = TrackGroupArray.EMPTY
      myCurrentTrackSelections = EMPTY_TRACK_SELECTION_ARRAY
-      myCurrentTracksInfo = TracksInfo.EMPTY
+      myCurrentTracksInfo = Tracks.EMPTY
      return hasChanged
    }
    var activeTrackIds = mediaStatus.activeTrackIds
@@ -414,7 +422,7 @@ class CastPlayer(var castContext: CastContext) : BasePlayer() {
    }
    val trackGroups = arrayOfNulls<TrackGroup>(castMediaTracks.size)
    val trackSelections = arrayOfNulls<TrackSelection>(RENDERER_COUNT)
-    val trackGroupInfos = arrayOfNulls<TrackGroupInfo>(castMediaTracks.size)
+    val trackGroupInfos = arrayOfNulls<Group>(castMediaTracks.size)
    for (i in castMediaTracks.indices) {
      val mediaTrack = castMediaTracks[i]
      trackGroups[i] = TrackGroup( /* id= */i.toString(), mediaTrackToFormat(mediaTrack))
@@ -428,18 +436,16 @@ class CastPlayer(var castContext: CastContext) : BasePlayer() {
      }
      val trackSupport = intArrayOf(if (supported) C.FORMAT_HANDLED else C.FORMAT_UNSUPPORTED_TYPE)
      val trackSelected = booleanArrayOf(selected)
-      trackGroupInfos[i] = TrackGroupInfo(trackGroups[i]!!, trackSupport, trackType, trackSelected)
+      trackGroupInfos[i] = Group(trackGroups[i]!!, false, trackSupport, trackSelected)
    }

    val tg = trackGroups.filterNotNull().toTypedArray()
-    var ts = trackSelections.filterNotNull().toTypedArray()
-    var tgi = trackGroupInfos.filterNotNull().toMutableList()
+    val ts = trackSelections.filterNotNull().toTypedArray()
+    val tgi = trackGroupInfos.filterNotNull().toMutableList()
    val newTrackGroups = TrackGroupArray(*tg)
    val newTrackSelections = TrackSelectionArray(*ts)
-    val newTracksInfo = TracksInfo(tgi)
-    if (newTrackGroups != currentTrackGroups
-      || newTrackSelections != currentTrackSelections
-      || newTracksInfo != currentTracksInfo) {
+    val newTracksInfo = Tracks(tgi)
+    if (newTracksInfo != currentTracks) {
      myCurrentTrackSelections = newTrackSelections
      myCurrentTrackGroups = newTrackGroups
      myCurrentTracksInfo = newTracksInfo
@@ -593,7 +599,7 @@ class CastPlayer(var castContext: CastContext) : BasePlayer() {
    listeners.flushEvents()
    val pendingResult: PendingResult<RemoteMediaClient.MediaChannelResult> = if (playWhenReady) remoteMediaClient!!.play() else remoteMediaClient!!.pause()

-    var resultCb = ResultCallback<RemoteMediaClient.MediaChannelResult?> {
+    val resultCb = ResultCallback<RemoteMediaClient.MediaChannelResult?> {
      updatePlayerStateAndNotifyIfChanged()
    }

@@ -622,10 +628,10 @@ class CastPlayer(var castContext: CastContext) : BasePlayer() {
    return false
  }

-  override fun seekTo(mediaItemIndex: Int, positionMs: Long) {
+  override fun seekTo(mediaItemIndex: Int, positionMs: Long, seekCommand: Int, isRepeatingCurrentItem: Boolean) {
    Log.d(tag, "seekTo $mediaItemIndex position $positionMs")

-    var resultCb = ResultCallback<RemoteMediaClient.MediaChannelResult?> {
+    val resultCb = ResultCallback<RemoteMediaClient.MediaChannelResult?> {
      val statusCode: Int = it.status.statusCode
      if (statusCode != CastStatusCodes.SUCCESS && statusCode != CastStatusCodes.REPLACED) {
        Log.e(tag, "Seek failed. Error code $statusCode")
@@ -645,14 +651,14 @@ class CastPlayer(var castContext: CastContext) : BasePlayer() {

    // We assume the default position is 0. There is no support for seeking to the default position
    // in RemoteMediaClient.
-    var positionMsFinal = if (positionMs != C.TIME_UNSET) positionMs else 0
+    val positionMsFinal = if (positionMs != C.TIME_UNSET) positionMs else 0
    if (mediaStatus != null) {
      if (currentMediaItemIndex != mediaItemIndex) {
        Log.d(tag, "seekTo: Changing media item index from $currentMediaItemIndex to $mediaItemIndex")
        remoteMediaClient?.queueJumpToItem(myCurrentTimeline.getPeriod(mediaItemIndex, period).uid as Int, positionMsFinal, JSONObject())?.setResultCallback(resultCb)
      } else {
        Log.d(tag, "seekTo: Same media index seek to position $positionMsFinal")
-        var mediaSeekOptions = MediaSeekOptions.Builder().setPosition(positionMsFinal).build()
+        val mediaSeekOptions = MediaSeekOptions.Builder().setPosition(positionMsFinal).build()
        remoteMediaClient?.seek(mediaSeekOptions)?.setResultCallback(resultCb)
      }
      val oldPosition = getCurrentPositionInfo()
@@ -709,7 +715,7 @@ class CastPlayer(var castContext: CastContext) : BasePlayer() {

    val pendingResult: PendingResult<RemoteMediaClient.MediaChannelResult>? = remoteMediaClient?.setPlaybackRate(actualPlaybackParameters.speed.toDouble(),  /* customData= */null)

-    var resultCb = ResultCallback<RemoteMediaClient.MediaChannelResult?> {
+    val resultCb = ResultCallback<RemoteMediaClient.MediaChannelResult?> {
      updatePlaybackRateAndNotifyIfChanged()
      listeners.flushEvents()
    }
@@ -736,15 +742,7 @@ class CastPlayer(var castContext: CastContext) : BasePlayer() {
    sessionManager.endCurrentSession(false)
  }

-  override fun getCurrentTrackGroups(): TrackGroupArray {
-    return this.myCurrentTrackGroups
-  }
-
-  override fun getCurrentTrackSelections(): TrackSelectionArray {
-    return this.myCurrentTrackSelections
-  }
-
-  override fun getCurrentTracksInfo(): TracksInfo {
+  override fun getCurrentTracks(): Tracks {
    return this.myCurrentTracksInfo
  }

@@ -817,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() {
@@ -858,8 +865,12 @@ class CastPlayer(var castContext: CastContext) : BasePlayer() {
   return VideoSize.UNKNOWN
  }

-  override fun getCurrentCues(): MutableList<Cue> {
-    return mutableListOf()
+  override fun getSurfaceSize(): Size {
+    return Size.UNKNOWN
+  }
+
+  override fun getCurrentCues(): CueGroup {
+    return CueGroup.EMPTY_TIME_ZERO
  }

  override fun getDeviceInfo(): DeviceInfo {
@@ -867,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()
+    }
+  }
+}
@@ -1,130 +0,0 @@
-package com.audiobookshelf.app.player
-
-import android.os.Handler
-import android.os.Looper
-import android.util.Log
-import com.audiobookshelf.app.data.LocalMediaProgress
-import com.audiobookshelf.app.data.PlaybackSession
-import com.audiobookshelf.app.device.DeviceManager
-import com.audiobookshelf.app.server.ApiHandler
-import java.util.*
-import kotlin.concurrent.schedule
-import kotlin.math.roundToInt
-
-data class MediaProgressSyncData(
-  var timeListened:Long, // seconds
-  var duration:Double, // seconds
-  var currentTime:Double // seconds
-)
-
-class MediaProgressSyncer(playerNotificationService:PlayerNotificationService, apiHandler: ApiHandler) {
-  private val tag = "MediaProgressSync"
-  private val playerNotificationService:PlayerNotificationService = playerNotificationService
-  private val apiHandler = apiHandler
-
-  private var listeningTimerTask: TimerTask? = null
-  var listeningTimerRunning:Boolean = false
-
-  private var lastSyncTime:Long = 0
-
-  var currentPlaybackSession: PlaybackSession? = null // copy of pb session currently syncing
-  var currentLocalMediaProgress: LocalMediaProgress? = null
-
-  val currentDisplayTitle get() = currentPlaybackSession?.displayTitle ?: "Unset"
-  val currentIsLocal get() = currentPlaybackSession?.isLocal == true
-  val currentSessionId get() = currentPlaybackSession?.id ?: ""
-  val currentPlaybackDuration get() = currentPlaybackSession?.duration ?: 0.0
-
-  fun start() {
-    if (listeningTimerRunning) {
-      Log.d(tag, "start: Timer already running for $currentDisplayTitle")
-      if (playerNotificationService.getCurrentPlaybackSessionId() != currentSessionId) {
-        Log.d(tag, "Playback session changed, reset timer")
-        currentLocalMediaProgress = null
-        listeningTimerTask?.cancel()
-        lastSyncTime = 0L
-      } else {
-        return
-      }
-    }
-    listeningTimerRunning = true
-    lastSyncTime = System.currentTimeMillis()
-    currentPlaybackSession = playerNotificationService.getCurrentPlaybackSessionCopy()
-
-    listeningTimerTask = Timer("ListeningTimer", false).schedule(0L, 5000L) {
-      Handler(Looper.getMainLooper()).post() {
-        if (playerNotificationService.currentPlayer.isPlaying) {
-          var currentTime = playerNotificationService.getCurrentTimeSeconds()
-          sync(currentTime)
-        }
-      }
-    }
-  }
-
-  fun stop() {
-    if (!listeningTimerRunning) return
-    Log.d(tag, "stop: Stopping listening for $currentDisplayTitle")
-
-    var currentTime = playerNotificationService.getCurrentTimeSeconds()
-    sync(currentTime)
-    reset()
-  }
-
-  fun sync(currentTime:Double) {
-    var diffSinceLastSync = System.currentTimeMillis() - lastSyncTime
-    if (diffSinceLastSync < 1000L) {
-      return
-    }
-    var listeningTimeToAdd = diffSinceLastSync / 1000L
-    lastSyncTime = System.currentTimeMillis()
-
-    var syncData = MediaProgressSyncData(listeningTimeToAdd,currentPlaybackDuration,currentTime)
-
-    currentPlaybackSession?.syncData(syncData)
-    if (currentIsLocal) {
-      // Save local progress sync
-      currentPlaybackSession?.let {
-        DeviceManager.dbManager.saveLocalPlaybackSession(it)
-        saveLocalProgress(it)
-
-        // Send sync to server also if connected to this server and local item belongs to this server
-        if (it.serverConnectionConfigId != null && DeviceManager.serverConnectionConfig?.id == it.serverConnectionConfigId) {
-          apiHandler.sendLocalProgressSync(it) {
-            Log.d(tag, "Local progress sync data sent to server $currentDisplayTitle for time $currentTime")
-          }
-        }
-      }
-    } else {
-      apiHandler.sendProgressSync(currentSessionId, syncData) {
-        Log.d(tag, "Progress sync data sent to server $currentDisplayTitle for time $currentTime")
-      }
-    }
-  }
-
-  private fun saveLocalProgress(playbackSession:PlaybackSession) {
-    if (currentLocalMediaProgress == null) {
-      var mediaProgress = DeviceManager.dbManager.getLocalMediaProgress(playbackSession.localMediaProgressId)
-      if (mediaProgress == null) {
-        currentLocalMediaProgress = playbackSession.getNewLocalMediaProgress()
-      } else {
-        currentLocalMediaProgress = mediaProgress
-      }
-    } else {
-      currentLocalMediaProgress?.updateFromPlaybackSession(playbackSession)
-    }
-    currentLocalMediaProgress?.let {
-      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.progress * 100).roundToInt()}%")
-    }
-  }
-
-  fun reset() {
-    listeningTimerTask?.cancel()
-    listeningTimerTask = null
-    listeningTimerRunning = false
-    currentPlaybackSession = null
-    currentLocalMediaProgress = null
-    lastSyncTime = 0L
-  }
-}
@@ -2,18 +2,12 @@ package com.audiobookshelf.app.player

 import android.annotation.SuppressLint
 import android.content.Intent
-import android.os.Bundle
-import android.os.Handler
-import android.os.Looper
-import android.os.Message
+import android.os.*
 import android.support.v4.media.session.MediaSessionCompat
 import android.util.Log
 import android.view.KeyEvent
-import com.audiobookshelf.app.data.LibraryItem
 import com.audiobookshelf.app.data.LibraryItemWrapper
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.launch
+import com.audiobookshelf.app.data.PodcastEpisode
 import java.util.*
 import kotlin.concurrent.schedule

@@ -21,16 +15,19 @@ class MediaSessionCallback(var playerNotificationService:PlayerNotificationServi
  var tag = "MediaSessionCallback"

  private var mediaButtonClickCount: Int = 0
-  var mediaButtonClickTimeout: Long = 1000  //ms
-  var seekAmount: Long = 20000   //ms
+  private var mediaButtonClickTimeout: Long = 1000  //ms

  override fun onPrepare() {
    Log.d(tag, "ON PREPARE MEDIA SESSION COMPAT")
    playerNotificationService.mediaManager.getFirstItem()?.let { li ->
-      playerNotificationService.mediaManager.play(li, playerNotificationService.getMediaPlayer()) {
-        Log.d(tag, "About to prepare player with ${it.displayTitle}")
-        Handler(Looper.getMainLooper()).post() {
-          playerNotificationService.preparePlayer(it,true,null)
+      playerNotificationService.mediaManager.play(li, null, playerNotificationService.getPlayItemRequestPayload(false)) {
+        if (it == null) {
+          Log.e(tag, "Failed to play library item")
+        } else {
+          val playbackRate = playerNotificationService.mediaManager.getSavedPlaybackRate()
+          Handler(Looper.getMainLooper()).post {
+            playerNotificationService.preparePlayer(it,true, playbackRate)
+          }
        }
      }
    }
@@ -49,10 +46,14 @@ class MediaSessionCallback(var playerNotificationService:PlayerNotificationServi
  override fun onPlayFromSearch(query: String?, extras: Bundle?) {
    Log.d(tag, "ON PLAY FROM SEARCH $query")
    playerNotificationService.mediaManager.getFromSearch(query)?.let { li ->
-      playerNotificationService.mediaManager.play(li, playerNotificationService.getMediaPlayer()) {
-        Log.d(tag, "About to prepare player with ${it.displayTitle}")
-        Handler(Looper.getMainLooper()).post() {
-          playerNotificationService.preparePlayer(it,true,null)
+      playerNotificationService.mediaManager.play(li, null, playerNotificationService.getPlayItemRequestPayload(false)) {
+        if (it == null) {
+           Log.e(tag, "Failed to play library item")
+        } else {
+          val playbackRate = playerNotificationService.mediaManager.getSavedPlaybackRate()
+          Handler(Looper.getMainLooper()).post {
+            playerNotificationService.preparePlayer(it, true, playbackRate)
+          }
        }
      }
    }
@@ -68,39 +69,74 @@ class MediaSessionCallback(var playerNotificationService:PlayerNotificationServi
  }

  override fun onSkipToPrevious() {
-    playerNotificationService.seekBackward(seekAmount)
+    playerNotificationService.skipToPrevious()
  }

  override fun onSkipToNext() {
-    playerNotificationService.seekForward(seekAmount)
+    playerNotificationService.skipToNext()
  }

  override fun onFastForward() {
-    playerNotificationService.seekForward(seekAmount)
+    playerNotificationService.jumpForward()
  }

  override fun onRewind() {
-    playerNotificationService.seekForward(seekAmount)
+    playerNotificationService.jumpBackward()
  }

  override fun onSeekTo(pos: Long) {
-    playerNotificationService.seekPlayer(pos)
+    val currentTrackStartOffset = playerNotificationService.getCurrentTrackStartOffsetMs()
+    playerNotificationService.seekPlayer(currentTrackStartOffset + pos)
+  }
+
+  private fun onChangeSpeed() {
+    // cycle to next speed, only contains preset android app options, as each increment needs it's own icon
+    // Rounding values in the event a non preset value (.5, 1, 1.2, 1.5, 2, 3) is selected in the phone app
+    val mediaManager = playerNotificationService.mediaManager
+    val newSpeed = when (mediaManager.getSavedPlaybackRate()) {
+      in 0.5f..0.7f -> 1.0f
+      in 0.8f..1.0f -> 1.2f
+      in 1.1f..1.2f -> 1.5f
+      in 1.3f..1.5f -> 2.0f
+      in 1.6f..2.0f -> 3.0f
+      in 2.1f..3.0f -> 0.5f
+      // anything set above 3 (can happen in the android app) will be reset to 1
+      else -> 1.0f
+    }
+    mediaManager.setSavedPlaybackRate(newSpeed)
+    playerNotificationService.setPlaybackSpeed(newSpeed)
+    playerNotificationService.clientEventEmitter?.onPlaybackSpeedChanged(newSpeed)
  }

  override fun onPlayFromMediaId(mediaId: String?, extras: Bundle?) {
    Log.d(tag, "ON PLAY FROM MEDIA ID $mediaId")
-    var libraryItemWrapper: LibraryItemWrapper? = null
+    val libraryItemWrapper: LibraryItemWrapper?
+    var podcastEpisode: PodcastEpisode? = null
+
    if (mediaId.isNullOrEmpty()) {
      libraryItemWrapper = playerNotificationService.mediaManager.getFirstItem()
    } else {
-      libraryItemWrapper = playerNotificationService.mediaManager.getById(mediaId)
+      val libraryItemWithEpisode = playerNotificationService.mediaManager.getPodcastWithEpisodeByEpisodeId(mediaId)
+      if (libraryItemWithEpisode != null) {
+        libraryItemWrapper = libraryItemWithEpisode.libraryItemWrapper
+        podcastEpisode = libraryItemWithEpisode.episode
+      } else {
+        libraryItemWrapper = playerNotificationService.mediaManager.getById(mediaId)
+        if (libraryItemWrapper == null) {
+          Log.e(tag, "onPlayFromMediaId: Media item not found $mediaId")
+        }
+      }
    }

    libraryItemWrapper?.let { li ->
-      playerNotificationService.mediaManager.play(li, playerNotificationService.getMediaPlayer()) {
-        Log.d(tag, "About to prepare player with ${it.displayTitle}")
-        Handler(Looper.getMainLooper()).post() {
-          playerNotificationService.preparePlayer(it,true,null)
+      playerNotificationService.mediaManager.play(li, podcastEpisode, playerNotificationService.getPlayItemRequestPayload(false)) {
+        if (it == null) {
+         Log.e(tag, "Failed to play library item")
+        } else {
+          val playbackRate = playerNotificationService.mediaManager.getSavedPlaybackRate()
+          Handler(Looper.getMainLooper()).post {
+            playerNotificationService.preparePlayer(it, true, playbackRate)
+          }
        }
      }
    }
@@ -110,12 +146,67 @@ class MediaSessionCallback(var playerNotificationService:PlayerNotificationServi
    return handleCallMediaButton(mediaButtonEvent)
  }

-  fun handleCallMediaButton(intent: Intent): Boolean {
+  private fun handleCallMediaButton(intent: Intent): Boolean {
+    Log.w(tag, "handleCallMediaButton $intent | ${intent.action}")
+
    if(Intent.ACTION_MEDIA_BUTTON == intent.action) {
-      var keyEvent = intent.getParcelableExtra<KeyEvent>(Intent.EXTRA_KEY_EVENT)
-      if (keyEvent?.getAction() == KeyEvent.ACTION_UP) {
-        when (keyEvent?.getKeyCode()) {
+      val keyEvent = if (Build.VERSION.SDK_INT >= 33) {
+        intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT, KeyEvent::class.java)
+      } else {
+        @Suppress("DEPRECATION")
+        intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT)
+      }
+
+      Log.d(tag, "handleCallMediaButton keyEvent = $keyEvent | action ${keyEvent?.action}")
+
+      // Widget button intent is only sending the action down event
+      if (keyEvent?.action == KeyEvent.ACTION_DOWN) {
+        Log.d(tag, "handleCallMediaButton: key action_down for ${keyEvent.keyCode}")
+        when (keyEvent.keyCode) {
+          KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE -> {
+            Log.d(tag, "handleCallMediaButton: Media Play/Pause")
+
+            // TODO: Play/pause event sent from widget when app is closed. Currently the service gets destroyed before anything can happen
+//            if (playerNotificationService.currentPlaybackSession == null && DeviceManager.deviceData.lastPlaybackSession != null) {
+//              Log.i(tag, "No playback session but had one in the db")
+//
+//              val connectionConfig = DeviceManager.deviceData.serverConnectionConfigs.find { it.id == DeviceManager.deviceData.lastPlaybackSession?.serverConnectionConfigId }
+//              connectionConfig?.let {
+//                Log.i(tag, "Setting playback session from db $it")
+//                DeviceManager.serverConnectionConfig = it
+//
+//                playerNotificationService.currentPlaybackSession = DeviceManager.deviceData.lastPlaybackSession
+//                playerNotificationService.startNewPlaybackSession()
+//                return true
+//              }
+//            }
+
+            if (playerNotificationService.mPlayer.isPlaying) {
+              if (0 == mediaButtonClickCount) playerNotificationService.pause()
+              handleMediaButtonClickCount()
+            } else {
+              if (0 == mediaButtonClickCount) {
+                playerNotificationService.play()
+              }
+              handleMediaButtonClickCount()
+            }
+          }
+          KeyEvent.KEYCODE_MEDIA_FAST_FORWARD -> {
+            Log.d(tag, "handleCallMediaButton: Media Fast Forward")
+            playerNotificationService.jumpForward()
+          }
+          KeyEvent.KEYCODE_MEDIA_REWIND -> {
+            Log.d(tag, "handleCallMediaButton: Media Rewind")
+            playerNotificationService.jumpBackward()
+          }
+        }
+      }
+
+      if (keyEvent?.action == KeyEvent.ACTION_UP) {
+        Log.d(tag, "handleCallMediaButton: key action_up for ${keyEvent.keyCode}")
+        when (keyEvent.keyCode) {
          KeyEvent.KEYCODE_HEADSETHOOK -> {
+            Log.d(tag, "handleCallMediaButton: Headset Hook")
            if (0 == mediaButtonClickCount) {
              if (playerNotificationService.mPlayer.isPlaying)
                playerNotificationService.pause()
@@ -125,39 +216,28 @@ class MediaSessionCallback(var playerNotificationService:PlayerNotificationServi
            handleMediaButtonClickCount()
          }
          KeyEvent.KEYCODE_MEDIA_PLAY -> {
+            Log.d(tag, "handleCallMediaButton: Media Play")
            if (0 == mediaButtonClickCount) {
              playerNotificationService.play()
-              playerNotificationService.sleepTimerManager.checkShouldExtendSleepTimer()
            }
            handleMediaButtonClickCount()
          }
          KeyEvent.KEYCODE_MEDIA_PAUSE -> {
+            Log.d(tag, "handleCallMediaButton: Media Pause")
            if (0 == mediaButtonClickCount) playerNotificationService.pause()
            handleMediaButtonClickCount()
          }
          KeyEvent.KEYCODE_MEDIA_NEXT -> {
-            playerNotificationService.seekForward(seekAmount)
+            playerNotificationService.jumpForward()
          }
          KeyEvent.KEYCODE_MEDIA_PREVIOUS -> {
-            playerNotificationService.seekBackward(seekAmount)
+            playerNotificationService.jumpBackward()
          }
          KeyEvent.KEYCODE_MEDIA_STOP -> {
-            playerNotificationService.closePlayback()
-          }
-          KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE -> {
-            if (playerNotificationService.mPlayer.isPlaying) {
-              if (0 == mediaButtonClickCount) playerNotificationService.pause()
-              handleMediaButtonClickCount()
-            } else {
-              if (0 == mediaButtonClickCount) {
-                playerNotificationService.play()
-                playerNotificationService.sleepTimerManager.checkShouldExtendSleepTimer()
-              }
-              handleMediaButtonClickCount()
-            }
+            playerNotificationService.pause()
          }
          else -> {
-            Log.d(tag, "KeyCode:${keyEvent.getKeyCode()}")
+            Log.d(tag, "KeyCode:${keyEvent.keyCode}")
            return false
          }
        }
@@ -166,7 +246,7 @@ class MediaSessionCallback(var playerNotificationService:PlayerNotificationServi
    return true
  }

-  fun handleMediaButtonClickCount() {
+  private fun handleMediaButtonClickCount() {
    mediaButtonClickCount++
    if (1 == mediaButtonClickCount) {
      Timer().schedule(mediaButtonClickTimeout) {
@@ -182,14 +262,25 @@ class MediaSessionCallback(var playerNotificationService:PlayerNotificationServi
    override fun handleMessage(msg: Message) {
      super.handleMessage(msg)
      if (2 == msg.what) {
-        playerNotificationService.seekBackward(seekAmount)
+        playerNotificationService.jumpBackward()
        playerNotificationService.play()
      }
      else if (msg.what >= 3) {
-        playerNotificationService.seekForward(seekAmount)
+        playerNotificationService.jumpForward()
        playerNotificationService.play()
      }
    }
  }

+  override fun onCustomAction(action: String?, extras: Bundle?) {
+    super.onCustomAction(action, extras)
+
+    when (action) {
+      CUSTOM_ACTION_JUMP_FORWARD -> onFastForward()
+      CUSTOM_ACTION_JUMP_BACKWARD -> onRewind()
+      CUSTOM_ACTION_SKIP_FORWARD -> onSkipToNext()
+      CUSTOM_ACTION_SKIP_BACKWARD -> onSkipToPrevious()
+      CUSTOM_ACTION_CHANGE_SPEED -> onChangeSpeed()
+    }
+  }
 }
@@ -7,8 +7,8 @@ import android.os.Looper
 import android.os.ResultReceiver
 import android.support.v4.media.session.PlaybackStateCompat
 import android.util.Log
-import com.audiobookshelf.app.data.LibraryItem
 import com.audiobookshelf.app.data.LibraryItemWrapper
+import com.audiobookshelf.app.data.PodcastEpisode
 import com.google.android.exoplayer2.Player
 import com.google.android.exoplayer2.ext.mediasession.MediaSessionConnector

@@ -30,9 +30,14 @@ class MediaSessionPlaybackPreparer(var playerNotificationService:PlayerNotificat
  override fun onPrepare(playWhenReady: Boolean) {
    Log.d(tag, "ON PREPARE $playWhenReady")
    playerNotificationService.mediaManager.getFirstItem()?.let { li ->
-      playerNotificationService.mediaManager.play(li, playerNotificationService.getMediaPlayer()) {
-        Handler(Looper.getMainLooper()).post() {
-          playerNotificationService.preparePlayer(it,playWhenReady,null)
+      playerNotificationService.mediaManager.play(li, null, playerNotificationService.getPlayItemRequestPayload(false)) {
+        if (it == null) {
+          Log.e(tag, "Failed to play library item")
+        } else {
+          val playbackRate = playerNotificationService.mediaManager.getSavedPlaybackRate()
+          Handler(Looper.getMainLooper()).post {
+            playerNotificationService.preparePlayer(it, playWhenReady, playbackRate)
+          }
        }
      }
    }
@@ -41,12 +46,26 @@ class MediaSessionPlaybackPreparer(var playerNotificationService:PlayerNotificat
  override fun onPrepareFromMediaId(mediaId: String, playWhenReady: Boolean, extras: Bundle?) {
    Log.d(tag, "ON PREPARE FROM MEDIA ID $mediaId $playWhenReady")

-    var libraryItemWrapper: LibraryItemWrapper? = playerNotificationService.mediaManager.getById(mediaId)
+    val libraryItemWrapper: LibraryItemWrapper?
+    var podcastEpisode: PodcastEpisode? = null
+
+    val libraryItemWithEpisode = playerNotificationService.mediaManager.getPodcastWithEpisodeByEpisodeId(mediaId)
+    if (libraryItemWithEpisode != null) {
+      libraryItemWrapper = libraryItemWithEpisode.libraryItemWrapper
+      podcastEpisode = libraryItemWithEpisode.episode
+    } else {
+      libraryItemWrapper = playerNotificationService.mediaManager.getById(mediaId)
+    }
+
    libraryItemWrapper?.let { li ->
-      playerNotificationService.mediaManager.play(li, playerNotificationService.getMediaPlayer()) {
-        Log.d(tag, "About to prepare player with ${it.displayTitle}")
-        Handler(Looper.getMainLooper()).post() {
-          playerNotificationService.preparePlayer(it,playWhenReady,null)
+      playerNotificationService.mediaManager.play(li, podcastEpisode, playerNotificationService.getPlayItemRequestPayload(false)) {
+        if (it == null) {
+         Log.e(tag, "Failed to play library item")
+        } else {
+          val playbackRate = playerNotificationService.mediaManager.getSavedPlaybackRate()
+          Handler(Looper.getMainLooper()).post {
+            playerNotificationService.preparePlayer(it, playWhenReady, playbackRate)
+          }
        }
      }
    }
@@ -55,10 +74,14 @@ class MediaSessionPlaybackPreparer(var playerNotificationService:PlayerNotificat
  override fun onPrepareFromSearch(query: String, playWhenReady: Boolean, extras: Bundle?) {
    Log.d(tag, "ON PREPARE FROM SEARCH $query")
    playerNotificationService.mediaManager.getFromSearch(query)?.let { li ->
-      playerNotificationService.mediaManager.play(li, playerNotificationService.getMediaPlayer()) {
-        Log.d(tag, "About to prepare player with ${it.displayTitle}")
-        Handler(Looper.getMainLooper()).post() {
-          playerNotificationService.preparePlayer(it,playWhenReady,null)
+      playerNotificationService.mediaManager.play(li, null, playerNotificationService.getPlayItemRequestPayload(false)) {
+        if (it == null) {
+         Log.e(tag, "Failed to play library item")
+        } else {
+          val playbackRate = playerNotificationService.mediaManager.getSavedPlaybackRate()
+          Handler(Looper.getMainLooper()).post {
+            playerNotificationService.preparePlayer(it, playWhenReady, playbackRate)
+          }
        }
      }
    }
@@ -0,0 +1,21 @@
+package com.audiobookshelf.app.player
+
+const val CUSTOM_ACTION_JUMP_FORWARD = "com.audiobookshelf.customAction.jump_forward";
+const val CUSTOM_ACTION_JUMP_BACKWARD = "com.audiobookshelf.customAction.jump_backward";
+const val CUSTOM_ACTION_SKIP_FORWARD = "com.audiobookshelf.customAction.skip_forward";
+const val CUSTOM_ACTION_SKIP_BACKWARD = "com.audiobookshelf.customAction.skip_backward";
+const val CUSTOM_ACTION_CHANGE_SPEED = "com.audiobookshelf.customAction.change_speed";
+
+const val PLAYMETHOD_DIRECTPLAY = 0
+const val PLAYMETHOD_DIRECTSTREAM = 1
+const val PLAYMETHOD_TRANSCODE = 2
+const val PLAYMETHOD_LOCAL = 3
+
+//
+// MEDIA BROWSER STUFF (ANDROID AUTO)
+//
+const val ANDROID_AUTO_PKG_NAME = "com.google.android.projection.gearhead"
+const val ANDROID_AUTO_SIMULATOR_PKG_NAME = "com.google.android.autosimulator"
+const val ANDROID_WEARABLE_PKG_NAME = "com.google.android.wearable.app"
+const val ANDROID_GSEARCH_PKG_NAME = "com.google.android.googlequicksearchbox"
+const val ANDROID_AUTOMOTIVE_PKG_NAME = "com.google.android.carassistant"
@@ -1,27 +1,121 @@
 package com.audiobookshelf.app.player

 import android.util.Log
+import com.audiobookshelf.app.data.PlaybackSession
 import com.audiobookshelf.app.data.PlayerState
+import com.audiobookshelf.app.device.DeviceManager
 import com.google.android.exoplayer2.PlaybackException
 import com.google.android.exoplayer2.Player

+//const val PAUSE_LEN_BEFORE_RECHECK = 30000 // 30 seconds
+
 class PlayerListener(var playerNotificationService:PlayerNotificationService) : Player.Listener {
  var tag = "PlayerListener"

  companion object {
    var lastPauseTime: Long = 0   //ms
+    var lazyIsPlaying: Boolean = false
  }

-  private var onSeekBack: Boolean = false
-
  override fun onPlayerError(error: PlaybackException) {
-    var errorMessage = error.message ?: "Unknown Error"
+    val errorMessage = error.message ?: "Unknown Error"
    Log.e(tag, "onPlayerError $errorMessage")
    playerNotificationService.handlePlayerPlaybackError(errorMessage) // If was direct playing session, fallback to transcode
  }

+  override fun onPositionDiscontinuity(
+    oldPosition: Player.PositionInfo,
+    newPosition: Player.PositionInfo,
+    reason: Int
+  ) {
+    if (reason == Player.DISCONTINUITY_REASON_SEEK) {
+      // If playing set seeking flag
+      Log.d(tag, "onPositionDiscontinuity: oldPosition=${oldPosition.positionMs}/${oldPosition.mediaItemIndex}, newPosition=${newPosition.positionMs}/${newPosition.mediaItemIndex}, isPlaying=${playerNotificationService.currentPlayer.isPlaying} reason=SEEK")
+      playerNotificationService.mediaProgressSyncer.seek()
+      lastPauseTime = 0 // When seeking while paused reset the auto-rewind
+    } else {
+      Log.d(tag, "onPositionDiscontinuity: oldPosition=${oldPosition.positionMs}/${oldPosition.mediaItemIndex}, newPosition=${newPosition.positionMs}/${newPosition.mediaItemIndex}, isPlaying=${playerNotificationService.currentPlayer.isPlaying}, reason=$reason")
+    }
+  }
+
+  override fun onIsPlayingChanged(isPlaying: Boolean) {
+    Log.d(tag, "onIsPlayingChanged to $isPlaying | ${playerNotificationService.getMediaPlayer()} | playbackState=${playerNotificationService.currentPlayer.playbackState}")
+
+    val player = playerNotificationService.currentPlayer
+
+    // Goal of these 2 if statements and the lazyIsPlaying is to ignore this event when it is triggered by a seek
+    //  When a seek occurs the player is paused and buffering, then plays again right afterwards.
+    if (!isPlaying && player.playbackState == Player.STATE_BUFFERING) {
+      Log.d(tag, "onIsPlayingChanged: Pause event when buffering is ignored")
+      return
+    }
+    if (lazyIsPlaying == isPlaying) {
+      Log.d(tag, "onIsPlayingChanged: Lazy is playing $lazyIsPlaying is already set to this so ignoring")
+      return
+    }
+
+    lazyIsPlaying = isPlaying
+
+    // Update widget
+    DeviceManager.widgetUpdater?.onPlayerChanged(playerNotificationService)
+
+    if (isPlaying) {
+      Log.d(tag, "SeekBackTime: Player is playing")
+      if (lastPauseTime > 0 && DeviceManager.deviceData.deviceSettings?.disableAutoRewind != true) {
+        Log.d(tag, "SeekBackTime: playing started now set seek back time $lastPauseTime")
+        var seekBackTime = calcPauseSeekBackTime()
+        if (seekBackTime > 0) {
+          // Current chapter is used so that seek back does not go back to the previous chapter
+          val currentChapter = playerNotificationService.getCurrentBookChapter()
+          val minSeekBackTime = currentChapter?.startMs ?: 0
+
+          val currentTime = playerNotificationService.getCurrentTime()
+          val newTime = currentTime - seekBackTime
+          if (newTime < minSeekBackTime) {
+            seekBackTime = currentTime - minSeekBackTime
+          }
+          Log.d(tag, "SeekBackTime $seekBackTime")
+        }
+
+        // TODO: this needs to be reworked so that the audio doesn't start playing before it checks for updated progress
+        // Check if playback session still exists or sync media progress if updated
+//        val pauseLength: Long = System.currentTimeMillis() - lastPauseTime
+//        if (pauseLength > PAUSE_LEN_BEFORE_RECHECK) {
+//          val shouldCarryOn = playerNotificationService.checkCurrentSessionProgress(seekBackTime)
+//          if (!shouldCarryOn) return
+//        }
+
+        if (seekBackTime > 0L) {
+          playerNotificationService.seekBackward(seekBackTime)
+        }
+      }
+    } else {
+      Log.d(tag, "SeekBackTime: Player not playing set last pause time | playbackState=${player.playbackState}")
+      lastPauseTime = System.currentTimeMillis()
+    }
+
+    // Start/stop progress sync interval
+    if (isPlaying) {
+      val playbackSession: PlaybackSession? = playerNotificationService.mediaProgressSyncer.currentPlaybackSession ?: playerNotificationService.currentPlaybackSession
+      playbackSession?.let {
+        // Handles auto-starting sleep timer and resetting sleep timer
+        playerNotificationService.sleepTimerManager.handleMediaPlayEvent(it.id)
+
+        player.volume = 1F // Volume on sleep timer might have decreased this
+
+        playerNotificationService.mediaProgressSyncer.play(it)
+      }
+    } else {
+      playerNotificationService.mediaProgressSyncer.pause {
+        Log.d(tag, "Media Progress Syncer paused and synced")
+      }
+    }
+
+    playerNotificationService.clientEventEmitter?.onPlayingUpdate(isPlaying)
+  }
+
  override fun onEvents(player: Player, events: Player.Events) {
-    Log.d(tag, "onEvents ${player.deviceInfo} | ${playerNotificationService.getMediaPlayer()} | ${events.size()}")
+    Log.d(tag, "onEvents ${playerNotificationService.getMediaPlayer()} | ${events.size()}")

    if (events.contains(Player.EVENT_POSITION_DISCONTINUITY)) {
      Log.d(tag, "EVENT_POSITION_DISCONTINUITY")
@@ -38,7 +132,7 @@ class PlayerListener(var playerNotificationService:PlayerNotificationService) :
        Log.d(tag, "STATE_READY : " + playerNotificationService.currentPlayer.duration)

        if (lastPauseTime == 0L) {
-          lastPauseTime = -1;
+          lastPauseTime = -1
        }
        playerNotificationService.sendClientMetadata(PlayerState.READY)
      }
@@ -49,6 +143,8 @@ class PlayerListener(var playerNotificationService:PlayerNotificationService) :
      if (playerNotificationService.currentPlayer.playbackState == Player.STATE_ENDED) {
        Log.d(tag, "STATE_ENDED")
        playerNotificationService.sendClientMetadata(PlayerState.ENDED)
+
+        playerNotificationService.handlePlaybackEnded()
      }
      if (playerNotificationService.currentPlayer.playbackState == Player.STATE_IDLE) {
        Log.d(tag, "STATE_IDLE")
@@ -62,49 +158,15 @@ class PlayerListener(var playerNotificationService:PlayerNotificationService) :
    if (events.contains(Player.EVENT_PLAYLIST_METADATA_CHANGED)) {
      Log.d(tag, "EVENT_PLAYLIST_METADATA_CHANGED ${playerNotificationService.getMediaPlayer()}")
    }
-    if (events.contains(Player.EVENT_IS_PLAYING_CHANGED)) {
-      Log.d(tag, "EVENT IS PLAYING CHANGED ${playerNotificationService.getMediaPlayer()}")
-
-      if (player.isPlaying) {
-        Log.d(tag, "SeekBackTime: Player is playing")
-        if (lastPauseTime > 0) {
-          if (onSeekBack) onSeekBack = false
-          else {
-            Log.d(tag, "SeekBackTime: playing started now set seek back time $lastPauseTime")
-            var backTime = calcPauseSeekBackTime()
-            if (backTime > 0) {
-              if (backTime >= playerNotificationService.getCurrentTime()) backTime = playerNotificationService.getCurrentTime() - 500
-              Log.d(tag, "SeekBackTime $backTime")
-              onSeekBack = true
-              playerNotificationService.seekBackward(backTime)
-            } else {
-              Log.d(tag, "SeekBackTime: back time is 0")
-            }
-          }
-        }
-      } else {
-        Log.d(tag, "SeekBackTime: Player not playing set last pause time")
-        lastPauseTime = System.currentTimeMillis()
-      }
-
-      // Start/stop progress sync interval
-      Log.d(tag, "Playing ${playerNotificationService.getCurrentBookTitle()}")
-      if (player.isPlaying) {
-        playerNotificationService.mediaProgressSyncer.start()
-      } else {
-        playerNotificationService.mediaProgressSyncer.stop()
-      }
-
-      playerNotificationService.clientEventEmitter?.onPlayingUpdate(player.isPlaying)
-    }
  }

  private fun calcPauseSeekBackTime() : Long {
    if (lastPauseTime <= 0) return 0
-    var time: Long = System.currentTimeMillis() - lastPauseTime
-    var seekback: Long
-    if (time < 3000) seekback = 0
-    else if (time < 300000) seekback = 10000 // 3s to 5m = jump back 10s
+    val time: Long = System.currentTimeMillis() - lastPauseTime
+    val seekback: Long
+    if (time < 10000) seekback = 0 // 10s or less = no seekback
+    else if (time < 60000) seekback = 3000 // 10s to 1m = jump back 3s
+    else if (time < 300000) seekback = 10000 // 1m to 5m = jump back 10s
    else if (time < 1800000) seekback = 20000 // 5m to 30m = jump back 20s
    else seekback = 29500 // 30m and up = jump back 30s
    return seekback
@@ -1,20 +1,37 @@
 package com.audiobookshelf.app.player

 import android.app.Notification
+import android.content.pm.ServiceInfo
+import android.os.Build
 import android.util.Log
 import com.google.android.exoplayer2.ui.PlayerNotificationManager

 class PlayerNotificationListener(var playerNotificationService:PlayerNotificationService) : PlayerNotificationManager.NotificationListener {
  var tag = "PlayerNotificationListener"

+  companion object {
+    var isForegroundService = false
+  }
+
  override fun onNotificationPosted(
    notificationId: Int,
    notification: Notification,
    onGoing: Boolean) {

-    // Start foreground service
-    Log.d(tag, "Notification Posted $notificationId - Start Foreground | $notification")
-    playerNotificationService.startForeground(notificationId, notification)
+    if (onGoing && !isForegroundService) {
+      // Start foreground service
+      Log.d(tag, "Notification Posted $notificationId - Start Foreground | $notification")
+      PlayerNotificationService.isClosed = false
+
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+        playerNotificationService.startForeground(notificationId, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK)
+      } else {
+        playerNotificationService.startForeground(notificationId, notification)
+      }
+      isForegroundService = true
+    } else {
+      Log.d(tag, "Notification posted $notificationId, not starting foreground - onGoing=$onGoing | isForegroundService=$isForegroundService")
+    }
  }

  override fun onNotificationCancelled(
@@ -26,6 +43,14 @@ class PlayerNotificationListener(var playerNotificationService:PlayerNotificatio
      playerNotificationService.stopSelf()
    } else {
      Log.d(tag, "onNotificationCancelled not dismissed by user")
+
+      if (PlayerNotificationService.isSwitchingPlayer) {
+        // When switching from cast player to exo player and vice versa the notification is cancelled and posted again
+          // so we don't want to cancel the playback during this switch
+        Log.d(tag, "PNS is switching player")
+        PlayerNotificationService.isSwitchingPlayer = false
+      }
    }
+    isForegroundService = false
  }
 }
@@ -4,6 +4,8 @@ import android.hardware.Sensor
 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 {
@@ -34,7 +36,8 @@ class ShakeDetector : SensorEventListener {
      val gZ = z / SensorManager.GRAVITY_EARTH
      // gForce will be close to 1 when there is no movement.
      val gForce: Float = sqrt(gX * gX + gY * gY + gZ * gZ)
-      if (gForce > SHAKE_THRESHOLD_GRAVITY) {
+      val shakeThreshold = DeviceManager.deviceData.deviceSettings?.getShakeThresholdGravity() ?: 1.6f
+      if (gForce > shakeThreshold) {
        val now = System.currentTimeMillis()
        // ignore shake events too close to each other (500ms)
        if (mShakeTimestamp + SHAKE_SLOP_TIME_MS > now) {
@@ -44,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)
@@ -59,7 +63,7 @@ class ShakeDetector : SensorEventListener {
 * from the Google Play Store and run it to see how
 *  many G's it takes to register a shake
 */
-    private const val SHAKE_THRESHOLD_GRAVITY = 1.5f // orig 2.7f
+//    var SHAKE_THRESHOLD_GRAVITY = 1.5f // orig 2.7f
    private const val SHAKE_SLOP_TIME_MS = 500
    private const val SHAKE_COUNT_RESET_TIME_MS = 3000
  }
@@ -1,251 +0,0 @@
-package com.audiobookshelf.app.player
-
-import android.content.Context
-import android.os.*
-import android.util.Log
-import java.util.*
-import kotlin.concurrent.schedule
-import kotlin.math.roundToInt
-
-const val SLEEP_EXTENSION_TIME = 900000L // 15m
-
-class SleepTimerManager constructor(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 sleepTimerExtensionTime:Long = 0L
-  private var sleepTimerFinishedAt:Long = 0L
-
-  private fun getCurrentTime():Long {
-    return playerNotificationService.getCurrentTime()
-  }
-
-  private fun getDuration():Long {
-    return playerNotificationService.getDuration()
-  }
-
-  private fun getIsPlaying():Boolean {
-    return playerNotificationService.currentPlayer.isPlaying
-  }
-
-  private fun setVolume(volume:Float) {
-    playerNotificationService.currentPlayer.volume = volume
-  }
-
-  private fun pause() {
-    playerNotificationService.currentPlayer.pause()
-  }
-
-  private fun play() {
-    playerNotificationService.currentPlayer.play()
-  }
-
-  private fun getSleepTimerTimeRemainingSeconds():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()
-  }
-
-  fun setSleepTimer(time: Long, isChapterTime: Boolean) : Boolean {
-    Log.d(tag, "Setting Sleep Timer for $time is chapter time $isChapterTime")
-    sleepTimerTask?.cancel()
-    sleepTimerRunning = false
-    sleepTimerFinishedAt = 0L
-    sleepTimerElapsed = 0L
-
-    // Register shake sensor
-    playerNotificationService.registerSensor()
-
-    val currentTime = getCurrentTime()
-    if (isChapterTime) {
-      if (currentTime > time) {
-        Log.d(tag, "Invalid sleep timer - current time is already passed chapter time $time")
-        return false
-      }
-      sleepTimerEndTime = time
-      sleepTimerLength = 0
-      sleepTimerExtensionTime = SLEEP_EXTENSION_TIME
-
-      if (sleepTimerEndTime > getDuration()) {
-        sleepTimerEndTime = getDuration()
-      }
-    } else {
-      sleepTimerLength = time
-      sleepTimerEndTime = 0L
-      sleepTimerExtensionTime = time
-
-      if (sleepTimerLength + getCurrentTime() > getDuration()) {
-        sleepTimerLength = getDuration() - getCurrentTime()
-      }
-    }
-
-    playerNotificationService.clientEventEmitter?.onSleepTimerSet(getSleepTimerTimeRemainingSeconds())
-
-    sleepTimerRunning = true
-    sleepTimerTask = Timer("SleepTimer", false).schedule(0L, 1000L) {
-      Handler(Looper.getMainLooper()).post() {
-        if (getIsPlaying()) {
-          sleepTimerElapsed += 1000L
-
-          val sleepTimeSecondsRemaining = getSleepTimerTimeRemainingSeconds()
-          Log.d(tag, "Timer Elapsed $sleepTimerElapsed | Sleep TIMER time remaining $sleepTimeSecondsRemaining s")
-
-          if (sleepTimeSecondsRemaining > 0) {
-            playerNotificationService.clientEventEmitter?.onSleepTimerSet(sleepTimeSecondsRemaining)
-          }
-
-          if (sleepTimeSecondsRemaining <= 0) {
-            Log.d(tag, "Sleep Timer Pausing Player on Chapter")
-            pause()
-
-            playerNotificationService.clientEventEmitter?.onSleepTimerEnded(getCurrentTime())
-            clearSleepTimer()
-            sleepTimerFinishedAt = System.currentTimeMillis()
-          } else if (sleepTimeSecondsRemaining <= 30) {
-            // Start fading out audio
-            val volume = sleepTimeSecondsRemaining / 30F
-            Log.d(tag, "SLEEP VOLUME FADE $volume | ${sleepTimeSecondsRemaining}s remaining")
-            setVolume(volume)
-          }
-        }
-      }
-    }
-    return true
-  }
-
-  fun clearSleepTimer() {
-    sleepTimerTask?.cancel()
-    sleepTimerTask = null
-    sleepTimerEndTime = 0
-    sleepTimerRunning = false
-    playerNotificationService.unregisterSensor()
-  }
-
-  fun getSleepTimerTime():Long {
-    return sleepTimerEndTime
-  }
-
-  fun cancelSleepTimer() {
-    Log.d(tag, "Canceling Sleep Timer")
-    clearSleepTimer()
-    playerNotificationService.clientEventEmitter?.onSleepTimerSet(0)
-  }
-
-  // Vibrate when extending sleep timer by shaking
-  private fun vibrate() {
-    val context = playerNotificationService.getContext()
-    val vibrator:Vibrator
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-      val vibratorManager =
-        context.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as VibratorManager
-      vibrator = vibratorManager.defaultVibrator
-    } else {
-      @Suppress("DEPRECATION")
-      vibrator = context.getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
-    }
-
-    vibrator.let {
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-        val vibrationEffect = VibrationEffect.createWaveform(longArrayOf(0, 150, 150, 150),-1)
-        it.vibrate(vibrationEffect)
-      } else {
-        @Suppress("DEPRECATION")
-        it.vibrate(10)
-      }
-    }
-  }
-
-  private fun extendSleepTime() {
-    if (!sleepTimerRunning) return
-    setVolume(1F)
-    if (sleepTimerEndTime == 0L) {
-      sleepTimerLength += sleepTimerExtensionTime
-      if (sleepTimerLength + getCurrentTime() > getDuration()) sleepTimerLength = getDuration() - getCurrentTime()
-    } else {
-      sleepTimerEndTime += sleepTimerExtensionTime
-      if (sleepTimerEndTime > getDuration()) sleepTimerEndTime = getDuration()
-    }
-
-    playerNotificationService.clientEventEmitter?.onSleepTimerSet(getSleepTimerTimeRemainingSeconds())
-  }
-
-  fun checkShouldExtendSleepTimer() {
-    if (!sleepTimerRunning) {
-      if (sleepTimerFinishedAt <= 0L) return
-
-      val finishedAtDistance = System.currentTimeMillis() - sleepTimerFinishedAt
-      if (finishedAtDistance > SLEEP_TIMER_WAKE_UP_EXPIRATION) // 2 minutes
-      {
-        Log.d(tag, "Sleep timer finished over 2 mins ago, clearing it")
-        sleepTimerFinishedAt = 0L
-        return
-      }
-
-      val newSleepTime = if (sleepTimerExtensionTime >= 0) sleepTimerExtensionTime else SLEEP_EXTENSION_TIME
-      vibrate()
-      setSleepTimer(newSleepTime, false)
-      play()
-      return
-    }
-    // Only extend if within 30 seconds of finishing
-    val sleepTimeRemaining = getSleepTimerTimeRemainingSeconds()
-    if (sleepTimeRemaining <= 30) {
-      vibrate()
-      extendSleepTime()
-    }
-  }
-
-  fun handleShake() {
-    Log.d(tag, "HANDLE SHAKE HERE")
-    if (sleepTimerRunning || sleepTimerFinishedAt > 0L) checkShouldExtendSleepTimer()
-  }
-
-  fun increaseSleepTime(time: Long) {
-    Log.d(tag, "Increase Sleep time $time")
-    if (!sleepTimerRunning) return
-
-    if (sleepTimerEndTime == 0L) {
-      sleepTimerLength += time
-      if (sleepTimerLength + getCurrentTime() > getDuration()) sleepTimerLength = getDuration() - getCurrentTime()
-    } else {
-      val newSleepEndTime = sleepTimerEndTime + time
-      sleepTimerEndTime = if (newSleepEndTime >= getDuration()) {
-        getDuration()
-      } else {
-        newSleepEndTime
-      }
-    }
-
-    setVolume(1F)
-    playerNotificationService.clientEventEmitter?.onSleepTimerSet(getSleepTimerTimeRemainingSeconds())
-  }
-
-  fun decreaseSleepTime(time: Long) {
-    Log.d(tag, "Decrease Sleep time $time")
-    if (!sleepTimerRunning) return
-
-
-    if (sleepTimerEndTime == 0L) {
-      sleepTimerLength -= time
-      if (sleepTimerLength <= 0) sleepTimerLength = 1000L
-    } else {
-      val newSleepEndTime = sleepTimerEndTime - time
-      sleepTimerEndTime = if (newSleepEndTime <= 1000) {
-        // End sleep timer in 1 second
-        getCurrentTime() + 1000
-      } else {
-        newSleepEndTime
-      }
-    }
-
-    setVolume(1F)
-    playerNotificationService.clientEventEmitter?.onSleepTimerSet(getSleepTimerTimeRemainingSeconds())
-  }
-}
@@ -1,14 +1,14 @@
 package com.audiobookshelf.app.plugins

-import android.content.Intent
 import android.os.Handler
 import android.os.Looper
 import android.util.Log
-import androidx.core.content.ContextCompat
 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.player.CastManager
+import com.audiobookshelf.app.player.PlayerListener
 import com.audiobookshelf.app.player.PlayerNotificationService
 import com.audiobookshelf.app.server.ApiHandler
 import com.fasterxml.jackson.core.json.JsonReadFeature
@@ -23,7 +23,7 @@ import org.json.JSONObject
@CapacitorPlugin(name = "AbsAudioPlayer")
 class AbsAudioPlayer : Plugin() {
  private val tag = "AbsAudioPlayer"
-  var jacksonMapper = jacksonObjectMapper().enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature())
+  private var jacksonMapper = jacksonObjectMapper().enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature())

  private lateinit var mainActivity: MainActivity
  private lateinit var apiHandler:ApiHandler
@@ -33,11 +33,18 @@ 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)

-    initCastManager()
+    try {
+      initCastManager()
+    } catch(e:Exception) {
+      Log.e(tag, "initCastManager exception ${e.printStackTrace()}")
+    }

    val foregroundServiceReady : () -> Unit = {
      playerNotificationService = mainActivity.foregroundService
@@ -56,25 +63,27 @@ 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)))
        }

-        override fun onPrepare(audiobookId: String, playWhenReady: Boolean) {
-          val jsobj = JSObject()
-          jsobj.put("audiobookId", audiobookId)
-          jsobj.put("playWhenReady", playWhenReady)
-          notifyListeners("onPrepareMedia", jsobj)
-        }
-
        override fun onSleepTimerEnded(currentPosition: Long) {
          emit("onSleepTimerEnded", currentPosition)
        }

-        override fun onSleepTimerSet(sleepTimeRemaining: Int) {
-          emit("onSleepTimerSet", sleepTimeRemaining)
+        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)
+          notifyListeners("onSleepTimerSet", ret)
        }

        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)))
        }

@@ -85,7 +94,29 @@ class AbsAudioPlayer : Plugin() {
        override fun onMediaPlayerChanged(mediaPlayer:String) {
          emit("onMediaPlayerChanged", mediaPlayer)
        }
+
+        override fun onProgressSyncFailing() {
+          emit("onProgressSyncFailing", "")
+        }
+
+        override fun onProgressSyncSuccess() {
+          emit("onProgressSyncSuccess", "")
+        }
+
+        override fun onNetworkMeteredChanged(isUnmetered:Boolean) {
+          emit("onNetworkMeteredChanged", isUnmetered)
+        }
+
+        override fun onMediaItemHistoryUpdated(mediaItemHistory:MediaItemHistory) {
+          notifyListeners("onMediaItemHistoryUpdated", JSObject(jacksonMapper.writeValueAsString(mediaItemHistory)))
+        }
+
+        override fun onPlaybackSpeedChanged(playbackSpeed:Float) {
+          emit("onPlaybackSpeedChanged", playbackSpeed)
+        }
      })
+
+      MediaEventManager.clientEventEmitter = playerNotificationService.clientEventEmitter
    }
    mainActivity.pluginCallback = foregroundServiceReady
  }
@@ -96,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)
@@ -153,22 +210,17 @@ class AbsAudioPlayer : Plugin() {

  @PluginMethod
  fun prepareLibraryItem(call: PluginCall) {
-    // Need to make sure the player service has been started
-    if (!PlayerNotificationService.isStarted) {
-      Log.w(tag, "prepareLibraryItem: PlayerService not started - Starting foreground service --")
-      Intent(mainActivity, PlayerNotificationService::class.java).also { intent ->
-        ContextCompat.startForegroundService(mainActivity, intent)
-      }
-    }
-
    val libraryItemId = call.getString("libraryItemId", "").toString()
    val episodeId = call.getString("episodeId", "").toString()
    val playWhenReady = call.getBoolean("playWhenReady") == true
    val playbackRate = call.getFloat("playbackRate",1f) ?: 1f
+    val startTimeOverride = call.getDouble("startTime")
+
+    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")
-      return call.resolve()
+      return call.resolve(JSObject("{\"error\":\"Invalid request\"}"))
    }

    if (libraryItemId.startsWith("local")) { // Play local media item
@@ -179,28 +231,63 @@ class AbsAudioPlayer : Plugin() {
          episode = podcastMedia.episodes?.find { ep -> ep.id == episodeId }
          if (episode == null) {
            Log.e(tag, "prepareLibraryItem: Podcast episode not found $episodeId")
-            return call.resolve(JSObject())
+            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)}")
-          val playbackSession = it.getPlaybackSession(episode)
-          playerNotificationService.preparePlayer(playbackSession, playWhenReady, playbackRate)
+          val playbackSession = it.getPlaybackSession(episode, playerNotificationService.getDeviceInfo())
+          if (startTimeOverride != null) {
+            Log.d(tag, "prepareLibraryItem: Using start time override $startTimeOverride")
+            playbackSession.currentTime = startTimeOverride
+          }
+
+          if (playerNotificationService.mediaProgressSyncer.listeningTimerRunning) { // If progress syncing then first stop before preparing next
+            playerNotificationService.mediaProgressSyncer.stop {
+              Log.d(tag, "Media progress syncer was already syncing - stopped")
+              PlayerListener.lazyIsPlaying = false
+
+              Handler(Looper.getMainLooper()).post { // TODO: This was needed again which is probably a design a flaw
+                playerNotificationService.preparePlayer(
+                  playbackSession,
+                  playWhenReady,
+                  playbackRate
+                )
+              }
+            }
+          } else {
+            playerNotificationService.mediaProgressSyncer.reset()
+            playerNotificationService.preparePlayer(playbackSession, playWhenReady, playbackRate)
+          }
        }
        return call.resolve(JSObject())
      }
    } else { // Play library item from server
-      val mediaPlayer = playerNotificationService.getMediaPlayer()
+      val playItemRequestPayload = playerNotificationService.getPlayItemRequestPayload(false)
+      Handler(Looper.getMainLooper()).post {
+        playerNotificationService.mediaProgressSyncer.stop {
+          apiHandler.playLibraryItem(libraryItemId, episodeId, playItemRequestPayload) {
+            if (it == null) {
+              call.resolve(JSObject("{\"error\":\"Server play request failed\"}"))
+            } else {
+              if (startTimeOverride != null) {
+                Log.d(tag, "prepareLibraryItem: Using start time override $startTimeOverride")
+                it.currentTime = startTimeOverride
+              }

-      apiHandler.playLibraryItem(libraryItemId, episodeId, false, mediaPlayer) {
-
-        Handler(Looper.getMainLooper()).post {
-          Log.d(tag, "Preparing Player TEST ${jacksonMapper.writeValueAsString(it)}")
-          playerNotificationService.preparePlayer(it, playWhenReady, playbackRate)
+              Handler(Looper.getMainLooper()).post {
+                Log.d(tag, "Preparing Player playback session ${jacksonMapper.writeValueAsString(it)}")
+                PlayerListener.lazyIsPlaying = false
+                playerNotificationService.preparePlayer(it, playWhenReady, playbackRate)
+              }
+              call.resolve(JSObject(jacksonMapper.writeValueAsString(it)))
+            }
+          }
        }
-
-        call.resolve(JSObject(jacksonMapper.writeValueAsString(it)))
      }
    }
  }
@@ -243,9 +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()
    }
  }
@@ -292,7 +380,8 @@ class AbsAudioPlayer : Plugin() {
    val isChapterTime:Boolean = call.getBoolean("isChapterTime", false) == true

    Handler(Looper.getMainLooper()).post {
-        val success:Boolean = playerNotificationService.sleepTimerManager.setSleepTimer(time, isChapterTime)
+        val playbackSession: PlaybackSession? = playerNotificationService.mediaProgressSyncer.currentPlaybackSession ?: playerNotificationService.currentPlaybackSession
+        val success:Boolean = playerNotificationService.sleepTimerManager.setManualSleepTimer(playbackSession?.id ?: "", time, isChapterTime)
        val ret = JSObject()
        ret.put("success", success)
        call.resolve(ret)
@@ -333,7 +422,9 @@ class AbsAudioPlayer : Plugin() {

  @PluginMethod
  fun cancelSleepTimer(call: PluginCall) {
-    playerNotificationService.sleepTimerManager.cancelSleepTimer()
+    Handler(Looper.getMainLooper()).post {
+      playerNotificationService.sleepTimerManager.cancelSleepTimer()
+    }
    call.resolve()
  }

@@ -1,42 +1,53 @@
-package com.audiobookshelf.app.data
+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
 import com.getcapacitor.*
 import com.getcapacitor.annotation.CapacitorPlugin
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
-import org.json.JSONObject

@CapacitorPlugin(name = "AbsDatabase")
 class AbsDatabase : Plugin() {
  val tag = "AbsDatabase"
-  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
-  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, 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
  fun getDeviceData(call:PluginCall) {
    GlobalScope.launch(Dispatchers.IO) {
-      var deviceData = DeviceManager.dbManager.getDeviceData()
+      val deviceData = DeviceManager.dbManager.getDeviceData()
      call.resolve(JSObject(jacksonMapper.writeValueAsString(deviceData)))
    }
  }
@@ -44,17 +55,17 @@ class AbsDatabase : Plugin() {
  @PluginMethod
  fun getLocalFolders(call:PluginCall) {
    GlobalScope.launch(Dispatchers.IO) {
-      var folders = DeviceManager.dbManager.getAllLocalFolders()
+      val folders = DeviceManager.dbManager.getAllLocalFolders()
      call.resolve(JSObject(jacksonMapper.writeValueAsString(LocalFoldersPayload(folders))))
    }
  }

  @PluginMethod
  fun getLocalFolder(call:PluginCall) {
-    var folderId = call.getString("folderId", "").toString()
+    val folderId = call.getString("folderId", "").toString()
    GlobalScope.launch(Dispatchers.IO) {
      DeviceManager.dbManager.getLocalFolder(folderId)?.let {
-        var folderObj = jacksonMapper.writeValueAsString(it)
+        val folderObj = jacksonMapper.writeValueAsString(it)
        call.resolve(JSObject(folderObj))
      } ?: call.resolve()
    }
@@ -62,10 +73,10 @@ class AbsDatabase : Plugin() {

  @PluginMethod
  fun getLocalLibraryItem(call:PluginCall) {
-    var id = call.getString("id", "").toString()
+    val id = call.getString("id", "").toString()

    GlobalScope.launch(Dispatchers.IO) {
-      var localLibraryItem = DeviceManager.dbManager.getLocalLibraryItem(id)
+      val localLibraryItem = DeviceManager.dbManager.getLocalLibraryItem(id)
      if (localLibraryItem == null) {
        call.resolve()
      } else {
@@ -75,10 +86,10 @@ class AbsDatabase : Plugin() {
  }

  @PluginMethod
-  fun getLocalLibraryItemByLLId(call:PluginCall) {
-    var libraryItemId = call.getString("libraryItemId", "").toString()
+  fun getLocalLibraryItemByLId(call:PluginCall) {
+    val libraryItemId = call.getString("libraryItemId", "").toString()
    GlobalScope.launch(Dispatchers.IO) {
-      var localLibraryItem = DeviceManager.dbManager.getLocalLibraryItemByLLId(libraryItemId)
+      val localLibraryItem = DeviceManager.dbManager.getLocalLibraryItemByLId(libraryItemId)
      if (localLibraryItem == null) {
        call.resolve()
      } else {
@@ -89,40 +100,52 @@ class AbsDatabase : Plugin() {

  @PluginMethod
  fun getLocalLibraryItems(call:PluginCall) {
-    var mediaType = call.getString("mediaType", "").toString()
+    val mediaType = call.getString("mediaType", "").toString()

    GlobalScope.launch(Dispatchers.IO) {
-      var localLibraryItems = DeviceManager.dbManager.getLocalLibraryItems(mediaType)
+      val localLibraryItems = DeviceManager.dbManager.getLocalLibraryItems(mediaType)
      call.resolve(JSObject(jacksonMapper.writeValueAsString(LocalLibraryItemsPayload(localLibraryItems))))
    }
  }

  @PluginMethod
  fun getLocalLibraryItemsInFolder(call:PluginCall) {
-    var folderId = call.getString("folderId", "").toString()
+    val folderId = call.getString("folderId", "").toString()
    GlobalScope.launch(Dispatchers.IO) {
-      var localLibraryItems = DeviceManager.dbManager.getLocalLibraryItemsInFolder(folderId)
+      val localLibraryItems = DeviceManager.dbManager.getLocalLibraryItemsInFolder(folderId)
      call.resolve(JSObject(jacksonMapper.writeValueAsString(LocalLibraryItemsPayload(localLibraryItems))))
    }
  }

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

-    var userId = call.getString("userId", "").toString()
-    var username = call.getString("username", "").toString()
-    var token = call.getString("token", "").toString()
+    val userId =  serverConfigPayload.userId
+    val username = serverConfigPayload.username
+    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
-        var serverAddress = call.getString("address", "").toString()
+        val serverAddress = call.getString("address", "").toString()

        // Create new server connection config
-        var sscId = DeviceManager.getBase64Id("$serverAddress@$username")
-        var sscIndex = DeviceManager.deviceData.serverConnectionConfigs.size
-        serverConnectionConfig = ServerConnectionConfig(sscId, sscIndex, "$serverAddress ($username)", serverAddress, userId, username, token)
+        val sscId = DeviceManager.getBase64Id("$serverAddress@$username")
+        val sscIndex = DeviceManager.deviceData.serverConnectionConfigs.size
+
+        // 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!!)
@@ -130,17 +153,24 @@ 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 != serverConnectionConfigId) {
-          DeviceManager.deviceData.lastServerConnectionConfigId = serverConnectionConfigId
+        if (DeviceManager.deviceData.lastServerConnectionConfigId != serverConfigPayload.id) {
+          DeviceManager.deviceData.lastServerConnectionConfigId = serverConfigPayload.id
          shouldSave = true
        }

@@ -155,7 +185,11 @@ class AbsDatabase : Plugin() {
  @PluginMethod
  fun removeServerConnectionConfig(call:PluginCall) {
    GlobalScope.launch(Dispatchers.IO) {
-      var serverConnectionConfigId = call.getString("serverConnectionConfigId", "").toString()
+      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
@@ -168,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) {
@@ -181,26 +251,124 @@ class AbsDatabase : Plugin() {
  @PluginMethod
  fun getAllLocalMediaProgress(call:PluginCall) {
    GlobalScope.launch(Dispatchers.IO) {
-      var localMediaProgress = DeviceManager.dbManager.getAllLocalMediaProgress()
+      val localMediaProgress = DeviceManager.dbManager.getAllLocalMediaProgress()
      call.resolve(JSObject(jacksonMapper.writeValueAsString(LocalMediaProgressPayload(localMediaProgress))))
    }
  }

+  @PluginMethod
+  fun getLocalMediaProgressForServerItem(call:PluginCall) {
+    val libraryItemId = call.getString("libraryItemId", "").toString()
+    var episodeId:String? = call.getString("episodeId", "").toString()
+    if (episodeId == "") episodeId = null
+
+    GlobalScope.launch(Dispatchers.IO) {
+      val allLocalMediaProgress = DeviceManager.dbManager.getAllLocalMediaProgress()
+      val localMediaProgress = allLocalMediaProgress.find { libraryItemId == it.libraryItemId && (episodeId == null || it.episodeId == episodeId) }
+
+      if (localMediaProgress == null) {
+        call.resolve()
+      } else {
+        call.resolve(JSObject(jacksonMapper.writeValueAsString(localMediaProgress)))
+      }
+    }
+  }
+
  @PluginMethod
  fun removeLocalMediaProgress(call:PluginCall) {
-    var localMediaProgressId = call.getString("localMediaProgressId", "").toString()
+    val localMediaProgressId = call.getString("localMediaProgressId", "").toString()
    DeviceManager.dbManager.removeLocalMediaProgress(localMediaProgressId)
    call.resolve()
  }

  @PluginMethod
-  fun syncLocalMediaProgressWithServer(call:PluginCall) {
+  fun syncLocalSessionsWithServer(call:PluginCall) {
    if (DeviceManager.serverConnectionConfig == null) {
-      Log.e(tag, "syncLocalMediaProgressWithServer not connected to server")
+      AbsLogger.error("AbsDatabase", "syncLocalSessionsWithServer: not connected to server")
      return call.resolve()
    }
-    apiHandler.syncMediaProgress {
-      call.resolve(JSObject(jacksonMapper.writeValueAsString(it)))
+
+    apiHandler.syncLocalMediaProgressForUser {
+      val savedSessions = DeviceManager.dbManager.getPlaybackSessions().filter { it.serverConnectionConfigId == DeviceManager.serverConnectionConfigId }
+
+      if (savedSessions.isNotEmpty()) {
+        apiHandler.sendSyncLocalSessions(savedSessions) { success, errorMsg ->
+          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)
+            }
+            call.resolve()
+          }
+        }
+      } else {
+        AbsLogger.info("AbsDatabase", "syncLocalSessionsWithServer: No saved local playback sessions to send to server.")
+        call.resolve()
+      }
+    }
+  }
+
+  // Updates received via web socket
+  // This function doesn't need to sync with the server also because this data is coming from the server
+  // If sending the localMediaProgressId then update existing media progress
+  // If sending localLibraryItemId then save new local media progress
+  @PluginMethod
+  fun syncServerMediaProgressWithLocalMediaProgress(call:PluginCall) {
+    val serverMediaProgress = call.getObject("mediaProgress").toString()
+    val localLibraryItemId = call.getString("localLibraryItemId", "").toString()
+    var localEpisodeId:String? = call.getString("localEpisodeId", "").toString()
+    if (localEpisodeId.isNullOrEmpty()) localEpisodeId = null
+    var localMediaProgressId = call.getString("localMediaProgressId") ?: ""
+
+    val mediaProgress =  jacksonMapper.readValue<MediaProgress>(serverMediaProgress)
+
+    if (localMediaProgressId == "") {
+      val localLibraryItem = DeviceManager.dbManager.getLocalLibraryItem(localLibraryItemId)
+      if (localLibraryItem != null) {
+        localMediaProgressId = if (localEpisodeId.isNullOrEmpty()) localLibraryItemId else "$localLibraryItemId-$localEpisodeId"
+
+        val localMediaProgress = 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 = localLibraryItem.serverConnectionConfigId,
+          serverAddress = localLibraryItem.serverAddress,
+          serverUserId = localLibraryItem.serverUserId,
+          libraryItemId = localLibraryItem.libraryItemId,
+          episodeId = mediaProgress.episodeId)
+
+        Log.d(tag, "syncServerMediaProgressWithLocalMediaProgress: Saving new local media progress $localMediaProgress")
+        DeviceManager.dbManager.saveLocalMediaProgress(localMediaProgress)
+        call.resolve(JSObject(jacksonMapper.writeValueAsString(localMediaProgress)))
+      } else {
+        Log.e(tag, "syncServerMediaProgressWithLocalMediaProgress: Local library item not found")
+      }
+    } else {
+      Log.d(tag, "syncServerMediaProgressWithLocalMediaProgress $localMediaProgressId")
+      val localMediaProgress = DeviceManager.dbManager.getLocalMediaProgress(localMediaProgressId)
+
+      if (localMediaProgress == null) {
+        Log.w(tag, "syncServerMediaProgressWithLocalMediaProgress Local media progress not found $localMediaProgressId")
+        call.resolve()
+      } else {
+        MediaEventManager.syncEvent(mediaProgress, "Received from webhook event")
+
+        localMediaProgress.updateFromServerMediaProgress(mediaProgress)
+        DeviceManager.dbManager.saveLocalMediaProgress(localMediaProgress)
+        call.resolve(JSObject(jacksonMapper.writeValueAsString(localMediaProgress)))
+      }
    }
  }

@@ -227,8 +395,8 @@ class AbsDatabase : Plugin() {
        return call.resolve(JSObject("{\"error\":\"Invalid library item not a podcast\"}"))
      }

-      var duration = 0.0
-      var podcastEpisode:PodcastEpisode? = null
+      val duration: Double
+      var podcastEpisode: PodcastEpisode? = null
      if (!localEpisodeId.isNullOrEmpty()) {
          val podcast = localLibraryItem.media as Podcast
        podcastEpisode = podcast.episodes?.find { episode ->
@@ -252,6 +420,8 @@ class AbsDatabase : Plugin() {
        progress = if (isFinished) 1.0 else 0.0,
        currentTime = 0.0,
        isFinished = isFinished,
+        ebookLocation = null,
+        ebookProgress = null,
        lastUpdate = currentTime,
        startedAt = if (isFinished) currentTime else 0L,
        finishedAt = if (isFinished) currentTime else null,
@@ -273,13 +443,13 @@ class AbsDatabase : Plugin() {
    // Send update to server media progress is linked to a server and user is logged into that server
    localMediaProgress.serverConnectionConfigId?.let { configId ->
      if (DeviceManager.serverConnectionConfigId == configId) {
-        var libraryItemId = localMediaProgress.libraryItemId ?: ""
-        var episodeId = localMediaProgress.episodeId ?: ""
-        var updatePayload = JSObject()
+        val libraryItemId = localMediaProgress.libraryItemId ?: ""
+        val episodeId = localMediaProgress.episodeId ?: ""
+        val updatePayload = JSObject()
        updatePayload.put("isFinished", isFinished)
        apiHandler.updateMediaProgress(libraryItemId,episodeId,updatePayload) {
          Log.d(tag, "updateLocalMediaProgressFinished: Updated media progress isFinished on server")
-          var jsobj = JSObject()
+          val jsobj = JSObject()
          jsobj.put("local", true)
          jsobj.put("server", true)
          jsobj.put("localMediaProgress", JSObject(lmpstring))
@@ -288,7 +458,7 @@ class AbsDatabase : Plugin() {
      }
    }
    if (localMediaProgress.serverConnectionConfigId == null || DeviceManager.serverConnectionConfigId != localMediaProgress.serverConnectionConfigId) {
-      var jsobj = JSObject()
+      val jsobj = JSObject()
      jsobj.put("local", true)
      jsobj.put("server", false)
      jsobj.put("localMediaProgress", JSObject(lmpstring))
@@ -296,27 +466,76 @@ class AbsDatabase : Plugin() {
    }
  }

+  @PluginMethod
+  fun updateLocalEbookProgress(call:PluginCall) {
+    val localLibraryItemId = call.getString("localLibraryItemId", "").toString()
+    val ebookLocation = call.getString("ebookLocation", "").toString()
+    val ebookProgress = call.getDouble("ebookProgress") ?: 0.0
+
+    val localMediaProgressId = localLibraryItemId
+    var localMediaProgress = DeviceManager.dbManager.getLocalMediaProgress(localMediaProgressId)
+
+    if (localMediaProgress == null) {
+      Log.d(tag, "updateLocalEbookProgress Local Media Progress not found $localMediaProgressId - Creating new")
+      val localLibraryItem = DeviceManager.dbManager.getLocalLibraryItem(localLibraryItemId)
+        ?: return call.resolve(JSObject("{\"error\":\"Library Item not found\"}"))
+
+      val book = localLibraryItem.media as Book
+
+      localMediaProgress = LocalMediaProgress(
+        id = localMediaProgressId,
+        localLibraryItemId = localLibraryItemId,
+        localEpisodeId = null,
+        duration = book.duration ?: 0.0,
+        progress = 0.0,
+        currentTime = 0.0,
+        isFinished = false,
+        ebookLocation = ebookLocation,
+        ebookProgress = ebookProgress,
+        lastUpdate = System.currentTimeMillis(),
+        startedAt = 0L,
+        finishedAt = null,
+        serverConnectionConfigId = localLibraryItem.serverConnectionConfigId,
+        serverAddress = localLibraryItem.serverAddress,
+        serverUserId = localLibraryItem.serverUserId,
+        libraryItemId = localLibraryItem.libraryItemId,
+        episodeId = null)
+    } else {
+      localMediaProgress.updateEbookProgress(ebookLocation, ebookProgress)
+    }
+
+    // Save local media progress locally
+    DeviceManager.dbManager.saveLocalMediaProgress(localMediaProgress)
+
+    val lmpstring = jacksonMapper.writeValueAsString(localMediaProgress)
+    Log.d(tag, "updateLocalEbookProgress: Local Media Progress String $lmpstring")
+
+    val jsobj = JSObject()
+    jsobj.put("localMediaProgress", JSObject(lmpstring))
+    call.resolve(jsobj)
+  }
+
  @PluginMethod
  fun updateLocalTrackOrder(call:PluginCall) {
-    var localLibraryItemId = call.getString("localLibraryItemId", "") ?: ""
-    var localLibraryItem = DeviceManager.dbManager.getLocalLibraryItem(localLibraryItemId)
+    val localLibraryItemId = call.getString("localLibraryItemId", "") ?: ""
+    val localLibraryItem = DeviceManager.dbManager.getLocalLibraryItem(localLibraryItemId)
    if (localLibraryItem == null) {
      call.resolve()
      return
    }

-    var audioTracks = localLibraryItem.media.getAudioTracks() as MutableList
+    val audioTracks = localLibraryItem.media.getAudioTracks() as MutableList

-    var tracks:JSArray = call.getArray("tracks") ?: JSArray()
+    val tracks:JSArray = call.getArray("tracks") ?: JSArray()
    Log.d(tag, "updateLocalTrackOrder $tracks")

    var index = 1
    var hasUpdates = false
    for (i in 0 until tracks.length()) {
-      var track = tracks.getJSONObject(i)
-      var localFileId = track.getString("localFileId")
+      val track = tracks.getJSONObject(i)
+      val localFileId = track.getString("localFileId")

-      var existingTrack = audioTracks.find{ it.localFileId == localFileId }
+      val existingTrack = audioTracks.find{ it.localFileId == localFileId }
      if (existingTrack != null) {
        Log.d(tag, "Found existing track ${existingTrack.localFileId} that has index ${existingTrack.index} should be index $index")
        if (existingTrack.index != index) hasUpdates = true
@@ -336,4 +555,37 @@ class AbsDatabase : Plugin() {
      call.resolve()
    }
  }
+
+  @PluginMethod
+  fun updateDeviceSettings(call:PluginCall) { // Returns device data
+    Log.d(tag, "updateDeviceSettings called")
+    val newDeviceSettings = jacksonMapper.readValue<DeviceSettings>(call.data.toString())
+
+    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 called")
+    val mediaId = call.getString("mediaId") ?: ""
+
+    GlobalScope.launch(Dispatchers.IO) {
+      val mediaItemHistory = DeviceManager.dbManager.getMediaItemHistory(mediaId)
+      if (mediaItemHistory == null) {
+        call.resolve()
+      } else {
+        call.resolve(JSObject(jacksonMapper.writeValueAsString(mediaItemHistory)))
+      }
+    }
+  }
 }
@@ -1,21 +1,14 @@
 package com.audiobookshelf.app.plugins

-import android.app.DownloadManager
-import android.content.Context
-import android.net.Uri
-import android.os.Build
 import android.os.Environment
-import android.util.Log
-import androidx.documentfile.provider.DocumentFile
-import com.anggrayudi.storage.callback.FileCallback
-import com.anggrayudi.storage.file.*
-import com.anggrayudi.storage.media.FileDescription
 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.fasterxml.jackson.annotation.JsonIgnore
+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
@@ -23,109 +16,65 @@ import com.getcapacitor.Plugin
 import com.getcapacitor.PluginCall
 import com.getcapacitor.PluginMethod
 import com.getcapacitor.annotation.CapacitorPlugin
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
 import java.io.File

@CapacitorPlugin(name = "AbsDownloader")
 class AbsDownloader : Plugin() {
  private val tag = "AbsDownloader"
-  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
-  lateinit var downloadManager: DownloadManager
  lateinit var apiHandler: ApiHandler
-  lateinit var folderScanner: FolderScanner
+  lateinit var downloadItemManager: DownloadItemManager

-  data class DownloadItemPart(
-    val id: String,
-    val filename: String,
-    val finalDestinationPath:String,
-    val itemTitle: String,
-    val serverPath: String,
-    val localFolderName: String,
-    val localFolderUrl: String,
-    val localFolderId: String,
-    val audioTrack: AudioTrack?,
-    val episode:PodcastEpisode?,
-    var completed:Boolean,
-    var moved:Boolean,
-    var failed:Boolean,
-    @JsonIgnore val uri: Uri,
-    @JsonIgnore val destinationUri: Uri,
-    @JsonIgnore val finalDestinationUri: Uri,
-    var downloadId: Long?,
-    var progress: Long
-  ) {
-    companion object {
-      fun make(filename:String, destinationFile:File, finalDestinationFile:File, itemTitle:String, serverPath:String, localFolder:LocalFolder, audioTrack:AudioTrack?, episode:PodcastEpisode?) :DownloadItemPart {
-        val destinationUri = Uri.fromFile(destinationFile)
-        val finalDestinationUri = Uri.fromFile(finalDestinationFile)
-
-        var downloadUrl = "${DeviceManager.serverAddress}${serverPath}?token=${DeviceManager.token}"
-        if (serverPath.endsWith("/cover")) downloadUrl += "&format=jpeg" // 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")
-        return DownloadItemPart(
-          id = DeviceManager.getBase64Id(finalDestinationFile.absolutePath),
-          filename = filename, finalDestinationFile.absolutePath,
-          itemTitle = itemTitle,
-          serverPath = serverPath,
-          localFolderName = localFolder.name,
-          localFolderUrl = localFolder.contentUrl,
-          localFolderId = localFolder.id,
-          audioTrack = audioTrack,
-          episode = episode,
-          completed = false,
-          moved = false,
-          failed = false,
-          uri = downloadUri,
-          destinationUri = destinationUri,
-          finalDestinationUri = finalDestinationUri,
-          downloadId = null,
-          progress = 0
-        )
-      }
+  private val clientEventEmitter = (object : DownloadItemManager.DownloadEventEmitter {
+    override fun onDownloadItem(downloadItem:DownloadItem) {
+      notifyListeners("onDownloadItem", JSObject(jacksonMapper.writeValueAsString(downloadItem)))
    }
-
-    @JsonIgnore
-    fun getDownloadRequest(): DownloadManager.Request {
-      val dlRequest = DownloadManager.Request(uri)
-      dlRequest.setTitle(filename)
-      dlRequest.setDescription("Downloading to $localFolderName for book $itemTitle")
-      dlRequest.setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED)
-      dlRequest.setDestinationUri(destinationUri)
-      return dlRequest
+    override fun onDownloadItemPartUpdate(downloadItemPart:DownloadItemPart) {
+      notifyListeners("onDownloadItemPartUpdate", JSObject(jacksonMapper.writeValueAsString(downloadItemPart)))
    }
-  }
-
-  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 media:MediaType,
-    val downloadItemParts: MutableList<DownloadItemPart>
-  )
-
-  var downloadQueue: MutableList<DownloadItem> = mutableListOf()
+    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 = DownloadServiceHost.ensure(mainActivity)
+    DownloadServiceHost.attachBridge(mainActivity, clientEventEmitter)
+  }

-    Log.d(tag, "Build SDK ${Build.VERSION.SDK_INT}")
+  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
@@ -133,49 +82,59 @@ class AbsDownloader : Plugin() {
    val libraryItemId = call.data.getString("libraryItemId").toString()
    var episodeId = call.data.getString("episodeId").toString()
    if (episodeId == "null") episodeId = ""
-    val localFolderId = call.data.getString("localFolderId").toString()
-    Log.d(tag, "Download library item $libraryItemId to folder $localFolderId / episode: $episodeId")
+    var localFolderId = call.data.getString("localFolderId", "").toString()
+    AbsLogger.info(tag, "Requested download for item $libraryItemId${if (episodeId.isEmpty()) "" else " / episode $episodeId"}")

    val downloadId = if (episodeId.isEmpty()) libraryItemId else "$libraryItemId-$episodeId"
-    if (downloadQueue.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 ->
-      Log.d(tag, "Got library item from server ${libraryItem.id}")
-
-      val localFolder = DeviceManager.dbManager.getLocalFolder(localFolderId)
-      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\"}"))
-          } else {
-            startLibraryItemDownload(libraryItem, localFolder, episode)
-            call.resolve()
-          }
-        } else {
-          startLibraryItemDownload(libraryItem, localFolder, null)
-          call.resolve()
+    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\"}"))
+        }
+        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 {
+              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 {
-        call.resolve(JSObject("{\"error\":\"Local Folder Not Found\"}"))
      }
    }
  }

-  // Clean folder path so it can be used in URL
-  private fun cleanRelPath(relPath: String): String {
-    val cleanedRelPath = relPath.replace("\\", "/").replace("%", "%25").replace("#", "%23")
-    return if (cleanedRelPath.startsWith("/")) cleanedRelPath.substring(1) else cleanedRelPath
+  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
@@ -198,226 +157,116 @@ class AbsDownloader : Plugin() {
    return newTitle
  }

-  private fun startLibraryItemDownload(libraryItem: LibraryItem, localFolder: LocalFolder, episode:PodcastEpisode?) {
-    val tempFolderPath = mainActivity.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS)
+  private fun startLibraryItemDownload(
+          libraryItem: LibraryItem,
+          localFolder: LocalFolder,
+          episode: PodcastEpisode?,
+          callback: (String?) -> Unit
+  ) {
+    val isInternal = localFolder.id.startsWith("internal-")
+
+    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}"
+            }
+

    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")
-      val itemFolderPath = localFolder.absolutePath + "/" + bookTitle
-      val downloadItem = DownloadItem(libraryItem.id, libraryItem.id, null, libraryItem.userMediaProgress,DeviceManager.serverConnectionConfig?.id ?: "", DeviceManager.serverAddress, DeviceManager.serverUserId, libraryItem.mediaType, itemFolderPath, localFolder, bookTitle, libraryItem.media, mutableListOf())
+      AbsLogger.info(tag, "Queueing library item download with ${tracks.size} files")
+      val itemSubfolder = "$bookAuthor/$bookTitle"
+      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
+      book.ebookFile?.let { ebookFile ->
+        val fileSize = ebookFile.metadata?.size ?: 0
+        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.part")
+
+        val downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename, fileSize, destinationFile,finalDestinationFile,itemSubfolder,serverPath,localFolder,ebookFile,null,null)
+        downloadItem.downloadItemParts.add(downloadItemPart)
+      }

      // Create download item part for each audio track
+      val audioFiles = (libraryItem.media as Book).audioFiles ?: mutableListOf()
      tracks.forEach { audioTrack ->
-        val serverPath = "/s/item/${libraryItem.id}/${cleanRelPath(audioTrack.relPath)}"
+        val fileSize = audioTrack.metadata?.size ?: 0
+
+        // TODO: Currently file ino is only stored on AudioFile. This should be updated server side to be in FileMetadata or on the AudioTrack
+        val audioFileIno = audioFiles.find { it.metadata.path == audioTrack.metadata?.path }?.ino
+
+        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")
+        val destinationFile = File("$tempFolderPath/$destinationFilename.part")

-        if (finalDestinationFile.exists()) {
-          Log.d(tag, "Audio file already exists, removing it from ${finalDestinationFile.absolutePath}")
-          finalDestinationFile.delete()
-        }
-
-        val downloadItemPart = DownloadItemPart.make(destinationFilename,destinationFile,finalDestinationFile,bookTitle,serverPath,localFolder,audioTrack,null)
+        val downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename, fileSize, destinationFile,finalDestinationFile,itemSubfolder,serverPath,localFolder,null,audioTrack,null)
        downloadItem.downloadItemParts.add(downloadItemPart)
-
-        val dlRequest = downloadItemPart.getDownloadRequest()
-        val downloadId = downloadManager.enqueue(dlRequest)
-        downloadItemPart.downloadId = downloadId
      }

      if (downloadItem.downloadItemParts.isNotEmpty()) {
        // Add cover download item
        if (libraryItem.media.coverPath != null && libraryItem.media.coverPath?.isNotEmpty() == true) {
+          val coverLibraryFile = libraryItem.libraryFiles?.find { it.metadata.path == libraryItem.media.coverPath }
+          val coverFileSize = coverLibraryFile?.metadata?.size ?: 0
+
          val serverPath = "/api/items/${libraryItem.id}/cover"
-          val destinationFilename = "cover.jpg"
-          val destinationFile = File("$tempFolderPath/$destinationFilename")
+          val destinationFilename = "cover-${libraryItem.id}.jpg"
+          val destinationFile = File("$tempFolderPath/$destinationFilename.part")
          val finalDestinationFile = File("$itemFolderPath/$destinationFilename")

-          if (finalDestinationFile.exists()) {
-            Log.d(tag, "Cover already exists, removing it from ${finalDestinationFile.absolutePath}")
-            finalDestinationFile.delete()
-          }
-
-          val downloadItemPart = DownloadItemPart.make(destinationFilename,destinationFile,finalDestinationFile,bookTitle,serverPath,localFolder,null,null)
+          val downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename, coverFileSize,  destinationFile,finalDestinationFile,itemSubfolder,serverPath,localFolder,null,null,null)
          downloadItem.downloadItemParts.add(downloadItemPart)
-
-          val dlRequest = downloadItemPart.getDownloadRequest()
-          val downloadId = downloadManager.enqueue(dlRequest)
-          downloadItemPart.downloadId = downloadId
        }

-        downloadQueue.add(downloadItem)
-        startWatchingDownloads(downloadItem)
-        DeviceManager.dbManager.saveDownloadItem(downloadItem)
-      }
+        DownloadServiceHost.enqueue(mainActivity, downloadItem, callback)
+      } else callback("No downloadable files found")
    } else {
      // Podcast episode download
      val podcastTitle = cleanStringForFileSystem(libraryItem.media.metadata.title)

      val audioTrack = episode?.audioTrack
-      Log.d(tag, "Starting podcast episode download")
-      val itemFolderPath = localFolder.absolutePath + "/" + podcastTitle
+      val audioFileIno = episode?.audioFile?.ino
+      val fileSize = audioTrack?.metadata?.size ?: 0
+
+      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, libraryItem.media, mutableListOf())
+      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 = "/s/item/${libraryItem.id}/${cleanRelPath(audioTrack?.relPath ?: "")}"
+      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(destinationFilename,destinationFile,finalDestinationFile,podcastTitle,serverPath,localFolder,audioTrack,null)
+      var downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename,fileSize, destinationFile,finalDestinationFile,podcastTitle,serverPath,localFolder,null,audioTrack,episode)
      downloadItem.downloadItemParts.add(downloadItemPart)

-      var dlRequest = downloadItemPart.getDownloadRequest()
-      var downloadId = downloadManager.enqueue(dlRequest)
-      downloadItemPart.downloadId = downloadId
-
      if (libraryItem.media.coverPath != null && libraryItem.media.coverPath?.isNotEmpty() == true) {
+        val coverLibraryFile = libraryItem.libraryFiles?.find { it.metadata.path == libraryItem.media.coverPath }
+        val coverFileSize = coverLibraryFile?.metadata?.size ?: 0
+
        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(destinationFilename,destinationFile,finalDestinationFile,podcastTitle,serverPath,localFolder,audioTrack,null)
-          downloadItem.downloadItemParts.add(downloadItemPart)
-
-          dlRequest = downloadItemPart.getDownloadRequest()
-          downloadId = downloadManager.enqueue(dlRequest)
-          downloadItemPart.downloadId = downloadId
-        }
+        downloadItemPart = DownloadItemPart.make(downloadItem.id, destinationFilename,coverFileSize,destinationFile,finalDestinationFile,podcastTitle,serverPath,localFolder,null,null,null)
+        downloadItem.downloadItemParts.add(downloadItemPart)
      }

-      downloadQueue.add(downloadItem)
-      startWatchingDownloads(downloadItem)
-      DeviceManager.dbManager.saveDownloadItem(downloadItem)
-    }
-  }
-
-  private fun startWatchingDownloads(downloadItem: DownloadItem) {
-    GlobalScope.launch(Dispatchers.IO) {
-      while (downloadItem.downloadItemParts.find { !it.moved && !it.failed } != null) { // While some item is not completed
-        val numPartsBefore = downloadItem.downloadItemParts.size
-        checkDownloads(downloadItem)
-
-        // Keep database updated as item parts finish downloading
-        if (downloadItem.downloadItemParts.size > 0 && downloadItem.downloadItemParts.size != numPartsBefore) {
-          Log.d(tag, "Save download item on num parts changed from $numPartsBefore to ${downloadItem.downloadItemParts.size}")
-          DeviceManager.dbManager.saveDownloadItem(downloadItem)
-        }
-
-        notifyListeners("onItemDownloadUpdate", JSObject(jacksonMapper.writeValueAsString(downloadItem)))
-        delay(500)
-      }
-
-      // Remove download notifications
-      downloadItem.downloadItemParts.forEach { downloadItemPart ->
-        downloadItemPart.downloadId?.let {
-          downloadManager.remove(it)
-        }
-      }
-
-      val downloadItemScanResult = folderScanner.scanDownloadItem(downloadItem)
-      DeviceManager.dbManager.removeDownloadItem(downloadItem.id)
-      downloadQueue.remove(downloadItem)
-
-      Log.d(tag, "Item download complete ${downloadItem.itemTitle} | local library item id: ${downloadItemScanResult?.localLibraryItem?.id} | Items remaining in Queue ${downloadQueue.size}")
-
-      val jsobj = JSObject()
-      jsobj.put("libraryItemId", downloadItem.id)
-      jsobj.put("localFolderId", downloadItem.localFolder.id)
-
-      downloadItemScanResult?.localLibraryItem?.let { localLibraryItem ->
-        jsobj.put("localLibraryItem", JSObject(jacksonMapper.writeValueAsString(localLibraryItem)))
-      }
-      downloadItemScanResult?.localMediaProgress?.let { localMediaProgress ->
-        jsobj.put("localMediaProgress", JSObject(jacksonMapper.writeValueAsString(localMediaProgress)))
-      }
-      notifyListeners("onItemDownloadComplete", jsobj)
-    }
-  }
-
-  private fun checkDownloads(downloadItem: DownloadItem) {
-    val itemParts = downloadItem.downloadItemParts.map { it }
-    for (downloadItemPart in itemParts) {
-      if (downloadItemPart.downloadId != null) {
-        val dlid = downloadItemPart.downloadId!!
-        val query = DownloadManager.Query().setFilterById(dlid)
-        downloadManager.query(query).use {
-          if (it.moveToFirst()) {
-            val bytesColumnIndex = it.getColumnIndex(DownloadManager.COLUMN_TOTAL_SIZE_BYTES)
-            val statusColumnIndex = it.getColumnIndex(DownloadManager.COLUMN_STATUS)
-            val bytesDownloadedColumnIndex = it.getColumnIndex(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR)
-
-            val totalBytes = if (bytesColumnIndex >= 0) it.getInt(bytesColumnIndex) else 0
-            val downloadStatus = if (statusColumnIndex >= 0) it.getInt(statusColumnIndex) else 0
-            val bytesDownloadedSoFar = if (bytesDownloadedColumnIndex >= 0) it.getInt(bytesDownloadedColumnIndex) else 0
-            Log.d(tag, "checkDownloads Download ${downloadItemPart.filename} bytes $totalBytes | bytes dled $bytesDownloadedSoFar | downloadStatus $downloadStatus")
-
-            if (downloadStatus == DownloadManager.STATUS_SUCCESSFUL) {
-              // Once file download is complete move the file to the final destination
-              if (!downloadItemPart.completed) {
-                Log.d(tag, "checkDownloads Download ${downloadItemPart.filename} Done")
-                downloadItemPart.completed = true
-
-                val file = DocumentFileCompat.fromUri(mainActivity, downloadItemPart.destinationUri)
-                Log.d(tag, "DOWNLOAD: Attempt move for file at destination ${downloadItemPart.destinationUri} | ${file?.getBasePath(mainActivity)}")
-
-                val fcb = object : FileCallback() {
-                  override fun onPrepare() {
-                    Log.d(tag, "DOWNLOAD: PREPARING MOVE FILE")
-                  }
-                  override fun onFailed(errorCode:ErrorCode) {
-                    Log.e(tag, "DOWNLOAD: FAILED TO MOVE FILE $errorCode")
-                    downloadItemPart.failed = true
-                    file?.delete()
-                  }
-                  override fun onCompleted(result:Any) {
-                    Log.d(tag, "DOWNLOAD: FILE MOVE COMPLETED")
-                    val resultDocFile = result as DocumentFile
-                    Log.d(tag, "DOWNLOAD: COMPLETED FILE INFO ${resultDocFile.getAbsolutePath(mainActivity)}")
-                    downloadItemPart.moved = true
-                  }
-                }
-
-                Log.d(tag, "DOWNLOAD: Move file to final destination path: ${downloadItemPart.finalDestinationPath}")
-                val localFolderFile = DocumentFileCompat.fromUri(mainActivity,Uri.parse(downloadItemPart.localFolderUrl))
-                val mimetype = if (downloadItemPart.audioTrack != null) MimeType.AUDIO else MimeType.IMAGE
-                val fileDescription = FileDescription(downloadItemPart.filename, downloadItemPart.itemTitle, mimetype)
-                file?.moveFileTo(mainActivity,localFolderFile!!,fileDescription,fcb)
-              } else {
-                // Why is kotlin requiring an else here..
-              }
-            } else if (downloadStatus == DownloadManager.STATUS_FAILED) {
-              Log.d(tag, "checkDownloads Download ${downloadItemPart.filename} Failed")
-              downloadItem.downloadItemParts.remove(downloadItemPart)
-            } else {
-              //update progress
-              val percentProgress = if (totalBytes > 0) ((bytesDownloadedSoFar * 100L) / totalBytes) else 0
-              Log.d(tag, "checkDownloads Download ${downloadItemPart.filename} Progress = $percentProgress%")
-              downloadItemPart.progress = percentProgress
-            }
-          } else {
-            Log.d(tag, "Download ${downloadItemPart.filename} not found in dlmanager")
-            downloadItem.downloadItemParts.remove(downloadItemPart)
-          }
-        }
-      }
+        DownloadServiceHost.enqueue(mainActivity, downloadItem, callback)
    }
  }
 }