diff --git a/.github/workflows/build-test-lint.yml b/.github/workflows/build-test-lint.yml
index 5a9d430b70..65e7101c35 100644
--- a/.github/workflows/build-test-lint.yml
+++ b/.github/workflows/build-test-lint.yml
@@ -5,6 +5,7 @@ on:
     branches:
       - 'dev'
       - 'main'
+      - 'releases/**'
   workflow_dispatch: # Allow running manually from web UI
 
 jobs:
@@ -33,7 +34,7 @@ jobs:
         run: ./gradlew :app:testPureDebugUnitTest
 
       - name: Test Report
-        uses: dorny/test-reporter@b082adf0eced0765477756c2a610396589b8c637 # v2.5.0
+        uses: dorny/test-reporter@a43b3a5f7366b97d083190328d2c652e1a8b6aa2 # v3.0.0
         if: always() # also run if tests failed
         with:
           name: JUnit Report
@@ -62,11 +63,10 @@ jobs:
         run: ./gradlew :app:lintPureRelease
 
       - name: Lint amzn release
-        if: ${{ contains(github.ref, 'release') }}
         run: ./gradlew :app:lintAmazonRelease
 
       - name: Upload lint reports
-        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         if: ${{ always() }} # also upload of lint errors
         with:
           name: Lint reports
diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 27c9928c8f..d7393dfbf7 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -2,31 +2,6 @@
   <code_scheme name="Project" version="173">
     <option name="CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND" value="99" />
     <option name="NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND" value="99" />
-    <option name="PACKAGES_TO_USE_IMPORT_ON_DEMAND">
-      <value />
-    </option>
-    <option name="IMPORT_LAYOUT_TABLE">
-      <value>
-        <package name="android" withSubpackages="true" static="false" />
-        <emptyLine />
-        <package name="com" withSubpackages="true" static="false" />
-        <emptyLine />
-        <package name="junit" withSubpackages="true" static="false" />
-        <emptyLine />
-        <package name="net" withSubpackages="true" static="false" />
-        <emptyLine />
-        <package name="org" withSubpackages="true" static="false" />
-        <emptyLine />
-        <package name="java" withSubpackages="true" static="false" />
-        <emptyLine />
-        <package name="javax" withSubpackages="true" static="false" />
-        <emptyLine />
-        <package name="" withSubpackages="true" static="false" />
-        <emptyLine />
-        <package name="" withSubpackages="true" static="true" />
-        <emptyLine />
-      </value>
-    </option>
     <JavaCodeStyleSettings>
       <option name="DO_NOT_WRAP_AFTER_SINGLE_ANNOTATION" value="true" />
       <option name="CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND" value="999" />
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ae5de5ae15..b78a9c04d0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,10 +8,40 @@
 Releases marked with 🧪 (or previously with the "beta" suffix) were released on
 [the preview program](https://www.seriesgui.de/help/how-to/basics/preview) only.
 
+## Version 2026.2
+
+* 🌟 Lists: movies can be added to lists, currently only from the details view.
+* 🔧 Lists: sort options are displayed in their own dialog.
+* 🔧 Shows: move manage lists button from more options menu to inside the overview and details tabs.
+
+### 2026.2.2 - 2026-07-04
+
+* 🔨 Potential fix to avoid a crash on Xiaomi and Honor devices when loading extensions due to aggressive system optimizations.
+* 📝 Import latest user interface translations.
+
+### 2026.2.1 - 2026-06-26 🧪
+
+* 🔧 Shows: move manage lists button from more options menu to inside the overview and details tabs.
+* 🔨 Trakt: downloading ratings also works if API returns rating 0.
+* 🔨 Shows: when adding a show fails, roll back any database changes.
+* 📝 Import latest user interface translations.
+
+### 2026.2.0 - 2026-06-18 🧪
+
+* 🌟 Lists: movies can be added to lists, currently only from the details view.
+* 🔧 Lists: sort options are displayed in their own dialog.
+* 🔨 Import: a failure no longer blocks trying again, adding shows or creating an auto backup.
+* 🔨 Export: for list items, no longer include always 0 tvdb_id value. 
+* 🔨 Import: skip movies without a TMDB ID.
+
 ## Version 2026.1
 
 * 📝 Trakt: support server changes to correctly fetch all collection and watchlist items.
 
+### 2026.1.6 - 2026-07-04
+
+* 🔨 Potential fix to avoid a crash on Xiaomi and Honor devices when loading extensions due to aggressive system optimizations.
+
 ### 2026.1.5 - 2026-05-21
 
 * 🔨 Trakt: address unexpected server changes to correctly fetch watched special episodes.
diff --git a/RELEASING.md b/RELEASING.md
index 875718afef..ef7041322a 100644
--- a/RELEASING.md
+++ b/RELEASING.md
@@ -4,10 +4,10 @@
 
   ```bash
   # If it does not exist, create a release branch
-  git checkout -b releases/2026.1
+  git checkout -b releases/2026.2
   
   # If it exists, merge latest changes
-  git checkout releases/2026.1
+  git checkout releases/2026.2
   git merge dev
   ```
 
@@ -27,8 +27,8 @@
 - Commit with the suggested message and push
 
   ```shell
-  git commit --all --message "Prepare version 2026.1.1 (23260101)"
-  git push --set-upstream origin releases/2026.1
+  git commit --all --message "Prepare version 2026.2.0 (23260101)"
+  git push --set-upstream origin releases/2026.2
   ```
 
 - If it does not exist, [create a merge request](https://github.com/UweTrottmann/SeriesGuide/compare/main...) against `main`
@@ -49,10 +49,10 @@
 - Tag release commit
   
   ```shell
-  git tag v2026.1.2
-  git push origin v2026.1.2
+  git tag v2026.2.0
+  git push origin v2026.2.0
   git checkout dev
-  git merge releases/2026.1
+  git merge releases/2026.2
   git push origin dev
   ```
 
@@ -65,7 +65,7 @@
 - Merge release pull request to `main`
 - Download universal APK from Play Store
 - [Create GitHub release](https://github.com/UweTrottmann/SeriesGuide/releases/new)
-  - title like `SeriesGuide 2026.1.2`
+  - title like `SeriesGuide 2026.2.0`
   - get release notes from [`CHANGELOG.md`](/CHANGELOG.md)
   - attach APK
 - Prepare release post on forum
@@ -77,5 +77,5 @@
 
   ```shell
   git checkout dev
-  git merge --no-ff releases/2026.1
+  git merge --no-ff releases/2026.2
   ```
\ No newline at end of file
diff --git a/api/build.gradle.kts b/api/build.gradle.kts
index 407232cf25..5e6653ffa4 100644
--- a/api/build.gradle.kts
+++ b/api/build.gradle.kts
@@ -42,7 +42,7 @@ android {
 }
 
 dependencies {
-    implementation(libs.androidx.core)
+    implementation(libs.androidx.annotation)
 }
 
 publishing {
diff --git a/api/src/main/java/com/battlelancer/seriesguide/api/SeriesGuideExtension.java b/api/src/main/java/com/battlelancer/seriesguide/api/SeriesGuideExtension.java
index c63c3bc8ec..dd018fc833 100644
--- a/api/src/main/java/com/battlelancer/seriesguide/api/SeriesGuideExtension.java
+++ b/api/src/main/java/com/battlelancer/seriesguide/api/SeriesGuideExtension.java
@@ -1,5 +1,5 @@
-// Copyright 2014-2019 Uwe Trottmann
 // SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright © 2014 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.api;
 
@@ -30,7 +30,6 @@
 import android.text.TextUtils;
 import android.util.Log;
 import androidx.annotation.NonNull;
-import androidx.core.app.JobIntentService;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
@@ -45,7 +44,7 @@
  * SeriesGuide. Actions may for example launch other apps or display interesting information related
  * to an episode or movie.
  *
- * <p> Extensions are specialized {@link JobIntentService} classes in combination with a broadcast
+ * <p> Extensions are specialized {@code JobIntentService} classes in combination with a broadcast
  * receiver.
  *
  * <p> Multiple extensions may be enabled within SeriesGuide at the same time. When a SeriesGuide
@@ -173,7 +172,7 @@
  * <p> Based on code from <a href="https://github.com/romannurik/muzei">Muzei</a>, an awesome Live
  * Wallpaper by Roman Nurik.
  */
-public abstract class SeriesGuideExtension extends JobIntentService {
+public abstract class SeriesGuideExtension extends SgJobIntentService {
 
     private static final String TAG = "SeriesGuideExtension";
 
@@ -225,6 +224,13 @@ public void onCreate() {
         loadLastAction();
     }
 
+    @Override
+    public boolean onStopCurrentWork() {
+        // Don't re-schedule stopped work, the app will just display no extension and request it again if the
+        // episode or movie in question is shown again.
+        return false;
+    }
+
     /**
      * Convenience method for accessing preferences specific to the extension (with the given name
      * within this package. The source name must be the one provided in the
diff --git a/api/src/main/java/com/battlelancer/seriesguide/api/SeriesGuideExtensionReceiver.java b/api/src/main/java/com/battlelancer/seriesguide/api/SeriesGuideExtensionReceiver.java
index 5504dbd217..0d54245137 100644
--- a/api/src/main/java/com/battlelancer/seriesguide/api/SeriesGuideExtensionReceiver.java
+++ b/api/src/main/java/com/battlelancer/seriesguide/api/SeriesGuideExtensionReceiver.java
@@ -1,12 +1,11 @@
-// Copyright 2017, 2018 Uwe Trottmann
 // SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright © 2017 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.api;
 
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
-import androidx.core.app.JobIntentService;
 
 /**
  * Base class to expose a {@link SeriesGuideExtension} service. See the documentation of {@link
@@ -22,8 +21,7 @@ public abstract class SeriesGuideExtensionReceiver extends BroadcastReceiver {
             = "com.battlelancer.seriesguide.api.SeriesGuideExtension";
 
     /**
-     * A unique job id within your app. Used to run the {@link SeriesGuideExtension} {@link
-     * JobIntentService}.
+     * A unique job id within your app. Used to run the {@link SeriesGuideExtension} job.
      */
     protected abstract int getJobId();
 
diff --git a/api/src/main/java/com/battlelancer/seriesguide/api/SgJobIntentService.java b/api/src/main/java/com/battlelancer/seriesguide/api/SgJobIntentService.java
new file mode 100644
index 0000000000..19cc8c8874
--- /dev/null
+++ b/api/src/main/java/com/battlelancer/seriesguide/api/SgJobIntentService.java
@@ -0,0 +1,654 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright © 2017 The Android Open Source Project
+// SPDX-FileCopyrightText: Copyright © 2026 Uwe Trottmann <uwe@uwetrottmann.com>
+
+// Original file by The Android Open Source Project licensed under Apache-2.0 copied from AndroidX Core
+
+package com.battlelancer.seriesguide.api;
+
+import android.app.Service;
+import android.app.job.JobInfo;
+import android.app.job.JobParameters;
+import android.app.job.JobScheduler;
+import android.app.job.JobServiceEngine;
+import android.app.job.JobWorkItem;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.os.IBinder;
+import android.os.PowerManager;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+/**
+ * Helper for processing work that has been enqueued for a job/service.  When running on
+ * {@link android.os.Build.VERSION_CODES#O Android O} or later, the work will be dispatched
+ * as a job via {@link android.app.job.JobScheduler#enqueue JobScheduler.enqueue}.  When running
+ * on older versions of the platform, it will use
+ * {@link android.content.Context#startService Context.startService}.
+ *
+ * <p>You must publish your subclass in your manifest for the system to interact with.  This
+ * should be published as a {@link android.app.job.JobService}, as described for that class,
+ * since on O and later platforms it will be executed that way.</p>
+ *
+ * <p>Use {@link #enqueueWork(Context, Class, int, Intent)} to enqueue new work to be
+ * dispatched to and handled by your service.  It will be executed in
+ * {@link #onHandleWork(Intent)}.</p>
+ *
+ * <p>You do not need to use {@code androidx.legacy.content.WakefulBroadcastReceiver}
+ * when using this class.  When running on {@link android.os.Build.VERSION_CODES#O Android O},
+ * the JobScheduler will take care of wake locks for you (holding a wake lock from the time
+ * you enqueue work until the job has been dispatched and while it is running).  When running
+ * on previous versions of the platform, this wake lock handling is emulated in the class here
+ * by directly calling the PowerManager; this means the application must request the
+ * {@link android.Manifest.permission#WAKE_LOCK} permission.</p>
+ *
+ * <p>There are a few important differences in behavior when running on
+ * {@link android.os.Build.VERSION_CODES#O Android O} or later as a Job vs. pre-O:</p>
+ *
+ * <ul>
+ *     <li><p>When running as a pre-O service, the act of enqueueing work will generally start
+ *     the service immediately, regardless of whether the device is dozing or in other
+ *     conditions.  When running as a Job, it will be subject to standard JobScheduler
+ *     policies for a Job with a {@link android.app.job.JobInfo.Builder#setOverrideDeadline(long)}
+ *     of 0: the job will not run while the device is dozing, it may get delayed more than
+ *     a service if the device is under strong memory pressure with lots of demand to run
+ *     jobs.</p></li>
+ *     <li><p>When running as a pre-O service, the normal service execution semantics apply:
+ *     the service can run indefinitely, though the longer it runs the more likely the system
+ *     will be to outright kill its process, and under memory pressure one should expect
+ *     the process to be killed even of recently started services.  When running as a Job,
+ *     the typical {@link android.app.job.JobService} execution time limit will apply, after
+ *     which the job will be stopped (cleanly, not by killing the process) and rescheduled
+ *     to continue its execution later.  Job are generally not killed when the system is
+ *     under memory pressure, since the number of concurrent jobs is adjusted based on the
+ *     memory state of the device.</p></li>
+ * </ul>
+ */
+public abstract class SgJobIntentService extends Service {
+    static final String TAG = "SgJobIntentService";
+
+    static final boolean DEBUG = false;
+
+    CompatJobEngine mJobImpl;
+    WorkEnqueuer mCompatWorkEnqueuer;
+    CommandProcessor mCurProcessor;
+    boolean mInterruptIfStopped = false;
+    boolean mStopped = false;
+    boolean mDestroyed = false;
+
+    final ArrayList<CompatWorkItem> mCompatQueue;
+
+    static final Object sLock = new Object();
+    static final HashMap<ComponentName, WorkEnqueuer> sClassWorkEnqueuer = new HashMap<>();
+
+    /**
+     * Base class for the target service we can deliver work to and the implementation of
+     * how to deliver that work.
+     */
+    abstract static class WorkEnqueuer {
+        final ComponentName mComponentName;
+
+        boolean mHasJobId;
+        int mJobId;
+
+        WorkEnqueuer(ComponentName cn) {
+            mComponentName = cn;
+        }
+
+        void ensureJobId(int jobId) {
+            if (!mHasJobId) {
+                mHasJobId = true;
+                mJobId = jobId;
+            } else if (mJobId != jobId) {
+                throw new IllegalArgumentException("Given job ID " + jobId
+                        + " is different than previous " + mJobId);
+            }
+        }
+
+        abstract void enqueueWork(Intent work);
+
+        public void serviceStartReceived() {
+        }
+
+        public void serviceProcessingStarted() {
+        }
+
+        public void serviceProcessingFinished() {
+        }
+    }
+
+    /**
+     * Get rid of lint warnings about API levels.
+     */
+    interface CompatJobEngine {
+        IBinder compatGetBinder();
+        GenericWorkItem dequeueWork();
+    }
+
+    /**
+     * An implementation of WorkEnqueuer that works for pre-O (raw Service-based).
+     */
+    static final class CompatWorkEnqueuer extends WorkEnqueuer {
+        private final Context mContext;
+        private final PowerManager.WakeLock mLaunchWakeLock;
+        private final PowerManager.WakeLock mRunWakeLock;
+        boolean mLaunchingService;
+        boolean mServiceProcessing;
+
+        CompatWorkEnqueuer(Context context, ComponentName cn) {
+            super(cn);
+            mContext = context.getApplicationContext();
+            // Make wake locks.  We need two, because the launch wake lock wants to have
+            // a timeout, and the system does not do the right thing if you mix timeout and
+            // non timeout (or even changing the timeout duration) in one wake lock.
+            PowerManager pm = ((PowerManager) context.getSystemService(Context.POWER_SERVICE));
+            mLaunchWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
+                    cn.getClassName() + ":launch");
+            mLaunchWakeLock.setReferenceCounted(false);
+            mRunWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
+                    cn.getClassName() + ":run");
+            mRunWakeLock.setReferenceCounted(false);
+        }
+
+        @Override
+        void enqueueWork(Intent work) {
+            Intent intent = new Intent(work);
+            intent.setComponent(mComponentName);
+            if (DEBUG) Log.d(TAG, "Starting service for work: " + work);
+            if (mContext.startService(intent) != null) {
+                synchronized (this) {
+                    if (!mLaunchingService) {
+                        mLaunchingService = true;
+                        if (!mServiceProcessing) {
+                            // If the service is not already holding the wake lock for
+                            // itself, acquire it now to keep the system running until
+                            // we get this work dispatched.  We use a timeout here to
+                            // protect against whatever problem may cause it to not get
+                            // the work.
+                            mLaunchWakeLock.acquire(60 * 1000);
+                        }
+                    }
+                }
+            }
+        }
+
+        @Override
+        public void serviceStartReceived() {
+            synchronized (this) {
+                // Once we have started processing work, we can count whatever last
+                // enqueueWork() that happened as handled.
+                mLaunchingService = false;
+            }
+        }
+
+        @Override
+        public void serviceProcessingStarted() {
+            synchronized (this) {
+                // We hold the wake lock as long as the service is processing commands.
+                if (!mServiceProcessing) {
+                    mServiceProcessing = true;
+                    // Keep the device awake, but only for at most 10 minutes at a time
+                    // (Similar to JobScheduler.)
+                    mRunWakeLock.acquire(10 * 60 * 1000L);
+                    mLaunchWakeLock.release();
+                }
+            }
+        }
+
+        @Override
+        public void serviceProcessingFinished() {
+            synchronized (this) {
+                if (mServiceProcessing) {
+                    // If we are transitioning back to a wakelock with a timeout, do the same
+                    // as if we had enqueued work without the service running.
+                    if (mLaunchingService) {
+                        mLaunchWakeLock.acquire(60 * 1000);
+                    }
+                    mServiceProcessing = false;
+                    mRunWakeLock.release();
+                }
+            }
+        }
+    }
+
+    /**
+     * Implementation of a JobServiceEngine for interaction with SgJobIntentService.
+     */
+    @RequiresApi(26)
+    static final class JobServiceEngineImpl extends JobServiceEngine
+            implements SgJobIntentService.CompatJobEngine {
+        static final String TAG = "JobServiceEngineImpl";
+
+        static final boolean DEBUG = false;
+
+        final SgJobIntentService mService;
+        final Object mLock = new Object();
+        JobParameters mParams;
+
+        final class WrapperWorkItem implements SgJobIntentService.GenericWorkItem {
+            final JobWorkItem mJobWork;
+
+            WrapperWorkItem(JobWorkItem jobWork) {
+                mJobWork = jobWork;
+            }
+
+            @Override
+            public Intent getIntent() {
+                return mJobWork.getIntent();
+            }
+
+            @Override
+            public void complete() {
+                synchronized (mLock) {
+                    if (mParams != null) {
+                        mParams.completeWork(mJobWork);
+                    }
+                }
+            }
+
+            @Override
+            public String toString() {
+                return mJobWork.toString();
+            }
+        }
+
+        JobServiceEngineImpl(SgJobIntentService service) {
+            super(service);
+            mService = service;
+        }
+
+        @Override
+        public IBinder compatGetBinder() {
+            return getBinder();
+        }
+
+        @Override
+        public boolean onStartJob(JobParameters params) {
+            if (DEBUG) Log.d(TAG, "onStartJob: " + params);
+            mParams = params;
+            // We can now start dequeuing work!
+            mService.ensureProcessorRunningLocked(false);
+            return true;
+        }
+
+        @Override
+        public boolean onStopJob(JobParameters params) {
+            if (DEBUG) Log.d(TAG, "onStopJob: " + params);
+            boolean result = mService.doStopCurrentWork();
+            synchronized (mLock) {
+                // Once we return, the job is stopped, so its JobParameters are no
+                // longer valid and we should not be doing anything with them.
+                mParams = null;
+            }
+            return result;
+        }
+
+        /**
+         * Dequeue some work.
+         */
+        @Override
+        public SgJobIntentService.GenericWorkItem dequeueWork() {
+            JobWorkItem work;
+            synchronized (mLock) {
+                if (mParams == null) {
+                    return null;
+                }
+                work = mParams.dequeueWork();
+            }
+            if (work != null) {
+                work.getIntent().setExtrasClassLoader(mService.getClassLoader());
+                return new WrapperWorkItem(work);
+            } else {
+                return null;
+            }
+        }
+    }
+
+    @RequiresApi(26)
+    static final class JobWorkEnqueuer extends SgJobIntentService.WorkEnqueuer {
+        private final JobInfo mJobInfo;
+        private final JobScheduler mJobScheduler;
+
+        JobWorkEnqueuer(Context context, ComponentName cn, int jobId) {
+            super(cn);
+            ensureJobId(jobId);
+            JobInfo.Builder b = new JobInfo.Builder(jobId, mComponentName);
+            mJobInfo = b.setOverrideDeadline(0).build();
+            mJobScheduler = (JobScheduler) context.getApplicationContext().getSystemService(
+                    Context.JOB_SCHEDULER_SERVICE);
+        }
+
+        @Override
+        void enqueueWork(Intent work) {
+            if (DEBUG) Log.d(TAG, "Enqueueing work: " + work);
+            mJobScheduler.enqueue(mJobInfo, new JobWorkItem(work));
+        }
+    }
+
+    /**
+     * Abstract definition of an item of work that is being dispatched.
+     */
+    interface GenericWorkItem {
+        Intent getIntent();
+        void complete();
+    }
+
+    /**
+     * An implementation of GenericWorkItem that dispatches work for pre-O platforms: intents
+     * received through a raw service's onStartCommand.
+     */
+    final class CompatWorkItem implements GenericWorkItem {
+        final Intent mIntent;
+        final int mStartId;
+
+        CompatWorkItem(Intent intent, int startId) {
+            mIntent = intent;
+            mStartId = startId;
+        }
+
+        @Override
+        public Intent getIntent() {
+            return mIntent;
+        }
+
+        @Override
+        public void complete() {
+            if (DEBUG) Log.d(TAG, "Stopping self: #" + mStartId);
+            stopSelf(mStartId);
+        }
+    }
+
+    /**
+     * This is a task to dequeue and process work in the background.
+     */
+    final class CommandProcessor extends android.os.AsyncTask<Void, Void, Void> {
+        @Override
+        protected Void doInBackground(Void... params) {
+            GenericWorkItem work;
+
+            if (DEBUG) Log.d(TAG, "Starting to dequeue work...");
+
+            while ((work = dequeueWork()) != null) {
+                if (DEBUG) Log.d(TAG, "Processing next work: " + work);
+                onHandleWork(work.getIntent());
+
+                // Because of some aggressive power management on Xiaomi and Honor devices (likely
+                // because many services are created for extensions in a brief amount of time) the
+                // system might have brought the work item into a state where
+                // JobParameters.completeWork(JobWorkItem) throws an IllegalArgumentException
+                // ("Given work is not active").
+                // Despite being unclear if the system will properly call onStopJob (in which case
+                // dequeueWork() would return null and also complete() would be a no-op, see
+                // JobServiceEngineImpl), continue processing as the API docs recommend to
+                // dequeueWork() until null is returned.
+                if (DEBUG) Log.d(TAG, "Completing work: " + work);
+                try {
+                    work.complete();
+                } catch (IllegalArgumentException e) {
+                    Log.e(TAG, "Not completing work because job was cancelled by system", e);
+                }
+            }
+
+            if (DEBUG) Log.d(TAG, "Done processing work!");
+
+            return null;
+        }
+
+        @Override
+        protected void onCancelled(Void aVoid) {
+            processorFinished();
+        }
+
+        @Override
+        protected void onPostExecute(Void aVoid) {
+            processorFinished();
+        }
+    }
+
+    /**
+     * Default empty constructor.
+     */
+    public SgJobIntentService() {
+        if (Build.VERSION.SDK_INT >= 26) {
+            mCompatQueue = null;
+        } else {
+            mCompatQueue = new ArrayList<>();
+        }
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        if (DEBUG) Log.d(TAG, "CREATING: " + this);
+        if (Build.VERSION.SDK_INT >= 26) {
+            mJobImpl = new JobServiceEngineImpl(this);
+            mCompatWorkEnqueuer = null;
+        } else {
+            mJobImpl = null;
+            ComponentName cn = new ComponentName(this, this.getClass());
+            mCompatWorkEnqueuer = getWorkEnqueuer(this, cn, false, 0);
+        }
+    }
+
+    /**
+     * Processes start commands when running as a pre-O service, enqueueing them to be
+     * later dispatched in {@link #onHandleWork(Intent)}.
+     */
+    @Override
+    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
+        if (mCompatQueue != null) {
+            mCompatWorkEnqueuer.serviceStartReceived();
+            if (DEBUG) Log.d(TAG, "Received compat start command #" + startId + ": " + intent);
+            synchronized (mCompatQueue) {
+                mCompatQueue.add(new CompatWorkItem(intent != null ? intent : new Intent(),
+                        startId));
+                ensureProcessorRunningLocked(true);
+            }
+            return START_REDELIVER_INTENT;
+        } else {
+            if (DEBUG) Log.d(TAG, "Ignoring start command: " + intent);
+            return START_NOT_STICKY;
+        }
+    }
+
+    /**
+     * Returns the IBinder for the {@link android.app.job.JobServiceEngine} when
+     * running as a JobService on O and later platforms.
+     */
+    @Override
+    public IBinder onBind(@NonNull Intent intent) {
+        if (mJobImpl != null) {
+            IBinder engine = mJobImpl.compatGetBinder();
+            if (DEBUG) Log.d(TAG, "Returning engine: " + engine);
+            return engine;
+        } else {
+            return null;
+        }
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        if (DEBUG) Log.d(TAG, "onDestroy");
+        if (mCompatQueue != null) {
+            synchronized (mCompatQueue) {
+                mDestroyed = true;
+                mCompatWorkEnqueuer.serviceProcessingFinished();
+            }
+        }
+    }
+
+    /**
+     * Call this to enqueue work for your subclass of {@link SgJobIntentService}.  This will
+     * either directly start the service (when running on pre-O platforms) or enqueue work
+     * for it as a job (when running on O and later).  In either case, a wake lock will be
+     * held for you to ensure you continue running.  The work you enqueue will ultimately
+     * appear at {@link #onHandleWork(Intent)}.
+     *
+     * @param context Context this is being called from.
+     * @param cls The concrete class the work should be dispatched to (this is the class that
+     * is published in your manifest).
+     * @param jobId A unique job ID for scheduling; must be the same value for all work
+     * enqueued for the same class.
+     * @param work The Intent of work to enqueue.
+     */
+    public static void enqueueWork(@NonNull Context context, @NonNull Class<?> cls, int jobId,
+            @NonNull Intent work) {
+        enqueueWork(context, new ComponentName(context, cls), jobId, work);
+    }
+
+    /**
+     * Like {@link #enqueueWork(Context, Class, int, Intent)}, but supplies a ComponentName
+     * for the service to interact with instead of its class.
+     *
+     * @param context Context this is being called from.
+     * @param component The published ComponentName of the class this work should be
+     * dispatched to.
+     * @param jobId A unique job ID for scheduling; must be the same value for all work
+     * enqueued for the same class.
+     * @param work The Intent of work to enqueue.
+     */
+    public static void enqueueWork(@NonNull Context context, @NonNull ComponentName component,
+            int jobId, @NonNull Intent work) {
+        if (work == null) {
+            throw new IllegalArgumentException("work must not be null");
+        }
+        synchronized (sLock) {
+            WorkEnqueuer we = getWorkEnqueuer(context, component, true, jobId);
+            we.ensureJobId(jobId);
+            we.enqueueWork(work);
+        }
+    }
+
+    static WorkEnqueuer getWorkEnqueuer(Context context, ComponentName cn, boolean hasJobId,
+            int jobId) {
+        WorkEnqueuer we = sClassWorkEnqueuer.get(cn);
+        if (we == null) {
+            if (Build.VERSION.SDK_INT >= 26) {
+                if (!hasJobId) {
+                    throw new IllegalArgumentException("Can't be here without a job id");
+                }
+                we = new JobWorkEnqueuer(context, cn, jobId);
+            } else {
+                we = new CompatWorkEnqueuer(context, cn);
+            }
+            sClassWorkEnqueuer.put(cn, we);
+        }
+        return we;
+    }
+
+    /**
+     * Called serially for each work dispatched to and processed by the service.  This
+     * method is called on a background thread, so you can do long blocking operations
+     * here.  Upon returning, that work will be considered complete and either the next
+     * pending work dispatched here or the overall service destroyed now that it has
+     * nothing else to do.
+     *
+     * <p>Be aware that when running as a job, you are limited by the maximum job execution
+     * time and any single or total sequential items of work that exceeds that limit will
+     * cause the service to be stopped while in progress and later restarted with the
+     * last unfinished work.  (There is currently no limit on execution duration when
+     * running as a pre-O plain Service.)</p>
+     *
+     * @param intent The intent describing the work to now be processed.
+     */
+    protected abstract void onHandleWork(@NonNull Intent intent);
+
+    /**
+     * Control whether code executing in {@link #onHandleWork(Intent)} will be interrupted
+     * if the job is stopped.  By default this is false.  If called and set to true, any
+     * time {@link #onStopCurrentWork()} is called, the class will first call
+     * {@link android.os.AsyncTask#cancel(boolean) AsyncTask.cancel(true)} to interrupt the running
+     * task.
+     *
+     * @param interruptIfStopped Set to true to allow the system to interrupt actively
+     * running work.
+     */
+    public void setInterruptIfStopped(boolean interruptIfStopped) {
+        mInterruptIfStopped = interruptIfStopped;
+    }
+
+    /**
+     * Returns true if {@link #onStopCurrentWork()} has been called.  You can use this,
+     * while executing your work, to see if it should be stopped.
+     */
+    public boolean isStopped() {
+        return mStopped;
+    }
+
+    /**
+     * This will be called if the JobScheduler has decided to stop this job.  The job for
+     * this service does not have any constraints specified, so this will only generally happen
+     * if the service exceeds the job's maximum execution time.
+     *
+     * @return True to indicate to the JobManager whether you'd like to reschedule this work,
+     * false to drop this and all following work. Regardless of the value returned, your service
+     * must stop executing or the system will ultimately kill it.  The default implementation
+     * returns true, and that is most likely what you want to return as well (so no work gets
+     * lost).
+     */
+    public boolean onStopCurrentWork() {
+        return true;
+    }
+
+    boolean doStopCurrentWork() {
+        if (mCurProcessor != null) {
+            mCurProcessor.cancel(mInterruptIfStopped);
+        }
+        mStopped = true;
+        return onStopCurrentWork();
+    }
+
+    @SuppressWarnings({"deprecation", "ObjectToString"}) /* AsyncTask */
+    void ensureProcessorRunningLocked(boolean reportStarted) {
+        if (mCurProcessor == null) {
+            mCurProcessor = new CommandProcessor();
+            if (mCompatWorkEnqueuer != null && reportStarted) {
+                mCompatWorkEnqueuer.serviceProcessingStarted();
+            }
+            if (DEBUG) Log.d(TAG, "Starting processor: " + mCurProcessor);
+            mCurProcessor.executeOnExecutor(android.os.AsyncTask.THREAD_POOL_EXECUTOR);
+        }
+    }
+
+    void processorFinished() {
+        if (mCompatQueue != null) {
+            synchronized (mCompatQueue) {
+                mCurProcessor = null;
+                // The async task has finished, but we may have gotten more work scheduled in the
+                // meantime.  If so, we need to restart the new processor to execute it.  If there
+                // is no more work at this point, either the service is in the process of being
+                // destroyed (because we called stopSelf on the last intent started for it), or
+                // someone has already called startService with a new Intent that will be
+                // arriving shortly.  In either case, we want to just leave the service
+                // waiting -- either to get destroyed, or get a new onStartCommand() callback
+                // which will then kick off a new processor.
+                if (mCompatQueue != null && mCompatQueue.size() > 0) {
+                    ensureProcessorRunningLocked(false);
+                } else if (!mDestroyed) {
+                    mCompatWorkEnqueuer.serviceProcessingFinished();
+                }
+            }
+        }
+    }
+
+    GenericWorkItem dequeueWork() {
+        if (mJobImpl != null) {
+            return mJobImpl.dequeueWork();
+        } else {
+            synchronized (mCompatQueue) {
+                if (mCompatQueue.size() > 0) {
+                    return mCompatQueue.remove(0);
+                } else {
+                    return null;
+                }
+            }
+        }
+    }
+}
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 33fd4af6b0..4c81e76a0a 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -318,8 +318,8 @@ dependencies {
     testImplementation(libs.truth)
     testImplementation(libs.robolectric)
     testImplementation(libs.androidx.test.core)
-    // https://github.com/mockito/mockito/releases
     testImplementation(libs.mockito)
+    testImplementation(libs.mockito.kotlin)
     testImplementation(libs.kotlinx.coroutines.test)
 }
 
diff --git a/app/src/androidTest/java/com/battlelancer/seriesguide/provider/DefaultValuesTest.kt b/app/src/androidTest/java/com/battlelancer/seriesguide/provider/DefaultValuesTest.kt
index bbb9b3a1e4..5914f37807 100644
--- a/app/src/androidTest/java/com/battlelancer/seriesguide/provider/DefaultValuesTest.kt
+++ b/app/src/androidTest/java/com/battlelancer/seriesguide/provider/DefaultValuesTest.kt
@@ -1,30 +1,35 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2018-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2018 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.provider
 
-import android.content.ContentProviderOperation
 import android.content.ContentResolver
 import android.content.Context
-import android.database.Cursor
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
-import com.battlelancer.seriesguide.SgApp
 import com.battlelancer.seriesguide.dataliberation.ImportTools.toSgEpisodeForImport
+import com.battlelancer.seriesguide.dataliberation.ImportTools.toSgListForImport
+import com.battlelancer.seriesguide.dataliberation.ImportTools.toSgListItemForImport
+import com.battlelancer.seriesguide.dataliberation.ImportTools.toSgMovieForImport
 import com.battlelancer.seriesguide.dataliberation.ImportTools.toSgSeasonForImport
 import com.battlelancer.seriesguide.dataliberation.ImportTools.toSgShowForImport
+import com.battlelancer.seriesguide.dataliberation.JsonExportTask.ListItemTypesExport
 import com.battlelancer.seriesguide.dataliberation.model.Episode
 import com.battlelancer.seriesguide.dataliberation.model.List
+import com.battlelancer.seriesguide.dataliberation.model.ListItem
 import com.battlelancer.seriesguide.dataliberation.model.Season
 import com.battlelancer.seriesguide.dataliberation.model.Show
+import com.battlelancer.seriesguide.lists.database.SgList
+import com.battlelancer.seriesguide.movies.database.SgMovie
+import com.battlelancer.seriesguide.movies.database.toSgMovieForInsert
 import com.battlelancer.seriesguide.movies.details.MovieDetails
+import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItemTypes
+import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItems
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.Lists
-import com.battlelancer.seriesguide.provider.SeriesGuideContract.Movies
 import com.battlelancer.seriesguide.shows.database.SgShow2
 import com.battlelancer.seriesguide.shows.episodes.EpisodeFlags
 import com.battlelancer.seriesguide.util.tasks.AddListTask
 import com.google.common.truth.Truth.assertThat
-import com.uwetrottmann.tmdb2.entities.Movie
 import org.junit.After
 import org.junit.Assert.fail
 import org.junit.Before
@@ -35,6 +40,7 @@ import org.junit.runner.RunWith
 class DefaultValuesTest {
 
     private lateinit var resolver: ContentResolver
+    private lateinit var testDb: SgRoomDatabase
 
     companion object {
         private val SHOW = Show().apply {
@@ -50,14 +56,24 @@ class DefaultValuesTest {
             tmdb_id = 123456
             tvdb_id = 123456
         }
+        private const val TEST_LIST_NAME = "Test List"
+        private val TEST_LIST_ID = Lists.generateListId(TEST_LIST_NAME)
         private val LIST = List().apply {
-            name = "Test List"
-            list_id = Lists.generateListId(name)
+            name = TEST_LIST_NAME
+            list_id = TEST_LIST_ID
         }
-        private val MOVIE = MovieDetails().apply {
-            val tmdbMovie = Movie().apply { id = 12 }
-            tmdbMovie(tmdbMovie)
+        private const val TEST_LIST_ITEM_EXTERNAL_ID = "test-external-id"
+        private val LIST_ITEM = ListItem().apply {
+            list_item_id = ListItems.generateListItemId(
+                TEST_LIST_ITEM_EXTERNAL_ID,
+                ListItemTypes.TMDB_SHOW,
+                TEST_LIST_ID
+            )
+            externalId = TEST_LIST_ITEM_EXTERNAL_ID
+            type = ListItemTypesExport.TMDB_SHOW
         }
+        private const val TEST_MOVIE_TMDB_ID = 12
+        private val MOVIE = MovieDetails()
         private val MOVIE_I = com.battlelancer.seriesguide.dataliberation.model.Movie()
     }
 
@@ -68,18 +84,18 @@ class DefaultValuesTest {
         // and use the real ContentResolver
         val context = ApplicationProvider.getApplicationContext<Context>()
         SgRoomDatabase.switchToInMemory(context)
+        testDb = SgRoomDatabase.getInstance(context)
         resolver = context.contentResolver
     }
 
     @After
     fun closeDb() {
-        SgRoomDatabase.getInstance(ApplicationProvider.getApplicationContext()).close()
+        testDb.close()
     }
 
     @Test
     fun showDefaultValuesImport() {
-        val context = ApplicationProvider.getApplicationContext<Context>()
-        val showHelper = SgRoomDatabase.getInstance(context).sgShow2Helper()
+        val showHelper = testDb.sgShow2Helper()
 
         val sgShow = SHOW.toSgShowForImport()
         val showId = showHelper.insertShow(sgShow)
@@ -90,6 +106,9 @@ class DefaultValuesTest {
             return
         }
 
+        // Check a primary key was assigned
+        assertThat(show.id).isGreaterThan(0)
+
         // Note: compare with SgShow2 and ImportTools.
         assertThat(show.tvdbId).isEqualTo(SHOW.tvdb_id)
         assertThat(show.title).isNotNull()
@@ -125,21 +144,21 @@ class DefaultValuesTest {
     @Test
     fun seasonDefaultValuesImport() {
         // with Room insert actually checks constraints, so add a matching show first
-        val context = ApplicationProvider.getApplicationContext<Context>()
-        val database = SgRoomDatabase.getInstance(context)
-
         val sgShow = SHOW.toSgShowForImport()
-        val showId = database.sgShow2Helper().insertShow(sgShow)
+        val showId = testDb.sgShow2Helper().insertShow(sgShow)
 
         val sgSeason = SEASON.toSgSeasonForImport(showId)
-        val seasonId = database.sgSeason2Helper().insertSeason(sgSeason)
+        val seasonId = testDb.sgSeason2Helper().insertSeason(sgSeason)
 
-        val season = database.sgSeason2Helper().getSeason(seasonId)
+        val season = testDb.sgSeason2Helper().getSeason(seasonId)
         if (season == null) {
             fail("season is null")
             return
         }
 
+        // Check a primary key was assigned
+        assertThat(season.id).isGreaterThan(0)
+
         assertThat(season.tmdbId).isEqualTo(SEASON.tmdb_id)
         assertThat(season.tvdbId).isEqualTo(SEASON.tvdb_id)
         assertThat(season.showId).isEqualTo(showId)
@@ -154,24 +173,24 @@ class DefaultValuesTest {
     @Test
     fun episodeDefaultValuesImport() {
         // with Room insert actually checks constraints, so add a matching show and season first
-        val context = ApplicationProvider.getApplicationContext<Context>()
-        val database = SgRoomDatabase.getInstance(context)
-
         val sgShow = SHOW.toSgShowForImport()
-        val showId = database.sgShow2Helper().insertShow(sgShow)
+        val showId = testDb.sgShow2Helper().insertShow(sgShow)
 
         val sgSeason = SEASON.toSgSeasonForImport(showId)
-        val seasonId = database.sgSeason2Helper().insertSeason(sgSeason)
+        val seasonId = testDb.sgSeason2Helper().insertSeason(sgSeason)
 
         val sgEpisode = EPISODE.toSgEpisodeForImport(showId, seasonId, sgSeason.number)
-        val episodeId = database.sgEpisode2Helper().insertEpisode(sgEpisode)
+        val episodeId = testDb.sgEpisode2Helper().insertEpisode(sgEpisode)
 
-        val episode = database.sgEpisode2Helper().getEpisode(episodeId)
+        val episode = testDb.sgEpisode2Helper().getEpisode(episodeId)
         if (episode == null) {
             fail("episode is null")
             return
         }
 
+        // Check a primary key was assigned
+        assertThat(episode.id).isGreaterThan(0)
+
         assertThat(episode.title).isNotNull()
         assertThat(episode.number).isEqualTo(0)
         assertThat(episode.watched).isEqualTo(EpisodeFlags.UNWATCHED)
@@ -188,83 +207,91 @@ class DefaultValuesTest {
 
     @Test
     fun listDefaultValues() {
-        val context = ApplicationProvider.getApplicationContext<Context>()
-        val database = SgRoomDatabase.getInstance(context)
-
         val addListTask = AddListTask(ApplicationProvider.getApplicationContext(), LIST.name)
         addListTask.doDatabaseUpdate(resolver, addListTask.listId)
 
-        val lists = database.sgListHelper().getListsForExport()
+        val lists = testDb.sgListHelper().getListsForExport()
         // Initial data + new list from above; initial data asserted with RoomInitialDataTest.
         assertThat(lists).hasSize(2)
-        assertThat(lists[1].name).isEqualTo(LIST.name)
-
-        assertThat(lists[1].order).isEqualTo(0)
+        assertTestList(lists[1])
     }
 
     @Test
     fun listDefaultValuesImport() {
-        val context = ApplicationProvider.getApplicationContext<Context>()
-        val database = SgRoomDatabase.getInstance(context)
-        // Delete initial list.
-        database.sgListHelper().deleteAllLists()
+        val listHelper = testDb.sgListHelper()
+        // By default, the database inserts a first list when being created: delete it
+        listHelper.deleteAllLists()
 
-        val values = LIST.toContentValues()
+        // List
+        val sgList = LIST.toSgListForImport()
 
-        val op = ContentProviderOperation.newInsert(Lists.CONTENT_URI)
-            .withValues(values).build()
+        listHelper.insertList(sgList)
 
-        val batch = ArrayList<ContentProviderOperation>()
-        batch.add(op)
-        resolver.applyBatch(SgApp.CONTENT_AUTHORITY, batch)
-
-        val lists = database.sgListHelper().getListsForExport()
+        val lists = listHelper.getListsForExport()
         assertThat(lists).hasSize(1)
-        assertThat(lists[0].name).isEqualTo(LIST.name)
+        assertTestList(lists[0])
+
+        // List item
+        val sgListItem = LIST_ITEM.toSgListItemForImport(TEST_LIST_ID)!!
+
+        listHelper.insertListItems(listOf(sgListItem))
+
+        val listItems = listHelper.getListItemsForExport(TEST_LIST_ID)
+        assertThat(listItems).hasSize(1)
+        val listItem = listItems[0]
+
+        // Check a primary key was assigned
+        assertThat(listItem.id).isGreaterThan(0)
+
+        assertThat(listItem.listItemId).isEqualTo(LIST_ITEM.list_item_id)
+        assertThat(listItem.type).isEqualTo(ListItemTypes.TMDB_SHOW)
+        assertThat(listItem.itemRefId).isEqualTo(LIST_ITEM.externalId)
+        assertThat(listItem.listId).isEqualTo(TEST_LIST_ID)
+    }
+
+    private fun assertTestList(actualList: SgList) {
+        // Check a primary key was assigned
+        assertThat(actualList.id).isGreaterThan(0)
 
-        assertThat(lists[0].order).isEqualTo(0)
+        assertThat(actualList.name).isEqualTo(LIST.name)
+        assertThat(actualList.order).isEqualTo(0)
     }
 
     @Test
     fun movieDefaultValues() {
-        val values = MOVIE.toContentValuesInsert()
-        resolver.insert(Movies.CONTENT_URI, values)
+        val movieHelper = testDb.movieHelper()
+
+        val sgMovie = MOVIE.toSgMovieForInsert(TEST_MOVIE_TMDB_ID)
 
-        assertMovie()
+        movieHelper.insertMovie(sgMovie)
+
+        assertMovie(movieHelper.getMovie(TEST_MOVIE_TMDB_ID))
     }
 
     @Test
     fun movieDefaultValuesImport() {
-        resolver.insert(Movies.CONTENT_URI, MOVIE_I.toContentValues())
+        val movieHelper = testDb.movieHelper()
 
-        assertMovie()
-    }
+        movieHelper.insertMovie(MOVIE_I.toSgMovieForImport())
 
-    private fun assertMovie() {
-        val query = resolver.query(Movies.CONTENT_URI, null, null, null, null)
-        assertThat(query).isNotNull()
-        assertThat(query!!.count).isEqualTo(1)
-        assertThat(query.moveToFirst()).isTrue()
-
-        assertDefaultValue(query, Movies.RUNTIME_MIN, 0)
-        assertDefaultValue(query, Movies.IN_COLLECTION, 0)
-        assertDefaultValue(query, Movies.IN_WATCHLIST, 0)
-        assertDefaultValue(query, Movies.PLAYS, 0)
-        assertDefaultValue(query, Movies.WATCHED, 0)
-        assertDefaultValue(query, Movies.RATING_TMDB, 0)
-        assertDefaultValue(query, Movies.RATING_VOTES_TMDB, 0)
-        assertDefaultValue(query, Movies.RATING_TRAKT, 0)
-        assertDefaultValue(query, Movies.RATING_VOTES_TRAKT, 0)
-
-        query.close()
+        assertMovie(movieHelper.getAllMovies()[0])
     }
 
-    private fun assertNotNullValue(query: Cursor, column: String) {
-        assertThat(query.isNull(query.getColumnIndexOrThrow(column))).isFalse()
+    private fun assertMovie(movie: SgMovie?) {
+        assertThat(movie).isNotNull()
+
+        // Check a primary key was assigned
+        assertThat(movie!!.id).isGreaterThan(0)
+
+        assertThat(movie.runtimeMin).isEqualTo(0)
+        assertThat(movie.inCollection).isEqualTo(false)
+        assertThat(movie.inWatchlist).isEqualTo(false)
+        assertThat(movie.plays).isEqualTo(0)
+        assertThat(movie.watched).isEqualTo(false)
+        assertThat(movie.ratingTmdb).isEqualTo(0.0)
+        assertThat(movie.ratingVotesTmdb).isEqualTo(0)
+        assertThat(movie.ratingTrakt).isEqualTo(0)
+        assertThat(movie.ratingVotesTrakt).isEqualTo(0)
     }
 
-    private fun assertDefaultValue(query: Cursor, column: String, defaultValue: Int) {
-        assertNotNullValue(query, column)
-        assertThat(query.getInt(query.getColumnIndexOrThrow(column))).isEqualTo(defaultValue)
-    }
 }
diff --git a/app/src/androidTest/java/com/battlelancer/seriesguide/sync/TmdbSyncTest.kt b/app/src/androidTest/java/com/battlelancer/seriesguide/sync/TmdbSyncTest.kt
index 390710a19d..e096b0dfc6 100644
--- a/app/src/androidTest/java/com/battlelancer/seriesguide/sync/TmdbSyncTest.kt
+++ b/app/src/androidTest/java/com/battlelancer/seriesguide/sync/TmdbSyncTest.kt
@@ -1,9 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2018-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2018 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.sync
 
-import android.content.ContentResolver
 import android.content.Context
 import android.text.format.DateUtils
 import androidx.test.core.app.ApplicationProvider
@@ -16,9 +15,9 @@ import com.battlelancer.seriesguide.modules.TestTmdbModule
 import com.battlelancer.seriesguide.modules.TestTraktModule
 import com.battlelancer.seriesguide.movies.database.MovieHelper
 import com.battlelancer.seriesguide.movies.database.SgMovie
+import com.battlelancer.seriesguide.movies.database.toSgMovieForInsert
 import com.battlelancer.seriesguide.movies.details.MovieDetails
 import com.battlelancer.seriesguide.movies.tools.MovieTools
-import com.battlelancer.seriesguide.provider.SeriesGuideContract.Movies
 import com.battlelancer.seriesguide.provider.SgRoomDatabase
 import com.google.common.truth.Truth.assertThat
 import com.google.common.truth.Truth.assertWithMessage
@@ -31,6 +30,10 @@ import org.junit.runner.RunWith
 import java.util.Date
 import javax.inject.Inject
 
+/**
+ * Note: these tests actually updates the movies with data from TMDB, so they require an internet
+ * connection and TMDB API key.
+ */
 @RunWith(AndroidJUnit4::class)
 class TmdbSyncTest {
 
@@ -40,19 +43,14 @@ class TmdbSyncTest {
     @Inject
     lateinit var movieTools: MovieTools
 
-    private lateinit var resolver: ContentResolver
     private lateinit var db: SgRoomDatabase
     private lateinit var movieHelper: MovieHelper
 
     @Before
     fun setup() {
-        /*
-        ProviderTestRule does not work with Room, so instead blatantly replace the instance with one
-        that uses an in-memory database and use the real ContentResolver.
-        */
+        // Use an in-memory database for testing with Room
         val context = ApplicationProvider.getApplicationContext<Context>()
         SgRoomDatabase.switchToInMemory(context)
-        resolver = context.contentResolver
         db = SgRoomDatabase.getInstance(context)
         movieHelper = db.movieHelper()
 
@@ -72,22 +70,20 @@ class TmdbSyncTest {
 
     @Test
     fun updatesMoviesLessFrequentIfOlder() {
-        val lastUpdatedCurrent =
-            System.currentTimeMillis()
+        val currentTime = System.currentTimeMillis()
+
         val lastUpdatedOutdated =
-            System.currentTimeMillis() - TmdbSync.UPDATED_BEFORE_DAYS - DateUtils.DAY_IN_MILLIS
+            currentTime - TmdbSync.UPDATED_BEFORE_DAYS - DateUtils.DAY_IN_MILLIS
         val lastUpdatedVeryOutdated =
-            System.currentTimeMillis() - TmdbSync.UPDATED_BEFORE_90_DAYS - DateUtils.DAY_IN_MILLIS
-        val releaseDateCurrent =
-            System.currentTimeMillis()
+            currentTime - TmdbSync.UPDATED_BEFORE_90_DAYS - DateUtils.DAY_IN_MILLIS
         val releaseDateOld =
-            System.currentTimeMillis() - TmdbSync.RELEASED_AFTER_DAYS - DateUtils.DAY_IN_MILLIS
+            currentTime - TmdbSync.RELEASED_AFTER_DAYS - DateUtils.DAY_IN_MILLIS
 
         // released today
-        insertMovie(10, releaseDateCurrent, lastUpdatedCurrent)
-        insertMovie(11, releaseDateCurrent, lastUpdatedOutdated)
+        insertMovie(10, releaseDateMs = currentTime, lastUpdatedMs = currentTime)
+        insertMovie(11, releaseDateMs = currentTime, lastUpdatedOutdated)
         // released a while ago
-        insertMovie(12, releaseDateOld, lastUpdatedCurrent)
+        insertMovie(12, releaseDateOld, lastUpdatedMs = currentTime)
         insertMovie(13, releaseDateOld, lastUpdatedOutdated)
         insertMovie(14, releaseDateOld, lastUpdatedVeryOutdated)
 
@@ -95,11 +91,12 @@ class TmdbSyncTest {
 
         // only the recently released outdated and the older very outdated movie should have been updated
         val movies = movieHelper.getAllMovies()
-        assertThat(findMovieWithId(movies, 10).lastUpdated).isEqualTo(lastUpdatedCurrent)
+        assertThat(findMovieWithId(movies, 10).lastUpdated).isEqualTo(currentTime)
+        // FIXME Movie 11 is not updated, only movie 14
         assertThat(lastUpdatedOutdated < findMovieWithId(movies, 11).lastUpdatedOrDefault)
             .isTrue()
 
-        assertThat(findMovieWithId(movies, 12).lastUpdated).isEqualTo(lastUpdatedCurrent)
+        assertThat(findMovieWithId(movies, 12).lastUpdated).isEqualTo(currentTime)
         assertThat(findMovieWithId(movies, 13).lastUpdated).isEqualTo(lastUpdatedOutdated)
         assertThat(lastUpdatedVeryOutdated < findMovieWithId(movies, 14).lastUpdatedOrDefault)
             .isTrue()
@@ -131,7 +128,6 @@ class TmdbSyncTest {
 
     private fun insertMovie(tmdbId: Int, releaseDateMs: Long, lastUpdatedMs: Long?) {
         val movie = Movie().apply {
-            id = tmdbId
             release_date = Date(releaseDateMs)
         }
 
@@ -141,13 +137,18 @@ class TmdbSyncTest {
             tmdbMovie(movie)
         }
 
-        val values = details.toContentValuesInsert()
-        if (lastUpdatedMs == null) {
-            values.remove(Movies.LAST_UPDATED)
-        } else {
-            values.put(Movies.LAST_UPDATED, lastUpdatedMs)
-        }
-        resolver.insert(Movies.CONTENT_URI, values)
+        details.toSgMovieForInsert(tmdbId)
+            .let {
+                // Replace the default lastUpdated value with the one needed for this test
+                if (lastUpdatedMs == null) {
+                    it.copy(lastUpdated = null)
+                } else {
+                    it.copy(lastUpdated = lastUpdatedMs)
+                }
+            }
+            .also {
+                movieHelper.insertMovie(it)
+            }
     }
 
     private fun doUpdateAndAssertSuccess() {
diff --git a/app/src/main/java/com/battlelancer/seriesguide/SgApp.kt b/app/src/main/java/com/battlelancer/seriesguide/SgApp.kt
index c50956e636..0639ddec9b 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/SgApp.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/SgApp.kt
@@ -93,6 +93,8 @@ class SgApp : Application() {
 
         const val RELEASE_VERSION_2025_2_6 = 21250207
 
+        const val RELEASE_VERSION_2026_2_0 = 23260200
+
         /**
          * The content authority used to identify the SeriesGuide [android.content.ContentProvider].
          */
diff --git a/app/src/main/java/com/battlelancer/seriesguide/backend/settings/HexagonSettings.kt b/app/src/main/java/com/battlelancer/seriesguide/backend/settings/HexagonSettings.kt
index fb91cdcb05..3aa940d4e6 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/backend/settings/HexagonSettings.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/backend/settings/HexagonSettings.kt
@@ -1,13 +1,17 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2013-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2013 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.backend.settings
 
 import android.content.Context
 import androidx.core.content.edit
 import androidx.preference.PreferenceManager
+import com.battlelancer.seriesguide.backend.settings.HexagonSettings.getLastListsSyncTime
+import com.battlelancer.seriesguide.backend.settings.HexagonSettings.getLastMoviesSyncTime
+import com.battlelancer.seriesguide.backend.settings.HexagonSettings.getLastSyncTime
 import com.battlelancer.seriesguide.billing.BillingTools
 import com.battlelancer.seriesguide.provider.SgRoomDatabase
+import timber.log.Timber
 
 object HexagonSettings {
 
@@ -136,6 +140,7 @@ object HexagonSettings {
         editor.remove(KEY_LAST_SYNC_MOVIES)
         editor.remove(KEY_LAST_SYNC_LISTS)
         return editor.commit()
+            .also { Timber.i("Sync state reset") }
     }
 
     /**
@@ -213,14 +218,8 @@ object HexagonSettings {
         }
     }
 
-    fun getLastMoviesSyncTime(context: Context): Long? {
-        val prefs = PreferenceManager.getDefaultSharedPreferences(context)
-        if (!prefs.contains(KEY_LAST_SYNC_MOVIES)) return null
-        return prefs.getLong(
-            KEY_LAST_SYNC_MOVIES,
-            0 /* Never returned, returning null above if it does not exist */
-        )
-    }
+    fun getLastMoviesSyncTime(context: Context): Long? =
+        getLastSyncTimeIfKeyExists(context, KEY_LAST_SYNC_MOVIES)
 
     fun setLastMoviesSyncTime(context: Context, timeInMs: Long) {
         PreferenceManager.getDefaultSharedPreferences(context).edit {
@@ -229,17 +228,18 @@ object HexagonSettings {
     }
 
     /**
-     * Sets [getLastMoviesSyncTime] so that all movies are downloaded on the next sync.
+     * Removes the key for [getLastMoviesSyncTime] so that all movies are downloaded on the next
+     * sync.
      */
     fun resetLastMoviesSyncTime(context: Context) {
         PreferenceManager.getDefaultSharedPreferences(context).edit {
             remove(KEY_LAST_SYNC_MOVIES)
         }
+        Timber.i("Last movies sync time reset")
     }
 
-    fun getLastListsSyncTime(context: Context): Long {
-        return getLastSyncTime(context, KEY_LAST_SYNC_LISTS)
-    }
+    fun getLastListsSyncTime(context: Context): Long? =
+        getLastSyncTimeIfKeyExists(context, KEY_LAST_SYNC_LISTS)
 
     fun setLastListsSyncTime(context: Context, timeInMs: Long) {
         PreferenceManager.getDefaultSharedPreferences(context).edit {
@@ -247,6 +247,16 @@ object HexagonSettings {
         }
     }
 
+    /**
+     * Removes the key for [getLastListsSyncTime] so that all lists are downloaded on the next sync.
+     */
+    fun resetLastListsSyncTime(context: Context) {
+        PreferenceManager.getDefaultSharedPreferences(context).edit {
+            remove(KEY_LAST_SYNC_LISTS)
+        }
+        Timber.i("Last lists sync time reset")
+    }
+
     private fun getLastSyncTime(context: Context, key: String): Long {
         val prefs = PreferenceManager.getDefaultSharedPreferences(context)
         var lastSync = prefs.getLong(key, 0)
@@ -256,4 +266,21 @@ object HexagonSettings {
         }
         return lastSync
     }
+
+    /**
+     * Unlike [getLastSyncTime], handles a deleted [key] by returning `null`.
+     *
+     * This is done to support resetting (deleting the key) to download all instead of just changed
+     * elements without resetting merged state.
+     */
+    private fun getLastSyncTimeIfKeyExists(context: Context, key: String): Long? {
+        val prefs = PreferenceManager.getDefaultSharedPreferences(context)
+        return if (prefs.contains(key)) {
+            prefs.getLong(
+                key,
+                0 /* Never returned, returning null above if it does not exist */
+            )
+        } else null
+    }
+
 }
\ No newline at end of file
diff --git a/app/src/main/java/com/battlelancer/seriesguide/billing/BillingTools.kt b/app/src/main/java/com/battlelancer/seriesguide/billing/BillingTools.kt
index 3bf11e1ee2..211a12c8f8 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/billing/BillingTools.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/billing/BillingTools.kt
@@ -6,6 +6,7 @@ package com.battlelancer.seriesguide.billing
 import android.content.Context
 import android.content.Intent
 import android.widget.Toast
+import androidx.annotation.VisibleForTesting
 import com.battlelancer.seriesguide.BuildConfig
 import com.battlelancer.seriesguide.R
 import com.battlelancer.seriesguide.SgApp
@@ -64,7 +65,11 @@ object BillingTools {
         }
     }
 
-    private fun updateUnlockState(context: Context) {
+    /**
+     * Typically use [updateUnlockStateAsync], only public for testing.
+     */
+    @VisibleForTesting
+    fun updateUnlockState(context: Context) {
         val amazonUnlockState = AdvancedSettings.getLastSupporterState(context)
         val passUnlockState = PackageTools.hasUnlockKeyInstalled(context)
         val playUnlockStateDb = LocalBillingDb.getInstance(context).unlockStateHelper()
diff --git a/app/src/main/java/com/battlelancer/seriesguide/dataliberation/ImportTools.kt b/app/src/main/java/com/battlelancer/seriesguide/dataliberation/ImportTools.kt
index 6beb2479ca..9654dc8483 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/dataliberation/ImportTools.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/dataliberation/ImportTools.kt
@@ -1,11 +1,20 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2021-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2021 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.dataliberation
 
+import com.battlelancer.seriesguide.dataliberation.JsonExportTask.ListItemTypesExport
 import com.battlelancer.seriesguide.dataliberation.model.Episode
+import com.battlelancer.seriesguide.dataliberation.model.List
+import com.battlelancer.seriesguide.dataliberation.model.ListItem
+import com.battlelancer.seriesguide.dataliberation.model.Movie
 import com.battlelancer.seriesguide.dataliberation.model.Season
 import com.battlelancer.seriesguide.dataliberation.model.Show
+import com.battlelancer.seriesguide.lists.database.SgList
+import com.battlelancer.seriesguide.lists.database.SgListItem
+import com.battlelancer.seriesguide.movies.database.SgMovie
+import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItemTypes
+import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItems
 import com.battlelancer.seriesguide.shows.database.SgEpisode2
 import com.battlelancer.seriesguide.shows.database.SgSeason2
 import com.battlelancer.seriesguide.shows.database.SgShow2
@@ -100,6 +109,75 @@ object ImportTools {
         )
     }
 
+    fun List.toSgListForImport(): SgList {
+        return SgList(
+            listId = list_id,
+            name = name,
+            order = order
+        )
+    }
+
+    /**
+     * May return null for unknown [ListItem.type] or if [ListItem.externalId] is missing.
+     */
+    fun ListItem.toSgListItemForImport(listId: String): SgListItem? {
+        // Note: DO import legacy types (seasons and episodes),
+        // as e.g. older backups can still contain legacy show data to allow displaying them.
+        val type: Int = if (ListItemTypesExport.MOVIE == type) {
+            ListItemTypes.TMDB_MOVIE
+        } else if (ListItemTypesExport.SHOW == type) {
+            ListItemTypes.TVDB_SHOW
+        } else if (ListItemTypesExport.TMDB_SHOW == type) {
+            ListItemTypes.TMDB_SHOW
+        } else if (ListItemTypesExport.SEASON == type) {
+            ListItemTypes.SEASON
+        } else if (ListItemTypesExport.EPISODE == type) {
+            ListItemTypes.EPISODE
+        } else {
+            return null // Unknown item type, skip
+        }
+
+        val externalId: String? = externalId
+        val legacyTvdbId: Int? = tvdb_id
+        val externalIdToInsert: String = if (!externalId.isNullOrEmpty()) {
+            externalId
+        } else if (legacyTvdbId != null && legacyTvdbId > 0) {
+            legacyTvdbId.toString()
+        } else {
+            return null // No external ID, skip
+        }
+
+        // Generate list item ID from values, do not trust given item ID
+        // (e.g. encoded list ID might not match)
+        val listItemId = ListItems.generateListItemId(externalIdToInsert, type, listId)
+
+        return SgListItem(
+            listItemId = listItemId,
+            itemRefId = externalIdToInsert,
+            type = type,
+            listId = listId
+        )
+    }
+
+    fun Movie.toSgMovieForImport(): SgMovie {
+        return SgMovie(
+            tmdbId = tmdb_id,
+            imdbId = imdb_id,
+            title = title,
+            titleNoArticle = TextTools.trimLeadingArticle(title),
+            releasedMs = released_utc_ms,
+            runtimeMin = runtime_min,
+            poster = poster,
+            inCollection = in_collection,
+            inWatchlist = in_watchlist,
+            watched = watched,
+            plays = if (watched && plays >= 1) plays else if (watched) 1 else 0,
+            lastUpdated = last_updated_ms,
+            // full dump values
+            overview = overview
+        )
+    }
+
     fun Double?.toRating(): Double? = if (this != null && this in 0.0..10.0) this else null
     private fun Int?.toUserRating(): Int? = if (this != null && this in 0..10) this else null
     fun Int?.toVotes(): Int? = if (this != null && this >= 0) this else null
diff --git a/app/src/main/java/com/battlelancer/seriesguide/dataliberation/JsonExportTask.kt b/app/src/main/java/com/battlelancer/seriesguide/dataliberation/JsonExportTask.kt
index 97ef6201a7..dc6658aeb0 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/dataliberation/JsonExportTask.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/dataliberation/JsonExportTask.kt
@@ -378,6 +378,7 @@ open class JsonExportTask(
             item.externalId = listItem.itemRefId
             // Note: export legacy types so users can get to legacy data if they need to.
             when (listItem.type) {
+                ListItemTypes.TMDB_MOVIE -> item.type = ListItemTypesExport.MOVIE
                 ListItemTypes.TVDB_SHOW -> item.type = ListItemTypesExport.SHOW
                 ListItemTypes.TMDB_SHOW -> item.type = ListItemTypesExport.TMDB_SHOW
                 ListItemTypes.SEASON -> item.type = ListItemTypesExport.SEASON
@@ -459,6 +460,7 @@ open class JsonExportTask(
     }
 
     object ListItemTypesExport {
+        const val MOVIE = "movie"
         const val SHOW = "show"
         const val TMDB_SHOW = "tmdb-show"
         const val SEASON = "season"
diff --git a/app/src/main/java/com/battlelancer/seriesguide/dataliberation/JsonImportTask.kt b/app/src/main/java/com/battlelancer/seriesguide/dataliberation/JsonImportTask.kt
index c9f8d027b9..e45e5d1917 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/dataliberation/JsonImportTask.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/dataliberation/JsonImportTask.kt
@@ -4,7 +4,6 @@
 package com.battlelancer.seriesguide.dataliberation
 
 import android.content.ContentProviderOperation
-import android.content.ContentValues
 import android.content.Context
 import android.content.OperationApplicationException
 import android.net.Uri
@@ -13,17 +12,20 @@ import androidx.annotation.VisibleForTesting
 import com.battlelancer.seriesguide.R
 import com.battlelancer.seriesguide.dataliberation.DataLiberationFragment.LiberationResultEvent
 import com.battlelancer.seriesguide.dataliberation.ImportTools.toSgEpisodeForImport
+import com.battlelancer.seriesguide.dataliberation.ImportTools.toSgListForImport
+import com.battlelancer.seriesguide.dataliberation.ImportTools.toSgListItemForImport
+import com.battlelancer.seriesguide.dataliberation.ImportTools.toSgMovieForImport
 import com.battlelancer.seriesguide.dataliberation.ImportTools.toSgSeasonForImport
 import com.battlelancer.seriesguide.dataliberation.ImportTools.toSgShowForImport
 import com.battlelancer.seriesguide.dataliberation.JsonExportTask.Export
-import com.battlelancer.seriesguide.dataliberation.JsonExportTask.ListItemTypesExport
 import com.battlelancer.seriesguide.dataliberation.model.List
 import com.battlelancer.seriesguide.dataliberation.model.Movie
 import com.battlelancer.seriesguide.dataliberation.model.Season
 import com.battlelancer.seriesguide.dataliberation.model.Show
+import com.battlelancer.seriesguide.lists.database.SgListHelper
+import com.battlelancer.seriesguide.lists.database.SgListItem
+import com.battlelancer.seriesguide.movies.database.MovieHelper
 import com.battlelancer.seriesguide.provider.SeriesGuideContract
-import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItemTypes
-import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItems
 import com.battlelancer.seriesguide.provider.SeriesGuideDatabase
 import com.battlelancer.seriesguide.provider.SgRoomDatabase
 import com.battlelancer.seriesguide.shows.database.SgEpisode2
@@ -42,6 +44,7 @@ import com.google.gson.stream.JsonReader
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.isActive
+import kotlinx.coroutines.sync.withPermit
 import kotlinx.coroutines.withContext
 import org.greenrobot.eventbus.EventBus
 import timber.log.Timber
@@ -62,7 +65,9 @@ class JsonImportTask(
     private val database: SgRoomDatabase,
     private val sgShow2Helper: SgShow2Helper,
     private val sgSeason2Helper: SgSeason2Helper,
-    private val sgEpisode2Helper: SgEpisode2Helper
+    private val sgEpisode2Helper: SgEpisode2Helper,
+    private val sgListHelper: SgListHelper,
+    private val sgMovieHelper: MovieHelper
 ) {
 
     private val context: Context = context.applicationContext
@@ -104,7 +109,9 @@ class JsonImportTask(
         SgRoomDatabase.getInstance(context),
         SgRoomDatabase.getInstance(context).sgShow2Helper(),
         SgRoomDatabase.getInstance(context).sgSeason2Helper(),
-        SgRoomDatabase.getInstance(context).sgEpisode2Helper()
+        SgRoomDatabase.getInstance(context).sgEpisode2Helper(),
+        SgRoomDatabase.getInstance(context).sgListHelper(),
+        SgRoomDatabase.getInstance(context).movieHelper()
     )
 
     constructor(context: Context) : this(context, true, true, true) {
@@ -113,22 +120,21 @@ class JsonImportTask(
 
     suspend fun run(): Int {
         return withContext(Dispatchers.IO) {
-            val result = doInBackground(this)
+            val result = if (SgSyncAdapter.isSyncActive(context, false)) {
+                // Do not import if an update task is running
+                ERROR_LARGE_DB_OP
+            } else {
+                // Do not import until an add or backup task are finished
+                TaskManager.addShowOrBackupSemaphore.withPermit {
+                    doInBackground(this)
+                }
+            }
             onPostExecute(result)
             return@withContext result
         }
     }
 
     private fun doInBackground(coroutineScope: CoroutineScope): Int {
-        // Do not import if an update task is running
-        if (SgSyncAdapter.isSyncActive(context, false)) {
-            return ERROR_LARGE_DB_OP
-        }
-        // Do not import if an add or backup task is running
-        if (!TaskManager.addShowOrBackupSemaphore.tryAcquire()) {
-            return ERROR_LARGE_DB_OP
-        }
-
         // last chance to abort
         if (!coroutineScope.isActive) {
             return ERROR
@@ -168,9 +174,6 @@ class JsonImportTask(
         // Renew search table
         SeriesGuideDatabase.rebuildFtsTable(context)
 
-        // allow other tasks to resume
-        TaskManager.addShowOrBackupSemaphore.release()
-
         return SUCCESS
     }
 
@@ -333,14 +336,11 @@ class JsonImportTask(
             }
 
             Export.Lists -> {
-                // delete list items before lists to prevent violating foreign key constraints
-                batch.add(
-                    ContentProviderOperation.newDelete(ListItems.CONTENT_URI).build()
-                )
-                batch.add(
-                    ContentProviderOperation.newDelete(SeriesGuideContract.Lists.CONTENT_URI)
-                        .build()
-                )
+                database.runInTransaction {
+                    // Delete list items before lists to prevent violating foreign key constraints
+                    sgListHelper.deleteAllListItems()
+                    sgListHelper.deleteAllLists()
+                }
             }
 
             Export.Movies -> {
@@ -389,10 +389,7 @@ class JsonImportTask(
             Export.Movies -> {
                 while (reader.hasNext()) {
                     val movie = gson.fromJson<Movie>(reader, Movie::class.java)
-                    context.contentResolver.insert(
-                        SeriesGuideContract.Movies.CONTENT_URI,
-                        movie.toContentValues()
-                    )
+                    addMovieToDatabase(movie)
                 }
             }
         }
@@ -400,6 +397,13 @@ class JsonImportTask(
         reader.close()
     }
 
+    private fun addMovieToDatabase(movie: Movie) {
+        if (movie.tmdb_id <= 0) {
+            return // Valid TMDB ID required
+        }
+        sgMovieHelper.insertMovie(movie.toSgMovieForImport())
+    }
+
     private fun addShowToDatabase(show: Show) {
         if ((show.tmdb_id == null || show.tmdb_id!! <= 0)
             && (show.tvdb_id == null || show.tvdb_id!! <= 0)) {
@@ -483,55 +487,21 @@ class JsonImportTask(
         }
 
         // Insert the list
-        context.contentResolver.insert(
-            SeriesGuideContract.Lists.CONTENT_URI,
-            list.toContentValues()
-        )
+        val sgList = list.toSgListForImport()
+        sgListHelper.insertList(sgList)
 
         if (list.items == null || list.items.isEmpty()) {
             return
         }
 
-        // Insert the lists items
-        val items = ArrayList<ContentValues>()
+        // Insert the list items
+        val items = ArrayList<SgListItem>()
         for (item in list.items) {
-            // Note: DO import legacy types (seasons and episodes),
-            // as e.g. older backups can still contain legacy show data to allow displaying them.
-            val type: Int = if (ListItemTypesExport.SHOW == item.type) {
-                ListItemTypes.TVDB_SHOW
-            } else if (ListItemTypesExport.TMDB_SHOW == item.type) {
-                ListItemTypes.TMDB_SHOW
-            } else if (ListItemTypesExport.SEASON == item.type) {
-                ListItemTypes.SEASON
-            } else if (ListItemTypesExport.EPISODE == item.type) {
-                ListItemTypes.EPISODE
-            } else {
-                // Unknown item type, skip
-                continue
-            }
-
-            var externalId: String? = null
-            if (item.externalId != null && item.externalId.isNotEmpty()) {
-                externalId = item.externalId
-            } else if (item.tvdb_id > 0) {
-                externalId = item.tvdb_id.toString()
-            }
-            if (externalId == null) continue  // No external ID, skip
-
-            // Generate list item ID from values, do not trust given item ID
-            // (e.g. encoded list ID might not match)
-            item.list_item_id = ListItems.generateListItemId(externalId, type, list.list_id)
-
-            val itemValues = ContentValues()
-            itemValues.put(ListItems.LIST_ITEM_ID, item.list_item_id)
-            itemValues.put(SeriesGuideContract.Lists.LIST_ID, list.list_id)
-            itemValues.put(ListItems.ITEM_REF_ID, externalId)
-            itemValues.put(ListItems.TYPE, type)
-
-            items.add(itemValues)
+            item.toSgListItemForImport(sgList.listId)
+                ?.let { items.add(it) }
         }
 
-        context.contentResolver.bulkInsert(ListItems.CONTENT_URI, items.toTypedArray())
+        sgListHelper.insertListItems(items)
     }
 
     companion object {
diff --git a/app/src/main/java/com/battlelancer/seriesguide/dataliberation/model/List.java b/app/src/main/java/com/battlelancer/seriesguide/dataliberation/model/List.java
index ae7d543317..e8fd26ac3b 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/dataliberation/model/List.java
+++ b/app/src/main/java/com/battlelancer/seriesguide/dataliberation/model/List.java
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2013-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2013 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.dataliberation.model;
 
@@ -14,11 +14,4 @@ public class List {
 
     public java.util.List<ListItem> items;
 
-    public ContentValues toContentValues() {
-        ContentValues values = new ContentValues();
-        values.put(Lists.LIST_ID, list_id);
-        values.put(Lists.NAME, name);
-        values.put(Lists.ORDER, order);
-        return values;
-    }
 }
diff --git a/app/src/main/java/com/battlelancer/seriesguide/dataliberation/model/ListItem.java b/app/src/main/java/com/battlelancer/seriesguide/dataliberation/model/ListItem.java
index ab5a855aa9..e15cbdcdc5 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/dataliberation/model/ListItem.java
+++ b/app/src/main/java/com/battlelancer/seriesguide/dataliberation/model/ListItem.java
@@ -3,14 +3,17 @@
 
 package com.battlelancer.seriesguide.dataliberation.model;
 
+import androidx.annotation.Nullable;
+
 public class ListItem {
 
     public String list_item_id;
 
     /**
-     * Used in legacy backup files.
+     * Null in new backups. Used in legacy backup files.
      */
-    public int tvdb_id;
+    @Nullable
+    public Integer tvdb_id;
 
     /**
      * TMDB ID for new list items, TVDB ID for legacy list items.
diff --git a/app/src/main/java/com/battlelancer/seriesguide/dataliberation/model/Movie.java b/app/src/main/java/com/battlelancer/seriesguide/dataliberation/model/Movie.java
index c28e7dd8c2..438c6db13c 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/dataliberation/model/Movie.java
+++ b/app/src/main/java/com/battlelancer/seriesguide/dataliberation/model/Movie.java
@@ -1,12 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2014-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2014 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.dataliberation.model;
 
-import android.content.ContentValues;
-import com.battlelancer.seriesguide.provider.SeriesGuideContract.Movies;
-import com.battlelancer.seriesguide.util.TextTools;
-
 public class Movie {
 
     /**
@@ -54,35 +50,4 @@ public class Movie {
      * Time in milliseconds a movie was last updated.
      */
     public long last_updated_ms;
-    
-    public ContentValues toContentValues() {
-        ContentValues values = new ContentValues();
-        values.put(Movies.TMDB_ID, tmdb_id);
-        values.put(Movies.IMDB_ID, imdb_id);
-        values.put(Movies.TITLE, title);
-        values.put(Movies.TITLE_NOARTICLE, TextTools.trimLeadingArticle(title));
-        values.put(Movies.RELEASED_UTC_MS, released_utc_ms);
-        values.put(Movies.RUNTIME_MIN, runtime_min);
-        values.put(Movies.POSTER, poster);
-        values.put(Movies.IN_COLLECTION, in_collection ? 1 : 0);
-        values.put(Movies.IN_WATCHLIST, in_watchlist ? 1 : 0);
-        values.put(Movies.WATCHED, watched ? 1 : 0);
-        int playsValue;
-        if (watched && plays >= 1) {
-            playsValue = plays;
-        } else {
-            playsValue = watched ? 1 : 0;
-        }
-        values.put(Movies.PLAYS, playsValue);
-        values.put(Movies.LAST_UPDATED, last_updated_ms);
-        // full dump values
-        values.put(Movies.OVERVIEW, overview);
-        // set default values
-        values.put(Movies.RATING_TMDB, 0);
-        values.put(Movies.RATING_VOTES_TMDB, 0);
-        values.put(Movies.RATING_TRAKT, 0);
-        values.put(Movies.RATING_VOTES_TRAKT, 0);
-        return values;
-    }
-
 }
diff --git a/app/src/main/java/com/battlelancer/seriesguide/jobs/episodes/BaseEpisodesJob.kt b/app/src/main/java/com/battlelancer/seriesguide/jobs/episodes/BaseEpisodesJob.kt
index 609b637713..fe3379fa4e 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/jobs/episodes/BaseEpisodesJob.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/jobs/episodes/BaseEpisodesJob.kt
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2017, 2018, 2020-2024 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2017 Uwe Trottmann <uwe@uwetrottmann.com>
 package com.battlelancer.seriesguide.jobs.episodes
 
 import android.content.Context
@@ -7,7 +7,6 @@ import androidx.annotation.CallSuper
 import com.battlelancer.seriesguide.jobs.BaseFlagJob
 import com.battlelancer.seriesguide.jobs.EpisodeInfo
 import com.battlelancer.seriesguide.jobs.SgJobInfo
-import com.battlelancer.seriesguide.provider.SeriesGuideContract
 import com.battlelancer.seriesguide.provider.SgRoomDatabase
 import com.battlelancer.seriesguide.shows.database.SgEpisode2Numbers
 import com.battlelancer.seriesguide.shows.episodes.EpisodeTools
@@ -62,10 +61,6 @@ abstract class BaseEpisodesJob(
             }
         }
 
-        // notify some other URIs about updates
-        context.contentResolver
-            .notifyChange(SeriesGuideContract.ListItems.CONTENT_WITH_DETAILS_URI, null)
-
         return true
     }
 
diff --git a/app/src/main/java/com/battlelancer/seriesguide/jobs/movies/MovieCollectionJob.kt b/app/src/main/java/com/battlelancer/seriesguide/jobs/movies/MovieCollectionJob.kt
index ea91f0d6fb..025be09bfc 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/jobs/movies/MovieCollectionJob.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/jobs/movies/MovieCollectionJob.kt
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2020, 2022, 2023 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2020 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.jobs.movies
 
@@ -25,7 +25,7 @@ class MovieCollectionJob(
         return if (isInCollection) {
             movieTools.addToList(movieTmdbId, MovieTools.Lists.COLLECTION)
         } else {
-            MovieTools.removeFromList(context, movieTmdbId, MovieTools.Lists.COLLECTION)
+            movieTools.removeFromList(movieTmdbId, MovieTools.Lists.COLLECTION)
         }
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/com/battlelancer/seriesguide/jobs/movies/MovieWatchedJob.kt b/app/src/main/java/com/battlelancer/seriesguide/jobs/movies/MovieWatchedJob.kt
index bb9e4df437..3d44992372 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/jobs/movies/MovieWatchedJob.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/jobs/movies/MovieWatchedJob.kt
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2019, 2020, 2022, 2023 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2019 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.jobs.movies
 
@@ -19,11 +19,11 @@ class MovieWatchedJob(
 ) {
 
     override suspend fun applyDatabaseUpdate(context: Context, movieTmdbId: Int): Boolean {
+        val movieTools = SgApp.getServicesComponent(context).movieTools()
         return if (isWatched) {
-            val movieTools = SgApp.getServicesComponent(context).movieTools()
             movieTools.addToList(movieTmdbId, MovieTools.Lists.WATCHED)
         } else {
-            MovieTools.removeFromList(context, movieTmdbId, MovieTools.Lists.WATCHED)
+            movieTools.removeFromList(movieTmdbId, MovieTools.Lists.WATCHED)
         }
     }
 }
diff --git a/app/src/main/java/com/battlelancer/seriesguide/jobs/movies/MovieWatchlistJob.kt b/app/src/main/java/com/battlelancer/seriesguide/jobs/movies/MovieWatchlistJob.kt
index 83c2d11c75..35d4ad1f24 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/jobs/movies/MovieWatchlistJob.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/jobs/movies/MovieWatchlistJob.kt
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2020, 2022, 2023 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2020 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.jobs.movies
 
@@ -25,7 +25,7 @@ class MovieWatchlistJob(
         return if (isInWatchlist) {
             movieTools.addToList(movieTmdbId, MovieTools.Lists.WATCHLIST)
         } else {
-            MovieTools.removeFromList(context, movieTmdbId, MovieTools.Lists.WATCHLIST)
+            movieTools.removeFromList(movieTmdbId, MovieTools.Lists.WATCHLIST)
         }
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/com/battlelancer/seriesguide/lists/ListsActivityImpl.kt b/app/src/main/java/com/battlelancer/seriesguide/lists/ListsActivityImpl.kt
index 72f589d8e4..1ee10467df 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/lists/ListsActivityImpl.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/lists/ListsActivityImpl.kt
@@ -1,29 +1,23 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2012-2024 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2012 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.lists
 
 import android.content.Intent
 import android.os.Bundle
-import android.view.Menu
-import android.view.MenuInflater
 import android.view.MenuItem
 import android.view.View
 import androidx.activity.viewModels
 import androidx.preference.PreferenceManager
 import androidx.viewpager2.widget.ViewPager2
 import com.battlelancer.seriesguide.R
-import com.battlelancer.seriesguide.appwidget.ListWidgetProvider
 import com.battlelancer.seriesguide.databinding.ActivityListsBinding
-import com.battlelancer.seriesguide.settings.DisplaySettings
 import com.battlelancer.seriesguide.ui.BaseTopActivity
 import com.battlelancer.seriesguide.ui.SearchActivity
 import com.battlelancer.seriesguide.ui.menus.ManualSyncMenu
 import com.battlelancer.seriesguide.util.ThemeUtils
 import com.battlelancer.seriesguide.util.ThemeUtils.setDefaultStyle
-import com.battlelancer.seriesguide.util.ViewTools
 import com.battlelancer.seriesguide.util.safeShow
-import org.greenrobot.eventbus.EventBus
 
 /**
  * Hosts a view pager to display and manage user created lists.
@@ -99,46 +93,6 @@ open class ListsActivityImpl : BaseTopActivity() {
     private val optionsMenuProvider by lazy {
         object : ManualSyncMenu(this@ListsActivityImpl, R.menu.lists_menu) {
 
-            override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
-                super.onCreateMenu(menu, menuInflater)
-
-                // set current sort order and check box states
-                val sortOrderId = ListsDistillationSettings.getSortOrderId(this@ListsActivityImpl)
-                val sortTitleItem = menu.findItem(R.id.menu_action_lists_sort_title)
-                sortTitleItem.setTitle(R.string.action_shows_sort_title)
-                val sortLatestItem = menu.findItem(R.id.menu_action_lists_sort_latest_episode)
-                sortLatestItem.setTitle(R.string.action_shows_sort_latest_episode)
-                val sortOldestItem = menu.findItem(R.id.menu_action_lists_sort_oldest_episode)
-                sortOldestItem.setTitle(R.string.action_shows_sort_oldest_episode)
-                val lastWatchedItem = menu.findItem(R.id.menu_action_lists_sort_last_watched)
-                lastWatchedItem.setTitle(R.string.action_shows_sort_last_watched)
-                val remainingItem = menu.findItem(R.id.menu_action_lists_sort_remaining)
-                remainingItem.setTitle(R.string.action_shows_sort_remaining)
-                when (sortOrderId) {
-                    ListsDistillationSettings.ListsSortOrder.TITLE_ALPHABETICAL_ID -> {
-                        ViewTools.setMenuItemActiveString(sortTitleItem)
-                    }
-
-                    ListsDistillationSettings.ListsSortOrder.LATEST_EPISODE_ID -> {
-                        ViewTools.setMenuItemActiveString(sortLatestItem)
-                    }
-
-                    ListsDistillationSettings.ListsSortOrder.OLDEST_EPISODE_ID -> {
-                        ViewTools.setMenuItemActiveString(sortOldestItem)
-                    }
-
-                    ListsDistillationSettings.ListsSortOrder.LAST_WATCHED_ID -> {
-                        ViewTools.setMenuItemActiveString(lastWatchedItem)
-                    }
-
-                    ListsDistillationSettings.ListsSortOrder.LEAST_REMAINING_EPISODES_ID -> {
-                        ViewTools.setMenuItemActiveString(remainingItem)
-                    }
-                }
-                menu.findItem(R.id.menu_action_lists_sort_ignore_articles).isChecked =
-                    DisplaySettings.isSortOrderIgnoringArticles(this@ListsActivityImpl)
-            }
-
             override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
                 when (menuItem.itemId) {
                     R.id.menu_action_lists_add -> {
@@ -154,28 +108,8 @@ open class ListsActivityImpl : BaseTopActivity() {
                         showListManageDialog(selectedListIndex)
                         return true
                     }
-                    R.id.menu_action_lists_sort_title -> {
-                        changeSortOrder(ListsDistillationSettings.ListsSortOrder.TITLE_ALPHABETICAL_ID)
-                        return true
-                    }
-                    R.id.menu_action_lists_sort_latest_episode -> {
-                        changeSortOrder(ListsDistillationSettings.ListsSortOrder.LATEST_EPISODE_ID)
-                        return true
-                    }
-                    R.id.menu_action_lists_sort_oldest_episode -> {
-                        changeSortOrder(ListsDistillationSettings.ListsSortOrder.OLDEST_EPISODE_ID)
-                        return true
-                    }
-                    R.id.menu_action_lists_sort_last_watched -> {
-                        changeSortOrder(ListsDistillationSettings.ListsSortOrder.LAST_WATCHED_ID)
-                        return true
-                    }
-                    R.id.menu_action_lists_sort_remaining -> {
-                        changeSortOrder(ListsDistillationSettings.ListsSortOrder.LEAST_REMAINING_EPISODES_ID)
-                        return true
-                    }
-                    R.id.menu_action_lists_sort_ignore_articles -> {
-                        toggleSortIgnoreArticles()
+                    R.id.menu_action_lists_sort -> {
+                        ListsSortDialogFragment.show(supportFragmentManager)
                         return true
                     }
                     R.id.menu_action_lists_reorder -> {
@@ -202,35 +136,6 @@ open class ListsActivityImpl : BaseTopActivity() {
         viewModel.scrollTabToTop(binding.viewPagerLists.currentItem)
     }
 
-    private fun changeSortOrder(sortOrderId: Int) {
-        PreferenceManager.getDefaultSharedPreferences(this).edit()
-            .putInt(ListsDistillationSettings.KEY_SORT_ORDER, sortOrderId)
-            .apply()
-
-        // refresh icon state
-        invalidateOptionsMenu()
-
-        // post event, so all active list fragments can react
-        EventBus.getDefault().post(ListsDistillationSettings.ListsSortOrderChangedEvent())
-    }
-
-    private fun toggleSortIgnoreArticles() {
-        PreferenceManager.getDefaultSharedPreferences(this).edit()
-            .putBoolean(
-                DisplaySettings.KEY_SORT_IGNORE_ARTICLE,
-                !DisplaySettings.isSortOrderIgnoringArticles(this)
-            )
-            .apply()
-
-        // refresh icon state
-        invalidateOptionsMenu()
-
-        // refresh all list widgets
-        ListWidgetProvider.notifyDataChanged(this)
-
-        // post event, so all active list fragments can react
-        EventBus.getDefault().post(ListsDistillationSettings.ListsSortOrderChangedEvent())
-    }
 
     override val snackbarParentView: View
         get() = binding.coordinatorLayoutLists
diff --git a/app/src/main/java/com/battlelancer/seriesguide/lists/ListsDistillationSettings.kt b/app/src/main/java/com/battlelancer/seriesguide/lists/ListsDistillationSettings.kt
index 6d709a31d5..1057e2215d 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/lists/ListsDistillationSettings.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/lists/ListsDistillationSettings.kt
@@ -1,14 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2015-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2015 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.lists
 
 import android.content.Context
+import androidx.core.content.edit
 import androidx.preference.PreferenceManager
-import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItems
+import com.battlelancer.seriesguide.lists.database.SgListItemWithDetails
 import com.battlelancer.seriesguide.settings.DisplaySettings
-import com.battlelancer.seriesguide.shows.ShowsDistillationSettings
-import com.battlelancer.seriesguide.shows.ShowsDistillationSettings.ShowSortOrder
 
 /**
  * Provides settings used to sort displayed list items.
@@ -17,46 +16,66 @@ object ListsDistillationSettings {
 
     class ListsSortOrderChangedEvent
 
-    const val KEY_SORT_ORDER = "com.battlelancer.seriesguide.lists.sortorder"
+    private const val KEY_SORT_ORDER = "com.battlelancer.seriesguide.lists.sortorder"
 
     /**
-     * Builds an appropriate SQL sort statement for sorting lists.
+     * Builds an appropriate SQL sort statement for sorting [SgListItemWithDetails] rows.
      */
     fun getSortQuery(context: Context): String {
-        val sortOrderId = when (getSortOrderId(context)) {
-            ListsSortOrder.LATEST_EPISODE_ID -> ShowSortOrder.LATEST_EPISODE_ID
-            ListsSortOrder.OLDEST_EPISODE_ID -> ShowSortOrder.OLDEST_EPISODE_ID
-            ListsSortOrder.LAST_WATCHED_ID -> ShowSortOrder.LAST_WATCHED_ID
-            ListsSortOrder.LEAST_REMAINING_EPISODES_ID -> ShowSortOrder.LEAST_REMAINING_EPISODES_ID
-            else -> ShowSortOrder.TITLE_ID
+        val query = StringBuilder()
+
+        val sortOrder = getSortOrder(context)
+        val orderClause: String = when (sortOrder) {
+            ListsSortOrder.TITLE_ALPHABETICAL ->
+                if (DisplaySettings.isSortOrderIgnoringArticles(context)) {
+                    SgListItemWithDetails.SORT_TITLE_NO_ARTICLE
+                } else {
+                    SgListItemWithDetails.SORT_TITLE
+                }
+
+            ListsSortOrder.LATEST_RELEASE_DATE -> SgListItemWithDetails.SORT_LATEST_RELEASE_DATE
+            ListsSortOrder.OLDEST_RELEASE_DATE -> SgListItemWithDetails.SORT_OLDEST_RELEASE_DATE
+            ListsSortOrder.LAST_WATCHED -> SgListItemWithDetails.SORT_LAST_WATCHED
+            ListsSortOrder.LEAST_REMAINING_EPISODES -> SgListItemWithDetails.SORT_REMAINING_EPISODES
         }
+        query.append(orderClause)
 
-        val baseQuery = ShowsDistillationSettings.getSortQuery2(
-            sortOrderId,
-            isSortFavoritesFirst = false,
-            DisplaySettings.isSortOrderIgnoringArticles(context)
-        )
+        // Then by type
+        query.append(",").append(SgListItemWithDetails.SORT_TYPE)
 
-        // append sorting by list type
-        return "$baseQuery,${ListItems.SORT_TYPE}"
+        return query.toString()
+    }
+
+    fun saveSortOrder(context: Context, sortOrder: ListsSortOrder) {
+        PreferenceManager.getDefaultSharedPreferences(context).edit {
+            putInt(KEY_SORT_ORDER, sortOrder.id)
+        }
     }
 
     /**
-     * Returns the id as of [ListsDistillationSettings.ListsSortOrder]
-     * of the current list sort order.
+     * Returns the current [ListsSortOrder], defaulting to [ListsSortOrder.TITLE_ALPHABETICAL]
+     * for unknown stored values.
      */
-    fun getSortOrderId(context: Context): Int {
+    fun getSortOrder(context: Context): ListsSortOrder {
         return PreferenceManager.getDefaultSharedPreferences(context)
-            .getInt(KEY_SORT_ORDER, ListsSortOrder.TITLE_ALPHABETICAL_ID)
+            .getInt(KEY_SORT_ORDER, ListsSortOrder.TITLE_ALPHABETICAL.id)
+            .let { ListsSortOrder.fromId(it) }
     }
 
-    object ListsSortOrder {
-        const val TITLE_ALPHABETICAL_ID = 0
-        // @deprecated Only supporting alphabetical sort order going forward.
-        // const val TITLE_REVERSE_ALPHABETICAL_ID = 1
-        const val LATEST_EPISODE_ID = 2
-        const val OLDEST_EPISODE_ID = 3
-        const val LAST_WATCHED_ID = 4
-        const val LEAST_REMAINING_EPISODES_ID = 5
+    enum class ListsSortOrder(val id: Int) {
+        TITLE_ALPHABETICAL(0),
+
+        // Deprecated: Only supporting alphabetical sort order going forward.
+        // TITLE_REVERSE_ALPHABETICAL(1),
+
+        LATEST_RELEASE_DATE(2),
+        OLDEST_RELEASE_DATE(3),
+        LAST_WATCHED(4),
+        LEAST_REMAINING_EPISODES(5);
+
+        companion object {
+            fun fromId(id: Int): ListsSortOrder =
+                entries.find { it.id == id } ?: TITLE_ALPHABETICAL
+        }
     }
 }
diff --git a/app/src/main/java/com/battlelancer/seriesguide/lists/ListsSortDialogFragment.kt b/app/src/main/java/com/battlelancer/seriesguide/lists/ListsSortDialogFragment.kt
new file mode 100644
index 0000000000..2db92fa063
--- /dev/null
+++ b/app/src/main/java/com/battlelancer/seriesguide/lists/ListsSortDialogFragment.kt
@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-FileCopyrightText: Copyright © 2026 Uwe Trottmann <uwe@uwetrottmann.com>
+
+package com.battlelancer.seriesguide.lists
+
+import android.app.Dialog
+import android.os.Bundle
+import androidx.appcompat.app.AppCompatDialogFragment
+import androidx.fragment.app.FragmentManager
+import com.battlelancer.seriesguide.R
+import com.battlelancer.seriesguide.appwidget.ListWidgetProvider
+import com.battlelancer.seriesguide.databinding.DialogListsSortBinding
+import com.battlelancer.seriesguide.lists.ListsDistillationSettings.ListsSortOrder
+import com.battlelancer.seriesguide.settings.DisplaySettings
+import com.battlelancer.seriesguide.util.safeShow
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import org.greenrobot.eventbus.EventBus
+
+/**
+ * Dialog to choose the sort order for list items and the ignore articles setting for sorting by
+ * title.
+ */
+class ListsSortDialogFragment : AppCompatDialogFragment() {
+
+    private var binding: DialogListsSortBinding? = null
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val binding = DialogListsSortBinding.inflate(layoutInflater)
+        this.binding = binding
+
+        val context = requireContext()
+
+        // Set initial state from saved settings
+        val sortOrder = ListsDistillationSettings.getSortOrder(context)
+        val radioButtonId = when (sortOrder) {
+            ListsSortOrder.TITLE_ALPHABETICAL -> R.id.radioListsSortTitle
+            ListsSortOrder.LATEST_RELEASE_DATE -> R.id.radioListsSortLatestReleaseDate
+            ListsSortOrder.OLDEST_RELEASE_DATE -> R.id.radioListsSortOldestReleaseDate
+            ListsSortOrder.LAST_WATCHED -> R.id.radioListsSortLastWatched
+            ListsSortOrder.LEAST_REMAINING_EPISODES -> R.id.radioListsSortRemaining
+        }
+        binding.radioGroupListsSort.check(radioButtonId)
+        binding.checkboxListsSortIgnoreArticles.isChecked =
+            DisplaySettings.isSortOrderIgnoringArticles(context)
+
+        // Apply sort order change immediately when a radio button is selected
+        binding.radioGroupListsSort.setOnCheckedChangeListener { _, checkedId ->
+            val newSortOrder = when (checkedId) {
+                R.id.radioListsSortTitle -> ListsSortOrder.TITLE_ALPHABETICAL
+                R.id.radioListsSortLatestReleaseDate -> ListsSortOrder.LATEST_RELEASE_DATE
+                R.id.radioListsSortOldestReleaseDate -> ListsSortOrder.OLDEST_RELEASE_DATE
+                R.id.radioListsSortLastWatched -> ListsSortOrder.LAST_WATCHED
+                R.id.radioListsSortRemaining -> ListsSortOrder.LEAST_REMAINING_EPISODES
+                else -> throw IllegalStateException("Unknown checkedId $checkedId")
+            }
+            ListsDistillationSettings.saveSortOrder(context, newSortOrder)
+
+            // Post event, so all active list fragments can react
+            EventBus.getDefault().post(ListsDistillationSettings.ListsSortOrderChangedEvent())
+        }
+
+        // Apply ignore articles change immediately when the check box is toggled
+        binding.checkboxListsSortIgnoreArticles.setOnCheckedChangeListener { _, isChecked ->
+            DisplaySettings.saveSortOrderIgnoringArticles(context, isChecked)
+
+            // Refresh all list widgets
+            ListWidgetProvider.notifyDataChanged(context)
+
+            // Post event, so all active list fragments can react
+            EventBus.getDefault().post(ListsDistillationSettings.ListsSortOrderChangedEvent())
+        }
+
+        return MaterialAlertDialogBuilder(context)
+            .setTitle(R.string.sort)
+            .setView(binding.root)
+            .setPositiveButton(R.string.dismiss) { _, _ -> dismiss() }
+            .create()
+    }
+
+    override fun onDestroyView() {
+        super.onDestroyView()
+        binding = null
+    }
+
+    companion object {
+        private const val TAG = "listsSortDialog"
+
+        fun show(fragmentManager: FragmentManager) {
+            ListsSortDialogFragment().safeShow(fragmentManager, TAG)
+        }
+    }
+}
diff --git a/app/src/main/java/com/battlelancer/seriesguide/lists/ListsTools.java b/app/src/main/java/com/battlelancer/seriesguide/lists/ListsTools.java
deleted file mode 100644
index 43bbe5f870..0000000000
--- a/app/src/main/java/com/battlelancer/seriesguide/lists/ListsTools.java
+++ /dev/null
@@ -1,164 +0,0 @@
-// Copyright 2023 Uwe Trottmann
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-package com.battlelancer.seriesguide.lists;
-
-import android.content.Context;
-import android.database.Cursor;
-import android.os.AsyncTask;
-import android.text.TextUtils;
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-import com.battlelancer.seriesguide.provider.SeriesGuideContract;
-import com.battlelancer.seriesguide.util.tasks.AddListTask;
-import com.battlelancer.seriesguide.util.tasks.ChangeListItemListsTask;
-import com.battlelancer.seriesguide.util.tasks.RemoveListItemTask;
-import com.battlelancer.seriesguide.util.tasks.DeleteListTask;
-import com.battlelancer.seriesguide.util.tasks.RenameListTask;
-import com.battlelancer.seriesguide.util.tasks.ReorderListsTask;
-import com.uwetrottmann.seriesguide.backend.lists.model.SgListItem;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-
-/**
- * Helper tools for SeriesGuide lists.
- */
-public class ListsTools {
-
-    private static final String[] SELECTION_ARG = new String[1];
-
-    public interface Query {
-        String[] PROJECTION_LIST_ID = new String[] {
-                SeriesGuideContract.Lists.LIST_ID
-        };
-        String[] PROJECTION_LIST = new String[] {
-                SeriesGuideContract.Lists.LIST_ID,
-                SeriesGuideContract.Lists.NAME,
-                SeriesGuideContract.Lists.ORDER
-        };
-        int LIST_ID = 0;
-        int NAME = 1;
-        int ORDER = 2;
-
-        String[] PROJECTION_LIST_ITEMS = new String[] {
-                SeriesGuideContract.ListItems.LIST_ITEM_ID
-        };
-        int LIST_ITEM_ID = 0;
-    }
-
-    private ListsTools() {
-    }
-
-    public static void addList(@NonNull Context context, @NonNull String listName) {
-        new AddListTask(context, listName).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
-    }
-
-    static void renameList(@NonNull Context context, @NonNull String listId,
-            @NonNull String listName) {
-        new RenameListTask(context, listId, listName).executeOnExecutor(
-                AsyncTask.THREAD_POOL_EXECUTOR);
-    }
-
-    static void deleteList(@NonNull Context context, @NonNull String listId) {
-        new DeleteListTask(context, listId).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
-    }
-
-    static void reorderLists(@NonNull Context context,
-            @NonNull List<String> listIdsInOrder) {
-        new ReorderListsTask(context, listIdsInOrder).executeOnExecutor(
-                AsyncTask.THREAD_POOL_EXECUTOR);
-    }
-
-    static void changeListsOfItem(@NonNull Context context, int itemStableId, int itemType,
-            @NonNull List<String> addToTheseLists, @NonNull List<String> removeFromTheseLists) {
-        new ChangeListItemListsTask(context, itemStableId, itemType, addToTheseLists,
-                removeFromTheseLists).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
-    }
-
-    static void removeListItem(@NonNull Context context, @NonNull String listItemId) {
-        new RemoveListItemTask(context, listItemId).executeOnExecutor(
-                AsyncTask.THREAD_POOL_EXECUTOR);
-    }
-
-    /**
-     * Returns a all list ids in the local database.
-     *
-     * @return null if there was an error, empty list if there are no lists.
-     */
-    public static HashSet<String> getListIds(Context context) {
-        Cursor query = context.getContentResolver().query(SeriesGuideContract.Lists.CONTENT_URI,
-                Query.PROJECTION_LIST_ID, null, null, null);
-        if (query == null) {
-            return null;
-        }
-
-        HashSet<String> listIds = new HashSet<>();
-        while (query.moveToNext()) {
-            listIds.add(query.getString(Query.LIST_ID));
-        }
-
-        query.close();
-
-        return listIds;
-    }
-
-    /**
-     * Returns a all list item ids of the given list in the local database.
-     *
-     * @return null if there was an error, empty list if there are no list items in this list.
-     */
-    public static HashSet<String> getListItemIds(Context context, String listId) {
-        SELECTION_ARG[0] = listId;
-        Cursor query = context.getContentResolver().query(SeriesGuideContract.ListItems.CONTENT_URI,
-                Query.PROJECTION_LIST_ITEMS,
-                SeriesGuideContract.ListItems.SELECTION_LIST,
-                SELECTION_ARG, null);
-        if (query == null) {
-            return null;
-        }
-
-        HashSet<String> listItemIds = new HashSet<>();
-        while (query.moveToNext()) {
-            listItemIds.add(query.getString(Query.LIST_ITEM_ID));
-        }
-
-        query.close();
-
-        return listItemIds;
-    }
-
-    @Nullable
-    public static List<SgListItem> getListItems(Context context, String listId) {
-        SELECTION_ARG[0] = listId;
-        Cursor query = context.getContentResolver()
-                .query(SeriesGuideContract.ListItems.CONTENT_URI,
-                        Query.PROJECTION_LIST_ITEMS,
-                        SeriesGuideContract.ListItems.SELECTION_LIST,
-                        SELECTION_ARG, null);
-        if (query == null) {
-            return null; // query failed
-        }
-
-        int itemCount = query.getCount();
-        if (itemCount == 0) {
-            query.close();
-            return null; // no items in this list
-        }
-
-        List<SgListItem> items = new ArrayList<>(itemCount);
-        while (query.moveToNext()) {
-            SgListItem item = new SgListItem();
-            String itemId = query.getString(Query.LIST_ITEM_ID);
-            if (TextUtils.isEmpty(itemId)) {
-                continue; // skip, no item id
-            }
-            item.setListItemId(itemId);
-            items.add(item);
-        }
-
-        query.close();
-
-        return items;
-    }
-}
diff --git a/app/src/main/java/com/battlelancer/seriesguide/lists/ListsTools.kt b/app/src/main/java/com/battlelancer/seriesguide/lists/ListsTools.kt
new file mode 100644
index 0000000000..4ddb7df538
--- /dev/null
+++ b/app/src/main/java/com/battlelancer/seriesguide/lists/ListsTools.kt
@@ -0,0 +1,249 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-FileCopyrightText: Copyright © 2016 Uwe Trottmann <uwe@uwetrottmann.com>
+
+@file:Suppress("DEPRECATION") // Ignore warning that AsyncTask should not be used for new code
+
+package com.battlelancer.seriesguide.lists
+
+import android.content.Context
+import android.os.AsyncTask
+import com.battlelancer.seriesguide.SgApp
+import com.battlelancer.seriesguide.backend.settings.HexagonSettings
+import com.battlelancer.seriesguide.lists.database.SgListItem
+import com.battlelancer.seriesguide.provider.SeriesGuideContract
+import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItemTypes
+import com.battlelancer.seriesguide.provider.SgRoomDatabase
+import com.battlelancer.seriesguide.util.Errors
+import com.battlelancer.seriesguide.util.tasks.AddListTask
+import com.battlelancer.seriesguide.util.tasks.ChangeListItemListsTask
+import com.battlelancer.seriesguide.util.tasks.DeleteListTask
+import com.battlelancer.seriesguide.util.tasks.RemoveListItemTask
+import com.battlelancer.seriesguide.util.tasks.RenameListTask
+import com.battlelancer.seriesguide.util.tasks.ReorderListsTask
+import com.google.api.client.http.HttpResponseException
+import com.uwetrottmann.seriesguide.backend.lists.model.SgListList
+import timber.log.Timber
+import java.io.IOException
+import com.uwetrottmann.seriesguide.backend.lists.model.SgList as SgCloudList
+import com.uwetrottmann.seriesguide.backend.lists.model.SgListItem as SgCloudListItem
+
+/**
+ * Helper tools for SeriesGuide lists.
+ */
+object ListsTools {
+
+    interface Query {
+        companion object {
+            val PROJECTION_LIST_ID = arrayOf(
+                SeriesGuideContract.Lists.LIST_ID
+            )
+            val PROJECTION_LIST = arrayOf(
+                SeriesGuideContract.Lists.LIST_ID,
+                SeriesGuideContract.Lists.NAME,
+                SeriesGuideContract.Lists.ORDER
+            )
+            const val LIST_ID = 0
+            const val NAME = 1
+            const val ORDER = 2
+
+            val PROJECTION_LIST_ITEMS = arrayOf(
+                SeriesGuideContract.ListItems.LIST_ITEM_ID
+            )
+            const val LIST_ITEM_ID = 0
+        }
+    }
+
+    fun addList(context: Context, listName: String) {
+        AddListTask(context, listName).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR)
+    }
+
+    fun renameList(context: Context, listId: String, listName: String) {
+        RenameListTask(context, listId, listName).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR)
+    }
+
+    fun deleteList(context: Context, listId: String) {
+        DeleteListTask(context, listId).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR)
+    }
+
+    fun reorderLists(context: Context, listIdsInOrder: List<String>) {
+        ReorderListsTask(context, listIdsInOrder).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR)
+    }
+
+    fun changeListsOfItem(
+        context: Context,
+        itemTmdbId: Int,
+        @ListItemTypes itemType: Int,
+        addToTheseLists: List<String>,
+        removeFromTheseLists: List<String>
+    ) {
+        ChangeListItemListsTask(
+            context,
+            itemTmdbId,
+            itemType,
+            addToTheseLists,
+            removeFromTheseLists
+        ).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR)
+    }
+
+    fun removeListItem(context: Context, listItemId: String) {
+        RemoveListItemTask(context, listItemId).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR)
+    }
+
+    /**
+     * Returns all list ids in the local database.
+     *
+     * @return null if there was an error, empty list if there are no lists.
+     */
+    fun getListIds(context: Context): HashSet<String>? {
+        val query = context.contentResolver.query(
+            SeriesGuideContract.Lists.CONTENT_URI,
+            Query.PROJECTION_LIST_ID, null, null, null
+        ) ?: return null
+
+        val listIds = HashSet<String>()
+        query.use {
+            while (it.moveToNext()) {
+                listIds.add(it.getString(Query.LIST_ID))
+            }
+        }
+        return listIds
+    }
+
+    /**
+     * Returns all list item ids of the given list in the local database.
+     *
+     * @return null if there was an error, empty list if there are no list items in this list.
+     */
+    fun getListItemIds(context: Context, listId: String): HashSet<String>? {
+        val query = context.contentResolver.query(
+            SeriesGuideContract.ListItems.CONTENT_URI,
+            Query.PROJECTION_LIST_ITEMS,
+            SeriesGuideContract.ListItems.SELECTION_LIST,
+            arrayOf(listId), null
+        ) ?: return null
+
+        val listItemIds = HashSet<String>()
+        query.use {
+            while (it.moveToNext()) {
+                listItemIds.add(it.getString(Query.LIST_ITEM_ID))
+            }
+        }
+        return listItemIds
+    }
+
+    fun getListItems(context: Context, listId: String): List<SgCloudListItem>? {
+        val query = context.contentResolver.query(
+            SeriesGuideContract.ListItems.CONTENT_URI,
+            Query.PROJECTION_LIST_ITEMS,
+            SeriesGuideContract.ListItems.SELECTION_LIST,
+            arrayOf(listId), null
+        ) ?: return null // query failed
+
+        if (query.count == 0) {
+            query.close()
+            return null // no items in this list
+        }
+
+        val items = ArrayList<SgCloudListItem>(query.count)
+        query.use {
+            while (it.moveToNext()) {
+                val itemId = it.getString(Query.LIST_ITEM_ID)
+                if (itemId.isNullOrEmpty()) continue // skip, no item id
+                val item = SgCloudListItem()
+                item.listItemId = itemId
+                items.add(item)
+            }
+        }
+        return items
+    }
+
+    @JvmStatic
+    fun migrateTvdbShowListItemsToTmdbIds(context: Context) {
+        val database = SgRoomDatabase.getInstance(context)
+
+        val tvdbShowListItems = database.sgListHelper().getTvdbShowListItems()
+        if (tvdbShowListItems.isEmpty()) return
+
+        // try to find TMDB ID for each show
+        val toRemove = mutableListOf<String>()
+        val toInsert = mutableListOf<SgListItem>()
+        val toRemoveCloud = mutableListOf<SgCloudList>()
+        val toInsertCloud = mutableListOf<SgCloudList>()
+        tvdbShowListItems.forEach { oldItem ->
+            val tvdbId = oldItem.itemRefId.toInt()
+            val tmdbIdOrZero = database.sgShow2Helper().getShowTmdbIdByTvdbId(tvdbId)
+            if (tmdbIdOrZero != 0) {
+                // Database changes
+                toRemove.add(oldItem.listItemId)
+
+                // Note: do not re-insert items with empty list ID (e.g. user modified database);
+                // also do not remove and re-insert to Cloud, would fail.
+                val oldListId = oldItem.listId
+                if (!oldListId.isNullOrEmpty()) {
+                    val newListItem =
+                        SgListItem(
+                            tmdbIdOrZero,
+                            ListItemTypes.TMDB_SHOW,
+                            oldListId
+                        )
+                    toInsert.add(newListItem)
+
+                    // Cloud changes
+                    toRemoveCloud.add(SgCloudList().apply {
+                        listId = oldListId
+                        listItems = listOf(SgCloudListItem().apply {
+                            listItemId = oldItem.listItemId
+                        })
+                    })
+                    toInsertCloud.add(SgCloudList().apply {
+                        listId = oldListId
+                        listItems = listOf(SgCloudListItem().apply {
+                            listItemId = newListItem.listItemId
+                        })
+                    })
+                }
+            }
+        }
+
+        Timber.d("Migrating %d list items to TMDB IDs", toRemove.size)
+
+        // For cloud need list ID and item ID
+        val requiresCloudUpdate = toRemoveCloud.isNotEmpty() || toInsertCloud.isNotEmpty()
+        if (requiresCloudUpdate && HexagonSettings.isEnabled(context)) {
+            val listsService = SgApp.getServicesComponent(context).hexagonTools().listsService
+            if (listsService == null) {
+                Timber.e("Cloud not signed in")
+                return
+            }
+            try {
+                if (toRemoveCloud.isNotEmpty()) {
+                    listsService.removeItems(SgListList().apply {
+                        lists = toRemoveCloud
+                    }).execute()
+                }
+                if (toInsertCloud.isNotEmpty()) {
+                    listsService.save(SgListList().apply {
+                        lists = toInsertCloud
+                    }).execute()
+                }
+            } catch (e: IOException) {
+                Errors.logAndReportHexagon("migrate list items", e)
+                if (e is HttpResponseException && e.statusCode == 400) {
+                    // Bad Request, do not try again, but require a full lists sync.
+                    // Note: had reports on Cloud where save failed due to not yet saved lists.
+                    if (!HexagonSettings.setHasNotMergedLists(context)) {
+                        // Failed to save, try again next sync
+                        return
+                    }
+                } else {
+                    // Abort and try again next sync
+                    return
+                }
+            }
+        }
+
+        // Apply database updates
+        if (toRemove.isNotEmpty()) database.sgListHelper().deleteListItems(toRemove)
+        if (toInsert.isNotEmpty()) database.sgListHelper().insertListItems(toInsert)
+    }
+}
diff --git a/app/src/main/java/com/battlelancer/seriesguide/lists/ListsTools2.kt b/app/src/main/java/com/battlelancer/seriesguide/lists/ListsTools2.kt
deleted file mode 100644
index c46dc5b52c..0000000000
--- a/app/src/main/java/com/battlelancer/seriesguide/lists/ListsTools2.kt
+++ /dev/null
@@ -1,112 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2021-2025 Uwe Trottmann
-
-package com.battlelancer.seriesguide.lists
-
-import android.content.Context
-import com.battlelancer.seriesguide.SgApp
-import com.battlelancer.seriesguide.backend.settings.HexagonSettings
-import com.battlelancer.seriesguide.lists.database.SgListItem
-import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItemTypes
-import com.battlelancer.seriesguide.provider.SgRoomDatabase
-import com.battlelancer.seriesguide.util.Errors
-import com.google.api.client.http.HttpResponseException
-import com.uwetrottmann.seriesguide.backend.lists.model.SgListList
-import timber.log.Timber
-import java.io.IOException
-import com.uwetrottmann.seriesguide.backend.lists.model.SgList as SgCloudList
-import com.uwetrottmann.seriesguide.backend.lists.model.SgListItem as SgCloudListItem
-
-object ListsTools2 {
-
-    @JvmStatic
-    fun migrateTvdbShowListItemsToTmdbIds(context: Context) {
-        val database = SgRoomDatabase.getInstance(context)
-
-        val tvdbShowListItems = database.sgListHelper().getTvdbShowListItems()
-        if (tvdbShowListItems.isEmpty()) return
-
-        // try to find TMDB ID for each show
-        val toRemove = mutableListOf<String>()
-        val toInsert = mutableListOf<SgListItem>()
-        val toRemoveCloud = mutableListOf<SgCloudList>()
-        val toInsertCloud = mutableListOf<SgCloudList>()
-        tvdbShowListItems.forEach { oldItem ->
-            val tvdbId = oldItem.itemRefId.toInt()
-            val tmdbIdOrZero = database.sgShow2Helper().getShowTmdbIdByTvdbId(tvdbId)
-            if (tmdbIdOrZero != 0) {
-                // Database changes
-                toRemove.add(oldItem.listItemId)
-
-                // Note: do not re-insert items with empty list ID (e.g. user modified database);
-                // also do not remove and re-insert to Cloud, would fail.
-                val oldListId = oldItem.listId
-                if (!oldListId.isNullOrEmpty()) {
-                    val newListItem =
-                        SgListItem(
-                            tmdbIdOrZero,
-                            ListItemTypes.TMDB_SHOW,
-                            oldListId
-                        )
-                    toInsert.add(newListItem)
-
-                    // Cloud changes
-                    toRemoveCloud.add(SgCloudList().apply {
-                        listId = oldListId
-                        listItems = listOf(SgCloudListItem().apply {
-                            listItemId = oldItem.listItemId
-                        })
-                    })
-                    toInsertCloud.add(SgCloudList().apply {
-                        listId = oldListId
-                        listItems = listOf(SgCloudListItem().apply {
-                            listItemId = newListItem.listItemId
-                        })
-                    })
-                }
-            }
-        }
-
-        Timber.d("Migrating %d list items to TMDB IDs", toRemove.size)
-
-        // For cloud need list ID and item ID
-        val requiresCloudUpdate = toRemoveCloud.isNotEmpty() || toInsertCloud.isNotEmpty()
-        if (requiresCloudUpdate && HexagonSettings.isEnabled(context)) {
-            val listsService = SgApp.getServicesComponent(context).hexagonTools().listsService
-            if (listsService == null) {
-                Timber.e("Cloud not signed in")
-                return
-            }
-            try {
-                if (toRemoveCloud.isNotEmpty()) {
-                    listsService.removeItems(SgListList().apply {
-                        lists = toRemoveCloud
-                    }).execute()
-                }
-                if (toInsertCloud.isNotEmpty()) {
-                    listsService.save(SgListList().apply {
-                        lists = toInsertCloud
-                    }).execute()
-                }
-            } catch (e: IOException) {
-                Errors.logAndReportHexagon("migrate list items", e)
-                if (e is HttpResponseException && e.statusCode == 400) {
-                    // Bad Request, do not try again, but require a full lists sync.
-                    // Note: had reports on Cloud where save failed due to not yet saved lists.
-                    if (!HexagonSettings.setHasNotMergedLists(context)) {
-                        // Failed to save, try again next sync
-                        return
-                    }
-                } else {
-                    // Abort and try again next sync
-                    return
-                }
-            }
-        }
-
-        // Apply database updates
-        if (toRemove.isNotEmpty()) database.sgListHelper().deleteListItems(toRemove)
-        if (toInsert.isNotEmpty()) database.sgListHelper().insertListItems(toInsert)
-    }
-
-}
\ No newline at end of file
diff --git a/app/src/main/java/com/battlelancer/seriesguide/lists/ManageListsDialogFragment.kt b/app/src/main/java/com/battlelancer/seriesguide/lists/ManageListsDialogFragment.kt
index 0f66962523..6843df845d 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/lists/ManageListsDialogFragment.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/lists/ManageListsDialogFragment.kt
@@ -1,5 +1,5 @@
-// Copyright 2023 Uwe Trottmann
 // SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-FileCopyrightText: Copyright © 2023 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.lists
 
@@ -14,39 +14,42 @@ import androidx.appcompat.app.AppCompatDialogFragment
 import androidx.core.view.isGone
 import androidx.fragment.app.FragmentManager
 import androidx.fragment.app.viewModels
+import androidx.lifecycle.lifecycleScope
 import androidx.recyclerview.widget.DiffUtil
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.ListAdapter
 import androidx.recyclerview.widget.RecyclerView
+import kotlinx.coroutines.launch
 import com.battlelancer.seriesguide.R
 import com.battlelancer.seriesguide.databinding.DialogManageListsBinding
 import com.battlelancer.seriesguide.databinding.ItemListCheckedBinding
+import com.battlelancer.seriesguide.lists.ManageListsDialogFragmentViewModel.ListItem
 import com.battlelancer.seriesguide.lists.ManageListsDialogFragmentViewModel.ListWithItem
-import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItemTypes
 import com.battlelancer.seriesguide.util.ViewTools
 import com.battlelancer.seriesguide.util.safeShow
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 
 /**
  * Displays a dialog displaying all user created lists,
- * allowing to add or remove the given show for any.
+ * allowing to add or remove the given show or movie for any.
  */
 class ManageListsDialogFragment : AppCompatDialogFragment() {
 
     private var binding: DialogManageListsBinding? = null
-    private val model by viewModels<ManageListsDialogFragmentViewModel> {
-        ManageListsDialogFragmentViewModelFactory(requireActivity().application, showId)
-    }
-    private var showId: Long = 0
 
-    /**
-     * Remains 0 if TMDB id for show not found (show is not migrated to TMDB data).
-     */
-    private var showTmdbId = 0
+    private val listItem: ListItem by lazy {
+        val args = requireArguments()
+        val movieTmdbId = args.getInt(ARG_INT_MOVIE_TMDB_ID, 0)
+        if (movieTmdbId != 0) {
+            val movieTitle = args.getString(ARG_STRING_MOVIE_TITLE)!!
+            ListItem.Movie(movieTmdbId, movieTitle)
+        } else {
+            ListItem.Show(args.getLong(ARG_LONG_SHOW_ID))
+        }
+    }
 
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        showId = requireArguments().getLong(ARG_LONG_SHOW_ID)
+    private val model by viewModels<ManageListsDialogFragmentViewModel> {
+        ManageListsDialogFragmentViewModelFactory(requireActivity().application, listItem)
     }
 
     override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
@@ -63,18 +66,17 @@ class ManageListsDialogFragment : AppCompatDialogFragment() {
         }
 
         // Note: viewLifeCycleOwner not available for DialogFragment, use DialogFragment itself.
-        model.showDetails.observe(this) { showDetails ->
-            if (showDetails == null) {
+        model.listItemDetails.observe(this) { details ->
+            if (details == null) {
                 Toast.makeText(requireContext(), R.string.database_error, Toast.LENGTH_LONG).show()
                 dismiss()
                 return@observe
             }
-            showTmdbId = showDetails.tmdbId ?: 0
 
-            binding.item.text = showDetails.title
+            binding.item.text = details.title
 
-            if (showTmdbId <= 0) {
-                // Note: see OK button handler that prevents changing lists if not migrated.
+            // For shows: warn if not yet migrated to TMDB data. Not applicable for movies.
+            if (listItem is ListItem.Show && details.tmdbId <= 0) {
                 ViewTools.configureNotMigratedWarning(binding.textViewManageListsError, true)
             }
         }
@@ -86,32 +88,10 @@ class ManageListsDialogFragment : AppCompatDialogFragment() {
             .setView(binding.root)
             .setNegativeButton(android.R.string.cancel, null)
             .setPositiveButton(android.R.string.ok) { _: DialogInterface, _: Int ->
-                // Note: see show details loader that prevents loading list data if not migrated.
-                if ((model.showDetails.value?.tmdbId ?: 0) <= 0) {
+                lifecycleScope.launch {
+                    model.saveChanges()
                     dismiss()
-                    return@setPositiveButton
                 }
-                // add item to selected lists, remove from previously selected lists
-                val addToTheseLists: MutableList<String> = ArrayList()
-                val removeFromTheseLists: MutableList<String> = ArrayList()
-                val lists = model.listsWithItem.value
-                    ?: return@setPositiveButton // Do nothing, lists not loaded, yet.
-                lists
-                    .filter { it.isItemOnList != it.isItemOnListOriginal }
-                    .forEach {
-                        if (it.isItemOnListOriginal) {
-                            // remove from list
-                            removeFromTheseLists.add(it.listId)
-                        } else {
-                            // add to list
-                            addToTheseLists.add(it.listId)
-                        }
-                    }
-                ListsTools.changeListsOfItem(
-                    requireContext(), showTmdbId,
-                    ListItemTypes.TMDB_SHOW, addToTheseLists, removeFromTheseLists
-                )
-                dismiss()
             }
             .create()
     }
@@ -185,28 +165,48 @@ class ManageListsDialogFragment : AppCompatDialogFragment() {
     companion object {
         private const val TAG = "listsdialog"
         private const val ARG_LONG_SHOW_ID = "show_id"
+        private const val ARG_INT_MOVIE_TMDB_ID = "movie_tmdb_id"
+        private const val ARG_STRING_MOVIE_TITLE = "movie_title"
+
+        private fun newInstance(listItem: ListItem): ManageListsDialogFragment =
+            ManageListsDialogFragment().apply {
+                arguments = Bundle().apply {
+                    when (listItem) {
+                        is ListItem.Show -> putLong(ARG_LONG_SHOW_ID, listItem.showId)
+                        is ListItem.Movie -> {
+                            putInt(ARG_INT_MOVIE_TMDB_ID, listItem.movieTmdbId)
+                            putString(ARG_STRING_MOVIE_TITLE, listItem.movieTitle)
+                        }
+                    }
+                }
+            }
 
-        private fun newInstance(showId: Long): ManageListsDialogFragment {
-            val f = ManageListsDialogFragment()
-            val args = Bundle()
-            args.putLong(ARG_LONG_SHOW_ID, showId)
-            f.arguments = args
-            return f
+        /**
+         * Replaces any currently shown list dialog and shows this in its place.
+         * (Does not add it to the back stack.)
+         */
+        private fun ManageListsDialogFragment.replaceAndShow(fm: FragmentManager): Boolean {
+            val ft = fm.beginTransaction()
+            fm.findFragmentByTag(TAG)?.also { ft.remove(it) }
+            return safeShow(fm, ft, TAG)
         }
 
         /**
          * Display a dialog which asks if the user wants to add the given show to one or more lists.
          */
         @JvmStatic
-        fun show(fm: FragmentManager, showId: Long): Boolean {
+        fun showForShow(fm: FragmentManager, showId: Long): Boolean {
             if (showId <= 0) return false
-            // replace any currently showing list dialog (do not add it to the back stack)
-            val ft = fm.beginTransaction()
-            val prev = fm.findFragmentByTag(TAG)
-            if (prev != null) {
-                ft.remove(prev)
-            }
-            return newInstance(showId).safeShow(fm, ft, TAG)
+            return newInstance(ListItem.Show(showId)).replaceAndShow(fm)
+        }
+
+        /**
+         * Display a dialog which asks if the user wants to add the given movie to one or more lists.
+         */
+        @JvmStatic
+        fun showForMovie(fm: FragmentManager, movieTmdbId: Int, movieTitle: String): Boolean {
+            if (movieTmdbId <= 0) return false
+            return newInstance(ListItem.Movie(movieTmdbId, movieTitle)).replaceAndShow(fm)
         }
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/com/battlelancer/seriesguide/lists/ManageListsDialogFragmentViewModel.kt b/app/src/main/java/com/battlelancer/seriesguide/lists/ManageListsDialogFragmentViewModel.kt
index efc545b36b..d3ea11f5a2 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/lists/ManageListsDialogFragmentViewModel.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/lists/ManageListsDialogFragmentViewModel.kt
@@ -1,5 +1,5 @@
-// Copyright 2023 Uwe Trottmann
 // SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-FileCopyrightText: Copyright © 2023 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.lists
 
@@ -10,27 +10,59 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
 import androidx.lifecycle.liveData
 import androidx.lifecycle.viewModelScope
+import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItemTypes
 import com.battlelancer.seriesguide.provider.SgRoomDatabase
-import com.battlelancer.seriesguide.shows.database.SgShow2Minimal
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 
 /**
- * Loads show details and lists with the initial is on list state for the item,
+ * Loads show or movie details and lists with the initial is-on-list state for the item,
  * allows to modify the state without changing the database.
  */
 class ManageListsDialogFragmentViewModel(
     application: Application,
-    showId: Long
+    private val listItem: ListItem
 ) : AndroidViewModel(application) {
 
-    val showDetails = liveData(context = viewModelScope.coroutineContext + Dispatchers.IO) {
-        val showDetails = SgRoomDatabase.getInstance(application)
-            .sgShow2Helper()
-            .getShowMinimal(showId)
-        emit(showDetails)
-        if (showDetails != null) {
-            loadLists(showDetails)
+    @ListItemTypes
+    private val listItemType: Int = when (listItem) {
+        is ListItem.Show -> ListItemTypes.TMDB_SHOW
+        is ListItem.Movie -> ListItemTypes.TMDB_MOVIE
+    }
+
+    sealed class ListItem {
+        /** A show identified by its local database row ID. */
+        data class Show(val showId: Long) : ListItem()
+
+        /** A movie identified by its TMDB ID. */
+        data class Movie(val movieTmdbId: Int, val movieTitle: String) : ListItem()
+    }
+
+    /**
+     * Minimal details needed to display the item in the dialog.
+     * [tmdbId] is 0 for shows that have not yet been migrated to TMDB data.
+     */
+    data class ItemDetails(
+        val title: String,
+        val tmdbId: Int
+    )
+
+    val listItemDetails = liveData(context = viewModelScope.coroutineContext + Dispatchers.IO) {
+        val db = SgRoomDatabase.getInstance(application)
+        val details: ItemDetails? = when (listItem) {
+            is ListItem.Show -> {
+                db.sgShow2Helper().getShowMinimal(listItem.showId)
+                    ?.let { ItemDetails(it.title, it.tmdbId ?: 0) }
+            }
+
+            is ListItem.Movie -> {
+                ItemDetails(listItem.movieTitle, listItem.movieTmdbId)
+            }
+        }
+        emit(details)
+        if (details != null && details.tmdbId > 0) {
+            loadLists(details.tmdbId)
         }
     }
 
@@ -43,25 +75,22 @@ class ManageListsDialogFragmentViewModel(
 
     val listsWithItem = MutableLiveData<List<ListWithItem>>()
 
-    private fun loadLists(showDetails: SgShow2Minimal) {
+    private fun loadLists(tmdbId: Int) {
         viewModelScope.launch(Dispatchers.IO) {
-            val showTmdbId = showDetails.tmdbId ?: 0
-            if (showTmdbId > 0) {
-                val listHelper = SgRoomDatabase.getInstance(getApplication()).sgListHelper()
-                val listItemsForShow = listHelper.getListItemsWithTmdbId(showTmdbId)
-                val initialListsWithItem = listHelper
-                    .getListsForExport()
-                    .map { list ->
-                        val isItemOnList = listItemsForShow.find { list.listId == it.listId } != null
-                        ListWithItem(
-                            listId = list.listId,
-                            listName = list.name,
-                            isItemOnListOriginal = isItemOnList,
-                            isItemOnList = isItemOnList
-                        )
-                    }
-                listsWithItem.postValue(initialListsWithItem)
-            }
+            val listHelper = SgRoomDatabase.getInstance(getApplication()).sgListHelper()
+            val listItemsForItem = listHelper.getListItemsWithTmdbId(tmdbId, listItemType)
+            val initialListsWithItem = listHelper
+                .getListsForExport()
+                .map { list ->
+                    val isItemOnList = listItemsForItem.find { list.listId == it.listId } != null
+                    ListWithItem(
+                        listId = list.listId,
+                        listName = list.name,
+                        isItemOnListOriginal = isItemOnList,
+                        isItemOnList = isItemOnList
+                    )
+                }
+            listsWithItem.postValue(initialListsWithItem)
         }
     }
 
@@ -75,16 +104,53 @@ class ManageListsDialogFragmentViewModel(
         }
     }
 
+    /**
+     * Adds the item to selected lists, removes it from previously selected lists.
+     *
+     * Does nothing if missing required data.
+     */
+    suspend fun saveChanges() = withContext(Dispatchers.IO) {
+        val tmdbId = listItemDetails.value?.tmdbId ?: 0
+        if (tmdbId <= 0) {
+            return@withContext // Show has no TMDB ID or failed to load it from database
+        }
+
+        val lists = listsWithItem.value
+            ?: return@withContext // Do nothing, lists not loaded, yet
+
+
+        val addToTheseLists = mutableListOf<String>()
+        val removeFromTheseLists = mutableListOf<String>()
+        lists
+            .filter { it.isItemOnList != it.isItemOnListOriginal }
+            .forEach {
+                if (it.isItemOnListOriginal) {
+                    // Remove from list
+                    removeFromTheseLists.add(it.listId)
+                } else {
+                    // Add to list
+                    addToTheseLists.add(it.listId)
+                }
+            }
+        ListsTools.changeListsOfItem(
+            getApplication(),
+            tmdbId,
+            listItemType,
+            addToTheseLists,
+            removeFromTheseLists
+        )
+    }
+
 }
 
 class ManageListsDialogFragmentViewModelFactory(
     private val application: Application,
-    private val showId: Long
+    private val listItem: ManageListsDialogFragmentViewModel.ListItem
 ) : ViewModelProvider.Factory {
 
     @Suppress("UNCHECKED_CAST")
     override fun <T : ViewModel> create(modelClass: Class<T>): T {
-        return ManageListsDialogFragmentViewModel(application, showId) as T
+        return ManageListsDialogFragmentViewModel(application, listItem) as T
     }
 
 }
diff --git a/app/src/main/java/com/battlelancer/seriesguide/lists/SgListFragment.kt b/app/src/main/java/com/battlelancer/seriesguide/lists/SgListFragment.kt
index 5234889e7e..bdc077bc6a 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/lists/SgListFragment.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/lists/SgListFragment.kt
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2012-2024 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2012 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.lists
 
@@ -14,11 +14,14 @@ import androidx.core.view.isGone
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentManager
 import androidx.fragment.app.viewModels
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
 import com.battlelancer.seriesguide.R
 import com.battlelancer.seriesguide.SgApp
 import com.battlelancer.seriesguide.databinding.FragmentListBinding
 import com.battlelancer.seriesguide.lists.ListsDistillationSettings.ListsSortOrderChangedEvent
-import com.battlelancer.seriesguide.lists.database.SgListItemWithDetails
+import com.battlelancer.seriesguide.movies.details.MovieDetailsActivity
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItemTypes
 import com.battlelancer.seriesguide.shows.episodes.EpisodeTools
 import com.battlelancer.seriesguide.shows.tools.ShowSync
@@ -27,9 +30,12 @@ import com.battlelancer.seriesguide.ui.OverviewActivity
 import com.battlelancer.seriesguide.ui.widgets.SgFastScroller
 import com.battlelancer.seriesguide.util.ViewTools
 import com.battlelancer.seriesguide.util.startActivityWithAnimation
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.launch
 import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import org.greenrobot.eventbus.ThreadMode
+import timber.log.Timber
 
 /**
  * Displays one user created list of shows.
@@ -80,11 +86,17 @@ class SgListFragment : Fragment() {
                 }
             }
 
-        model.sgListItemLiveData.observe(viewLifecycleOwner) {
-            val bindingOnDemand = this.binding ?: return@observe
-            bindingOnDemand.recyclerViewListItems.isGone = it.isEmpty()
-            bindingOnDemand.emptyViewList.isGone = it.isNotEmpty()
-            adapter.submitList(it)
+        viewLifecycleOwner.lifecycleScope.launch {
+            // This is a page in a RecyclerView-based ViewPager2, so use STARTED to work with the
+            // pager prefetching next/previous pages.
+            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
+                model.items.collectLatest {
+                    val bindingOnDemand = this@SgListFragment.binding ?: return@collectLatest
+                    bindingOnDemand.recyclerViewListItems.isGone = it.isEmpty()
+                    bindingOnDemand.emptyViewList.isGone = it.isNotEmpty()
+                    adapter.submitList(it)
+                }
+            }
         }
     }
 
@@ -111,39 +123,51 @@ class SgListFragment : Fragment() {
 
     private val itemClickListener: SgListItemViewHolder.ItemClickListener =
         object : SgListItemViewHolder.ItemClickListener {
-            override fun onItemClick(anchor: View, item: SgListItemWithDetails) {
-                requireActivity().startActivityWithAnimation(
-                    OverviewActivity.intentShow(requireActivity(), item.showId),
-                    anchor
-                )
+            override fun onItemClick(anchor: View, item: UiListItem) {
+                val intent = if (item.movieTmdbId != null) {
+                    MovieDetailsActivity.intentMovie(requireContext(), item.movieTmdbId)
+                } else if (item.showId != null) {
+                    OverviewActivity.intentShow(requireActivity(), item.showId)
+                } else {
+                    Timber.e("Item click not supported for type %s", item.type)
+                    return
+                }
+                requireActivity().startActivityWithAnimation(intent, anchor)
             }
 
-            override fun onMoreOptionsClick(anchor: View, item: SgListItemWithDetails) {
+            override fun onMoreOptionsClick(anchor: View, item: UiListItem) {
                 val popupMenu = PopupMenu(anchor.context, anchor)
                 popupMenu.inflate(R.menu.lists_popup_menu)
-                val menu = popupMenu.menu
-                // Hide some options that only make sense for shows (for legacy non-show items)
-                val isShow =
-                    item.type == ListItemTypes.TMDB_SHOW || item.type == ListItemTypes.TVDB_SHOW
-                menu.findItem(R.id.menu_action_lists_watched_next).isVisible = isShow
-                menu.findItem(R.id.menu_action_lists_favorites_add).isVisible =
-                    isShow && !item.favorite
-                menu.findItem(R.id.menu_action_lists_favorites_remove).isVisible =
-                    isShow && item.favorite
+                // If not a show item (movies and legacy season and episode items),
+                // remove not applicable options.
+                val isShow = item.isShow
+                if (!isShow) {
+                    popupMenu.menu.removeItem(R.id.menu_action_lists_watched_next)
+                    popupMenu.menu.removeItem(R.id.menu_action_lists_update)
+                }
+                if (!isShow || item.isFavorite) {
+                    popupMenu.menu.removeItem(R.id.menu_action_lists_favorites_add)
+                }
+                if (!isShow || !item.isFavorite) {
+                    popupMenu.menu.removeItem(R.id.menu_action_lists_favorites_remove)
+                }
+                // Hide manage lists option for legacy show, season and episode items
+                // (only allow removing those).
+                if (item.type != ListItemTypes.TMDB_MOVIE && item.type != ListItemTypes.TMDB_SHOW) {
+                    popupMenu.menu.removeItem(R.id.menu_action_lists_manage)
+                }
                 popupMenu.setOnMenuItemClickListener(
                     PopupMenuItemClickListener(
                         requireContext(), parentFragmentManager,
-                        item.listItemId, item.showId, item.nextEpisodeId
+                        item.listItemId,
+                        item.titleText,
+                        item.movieTmdbId, item.showId, item.nextEpisodeId
                     )
                 )
-                // Hide manage lists option for legacy show items, only allow removal.
-                if (item.type != ListItemTypes.TMDB_SHOW) {
-                    popupMenu.menu.removeItem(R.id.menu_action_lists_manage)
-                }
                 popupMenu.show()
             }
 
-            override fun onSetWatchedClick(item: SgListItemWithDetails) {
+            override fun onSetWatchedClick(item: UiListItem) {
                 EpisodeTools.episodeWatchedIfNotZero(requireContext(), item.nextEpisodeId)
             }
         }
@@ -152,8 +176,10 @@ class SgListFragment : Fragment() {
         private val context: Context,
         private val fragmentManager: FragmentManager,
         private val itemId: String,
-        private val showId: Long,
-        private val nextEpisodeId: Long
+        private val itemTitle: String,
+        private val movieTmdbId: Int?,
+        private val showId: Long?,
+        private val nextEpisodeId: Long?
     ) : PopupMenu.OnMenuItemClickListener {
 
         private val showTools = SgApp.getServicesComponent(context).showTools()
@@ -161,27 +187,35 @@ class SgListFragment : Fragment() {
         override fun onMenuItemClick(item: MenuItem): Boolean {
             when (item.itemId) {
                 R.id.menu_action_lists_watched_next -> {
-                    EpisodeTools.episodeWatchedIfNotZero(context, nextEpisodeId)
+                    nextEpisodeId?.let { EpisodeTools.episodeWatchedIfNotZero(context, it) }
                     return true
                 }
 
                 R.id.menu_action_lists_favorites_add -> {
-                    showTools.storeIsFavorite(showId, true)
+                    showId?.let { showTools.storeIsFavorite(it, true) }
                     return true
                 }
 
                 R.id.menu_action_lists_favorites_remove -> {
-                    showTools.storeIsFavorite(showId, false)
+                    showId?.let { showTools.storeIsFavorite(it, false) }
                     return true
                 }
 
                 R.id.menu_action_lists_manage -> {
-                    ManageListsDialogFragment.show(fragmentManager, showId)
+                    if (movieTmdbId != null) {
+                        ManageListsDialogFragment.showForMovie(
+                            fragmentManager,
+                            movieTmdbId,
+                            itemTitle
+                        )
+                    } else if (showId != null) {
+                        ManageListsDialogFragment.showForShow(fragmentManager, showId)
+                    }
                     return true
                 }
 
                 R.id.menu_action_lists_update -> {
-                    ShowSync.triggerDeltaSync(context, showId)
+                    showId?.let { ShowSync.triggerDeltaSync(context, it) }
                     return true
                 }
 
diff --git a/app/src/main/java/com/battlelancer/seriesguide/lists/SgListItemAdapter.kt b/app/src/main/java/com/battlelancer/seriesguide/lists/SgListItemAdapter.kt
index a682820b42..c5cc8e56a5 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/lists/SgListItemAdapter.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/lists/SgListItemAdapter.kt
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2021-2024 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2021 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.lists
 
@@ -8,30 +8,17 @@ import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import androidx.appcompat.widget.TooltipCompat
-import androidx.core.view.isGone
 import androidx.core.view.isVisible
-import androidx.recyclerview.widget.DiffUtil
 import androidx.recyclerview.widget.ListAdapter
 import androidx.recyclerview.widget.RecyclerView
-import com.battlelancer.seriesguide.R
 import com.battlelancer.seriesguide.databinding.ItemShowListBinding
-import com.battlelancer.seriesguide.lists.database.SgListItemWithDetails
-import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItemTypes
-import com.battlelancer.seriesguide.provider.SgRoomDatabase
-import com.battlelancer.seriesguide.settings.DisplaySettings
-import com.battlelancer.seriesguide.shows.overview.SeasonTools
-import com.battlelancer.seriesguide.shows.tools.ShowStatus
 import com.battlelancer.seriesguide.util.ImageTools
-import com.battlelancer.seriesguide.util.TextTools
-import com.battlelancer.seriesguide.util.TimeTools
-import com.battlelancer.seriesguide.util.TimeTools.formatWithDeviceZoneToDayAndTime
 import com.battlelancer.seriesguide.util.ViewTools.setContextAndLongClickListener
-import org.threeten.bp.Instant
 
 class SgListItemAdapter(
     private val context: Context,
     private val itemClickListener: SgListItemViewHolder.ItemClickListener
-) : ListAdapter<SgListItemWithDetails, SgListItemViewHolder>(DIFF_CALLBACK) {
+) : ListAdapter<UiListItem, SgListItemViewHolder>(UiListItem.DIFF_CALLBACK) {
 
     override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): SgListItemViewHolder {
         return SgListItemViewHolder.create(itemClickListener, parent)
@@ -41,19 +28,6 @@ class SgListItemAdapter(
         holder.bindTo(getItem(position), context)
     }
 
-    companion object {
-        val DIFF_CALLBACK = object : DiffUtil.ItemCallback<SgListItemWithDetails>() {
-            override fun areItemsTheSame(
-                oldItem: SgListItemWithDetails,
-                newItem: SgListItemWithDetails
-            ): Boolean = oldItem.id == newItem.id
-
-            override fun areContentsTheSame(
-                oldItem: SgListItemWithDetails,
-                newItem: SgListItemWithDetails
-            ): Boolean = oldItem == newItem
-        }
-    }
 
 }
 
@@ -63,12 +37,12 @@ class SgListItemViewHolder(
 ) : RecyclerView.ViewHolder(binding.root) {
 
     interface ItemClickListener {
-        fun onItemClick(anchor: View, item: SgListItemWithDetails)
-        fun onMoreOptionsClick(anchor: View, item: SgListItemWithDetails)
-        fun onSetWatchedClick(item: SgListItemWithDetails)
+        fun onItemClick(anchor: View, item: UiListItem)
+        fun onMoreOptionsClick(anchor: View, item: UiListItem)
+        fun onSetWatchedClick(item: UiListItem)
     }
 
-    var item: SgListItemWithDetails? = null
+    var item: UiListItem? = null
 
     init {
         // item
@@ -103,137 +77,29 @@ class SgListItemViewHolder(
         }
     }
 
-    fun bindTo(item: SgListItemWithDetails?, context: Context) {
+    fun bindTo(item: UiListItem?, context: Context) {
         this.item = item
 
-        if (item == null) {
-            binding.textViewItemShowListTitle.text = null
-            return
-        }
+        // Title and favorite star
+        binding.textViewItemShowListTitle.text = item?.titleText
+        binding.imageViewItemShowListFavorited.isVisible = item?.isFavorite ?: false
 
-        binding.textViewItemShowListTitle.text = item.title
-        binding.imageViewItemShowListFavorited.isVisible = item.favorite
-        ImageTools.loadShowPosterResizeCrop(
+        // Poster
+        ImageTools.loadAndResizeCropToShowPosterSize(
             context,
             binding.imageViewItemShowListPoster,
-            item.posterSmall
+            item?.posterUrl
         )
 
-        val isShow = item.type == ListItemTypes.TMDB_SHOW || item.type == ListItemTypes.TVDB_SHOW
-        // Hide set watched button for legacy season and episode items
-        binding.imageViewItemShowListSetWatched.isVisible = isShow
-
-        // network, regular day and time, or type for legacy season/episode
-        if (isShow) {
-            // show details
-            val weekDay = item.releaseWeekDayOrDefault
-            val network = item.network
-
-            val releaseTimeShow = TimeTools.getReleaseDateTime(context, item)
-
-            binding.textViewItemShowListTimeAndNetwork.text = TextTools.dotSeparate(
-                network,
-                releaseTimeShow?.formatWithDeviceZoneToDayAndTime()
-            )
-
-            // next episode info
-            val fieldValue: String? = item.nextText
-            val hasNoNextEpisode = fieldValue.isNullOrEmpty()
-            binding.imageViewItemShowListSetWatched.isGone = hasNoNextEpisode
-            if (hasNoNextEpisode) {
-                // display show status if there is no next episode
-                binding.textViewItemShowListNextEpisodeTime.text =
-                    ShowStatus.getStatus(context, item.statusOrUnknown)
-                binding.textViewItemShowListNextEpisode.text = null
-            } else {
-                binding.textViewItemShowListNextEpisode.text = fieldValue
-
-                val releaseTimeEpisode = TimeTools.applyUserOffset(context, item.nextAirdateMs)
-                val displayExactDate = DisplaySettings.isDisplayExactDate(context)
-                val dateTime = if (displayExactDate) {
-                    TimeTools.formatToLocalDateShort(context, releaseTimeEpisode)
-                } else {
-                    TimeTools.formatToLocalRelativeTime(context, releaseTimeEpisode)
-                }
-                if (TimeTools.isSameWeekDay(
-                        Instant.ofEpochMilli(releaseTimeEpisode.time),
-                        releaseTimeShow?.toInstant(),
-                        weekDay
-                    )) {
-                    // just display date
-                    binding.textViewItemShowListNextEpisodeTime.text = dateTime
-                } else {
-                    // display date and explicitly day
-                    binding.textViewItemShowListNextEpisodeTime.text = context.getString(
-                        R.string.format_date_and_day, dateTime,
-                        TimeTools.formatToLocalDay(releaseTimeEpisode)
-                    )
-                }
-            }
-
-            // remaining count
-            setRemainingCount(item.unwatchedCount)
-        } else if (item.type == ListItemTypes.SEASON) {
-            binding.textViewItemShowListTimeAndNetwork.setText(R.string.season)
-            binding.textViewItemShowListNextEpisodeTime.text = null
-            binding.textViewItemShowListRemaining.visibility = View.GONE
-
-            // Note: Running query in adapter, but it's for legacy items, so fine for now.
-            val sesaonTvdbId: Int = item.itemRefId.toIntOrNull() ?: 0
-            val seasonNumbersOrNull = SgRoomDatabase.getInstance(context).sgSeason2Helper()
-                .getSeasonNumbersByTvdbId(sesaonTvdbId)
-            if (seasonNumbersOrNull != null) {
-                binding.textViewItemShowListNextEpisode.text = SeasonTools.getSeasonString(
-                    context,
-                    seasonNumbersOrNull.number
-                )
-            } else {
-                binding.textViewItemShowListNextEpisode.setText(R.string.unknown)
-            }
-        } else if (item.type == ListItemTypes.EPISODE) {
-            binding.textViewItemShowListTimeAndNetwork.setText(R.string.episode)
-            binding.textViewItemShowListRemaining.visibility = View.GONE
-
-            // Note: Running query in adapter, but it's for legacy items, so fine for now.
-            val episodeTvdbId: Int = item.itemRefId.toIntOrNull() ?: 0
-            val helper = SgRoomDatabase.getInstance(context).sgEpisode2Helper()
-            val episodeIdOrZero = helper.getEpisodeIdByTvdbId(episodeTvdbId)
-            val episodeInfo = if (episodeIdOrZero > 0) {
-                helper.getEpisodeInfo(episodeIdOrZero)
-            } else null
-
-            if (episodeInfo != null) {
-                binding.textViewItemShowListNextEpisode.text = TextTools.getNextEpisodeString(
-                    context,
-                    episodeInfo.season,
-                    episodeInfo.episodenumber,
-                    episodeInfo.title
-                )
-                val releaseTime = episodeInfo.firstReleasedMs
-                if (releaseTime != -1L) {
-                    // "in 15 mins (Fri)"
-                    val actualRelease = TimeTools.applyUserOffset(context, releaseTime)
-                    binding.textViewItemShowListNextEpisodeTime.text = context.getString(
-                        R.string.format_date_and_day,
-                        TimeTools.formatToLocalRelativeTime(context, actualRelease),
-                        TimeTools.formatToLocalDay(actualRelease)
-                    )
-                }
-            } else {
-                binding.textViewItemShowListNextEpisode.setText(R.string.unknown)
-                binding.textViewItemShowListNextEpisodeTime.text = null
-            }
-        }
-    }
+        // Set watched button
+        binding.imageViewItemShowListSetWatched.isVisible = item?.isSetWatchedButtonVisible ?: false
 
-    private fun setRemainingCount(unwatched: Int) {
-        val textView = binding.textViewItemShowListRemaining
-        textView.text = TextTools.getRemainingEpisodes(textView.resources, unwatched)
-        if (unwatched > 0) {
-            textView.visibility = View.VISIBLE
-        } else {
-            textView.visibility = View.GONE
-        }
+        binding.textViewItemShowListNextEpisode.text = item?.nextEpisodeText
+        binding.textViewItemShowListNextEpisodeTime.text = item?.nextEpisodeTimeText
+        binding.textViewItemShowListTimeAndNetwork.text = item?.timeAndNetworkText
+        // Use gone if not needed because remaining view adds padding
+        binding.textViewItemShowListRemaining.isVisible = item?.remainingText != null
+        binding.textViewItemShowListRemaining.text = item?.remainingText
     }
 
     companion object {
diff --git a/app/src/main/java/com/battlelancer/seriesguide/lists/SgListItemViewModel.kt b/app/src/main/java/com/battlelancer/seriesguide/lists/SgListItemViewModel.kt
index 0a829edd74..7762f1ae1c 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/lists/SgListItemViewModel.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/lists/SgListItemViewModel.kt
@@ -1,21 +1,24 @@
-// Copyright 2023 Uwe Trottmann
 // SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-FileCopyrightText: Copyright © 2021 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.lists
 
 import android.app.Application
 import androidx.lifecycle.AndroidViewModel
-import androidx.lifecycle.LiveData
-import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
-import androidx.lifecycle.switchMap
+import androidx.lifecycle.viewModelScope
 import androidx.sqlite.db.SimpleSQLiteQuery
 import com.battlelancer.seriesguide.lists.database.SgListItemWithDetails
-import com.battlelancer.seriesguide.provider.SeriesGuideContract.Lists
-import com.battlelancer.seriesguide.provider.SeriesGuideContract.SgShow2Columns
-import com.battlelancer.seriesguide.provider.SeriesGuideDatabase.Tables
 import com.battlelancer.seriesguide.provider.SgRoomDatabase
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
 
 /**
  * Uses raw query to get list items with show details.
@@ -25,12 +28,26 @@ class SgListItemViewModel(
     application: Application
 ) : AndroidViewModel(application) {
 
-    private val queryString = MutableLiveData<String>()
-    val sgListItemLiveData: LiveData<List<SgListItemWithDetails>> =
-        queryString.switchMap { queryString ->
+    private val queryString = MutableStateFlow("")
+    val items: StateFlow<List<UiListItem>> = queryString
+        .flatMapLatest { queryString ->
             SgRoomDatabase.getInstance(getApplication()).sgListHelper()
                 .getListItemsWithDetails(SimpleSQLiteQuery(queryString, arrayOf(listId)))
         }
+        .map { items ->
+            val builder = UiListItemBuilder(getApplication())
+            items.map { builder.buildFrom(it) }
+        }
+        // UiListItemBuilder may do database queries for legacy season and episode items, so use
+        // IO dispatcher for both.
+        .flowOn(Dispatchers.IO)
+        .stateIn(
+            scope = viewModelScope,
+            // Note: the associated fragment is shown in a RecyclerView-based ViewPager2 and
+            // SgListFragment uses repeatOnLifecycle(Lifecycle.State.STARTED)
+            started = SharingStarted.WhileSubscribed(5_000),
+            initialValue = emptyList()
+        )
 
     init {
         updateQuery()
@@ -38,13 +55,7 @@ class SgListItemViewModel(
 
     fun updateQuery() {
         val orderClause = ListsDistillationSettings.getSortQuery(getApplication())
-
-        // items of this list, but exclude any if show was removed from the database
-        // (the join on show data will fail, hence the show id will be 0/null)
-        queryString.value =
-            "SELECT * FROM ${Tables.LIST_ITEMS_WITH_DETAILS}" +
-                    " WHERE ${Lists.LIST_ID}=? AND ${SgShow2Columns.REF_SHOW_ID}>0" +
-                    " ORDER BY $orderClause"
+        queryString.value = SgListItemWithDetails.buildSelect(orderClause)
     }
 
 }
diff --git a/app/src/main/java/com/battlelancer/seriesguide/lists/UiListItem.kt b/app/src/main/java/com/battlelancer/seriesguide/lists/UiListItem.kt
new file mode 100644
index 0000000000..99c7d7c364
--- /dev/null
+++ b/app/src/main/java/com/battlelancer/seriesguide/lists/UiListItem.kt
@@ -0,0 +1,277 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-FileCopyrightText: Copyright © 2026 Uwe Trottmann <uwe@uwetrottmann.com>
+
+package com.battlelancer.seriesguide.lists
+
+import android.content.Context
+import androidx.recyclerview.widget.DiffUtil
+import com.battlelancer.seriesguide.R
+import com.battlelancer.seriesguide.lists.UiListItem.Companion.DIFF_CALLBACK
+import com.battlelancer.seriesguide.lists.database.SgListItemWithDetails
+import com.battlelancer.seriesguide.movies.database.SgMovie
+import com.battlelancer.seriesguide.movies.tools.MovieTools
+import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItemTypes
+import com.battlelancer.seriesguide.provider.SgRoomDatabase
+import com.battlelancer.seriesguide.settings.DisplaySettings
+import com.battlelancer.seriesguide.shows.overview.SeasonTools
+import com.battlelancer.seriesguide.shows.tools.ShowStatus
+import com.battlelancer.seriesguide.util.ImageUrlTools
+import com.battlelancer.seriesguide.util.TextTools
+import com.battlelancer.seriesguide.util.TimeTools
+import com.battlelancer.seriesguide.util.TimeTools.formatWithDeviceZoneToDayAndTime
+import org.threeten.bp.Instant
+
+/**
+ * UI model for a list item for [SgListItemAdapter].
+ */
+data class UiListItem(
+    /**
+     * Database row ID. Used as the stable ID in [DIFF_CALLBACK].
+     */
+    val id: Long,
+    val listItemId: String,
+    @ListItemTypes val type: Int,
+
+    /**
+     * Only if [type] is [ListItemTypes.TMDB_MOVIE].
+     */
+    val movieTmdbId: Int?,
+    /**
+     * Only if [type] is **not** a [ListItemTypes.TMDB_MOVIE].
+     */
+    val showId: Long?,
+
+    val isSetWatchedButtonVisible: Boolean,
+    val isFavorite: Boolean,
+
+    /**
+     * A poster URL ready to be loaded.
+     */
+    val posterUrl: String?,
+
+    val titleText: String,
+    val nextEpisodeText: String?,
+    val nextEpisodeTimeText: String?,
+    val timeAndNetworkText: String,
+    val remainingText: String?,
+
+    /**
+     * Database ID of the next episode; 0 if there is none.
+     */
+    val nextEpisodeId: Long,
+) {
+    /**
+     * Whether this item represents a show (TMDB or legacy TVDB).
+     */
+    val isShow: Boolean
+        get() = type == ListItemTypes.TMDB_SHOW || type == ListItemTypes.TVDB_SHOW
+
+    companion object {
+        val DIFF_CALLBACK = object : DiffUtil.ItemCallback<UiListItem>() {
+            override fun areItemsTheSame(oldItem: UiListItem, newItem: UiListItem): Boolean =
+                oldItem.id == newItem.id
+
+            override fun areContentsTheSame(oldItem: UiListItem, newItem: UiListItem): Boolean =
+                oldItem == newItem
+        }
+    }
+}
+
+/**
+ * Converts [SgListItemWithDetails] rows (coming from the database) into
+ * [UiListItem] instances that are ready to be bound by [SgListItemAdapter].
+ */
+class UiListItemBuilder(private val context: Context) {
+
+    private val imageUrlTools = ImageUrlTools(context)
+    private val dateFormatMovieReleaseDate = MovieTools.getMovieShortDateFormat()
+
+    fun buildFrom(item: SgListItemWithDetails): UiListItem {
+        return when (item.type) {
+            ListItemTypes.TMDB_MOVIE -> buildMovie(item)
+            ListItemTypes.TMDB_SHOW, ListItemTypes.TVDB_SHOW -> buildShow(item)
+            ListItemTypes.SEASON -> buildSeason(item)
+            ListItemTypes.EPISODE -> buildEpisode(item)
+            else -> throw IllegalArgumentException("Unsupported item type ${item.type}")
+        }
+    }
+
+    private fun SgListItemWithDetails.posterUrl(): String? =
+        imageUrlTools.tmdbOrTvdbPosterUrl(this.poster)
+
+    private fun buildMovie(item: SgListItemWithDetails): UiListItem {
+        val releaseDate = if (item.releasedMsOrDefault != SgMovie.RELEASED_MS_UNKNOWN) {
+            TimeTools.formatToLocalDateShort(context, item.releasedMsOrDefault)
+        } else {
+            ""
+        }
+
+        val runningTime =
+            TimeTools.formatToHoursAndMinutes(context.resources, item.runningTimeMinutesOrZero)
+
+        return UiListItem(
+            id = item.id,
+            listItemId = item.listItemId,
+            type = item.type,
+            movieTmdbId = item.movieTmdbId,
+            showId = null,
+            isSetWatchedButtonVisible = false,
+            isFavorite = false,
+            posterUrl = item.posterUrl(),
+            titleText = item.title,
+            nextEpisodeText = runningTime,
+            nextEpisodeTimeText = releaseDate,
+            timeAndNetworkText = "",
+            remainingText = null,
+            nextEpisodeId = 0,
+        )
+    }
+
+    private fun buildShow(item: SgListItemWithDetails): UiListItem {
+        val releaseDateTime = TimeTools.getReleaseDateTime(context, item)
+        val timeAndNetwork = TextTools.dotSeparate(
+            item.network,
+            releaseDateTime?.formatWithDeviceZoneToDayAndTime()
+        )
+
+        val nextEpisodeText = item.nextText
+        val nextEpisodeTimeText: String?
+        val hasNextEpisode = !nextEpisodeText.isNullOrEmpty()
+        if (!hasNextEpisode) {
+            // Display show status if there is no next episode
+            nextEpisodeTimeText = ShowStatus.getStatus(context, item.statusOrUnknown)
+        } else {
+            val releaseTimeEpisode =
+                TimeTools.applyUserOffset(context, item.releasedMsOrDefault)
+            val displayExactDate = DisplaySettings.isDisplayExactDate(context)
+            val dateTime = if (displayExactDate) {
+                TimeTools.formatToLocalDateShort(context, releaseTimeEpisode)
+            } else {
+                TimeTools.formatToLocalRelativeTime(context, releaseTimeEpisode)
+            }
+            nextEpisodeTimeText = if (
+                TimeTools.isSameWeekDay(
+                    Instant.ofEpochMilli(releaseTimeEpisode.time),
+                    releaseDateTime?.toInstant(),
+                    item.releaseWeekDayOrDefault
+                )
+            ) {
+                dateTime
+            } else {
+                context.getString(
+                    R.string.format_date_and_day,
+                    dateTime,
+                    TimeTools.formatToLocalDay(releaseTimeEpisode)
+                )
+            }
+        }
+
+        // remaining count
+        val remainingText = item.unwatchedCount
+            .let {
+                if (it > 0) {
+                    TextTools.getRemainingEpisodes(context.resources, it)
+                } else null
+            }
+
+        return UiListItem(
+            id = item.id,
+            listItemId = item.listItemId,
+            type = item.type,
+            movieTmdbId = null,
+            showId = item.showId,
+            isSetWatchedButtonVisible = hasNextEpisode,
+            isFavorite = item.favorite,
+            posterUrl = item.posterUrl(),
+            titleText = item.title,
+            nextEpisodeText = nextEpisodeText,
+            nextEpisodeTimeText = nextEpisodeTimeText,
+            timeAndNetworkText = timeAndNetwork,
+            remainingText = remainingText,
+            nextEpisodeId = item.nextEpisodeId,
+        )
+    }
+
+    private fun buildSeason(item: SgListItemWithDetails): UiListItem {
+        // Note: running a database query per item, but it's for legacy items, so fine for now
+        val seasonTvdbId = item.itemRefId.toIntOrNull() ?: 0
+        val seasonNumbersOrNull = SgRoomDatabase.getInstance(context)
+            .sgSeason2Helper()
+            .getSeasonNumbersByTvdbId(seasonTvdbId)
+        val nextEpisodeText = if (seasonNumbersOrNull != null) {
+            SeasonTools.getSeasonString(context, seasonNumbersOrNull.number)
+        } else {
+            context.getString(R.string.unknown)
+        }
+
+        return UiListItem(
+            id = item.id,
+            listItemId = item.listItemId,
+            type = item.type,
+            movieTmdbId = null,
+            showId = item.showId,
+            isSetWatchedButtonVisible = false,
+            isFavorite = item.favorite,
+            posterUrl = item.posterUrl(),
+            titleText = item.title,
+            nextEpisodeText = nextEpisodeText,
+            nextEpisodeTimeText = null,
+            timeAndNetworkText = context.getString(R.string.season),
+            remainingText = null,
+            nextEpisodeId = 0,
+        )
+    }
+
+    private fun buildEpisode(item: SgListItemWithDetails): UiListItem {
+        // Note: running a database query per item, but it's for legacy items, so fine for now
+        val episodeTvdbId = item.itemRefId.toIntOrNull() ?: 0
+        val helper = SgRoomDatabase.getInstance(context).sgEpisode2Helper()
+        val episodeIdOrZero = helper.getEpisodeIdByTvdbId(episodeTvdbId)
+        val episodeInfo = if (episodeIdOrZero > 0) {
+            helper.getEpisodeInfo(episodeIdOrZero)
+        } else null
+
+        val nextEpisodeText: String
+        val nextEpisodeTimeText: String?
+
+        if (episodeInfo != null) {
+            nextEpisodeText = TextTools.getNextEpisodeString(
+                context,
+                episodeInfo.season,
+                episodeInfo.episodenumber,
+                episodeInfo.title
+            )
+            val releaseTime = episodeInfo.firstReleasedMs
+            nextEpisodeTimeText = if (releaseTime != -1L) {
+                // "in 15 mins (Fri)"
+                val actualRelease = TimeTools.applyUserOffset(context, releaseTime)
+                context.getString(
+                    R.string.format_date_and_day,
+                    TimeTools.formatToLocalRelativeTime(context, actualRelease),
+                    TimeTools.formatToLocalDay(actualRelease)
+                )
+            } else null
+        } else {
+            nextEpisodeText = context.getString(R.string.unknown)
+            nextEpisodeTimeText = null
+        }
+
+        return UiListItem(
+            id = item.id,
+            listItemId = item.listItemId,
+            type = item.type,
+            movieTmdbId = null,
+            showId = item.showId,
+            isSetWatchedButtonVisible = false,
+            isFavorite = item.favorite,
+            posterUrl = item.posterUrl(),
+            titleText = item.title,
+            nextEpisodeText = nextEpisodeText,
+            nextEpisodeTimeText = nextEpisodeTimeText,
+            timeAndNetworkText = context.getString(R.string.episode),
+            remainingText = null,
+            nextEpisodeId = 0,
+        )
+    }
+}
+
diff --git a/app/src/main/java/com/battlelancer/seriesguide/lists/database/SgList.kt b/app/src/main/java/com/battlelancer/seriesguide/lists/database/SgList.kt
index 8e5d4657ad..028e14b15b 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/lists/database/SgList.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/lists/database/SgList.kt
@@ -22,7 +22,7 @@ import com.battlelancer.seriesguide.provider.SeriesGuideDatabase.Tables
 data class SgList(
     @PrimaryKey(autoGenerate = true)
     @ColumnInfo(name = Lists._ID)
-    val id: Long? = 0,
+    val id: Long? = null,
 
     /**
      * Unique string identifier.
diff --git a/app/src/main/java/com/battlelancer/seriesguide/lists/database/SgListHelper.kt b/app/src/main/java/com/battlelancer/seriesguide/lists/database/SgListHelper.kt
index efdcb4ebb8..f61e70c8cb 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/lists/database/SgListHelper.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/lists/database/SgListHelper.kt
@@ -1,9 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2021-2024 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2021 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.lists.database
 
-import androidx.annotation.VisibleForTesting
 import androidx.lifecycle.LiveData
 import androidx.room.ColumnInfo
 import androidx.room.Dao
@@ -13,12 +12,19 @@ import androidx.room.Query
 import androidx.room.RawQuery
 import androidx.room.Transaction
 import androidx.sqlite.db.SupportSQLiteQuery
+import com.battlelancer.seriesguide.lists.database.SgListItemWithDetails.Companion.LIST_ITEMS_WITH_DETAILS
+import com.battlelancer.seriesguide.movies.database.SgMovie
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItemTypes
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItems
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.Lists
+import com.battlelancer.seriesguide.provider.SeriesGuideContract.MoviesColumns
+import com.battlelancer.seriesguide.provider.SeriesGuideContract.SgEpisode2Columns
+import com.battlelancer.seriesguide.provider.SeriesGuideContract.SgSeason2Columns
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.SgShow2Columns
+import com.battlelancer.seriesguide.provider.SeriesGuideDatabase.Tables
 import com.battlelancer.seriesguide.shows.database.SgShow2
 import com.battlelancer.seriesguide.shows.tools.ShowStatus
+import kotlinx.coroutines.flow.Flow
 
 @Dao
 interface SgListHelper {
@@ -41,20 +47,40 @@ interface SgListHelper {
     @Query("SELECT COUNT(_id) FROM lists")
     fun getListsCount(): Int
 
-    @Query("SELECT  * FROM listitems WHERE item_ref_id = :tmdbId AND item_type = ${ListItemTypes.TMDB_SHOW}")
-    fun getListItemsWithTmdbId(tmdbId: Int): List<SgListItem>
+    @Query("SELECT * FROM listitems WHERE item_ref_id = :tmdbId AND item_type = :type")
+    fun getListItemsWithTmdbId(tmdbId: Int, @ListItemTypes type: Int): List<SgListItem>
 
-    @RawQuery(observedEntities = [SgListItem::class, SgShow2::class])
-    fun getListItemsWithDetails(query: SupportSQLiteQuery): LiveData<List<SgListItemWithDetails>>
+    @Query("SELECT COUNT(_id) FROM listitems WHERE item_ref_id = :tmdbId AND item_type = :type")
+    fun getListItemsWithTmdbIdCount(tmdbId: Int, @ListItemTypes type: Int): Int
+
+    // Note: use "SELECT 1" to just return 1 if there is a matching row as EXISTS only checks if a
+    // row is returned, not what row is returned.
+    @Query(
+        "SELECT item_ref_id FROM listitems " +
+                "WHERE item_type = ${ListItemTypes.TMDB_MOVIE} " +
+                "AND NOT EXISTS (SELECT 1 FROM movies WHERE movies.movies_tmdbid = listitems.item_ref_id)"
+    )
+    fun getRefIdsOfMovieListItemsNotInDatabase(): List<String>
+
+    fun getTmdbIdsOfMovieListItemsNotInDatabase(): List<Int> {
+        return getRefIdsOfMovieListItemsNotInDatabase()
+            .mapNotNull { it.toIntOrNull() }
+    }
+
+    @Query("SELECT * FROM listitems WHERE item_type = ${ListItemTypes.TVDB_SHOW}")
+    fun getTvdbShowListItems(): List<SgListItem>
+
+    @RawQuery(observedEntities = [SgListItem::class, SgShow2::class, SgMovie::class])
+    fun getListItemsWithDetails(query: SupportSQLiteQuery): Flow<List<SgListItemWithDetails>>
 
     @Query("SELECT * FROM listitems WHERE list_id = :listId")
     fun getListItemsForExport(listId: String): List<SgListItem>
 
     @Insert(onConflict = OnConflictStrategy.REPLACE)
-    fun insertListItems(listItems: List<SgListItem>)
+    fun insertList(list: SgList)
 
-    @Query("SELECT * FROM listitems WHERE item_type = ${ListItemTypes.TVDB_SHOW}")
-    fun getTvdbShowListItems(): List<SgListItem>
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    fun insertListItems(listItems: List<SgListItem>)
 
     @Query("DELETE FROM listitems WHERE list_item_id = :listItemId")
     fun deleteListItem(listItemId: String)
@@ -66,17 +92,15 @@ interface SgListHelper {
         }
     }
 
-    /**
-     * By default the database inserts a first list when being created, d
-     */
-    @VisibleForTesting
     @Query("DELETE FROM lists")
     fun deleteAllLists()
 
+    @Query("DELETE FROM listitems")
+    fun deleteAllListItems()
 }
 
 /**
- * Compare with [com.battlelancer.seriesguide.provider.SeriesGuideDatabase.Tables.LIST_ITEMS_WITH_DETAILS]
+ * For query see [LIST_ITEMS_WITH_DETAILS].
  */
 data class SgListItemWithDetails(
     @ColumnInfo(name = ListItems._ID) val id: Long,
@@ -84,13 +108,27 @@ data class SgListItemWithDetails(
     @ColumnInfo(name = Lists.LIST_ID) val listId: String,
     @ColumnInfo(name = ListItems.TYPE) val type: Int,
     @ColumnInfo(name = ListItems.ITEM_REF_ID) val itemRefId: String,
-    @ColumnInfo(name = SgShow2Columns.REF_SHOW_ID) val showId: Long,
+    /**
+     * Only if [type] is [ListItemTypes.TMDB_MOVIE].
+     */
+    @ColumnInfo(name = MoviesColumns.TMDB_ID) val movieTmdbId: Int?,
+    /**
+     * Only if [type] is **not** a [ListItemTypes.TMDB_MOVIE].
+     */
+    @ColumnInfo(name = SgShow2Columns.REF_SHOW_ID) val showId: Long?,
     @ColumnInfo(name = SgShow2Columns.RELEASE_TIME) val releaseTime: Int?,
+    @ColumnInfo(name = RUNNING_TIME_MINUTES) val runningTimeMinutes: Int?,
     @ColumnInfo(name = SgShow2Columns.NEXTTEXT) val nextText: String?,
-    @ColumnInfo(name = SgShow2Columns.NEXTAIRDATEMS) val nextAirdateMs: Long,
-    @ColumnInfo(name = SgShow2Columns.TITLE) val title: String,
-    @ColumnInfo(name = SgShow2Columns.TITLE_NOARTICLE) val titleNoArticle: String?,
-    @ColumnInfo(name = SgShow2Columns.POSTER_SMALL) val posterSmall: String?,
+    /**
+     * Get via [releasedMsOrDefault].
+     */
+    @ColumnInfo(name = RELEASED_MS) val releasedMs: Long?,
+    @ColumnInfo(name = TITLE) val title: String,
+    @ColumnInfo(name = TITLE_NO_ARTICLE) val titleNoArticle: String?,
+    /**
+     * [MoviesColumns.POSTER] or [SgShow2Columns.POSTER_SMALL].
+     */
+    @ColumnInfo(name = POSTER) val poster: String?,
     @ColumnInfo(name = SgShow2Columns.NETWORK) val network: String?,
     @ColumnInfo(name = SgShow2Columns.STATUS) val status: Int?,
     @ColumnInfo(name = SgShow2Columns.NEXTEPISODE) val nextEpisode: String?,
@@ -103,10 +141,19 @@ data class SgListItemWithDetails(
     @ColumnInfo(name = SgShow2Columns.CUSTOM_RELEASE_TIME_ZONE) var customReleaseTimeZone: String?,
     @ColumnInfo(name = SgShow2Columns.LASTWATCHED_MS) val lastWatchedMs: Long,
     @ColumnInfo(name = SgShow2Columns.UNWATCHED_COUNT) val unwatchedCount: Int,
-    ) {
+) {
 
-    val releaseTimeOrDefault: Int
-        get() = releaseTime ?: -1
+    /**
+     * If [releasedMs] is not null returns it, otherwise [Long.MAX_VALUE].
+     * This works for both shows and movies as that's the default for both
+     * ([SgMovie.RELEASED_MS_UNKNOWN] and
+     * [com.battlelancer.seriesguide.shows.tools.NextEpisodeUpdater.UNKNOWN_NEXT_RELEASE_DATE]), see
+     * [MoviesColumns.RELEASED_UTC_MS] and [SgShow2Columns.NEXTAIRDATEMS].
+     */
+    val releasedMsOrDefault: Long
+        get() = releasedMs ?: Long.MAX_VALUE
+    val runningTimeMinutesOrZero: Int
+        get() = runningTimeMinutes ?: 0
     val releaseWeekDayOrDefault: Int
         get() = releaseWeekDay ?: -1
     val customReleaseTimeOrDefault: Int
@@ -118,4 +165,208 @@ data class SgListItemWithDetails(
 
     val nextEpisodeId: Long
         get() = nextEpisode?.toLongOrNull() ?: 0
+
+    companion object {
+
+        private const val TITLE = "list_item_title"
+        private const val TITLE_NO_ARTICLE = "list_item_title_no_article"
+        private const val POSTER = "list_item_poster"
+        private const val RELEASED_MS = "list_item_released_ms"
+        private const val RUNNING_TIME_MINUTES = "list_item_running_time_minutes"
+        private const val ITEM_ROW_ID = "item_row_id"
+
+        /** Qualified name of list item ref ID column for use with [LIST_ITEMS_WITH_DETAILS]. */
+        private const val LIST_ITEMS_REF_ID = Tables.LIST_ITEMS + "." + ListItems.ITEM_REF_ID
+
+        /** Qualified name of show ID column for use with [LIST_ITEMS_WITH_DETAILS]. */
+        private const val SG_SHOW_ID = Tables.SG_SHOW + "." + SgShow2Columns._ID
+
+        private const val ITEMS_COLUMNS: String =
+            "${ListItems.LIST_ITEM_ID},${Lists.LIST_ID},${ListItems.TYPE},${ListItems.ITEM_REF_ID}"
+
+        private const val SELECT_LIST_ITEMS_MAP_ROW_ID: String =
+            "SELECT ${ListItems._ID} AS $ITEM_ROW_ID,$ITEMS_COLUMNS " +
+                    "FROM ${Tables.LIST_ITEMS}"
+
+        private const val SELECT_TMDB_MOVIES: String =
+            "($SELECT_LIST_ITEMS_MAP_ROW_ID " +
+                    "WHERE ${ListItems.TYPE}=${ListItemTypes.TMDB_MOVIE}) " +
+                    "AS ${Tables.LIST_ITEMS}"
+
+        private const val SELECT_TMDB_SHOWS: String =
+            "($SELECT_LIST_ITEMS_MAP_ROW_ID " +
+                    "WHERE ${ListItems.TYPE}=${ListItemTypes.TMDB_SHOW}) " +
+                    "AS ${Tables.LIST_ITEMS}"
+
+        private const val SELECT_TVDB_SHOWS: String =
+            "($SELECT_LIST_ITEMS_MAP_ROW_ID " +
+                    "WHERE ${ListItems.TYPE}=${ListItemTypes.TVDB_SHOW}) " +
+                    "AS ${Tables.LIST_ITEMS}"
+
+        private const val SELECT_TVDB_SEASONS: String =
+            "($SELECT_LIST_ITEMS_MAP_ROW_ID " +
+                    "WHERE ${ListItems.TYPE}=${ListItemTypes.SEASON}) " +
+                    "AS ${Tables.LIST_ITEMS}"
+
+        private const val SELECT_TVDB_EPISODES: String =
+            "($SELECT_LIST_ITEMS_MAP_ROW_ID " +
+                    "WHERE ${ListItems.TYPE}=${ListItemTypes.EPISODE}) " +
+                    "AS ${Tables.LIST_ITEMS}"
+
+        /**
+         * Show columns are mapped to `NULL`.
+         */
+        private const val SELECT_ITEMS_AND_MOVIES_COLUMNS: String =
+            "SELECT $ITEM_ROW_ID AS " + ListItems._ID + "," +
+                    ITEMS_COLUMNS + "," +
+                    MoviesColumns.TMDB_ID + "," +
+                    "NULL AS ${SgShow2Columns.REF_SHOW_ID}," +
+                    "NULL AS ${SgShow2Columns.RELEASE_TIME}," +
+                    "NULL AS ${SgShow2Columns.NEXTTEXT}," +
+                    "${MoviesColumns.RELEASED_UTC_MS} AS $RELEASED_MS," +
+                    "${MoviesColumns.RUNTIME_MIN} AS $RUNNING_TIME_MINUTES," +
+                    "${MoviesColumns.TITLE} AS $TITLE," +
+                    "${MoviesColumns.TITLE_NOARTICLE} AS $TITLE_NO_ARTICLE," +
+                    "${MoviesColumns.POSTER} AS $POSTER," +
+                    "NULL AS ${SgShow2Columns.NETWORK}," +
+                    "NULL AS ${SgShow2Columns.STATUS}," +
+                    "NULL AS ${SgShow2Columns.NEXTEPISODE}," +
+                    "NULL AS ${SgShow2Columns.FAVORITE}," +
+                    "NULL AS ${SgShow2Columns.RELEASE_WEEKDAY}," +
+                    "NULL AS ${SgShow2Columns.RELEASE_TIMEZONE}," +
+                    "NULL AS ${SgShow2Columns.RELEASE_COUNTRY}," +
+                    "NULL AS ${SgShow2Columns.CUSTOM_RELEASE_TIME}," +
+                    "NULL AS ${SgShow2Columns.CUSTOM_RELEASE_DAY_OFFSET}," +
+                    "NULL AS ${SgShow2Columns.CUSTOM_RELEASE_TIME_ZONE}," +
+                    "NULL AS ${SgShow2Columns.LASTWATCHED_MS}," +
+                    "NULL AS ${SgShow2Columns.UNWATCHED_COUNT}"
+
+        /**
+         * Movie columns are mapped to `NULL`.
+         */
+        private const val SELECT_ITEMS_AND_SHOWS_COLUMNS: String =
+            "SELECT $ITEM_ROW_ID AS " + ListItems._ID + "," +
+                    ITEMS_COLUMNS + "," +
+                    "NULL AS ${MoviesColumns.TMDB_ID}," +
+                    "$SG_SHOW_ID AS ${SgShow2Columns.REF_SHOW_ID}," +
+                    SgShow2Columns.RELEASE_TIME + "," +
+                    SgShow2Columns.NEXTTEXT + "," +
+                    "${SgShow2Columns.NEXTAIRDATEMS} AS $RELEASED_MS," +
+                    "${SgShow2Columns.RUNTIME} AS $RUNNING_TIME_MINUTES," +
+                    "${SgShow2Columns.TITLE} AS $TITLE," +
+                    "${SgShow2Columns.TITLE_NOARTICLE} AS $TITLE_NO_ARTICLE," +
+                    "${SgShow2Columns.POSTER_SMALL} AS $POSTER," +
+                    SgShow2Columns.NETWORK + "," +
+                    SgShow2Columns.STATUS + "," +
+                    SgShow2Columns.NEXTEPISODE + "," +
+                    SgShow2Columns.FAVORITE + "," +
+                    SgShow2Columns.RELEASE_WEEKDAY + "," +
+                    SgShow2Columns.RELEASE_TIMEZONE + "," +
+                    SgShow2Columns.RELEASE_COUNTRY + "," +
+                    SgShow2Columns.CUSTOM_RELEASE_TIME + "," +
+                    SgShow2Columns.CUSTOM_RELEASE_DAY_OFFSET + "," +
+                    SgShow2Columns.CUSTOM_RELEASE_TIME_ZONE + "," +
+                    SgShow2Columns.LASTWATCHED_MS + "," +
+                    SgShow2Columns.UNWATCHED_COUNT
+
+        private const val SG_SEASON_JOIN_SG_SHOW: String =
+            "${Tables.SG_SEASON} LEFT OUTER JOIN ${Tables.SG_SHOW} " +
+                    "ON ${Tables.SG_SEASON}.${SgShow2Columns.REF_SHOW_ID}=$SG_SHOW_ID"
+
+        private const val SG_EPISODE_JOIN_SG_SHOW: String =
+            "${Tables.SG_EPISODE} LEFT OUTER JOIN ${Tables.SG_SHOW} " +
+                    "ON ${Tables.SG_EPISODE}.${SgShow2Columns.REF_SHOW_ID}=$SG_SHOW_ID"
+
+        /**
+         * The columns of the final rows must match [SgListItemWithDetails].
+         *
+         * Using left outer join so joined show or movie data will be null/0 if there is no match.
+         * Can then use this to not display list items for shows or movies that aren't added to the
+         * database.
+         */
+        private const val LIST_ITEMS_WITH_DETAILS: String = "(" +
+                // TMDB movies
+                SELECT_ITEMS_AND_MOVIES_COLUMNS + " FROM " +
+                "(" +
+                SELECT_TMDB_MOVIES +
+                " LEFT OUTER JOIN " + Tables.MOVIES +
+                " ON " + LIST_ITEMS_REF_ID + "=" + MoviesColumns.TMDB_ID +
+                ")" +
+                " UNION " +
+                // new TMDB shows
+                SELECT_ITEMS_AND_SHOWS_COLUMNS + " FROM " +
+                "(" +
+                SELECT_TMDB_SHOWS +
+                " LEFT OUTER JOIN " + Tables.SG_SHOW +
+                " ON " + LIST_ITEMS_REF_ID + "=" + SgShow2Columns.TMDB_ID +
+                ")" +
+                // legacy TVDB shows
+                " UNION " +
+                SELECT_ITEMS_AND_SHOWS_COLUMNS + " FROM " +
+                "(" +
+                SELECT_TVDB_SHOWS +
+                " LEFT OUTER JOIN " + Tables.SG_SHOW +
+                " ON " + LIST_ITEMS_REF_ID + "=" + SgShow2Columns.TVDB_ID +
+                ")" +
+                // legacy TVDB seasons
+                " UNION " +
+                SELECT_ITEMS_AND_SHOWS_COLUMNS + " FROM " +
+                "(" +
+                SELECT_TVDB_SEASONS +
+                " LEFT OUTER JOIN " + "(" + SG_SEASON_JOIN_SG_SHOW + ") AS " + Tables.SG_SEASON +
+                " ON " + LIST_ITEMS_REF_ID + "=" + SgSeason2Columns.TVDB_ID +
+                ")" +
+                // legacy TVDB episodes
+                " UNION " +
+                SELECT_ITEMS_AND_SHOWS_COLUMNS + " FROM " +
+                "(" +
+                SELECT_TVDB_EPISODES +
+                " LEFT OUTER JOIN " + "(" + SG_EPISODE_JOIN_SG_SHOW + ") AS " + Tables.SG_EPISODE +
+                " ON " + LIST_ITEMS_REF_ID + "=" + SgEpisode2Columns.TVDB_ID +
+                ")" +
+                //
+                ")"
+
+        // Android provides the UNICODE collator,
+        // use it to correctly order characters with, for example, accents.
+        // https://developer.android.com/reference/android/database/sqlite/SQLiteDatabase
+        const val SORT_TITLE: String = "$TITLE COLLATE UNICODE ASC"
+        const val SORT_TITLE_NO_ARTICLE: String = "$TITLE_NO_ARTICLE COLLATE UNICODE ASC"
+
+        /**
+         * By oldest movie or next episode release date, then continued first (for no next episode).
+         */
+        const val SORT_OLDEST_RELEASE_DATE =
+            "$RELEASED_MS ASC,${SgShow2Columns.STATUS} DESC"
+
+        /**
+         * By latest movie or next episode release date, then continued first (for no next episode).
+         */
+        const val SORT_LATEST_RELEASE_DATE =
+            "$RELEASED_MS DESC,${SgShow2Columns.STATUS} DESC"
+
+        /**
+         * By latest watched first.
+         */
+        const val SORT_LAST_WATCHED = "${SgShow2Columns.LASTWATCHED_MS} DESC"
+
+        /**
+         * By least episodes remaining to watch, then continued first (for no remaining episode).
+         */
+        const val SORT_REMAINING_EPISODES =
+            "${SgShow2Columns.UNWATCHED_COUNT} ASC,${SgShow2Columns.STATUS} DESC"
+
+        const val SORT_TYPE: String = ListItems.TYPE + " ASC"
+
+        /**
+         * Selects items of this list, but excludes any where the associated movie or show is not in
+         * the database (the join on movie or show data will fail and the movie TMDB ID or show ID
+         * will be 0/null).
+         *
+         * [orderClause] as built by [com.battlelancer.seriesguide.lists.ListsDistillationSettings].
+         */
+        fun buildSelect(orderClause: String): String = "SELECT * FROM $LIST_ITEMS_WITH_DETAILS" +
+                " WHERE ${Lists.LIST_ID}=? AND (${MoviesColumns.TMDB_ID}>0 OR ${SgShow2Columns.REF_SHOW_ID}>0)" +
+                " ORDER BY $orderClause"
+    }
 }
diff --git a/app/src/main/java/com/battlelancer/seriesguide/lists/database/SgListItem.kt b/app/src/main/java/com/battlelancer/seriesguide/lists/database/SgListItem.kt
index 8ffe2c55b2..a8bec936b6 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/lists/database/SgListItem.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/lists/database/SgListItem.kt
@@ -31,7 +31,7 @@ import com.battlelancer.seriesguide.provider.SeriesGuideDatabase.Tables
 data class SgListItem(
     @PrimaryKey(autoGenerate = true)
     @ColumnInfo(name = ListItems._ID)
-    val id: Long? = 0,
+    val id: Long? = null,
 
     @ColumnInfo(name = ListItems.LIST_ITEM_ID)
     var listItemId: String,
diff --git a/app/src/main/java/com/battlelancer/seriesguide/movies/MovieLoader.kt b/app/src/main/java/com/battlelancer/seriesguide/movies/MovieLoader.kt
index d76e1b2dd2..dcfcec2f18 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/movies/MovieLoader.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/movies/MovieLoader.kt
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2020-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2020 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.movies
 
@@ -27,7 +27,9 @@ internal class MovieLoader(
         val movieTools = getServicesComponent(context).movieTools()
         // No need to handle InterruptedException as ModernAsyncTask does (see its constructor)
         val details = runBlocking {
-            movieTools.getMovieDetailsWithDefaults(tmdbId, true).movieDetails
+            movieTools.downloader
+                .getMovieDetailsWithDefaults(tmdbId, true)
+                .movieDetails
         }
 
         // Update local database (no-op if movie not in database).
diff --git a/app/src/main/java/com/battlelancer/seriesguide/movies/MovieViewHolder.kt b/app/src/main/java/com/battlelancer/seriesguide/movies/MovieViewHolder.kt
index 1dddfc4c34..8426c33ca1 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/movies/MovieViewHolder.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/movies/MovieViewHolder.kt
@@ -120,7 +120,7 @@ class UiMovieBuilder(context: Context) {
         return UiMovie(
             sgMovie.tmdbId,
             sgMovie.title.orEmpty(),
-            if (sgMovie.releasedMsOrDefault != Long.MAX_VALUE) {
+            if (sgMovie.releasedMsOrDefault != SgMovie.RELEASED_MS_UNKNOWN) {
                 dateFormatMovieReleaseDate.format(sgMovie.releasedMsOrDefault)
             } else {
                 ""
diff --git a/app/src/main/java/com/battlelancer/seriesguide/movies/MoviesOptionsMenu.kt b/app/src/main/java/com/battlelancer/seriesguide/movies/MoviesOptionsMenu.kt
index 33855e6579..7a8faa9a6f 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/movies/MoviesOptionsMenu.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/movies/MoviesOptionsMenu.kt
@@ -67,9 +67,7 @@ class MoviesOptionsMenu(val activity: Activity) :
     }
 
     private fun changeSortIgnoreArticles(value: Boolean, activity: Activity) {
-        PreferenceManager.getDefaultSharedPreferences(activity).edit()
-            .putBoolean(DisplaySettings.KEY_SORT_IGNORE_ARTICLE, value)
-            .apply()
+        DisplaySettings.saveSortOrderIgnoringArticles(activity, value)
 
         // refresh icon state
         activity.invalidateOptionsMenu()
diff --git a/app/src/main/java/com/battlelancer/seriesguide/movies/database/MovieHelper.kt b/app/src/main/java/com/battlelancer/seriesguide/movies/database/MovieHelper.kt
index 2649ca70e1..7c195dc6fa 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/movies/database/MovieHelper.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/movies/database/MovieHelper.kt
@@ -1,13 +1,18 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2020-2024 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2020 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.movies.database
 
 import androidx.paging.PagingSource
 import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
 import androidx.room.Query
 import androidx.room.RawQuery
+import androidx.room.Transaction
 import androidx.sqlite.db.SupportSQLiteQuery
+import com.battlelancer.seriesguide.movies.details.MovieDetails
+import com.battlelancer.seriesguide.util.TextTools
 
 /**
  * Data Access Object for the movies table.
@@ -15,6 +20,12 @@ import androidx.sqlite.db.SupportSQLiteQuery
 @Dao
 interface MovieHelper {
 
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    fun insertMovie(movie: SgMovie)
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    fun insertMovies(movie: List<SgMovie>)
+
     @Query("SELECT * FROM movies WHERE movies_tmdbid=:tmdbId")
     fun getMovie(tmdbId: Int): SgMovie?
 
@@ -49,6 +60,15 @@ interface MovieHelper {
     )
     fun getMoviesOnListsOrWatched(): List<SgMovieFlags>
 
+    // Note: use "SELECT 1" to just return 1 if there is a matching row as EXISTS only checks if a
+    // row is returned, not what row is returned.
+    @Query(
+        "SELECT movies_tmdbid FROM movies " +
+                "WHERE movies_incollection=0 AND movies_inwatchlist=0 AND movies_watched=0 " +
+                "AND NOT EXISTS (SELECT 1 FROM listitems WHERE listitems.item_ref_id = movies.movies_tmdbid)"
+    )
+    fun getTmdbIdsOfMoviesNotOnAnyList(): List<Int>
+
     @Query("SELECT movies_tmdbid, movies_incollection, movies_inwatchlist, movies_watched, movies_plays FROM movies")
     fun getMovieFlags(): List<SgMovieFlags>
 
@@ -91,6 +111,13 @@ interface MovieHelper {
     @Query("DELETE FROM movies WHERE movies_tmdbid=:tmdbId")
     fun deleteMovie(tmdbId: Int): Int
 
+    @Transaction
+    fun deleteMovies(tmdbIds: List<Int>) {
+        for (tmdbId in tmdbIds) {
+            deleteMovie(tmdbId)
+        }
+    }
+
     /**
      * For testing.
      */
@@ -102,3 +129,61 @@ data class MovieStats(
     val count: Int,
     val runtime: Long
 )
+
+/**
+ * Extracts ratings from Trakt, all other properties from TMDB data.
+ *
+ * If either Trakt or TMDB movie data is null, will still extract the properties of the other.
+ *
+ * Does not set collection, watchlist or watched flags or plays value.
+ *
+ * See [toSgMovieForInsert] for that.
+ */
+fun MovieDetails.toSgMovieForUpdate(tmdbId: Int): SgMovie {
+    val sgMovie = SgMovie(tmdbId = tmdbId)
+        .let {
+            val traktRatings = traktRatings()
+            if (traktRatings != null) {
+                it.copy(
+                    ratingTrakt = traktRatings.rating?.toInt() ?: 0,
+                    ratingVotesTrakt = traktRatings.votes ?: 0
+                )
+            } else {
+                it
+            }
+        }.let {
+            val tmdbMovie = tmdbMovie()
+            if (tmdbMovie != null) {
+                it.copy(
+                    imdbId = tmdbMovie.imdb_id,
+                    title = tmdbMovie.title,
+                    titleNoArticle = TextTools.trimLeadingArticle(tmdbMovie.title),
+                    overview = tmdbMovie.overview,
+                    poster = tmdbMovie.poster_path,
+                    runtimeMin = tmdbMovie.runtime ?: 0,
+                    ratingTmdb = tmdbMovie.vote_average ?: 0.0,
+                    ratingVotesTmdb = tmdbMovie.vote_count ?: 0,
+                    releasedMs = tmdbMovie.release_date?.time ?: SgMovie.RELEASED_MS_UNKNOWN
+                )
+            } else {
+                it
+            }
+        }
+
+    return sgMovie
+}
+
+/**
+ * Like [toSgMovieForUpdate] and adds values for collection, watchlist, watched status and plays
+ * and sets [SgMovie.lastUpdated] to the current time.
+ */
+fun MovieDetails.toSgMovieForInsert(tmdbId: Int): SgMovie {
+    return toSgMovieForUpdate(tmdbId)
+        .copy(
+            inCollection = isInCollection,
+            inWatchlist = isInWatchlist,
+            plays = plays,
+            watched = isWatched,
+            lastUpdated = System.currentTimeMillis()
+        )
+}
diff --git a/app/src/main/java/com/battlelancer/seriesguide/movies/database/SgMovie.kt b/app/src/main/java/com/battlelancer/seriesguide/movies/database/SgMovie.kt
index 46c7c53826..7acd0a924b 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/movies/database/SgMovie.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/movies/database/SgMovie.kt
@@ -7,6 +7,7 @@ import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.Index
 import androidx.room.PrimaryKey
+import com.battlelancer.seriesguide.movies.database.SgMovie.Companion.RELEASED_MS_UNKNOWN
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.Movies
 import com.battlelancer.seriesguide.provider.SeriesGuideDatabase.Tables
 
@@ -34,6 +35,9 @@ data class SgMovie(
     @ColumnInfo(name = Movies.TITLE_NOARTICLE)
     val titleNoArticle: String? = null,
 
+    /**
+     * A poster path. Needs to be prefixed with the poster server URL.
+     */
     @ColumnInfo(name = Movies.POSTER)
     val poster: String? = null,
 
@@ -43,9 +47,15 @@ data class SgMovie(
     @ColumnInfo(name = Movies.OVERVIEW)
     val overview: String? = null,
 
+    /**
+     * Get safely via [releasedMsOrDefault].
+     */
     @ColumnInfo(name = Movies.RELEASED_UTC_MS)
     val releasedMs: Long? = null,
 
+    /**
+     * Running time of this movie in minutes.
+     */
     @ColumnInfo(name = Movies.RUNTIME_MIN)
     val runtimeMin: Int? = 0,
 
@@ -67,12 +77,29 @@ data class SgMovie(
     @ColumnInfo(name = Movies.WATCHED)
     val watched: Boolean? = false,
 
+    /**
+     * TMDB rating. Encoded as double.
+     * ```
+     * Range:   0.0-10.0
+     * Default: 0.0
+     * ```
+     */
     @ColumnInfo(name = Movies.RATING_TMDB)
     val ratingTmdb: Double? = 0.0,
 
     @ColumnInfo(name = Movies.RATING_VOTES_TMDB)
     val ratingVotesTmdb: Int? = 0,
 
+    /**
+     * **Note**: Due to an oversight, the current database type is INTEGER and not REAL (Int? below
+     * instead of Double?).
+     *
+     * Trakt rating. Encoded as double.
+     * ```
+     * Range:   0.0-10.0
+     * Default: 0.0
+     * ```
+     */
     @ColumnInfo(name = Movies.RATING_TRAKT)
     val ratingTrakt: Int? = 0,
 
@@ -87,11 +114,11 @@ data class SgMovie(
 ) {
 
     /**
-     * If [releasedMs] is not null returns it, otherwise [Long.MAX_VALUE].
-     * See [Movies.RELEASED_UTC_MS].
+     * Release date in milliseconds. [RELEASED_MS_UNKNOWN] if unknown, assuming the true date is
+     * likely in the future (also helps to correctly sort movies by release date).
      */
     val releasedMsOrDefault: Long
-        get() = releasedMs ?: Long.MAX_VALUE
+        get() = releasedMs ?: RELEASED_MS_UNKNOWN
 
     val runtimeMinOrDefault: Int
         get() = runtimeMin ?: 0
@@ -110,4 +137,13 @@ data class SgMovie(
 
     val lastUpdatedOrDefault: Long
         get() = lastUpdated ?: 0
+
+    companion object {
+        /**
+         * If there is no release date, store max value as it is most likely not known, yet. This
+         * will then order this release date after known ones, which is likely expected most of the
+         * time.
+         */
+        const val RELEASED_MS_UNKNOWN = Long.MAX_VALUE
+    }
 }
\ No newline at end of file
diff --git a/app/src/main/java/com/battlelancer/seriesguide/movies/details/MovieDetails.java b/app/src/main/java/com/battlelancer/seriesguide/movies/details/MovieDetails.java
index 28f9b6934d..3ac628e5e8 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/movies/details/MovieDetails.java
+++ b/app/src/main/java/com/battlelancer/seriesguide/movies/details/MovieDetails.java
@@ -5,6 +5,7 @@
 
 import android.content.ContentValues;
 import androidx.annotation.Nullable;
+import com.battlelancer.seriesguide.movies.database.SgMovie;
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.Movies;
 import com.battlelancer.seriesguide.util.DBUtils;
 import com.battlelancer.seriesguide.util.TextTools;
@@ -129,7 +130,7 @@ public ContentValues toContentValuesUpdate() {
             // also helps correctly sorting movies by release date
             Date releaseDate = tmdbMovie.release_date;
             values.put(Movies.RELEASED_UTC_MS,
-                    releaseDate == null ? Long.MAX_VALUE : releaseDate.getTime());
+                    releaseDate == null ? SgMovie.RELEASED_MS_UNKNOWN : releaseDate.getTime());
         }
 
         return values;
diff --git a/app/src/main/java/com/battlelancer/seriesguide/movies/details/MovieDetailsFragment.kt b/app/src/main/java/com/battlelancer/seriesguide/movies/details/MovieDetailsFragment.kt
index 5d0e3386b9..64e4e45abc 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/movies/details/MovieDetailsFragment.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/movies/details/MovieDetailsFragment.kt
@@ -36,6 +36,7 @@ import com.battlelancer.seriesguide.extensions.ActionsHelper
 import com.battlelancer.seriesguide.extensions.ExtensionManager
 import com.battlelancer.seriesguide.extensions.MovieActionsContract
 import com.battlelancer.seriesguide.getSgAppContainer
+import com.battlelancer.seriesguide.lists.ManageListsDialogFragment
 import com.battlelancer.seriesguide.movies.MovieLoader
 import com.battlelancer.seriesguide.movies.MovieLocalizationDialogFragment
 import com.battlelancer.seriesguide.movies.MoviesSettings
@@ -125,6 +126,18 @@ class MovieDetailsFragment : Fragment(), MovieActionsContract {
         // some action buttons
         binding.containerMovieButtons.apply {
             root.isGone = true
+            // Manage lists button
+            buttonMovieManageLists.setOnClickListener {
+                movieDetails?.tmdbMovie()
+                    ?.title
+                    ?.let {
+                        ManageListsDialogFragment.showForMovie(
+                            parentFragmentManager,
+                            tmdbId,
+                            it
+                        )
+                    }
+            }
             // trailer button
             buttonMovieTrailer.apply {
                 setOnClickListener {
diff --git a/app/src/main/java/com/battlelancer/seriesguide/movies/tools/MovieDownloader.kt b/app/src/main/java/com/battlelancer/seriesguide/movies/tools/MovieDownloader.kt
new file mode 100644
index 0000000000..a419bf0569
--- /dev/null
+++ b/app/src/main/java/com/battlelancer/seriesguide/movies/tools/MovieDownloader.kt
@@ -0,0 +1,181 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-FileCopyrightText: Copyright © 2026 Uwe Trottmann <uwe@uwetrottmann.com>
+
+package com.battlelancer.seriesguide.movies.tools
+
+import android.content.Context
+import com.battlelancer.seriesguide.movies.MoviesSettings
+import com.battlelancer.seriesguide.movies.details.MovieDetails
+import com.battlelancer.seriesguide.movies.tools.MovieTools.Companion.updateReleaseDateForRegion
+import com.battlelancer.seriesguide.tmdbapi.TmdbTools4
+import com.battlelancer.seriesguide.tmdbapi.TmdbTools4.TmdbErrorResponse
+import com.battlelancer.seriesguide.tmdbapi.TmdbTools4.TmdbErrorResponse.IsNotFound
+import com.battlelancer.seriesguide.tmdbapi.TmdbTools4.TmdbNonNullResponse.Success
+import com.battlelancer.seriesguide.traktapi.SgTrakt
+import com.battlelancer.seriesguide.traktapi.TraktTools
+import com.battlelancer.seriesguide.util.Errors
+import com.battlelancer.seriesguide.util.TextTools
+import com.uwetrottmann.tmdb2.entities.Movie
+import com.uwetrottmann.tmdb2.services.MoviesService
+import com.uwetrottmann.trakt5.entities.Ratings
+
+/**
+ * Helps download movie details.
+ *
+ * See also [MoviePosterDownloader].
+ */
+class MovieDownloader(
+    private val context: Context,
+    private val tmdbMovies: MoviesService,
+    private val trakt: SgTrakt,
+) {
+
+    data class MovieDetailsResult(
+        val movieDetails: MovieDetails,
+        val isNotFoundOnTmdb: Boolean
+    )
+
+    /**
+     * Download movie data from TMDB and if [getTraktRating] ratings from Trakt.
+     *
+     * Fetching the rating from Trakt requires to look up the Trakt ID first, so skip if not
+     * necessary.
+     */
+    suspend fun getMovieDetails(
+        languageCode: String,
+        regionCode: String,
+        movieTmdbId: Int,
+        getTraktRating: Boolean
+    ): MovieDetailsResult {
+        val details = MovieDetails()
+
+        // Load movie details from TMDB
+        val tmdbResult = getEnhancedMovieFromTmdb(languageCode, regionCode, movieTmdbId)
+        details.tmdbMovie(tmdbResult.movie)
+
+        // Optionally load ratings from Trakt
+        if (tmdbResult.movie != null) {
+            if (getTraktRating) {
+                val movieTraktId = TraktTools.lookupMovieTraktId(trakt, movieTmdbId)
+                if (movieTraktId != null) {
+                    details.traktRatings(loadRatingsFromTrakt(movieTraktId))
+                }
+            }
+        }
+
+        return MovieDetailsResult(details, isNotFoundOnTmdb = tmdbResult.isNotFoundOnTmdb)
+    }
+
+    /**
+     * Like [getMovieDetails], but uses [MoviesSettings.getMoviesLanguage]
+     * and [MoviesSettings.getMoviesRegion].
+     */
+    suspend fun getMovieDetailsWithDefaults(
+        movieTmdbId: Int,
+        getTraktRating: Boolean
+    ): MovieDetailsResult {
+        val languageCode = MoviesSettings.getMoviesLanguage(context)
+        val regionCode = MoviesSettings.getMoviesRegion(context)
+        return getMovieDetails(languageCode, regionCode, movieTmdbId, getTraktRating)
+    }
+
+    private fun loadRatingsFromTrakt(movieTraktId: Int): Ratings? {
+        try {
+            val response = trakt.movies()
+                .ratings(movieTraktId.toString())
+                .execute()
+            if (response.isSuccessful) {
+                return response.body()
+            }
+            Errors.logAndReport("get movie rating", response)
+        } catch (e: Exception) {
+            Errors.logAndReport("get movie rating", e)
+        }
+        return null
+    }
+
+    data class EnhancedTmdbMovieResult(
+        val movie: Movie?,
+        val isNotFoundOnTmdb: Boolean
+    ) {
+        constructor(movie: Movie) : this(movie, false)
+        constructor(isNotFoundOnTmdb: Boolean) : this(null, isNotFoundOnTmdb)
+    }
+
+    /**
+     * Loads movie from TMDB and calls [updateReleaseDateForRegion] using [regionCode] on it.
+     *
+     * If there is no description for the given [languageCode], fetches the default description.
+     * In this case and also if there is no description in the default language, adds a note that
+     * there is no description in that language available.
+     */
+    private suspend fun getEnhancedMovieFromTmdb(
+        languageCode: String,
+        regionCode: String,
+        movieTmdbId: Int
+    ): EnhancedTmdbMovieResult {
+        // Try to get movie details for desired language
+        val movieResult = TmdbTools4.getMovieSummary(
+            tmdbMovies,
+            movieTmdbId,
+            languageCode,
+            includeReleaseDates = true,
+            "get localized movie summary"
+        )
+        when (movieResult) {
+            is Success -> {
+                val movie = movieResult.data
+                updateReleaseDateForRegion(movie, movie.release_dates, regionCode)
+
+                // The title will never be empty, TMDB returns the title in the default language if
+                // there is no translation. However, the overview might be empty if not translated.
+                // So if there is no overview, try to get the default one.
+                if (movie.overview.isNullOrEmpty()) {
+                    movie.overview = getMovieDefaultOverviewFromTmdb(languageCode, movieTmdbId)
+                }
+
+                return EnhancedTmdbMovieResult(movie)
+            }
+
+            is IsNotFound -> {
+                return EnhancedTmdbMovieResult(isNotFoundOnTmdb = true)
+            }
+
+            is TmdbErrorResponse.Other -> {
+                return EnhancedTmdbMovieResult(isNotFoundOnTmdb = false)
+            }
+        }
+    }
+
+    private suspend fun getMovieDefaultOverviewFromTmdb(
+        originalLanguageCode: String,
+        movieTmdbId: Int
+    ): String {
+        // Try with default language if TMDb has no localized overview
+        val fallbackResult = TmdbTools4.getMovieSummary(
+            tmdbMovies,
+            movieTmdbId,
+            language = null,
+            includeReleaseDates = false,
+            "get default movie summary"
+        )
+
+        // Add note about non-translated or non-existing overview
+        var overviewWithNote = TextTools.textNoTranslationMovieLanguage(
+            context, originalLanguageCode,
+            MoviesSettings.getMoviesLanguage(context)
+        )
+
+        // Add default overview
+        if (fallbackResult is Success) {
+            val fallbackMovie = fallbackResult.data
+            val defaultOverview = fallbackMovie.overview
+            if (!defaultOverview.isNullOrEmpty()) {
+                overviewWithNote += "\n\n" + defaultOverview
+            }
+        }
+
+        return overviewWithNote
+    }
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/battlelancer/seriesguide/movies/tools/MoviePosterDownloader.kt b/app/src/main/java/com/battlelancer/seriesguide/movies/tools/MoviePosterDownloader.kt
new file mode 100644
index 0000000000..0a331a5149
--- /dev/null
+++ b/app/src/main/java/com/battlelancer/seriesguide/movies/tools/MoviePosterDownloader.kt
@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-FileCopyrightText: Copyright © 2026 Uwe Trottmann <uwe@uwetrottmann.com>
+
+package com.battlelancer.seriesguide.movies.tools
+
+import android.content.Context
+import com.battlelancer.seriesguide.movies.MoviesSettings
+import com.battlelancer.seriesguide.tmdbapi.TmdbTools4
+import com.battlelancer.seriesguide.tmdbapi.TmdbTools4.TmdbNonNullResponse.Success
+import com.uwetrottmann.tmdb2.services.MoviesService
+
+/**
+ * Helps download movie poster details.
+ *
+ * See also [MovieDownloader].
+ */
+class MoviePosterDownloader(
+    private val context: Context,
+    private val tmdbMovies: MoviesService
+) {
+
+    /**
+     * Downloads movie info for [MoviesSettings.getMoviesLanguage] and returns only the poster path.
+     */
+    suspend fun getMoviePosterPath(movieTmdbId: Int): String? {
+        val languageCode = MoviesSettings.getMoviesLanguage(context)
+        val result = TmdbTools4.getMovieSummary(
+            tmdbMovies,
+            movieTmdbId,
+            languageCode,
+            includeReleaseDates = false,
+            "get movie poster"
+        )
+        return if (result is Success) {
+            result.data.poster_path
+        } else {
+            null
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/battlelancer/seriesguide/movies/tools/MovieTools.kt b/app/src/main/java/com/battlelancer/seriesguide/movies/tools/MovieTools.kt
index 1abd1849c1..b691170705 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/movies/tools/MovieTools.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/movies/tools/MovieTools.kt
@@ -1,78 +1,201 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2014-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2014 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.movies.tools
 
-import android.content.ContentValues
 import android.content.Context
 import com.battlelancer.seriesguide.jobs.FlagJobExecutor
 import com.battlelancer.seriesguide.jobs.movies.MovieCollectionJob
 import com.battlelancer.seriesguide.jobs.movies.MovieWatchedJob
 import com.battlelancer.seriesguide.jobs.movies.MovieWatchlistJob
+import com.battlelancer.seriesguide.lists.database.SgListHelper
 import com.battlelancer.seriesguide.modules.ApplicationContext
 import com.battlelancer.seriesguide.movies.MoviesSettings
+import com.battlelancer.seriesguide.movies.database.MovieHelper
+import com.battlelancer.seriesguide.movies.database.SgMovie
+import com.battlelancer.seriesguide.movies.database.SgMovieFlags
+import com.battlelancer.seriesguide.movies.database.toSgMovieForInsert
 import com.battlelancer.seriesguide.movies.details.MovieDetails
-import com.battlelancer.seriesguide.movies.tools.MovieTools.Lists
+import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItemTypes
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.Movies
 import com.battlelancer.seriesguide.provider.SgRoomDatabase
-import com.battlelancer.seriesguide.tmdbapi.TmdbTools4
-import com.battlelancer.seriesguide.tmdbapi.TmdbTools4.TmdbErrorResponse
-import com.battlelancer.seriesguide.tmdbapi.TmdbTools4.TmdbErrorResponse.IsNotFound
-import com.battlelancer.seriesguide.tmdbapi.TmdbTools4.TmdbNonNullResponse.Success
 import com.battlelancer.seriesguide.traktapi.SgTrakt
 import com.battlelancer.seriesguide.traktapi.TraktSettings
-import com.battlelancer.seriesguide.traktapi.TraktTools
-import com.battlelancer.seriesguide.util.Errors
-import com.battlelancer.seriesguide.util.TextTools
 import com.uwetrottmann.androidutils.AndroidUtils
 import com.uwetrottmann.tmdb2.entities.Movie
 import com.uwetrottmann.tmdb2.entities.ReleaseDate
 import com.uwetrottmann.tmdb2.entities.ReleaseDatesResults
 import com.uwetrottmann.tmdb2.services.MoviesService
-import com.uwetrottmann.trakt5.entities.Ratings
-import dagger.Lazy
 import timber.log.Timber
 import java.text.DateFormat
 import java.util.Date
-import java.util.LinkedList
 import javax.inject.Inject
 
 /**
  * Helps with loading movie details and adding or removing movies from [Lists].
  */
-class MovieTools @Inject constructor(
-    @param:ApplicationContext private val context: Context,
-    private val tmdbMovies: Lazy<MoviesService>,
-    private val trakt: Lazy<SgTrakt>
+class MovieTools(
+    private val context: Context,
+    private val databaseHelper: MovieHelper,
+    private val listHelper: SgListHelper,
+    val downloader: MovieDownloader
 ) {
 
+    @Inject
+    constructor(
+        @ApplicationContext context: Context,
+        tmdbMovies: MoviesService,
+        trakt: SgTrakt
+    ) : this(
+        context,
+        SgRoomDatabase.getInstance(context).movieHelper(),
+        SgRoomDatabase.getInstance(context).sgListHelper(),
+        MovieDownloader(context, tmdbMovies, trakt)
+    )
+
     enum class Lists {
         COLLECTION,
         WATCHLIST,
         WATCHED
     }
 
+    /**
+     * If the movie is no longer on a custom or built-in list, deletes it from the database.
+     * If it is on a custom list and isn't already in the database, adds it.
+     *
+     * Returns false if a database or network operation failed.
+     *
+     * @see addToList
+     */
+    suspend fun addToOrDeleteFromDatabaseAfterCustomListChange(movieTmdbId: Int): Boolean {
+        if (isMovieNotOnCustomList(movieTmdbId)) {
+            // Movie is no longer on a custom list, but maybe still on a built-in list?
+            val movieFlags = databaseHelper.getMovieFlags(movieTmdbId)
+                ?: return true // Already deleted from database (like by a concurrent sync)
+
+            return if (movieFlags.isNotOnBuiltInList()) {
+                deleteMovie(movieTmdbId)
+            } else {
+                true // Movie still on built-in list, don't delete
+            }
+        } else {
+            // Movie was added to at least one custom list
+            return if (isMovieInDatabase(movieTmdbId)) {
+                true // Movie already in database, nothing to do
+            } else {
+                addMovie(movieTmdbId, null)
+            }
+        }
+    }
+
+    /**
+     * Adds any movies that are on a custom list, but not in the database. Deletes any movies from
+     * the database that are not on any built-in or custom list.
+     */
+    suspend fun updateDatabaseAfterCustomListChange(): Boolean {
+        var hasError = false
+
+        // Get all movies on custom lists, but not in the database and add them
+        val moviesToAdd = listHelper.getTmdbIdsOfMovieListItemsNotInDatabase()
+        for (movieTmdbId in moviesToAdd) {
+            val success = addMovie(movieTmdbId, null)
+            if (!success) {
+                hasError = true
+                Timber.e("Failed to add movie on custom list to database: tmdbId = %s", movieTmdbId)
+            }
+        }
+
+        // Get all movies not on a built-in list and if they are not on a custom list, delete them
+        val moviesToDelete = databaseHelper.getTmdbIdsOfMoviesNotOnAnyList()
+        databaseHelper.deleteMovies(moviesToDelete)
+
+        return !hasError
+    }
+
     /**
      * Adds the movie to the given list. If it was not in any list before, adds the movie to the
      * local database first. Returns if the database operation was successful.
+     *
+     * @see addToOrDeleteFromDatabaseAfterCustomListChange
      */
     suspend fun addToList(movieTmdbId: Int, list: Lists): Boolean {
         val movieExists = isMovieInDatabase(movieTmdbId)
         return if (movieExists) {
-            updateMovie(context, movieTmdbId, list, true)
+            updateMovie(movieTmdbId, list, true)
         } else {
             addMovie(movieTmdbId, list)
         }
     }
 
-    private fun isMovieInDatabase(movieTmdbId: Int): Boolean {
-        val count = SgRoomDatabase.getInstance(context).movieHelper().getCount(movieTmdbId)
-        return count > 0
+    /**
+     * Removes the movie from [listToRemoveFrom] or if the movie wouldn't be on any built-in or
+     * custom list after removing it, deletes it from the database instead.
+     *
+     * @return If the database operation was successful.
+     */
+    fun removeFromList(movieTmdbId: Int, listToRemoveFrom: Lists): Boolean {
+        val movieFlags = databaseHelper.getMovieFlags(movieTmdbId)
+            ?: return false // query failed
+
+        val newMovieFlags = when (listToRemoveFrom) {
+            Lists.COLLECTION -> movieFlags.copy(inCollection = false)
+            Lists.WATCHLIST -> movieFlags.copy(inWatchlist = false)
+            Lists.WATCHED -> movieFlags.copy(watched = false)
+        }
+
+        return if (newMovieFlags.isNotOnBuiltInList() && isMovieNotOnCustomList(movieTmdbId)) {
+            deleteMovie(movieTmdbId)
+        } else {
+            // otherwise, just update
+            updateMovie(movieTmdbId, listToRemoveFrom, false)
+        }
     }
 
-    private suspend fun addMovie(movieTmdbId: Int, listToAddTo: Lists): Boolean {
+    private fun SgMovieFlags.isNotOnBuiltInList(): Boolean =
+        !inWatchlist && !inCollection && !watched
+
+    private fun isMovieNotOnCustomList(movieTmdbId: Int): Boolean =
+        listHelper
+            .getListItemsWithTmdbIdCount(movieTmdbId, ListItemTypes.TMDB_MOVIE) == 0
+
+    private fun isMovieInDatabase(movieTmdbId: Int): Boolean =
+        databaseHelper.getCount(movieTmdbId) > 0
+
+    /**
+     * Returns `true` if the movie was updated.
+     */
+    private fun updateMovie(
+        movieTmdbId: Int,
+        list: Lists,
+        value: Boolean
+    ): Boolean {
+        val rowsUpdated = when (list) {
+            Lists.COLLECTION -> databaseHelper.updateInCollection(movieTmdbId, value)
+
+            Lists.WATCHLIST -> databaseHelper.updateInWatchlist(movieTmdbId, value)
+
+            Lists.WATCHED -> if (value) {
+                databaseHelper.setWatchedAndAddPlay(movieTmdbId)
+            } else {
+                databaseHelper.setNotWatchedAndRemovePlays(movieTmdbId)
+            }
+        }
+
+        return rowsUpdated > 0
+    }
+
+    /**
+     * Returns `true` if the movie was deleted.
+     */
+    private fun deleteMovie(movieTmdbId: Int): Boolean {
+        val rowsDeleted = databaseHelper.deleteMovie(movieTmdbId)
+        Timber.d("deleteMovie: deleted %s movies", rowsDeleted)
+        return rowsDeleted > 0
+    }
+
+    private suspend fun addMovie(movieTmdbId: Int, listToAddTo: Lists?): Boolean {
         // get movie info
-        val details = getMovieDetailsWithDefaults(movieTmdbId, false).movieDetails
+        val details = downloader.getMovieDetailsWithDefaults(movieTmdbId, false).movieDetails
         if (details.tmdbMovie() == null) {
             // abort if minimal data failed to load
             return false
@@ -84,10 +207,10 @@ class MovieTools @Inject constructor(
         val isWatched = listToAddTo == Lists.WATCHED
         details.isWatched = isWatched
         details.plays = if (isWatched) 1 else 0
-        val values = details.toContentValuesInsert()
 
         // add to database
-        context.contentResolver.insert(Movies.CONTENT_URI, values)
+        val sgMovie = details.toSgMovieForInsert(movieTmdbId)
+        databaseHelper.insertMovie(sgMovie)
 
         // ensure ratings for new movie are downloaded on next sync
         TraktSettings.resetMoviesLastRatedAt(context)
@@ -136,7 +259,7 @@ class MovieTools @Inject constructor(
 
         val languageCode = MoviesSettings.getMoviesLanguage(context)
         val regionCode = MoviesSettings.getMoviesRegion(context)
-        val movies: MutableList<MovieDetails> = LinkedList()
+        val moviesToInsert = mutableListOf<SgMovie>()
 
         // loop through ids
         val iterator: Iterator<Int> = newMovies.iterator()
@@ -148,7 +271,7 @@ class MovieTools @Inject constructor(
             }
 
             // download movie data
-            val result = getMovieDetails(languageCode, regionCode, tmdbId, false)
+            val result = downloader.getMovieDetails(languageCode, regionCode, tmdbId, false)
             if (result.isNotFoundOnTmdb) {
                 Timber.w("addMovies: movie with TMDB ID %s not found, skipping", tmdbId)
                 continue
@@ -168,198 +291,25 @@ class MovieTools @Inject constructor(
             val plays = newWatchedMoviesToPlays[tmdbId]
             val isWatched = plays != null
             movieDetails.isWatched = isWatched
-            movieDetails.plays = (if (isWatched) plays else 0)!!
+            movieDetails.plays = (if (isWatched) plays else 0)
 
-            movies.add(movieDetails)
+            moviesToInsert.add(movieDetails.toSgMovieForInsert(tmdbId))
 
             // Already add to the database if we have 10 movies so UI can already update.
-            if (movies.size == 10) {
-                context.contentResolver.bulkInsert(
-                    Movies.CONTENT_URI,
-                    buildMoviesContentValues(movies)
-                )
-                movies.clear() // Start a new batch.
+            if (moviesToInsert.size == 10) {
+                databaseHelper.insertMovies(moviesToInsert)
+                moviesToInsert.clear() // Start a new batch.
             }
         }
 
         // Insert remaining new movies into the database.
-        if (movies.isNotEmpty()) {
-            context.contentResolver.bulkInsert(
-                Movies.CONTENT_URI,
-                buildMoviesContentValues(movies)
-            )
+        if (moviesToInsert.isNotEmpty()) {
+            databaseHelper.insertMovies(moviesToInsert)
         }
 
         return true
     }
 
-    data class MovieDetailsResult(
-        val movieDetails: MovieDetails,
-        val isNotFoundOnTmdb: Boolean
-    )
-
-    /**
-     * Download movie data from TMDB and if [getTraktRating] ratings from Trakt.
-     *
-     * Fetching the rating from Trakt requires to look up the Trakt ID first, so skip if not
-     * necessary.
-     */
-    suspend fun getMovieDetails(
-        languageCode: String,
-        regionCode: String,
-        movieTmdbId: Int,
-        getTraktRating: Boolean
-    ): MovieDetailsResult {
-        val details = MovieDetails()
-
-        // Load movie details from TMDB
-        val tmdbResult = getEnhancedMovieFromTmdb(languageCode, regionCode, movieTmdbId)
-        details.tmdbMovie(tmdbResult.movie)
-
-        // Optionally load ratings from Trakt
-        if (tmdbResult.movie != null) {
-            if (getTraktRating) {
-                val movieTraktId = TraktTools.lookupMovieTraktId(trakt.get(), movieTmdbId)
-                if (movieTraktId != null) {
-                    details.traktRatings(loadRatingsFromTrakt(movieTraktId))
-                }
-            }
-        }
-
-        return MovieDetailsResult(details, isNotFoundOnTmdb = tmdbResult.isNotFoundOnTmdb)
-    }
-
-    /**
-     * Like [getMovieDetails], but uses [MoviesSettings.getMoviesLanguage]
-     * and [MoviesSettings.getMoviesRegion].
-     */
-    suspend fun getMovieDetailsWithDefaults(
-        movieTmdbId: Int,
-        getTraktRating: Boolean
-    ): MovieDetailsResult {
-        val languageCode = MoviesSettings.getMoviesLanguage(context)
-        val regionCode = MoviesSettings.getMoviesRegion(context)
-        return getMovieDetails(languageCode, regionCode, movieTmdbId, getTraktRating)
-    }
-
-    private fun loadRatingsFromTrakt(movieTraktId: Int): Ratings? {
-        try {
-            val response = trakt.get().movies()
-                .ratings(movieTraktId.toString())
-                .execute()
-            if (response.isSuccessful) {
-                return response.body()
-            }
-            Errors.logAndReport("get movie rating", response)
-        } catch (e: Exception) {
-            Errors.logAndReport("get movie rating", e)
-        }
-        return null
-    }
-
-    data class EnhancedTmdbMovieResult(
-        val movie: Movie?,
-        val isNotFoundOnTmdb: Boolean
-    ) {
-        constructor(movie: Movie) : this(movie, false)
-        constructor(isNotFoundOnTmdb: Boolean) : this(null, isNotFoundOnTmdb)
-    }
-
-    /**
-     * Loads movie from TMDB and calls [updateReleaseDateForRegion] using [regionCode] on it.
-     *
-     * If there is no description for the given [languageCode], fetches the default description.
-     * In this case and also if there is no description in the default language, adds a note that
-     * there is no description in that language available.
-     */
-    private suspend fun getEnhancedMovieFromTmdb(
-        languageCode: String,
-        regionCode: String,
-        movieTmdbId: Int
-    ): EnhancedTmdbMovieResult {
-        // Try to get movie details for desired language
-        val movieResult = TmdbTools4.getMovieSummary(
-            tmdbMovies.get(),
-            movieTmdbId,
-            languageCode,
-            includeReleaseDates = true,
-            "get localized movie summary"
-        )
-        when (movieResult) {
-            is Success -> {
-                val movie = movieResult.data
-                updateReleaseDateForRegion(movie, movie.release_dates, regionCode)
-
-                // The title will never be empty, TMDB returns the title in the default language if
-                // there is no translation. However, the overview might be empty if not translated.
-                // So if there is no overview, try to get the default one.
-                if (movie.overview.isNullOrEmpty()) {
-                    movie.overview = getMovieDefaultOverviewFromTmdb(languageCode, movieTmdbId)
-                }
-
-                return EnhancedTmdbMovieResult(movie)
-            }
-
-            is IsNotFound -> {
-                return EnhancedTmdbMovieResult(isNotFoundOnTmdb = true)
-            }
-
-            is TmdbErrorResponse.Other -> {
-                return EnhancedTmdbMovieResult(isNotFoundOnTmdb = false)
-            }
-        }
-    }
-
-    private suspend fun getMovieDefaultOverviewFromTmdb(
-        originalLanguageCode: String,
-        movieTmdbId: Int
-    ): String {
-        // Try with default language if TMDb has no localized overview
-        val fallbackResult = TmdbTools4.getMovieSummary(
-            tmdbMovies.get(),
-            movieTmdbId,
-            language = null,
-            includeReleaseDates = false,
-            "get default movie summary"
-        )
-
-        // Add note about non-translated or non-existing overview
-        var overviewWithNote = TextTools.textNoTranslationMovieLanguage(
-            context, originalLanguageCode,
-            MoviesSettings.getMoviesLanguage(context)
-        )
-
-        // Add default overview
-        if (fallbackResult is Success) {
-            val fallbackMovie = fallbackResult.data
-            val defaultOverview = fallbackMovie.overview
-            if (!defaultOverview.isNullOrEmpty()) {
-                overviewWithNote += "\n\n" + defaultOverview
-            }
-        }
-
-        return overviewWithNote
-    }
-
-    /**
-     * Downloads movie info for [MoviesSettings.getMoviesLanguage] and returns only the poster path.
-     */
-    suspend fun getMoviePosterPath(movieTmdbId: Int): String? {
-        val languageCode = MoviesSettings.getMoviesLanguage(context)
-        val result = TmdbTools4.getMovieSummary(
-            tmdbMovies.get(),
-            movieTmdbId,
-            languageCode,
-            includeReleaseDates = false,
-            "get movie poster"
-        )
-        return if (result is Success) {
-            result.data.poster_path
-        } else {
-            null
-        }
-    }
-
     companion object {
 
         /**
@@ -375,7 +325,7 @@ class MovieTools @Inject constructor(
          * [Movies.RELEASED_UTC_MS].
          */
         fun movieReleaseDateFrom(releaseDateMs: Long): Date? {
-            return if (releaseDateMs == Long.MAX_VALUE) null else Date(releaseDateMs)
+            return if (releaseDateMs == SgMovie.RELEASED_MS_UNKNOWN) null else Date(releaseDateMs)
         }
 
         /**
@@ -417,19 +367,6 @@ class MovieTools @Inject constructor(
             }
         }
 
-        /**
-         * Deletes all movies which are not watched and not in any list.
-         */
-        fun deleteUnusedMovies(context: Context) {
-            val rowsDeleted = context.contentResolver
-                .delete(
-                    Movies.CONTENT_URI,
-                    "${Movies.SELECTION_UNWATCHED} AND ${Movies.SELECTION_NOT_COLLECTION} AND ${Movies.SELECTION_NOT_WATCHLIST}",
-                    null
-                )
-            Timber.d("deleteUnusedMovies: removed %s movies", rowsDeleted)
-        }
-
         fun addToCollection(context: Context, movieTmdbId: Int) {
             FlagJobExecutor.execute(context, MovieCollectionJob(movieTmdbId, true))
         }
@@ -446,38 +383,6 @@ class MovieTools @Inject constructor(
             FlagJobExecutor.execute(context, MovieWatchlistJob(movieTmdbId, false))
         }
 
-        /**
-         * Removes the movie from the given list.
-         *
-         * If it would not be on any list afterwards, deletes the movie from the local database.
-         *
-         * @return If the database operation was successful.
-         */
-        fun removeFromList(context: Context, movieTmdbId: Int, listToRemoveFrom: Lists): Boolean {
-            val movieFlags = SgRoomDatabase.getInstance(context).movieHelper()
-                .getMovieFlags(movieTmdbId)
-            if (movieFlags == null) {
-                return false // query failed
-            }
-
-            var removeMovie = false
-            if (listToRemoveFrom == Lists.COLLECTION) {
-                removeMovie = !movieFlags.inWatchlist && !movieFlags.watched
-            } else if (listToRemoveFrom == Lists.WATCHLIST) {
-                removeMovie = !movieFlags.inCollection && !movieFlags.watched
-            } else if (listToRemoveFrom == Lists.WATCHED) {
-                removeMovie = !movieFlags.inCollection && !movieFlags.inWatchlist
-            }
-
-            // if movie will not be in any list, remove it completely
-            return if (removeMovie) {
-                deleteMovie(context, movieTmdbId)
-            } else {
-                // otherwise, just update
-                updateMovie(context, movieTmdbId, listToRemoveFrom, false)
-            }
-        }
-
         fun watchedMovie(
             context: Context,
             movieTmdbId: Int,
@@ -499,10 +404,6 @@ class MovieTools @Inject constructor(
             FlagJobExecutor.execute(context, MovieWatchedJob(movieTmdbId, false, 0))
         }
 
-        private fun buildMoviesContentValues(movies: List<MovieDetails>): Array<ContentValues> {
-            return movies.map { it.toContentValuesInsert() }.toTypedArray()
-        }
-
         /**
          * Returns a set of the TMDb ids of all movies in the local database.
          *
@@ -529,47 +430,5 @@ class MovieTools @Inject constructor(
             return localMoviesIds
         }
 
-        /**
-         * Returns `true` if the movie was updated.
-         */
-        private fun updateMovie(
-            context: Context,
-            movieTmdbId: Int,
-            list: Lists,
-            value: Boolean
-        ): Boolean {
-            val helper = SgRoomDatabase.getInstance(context).movieHelper()
-
-            val rowsUpdated = when (list) {
-                Lists.COLLECTION -> helper.updateInCollection(movieTmdbId, value)
-
-                Lists.WATCHLIST -> helper.updateInWatchlist(movieTmdbId, value)
-
-                Lists.WATCHED -> if (value) {
-                    helper.setWatchedAndAddPlay(movieTmdbId)
-                } else {
-                    helper.setNotWatchedAndRemovePlays(movieTmdbId)
-                }
-            }
-
-            // As some movie lists still use the old ContentProvider, notify the movie URI.
-            context.contentResolver.notifyChange(Movies.CONTENT_URI, null)
-
-            return rowsUpdated > 0
-        }
-
-        /**
-         * Returns `true` if the movie was deleted.
-         */
-        private fun deleteMovie(context: Context, movieTmdbId: Int): Boolean {
-            val rowsDeleted = SgRoomDatabase.getInstance(context).movieHelper()
-                .deleteMovie(movieTmdbId)
-            Timber.d("deleteMovie: deleted %s movies", rowsDeleted)
-
-            // As some movie lists still use the old ContentProvider, notify the movie URI.
-            context.contentResolver.notifyChange(Movies.CONTENT_URI, null)
-
-            return rowsDeleted > 0
-        }
     }
 }
diff --git a/app/src/main/java/com/battlelancer/seriesguide/notifications/NotificationService.kt b/app/src/main/java/com/battlelancer/seriesguide/notifications/NotificationService.kt
index da2bc64d01..a15287ebc8 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/notifications/NotificationService.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/notifications/NotificationService.kt
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2012-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2012 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.notifications
 
@@ -29,7 +29,6 @@ import com.battlelancer.seriesguide.billing.BillingTools
 import com.battlelancer.seriesguide.notifications.NotificationService.Companion.ORDER
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.SgEpisode2Columns
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.SgShow2Columns
-import com.battlelancer.seriesguide.provider.SeriesGuideDatabase
 import com.battlelancer.seriesguide.provider.SgRoomDatabase.Companion.getInstance
 import com.battlelancer.seriesguide.settings.DisplaySettings
 import com.battlelancer.seriesguide.settings.DisplaySettings.isHidingSpecials
@@ -291,7 +290,7 @@ class NotificationService(context: Context) {
             selection.append(" AND (")
                 .append(SgShow2Columns.NEXTEPISODE + "=''")
                 .append(" OR ")
-                .append(SgShow2Columns.NEXTEPISODE + "=" + SeriesGuideDatabase.Qualified.SG_EPISODE_ID)
+                .append(SgShow2Columns.NEXTEPISODE + "=" + SgEpisode2WithShow.SG_EPISODE_ID)
                 .append(")")
         }
 
diff --git a/app/src/main/java/com/battlelancer/seriesguide/provider/SeriesGuideContract.java b/app/src/main/java/com/battlelancer/seriesguide/provider/SeriesGuideContract.java
index 340b0e8a11..25d41e7a97 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/provider/SeriesGuideContract.java
+++ b/app/src/main/java/com/battlelancer/seriesguide/provider/SeriesGuideContract.java
@@ -10,12 +10,13 @@
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import com.battlelancer.seriesguide.SgApp;
+import com.battlelancer.seriesguide.movies.database.SgMovie;
 import com.battlelancer.seriesguide.shows.database.SgEpisode2;
 import com.battlelancer.seriesguide.shows.database.SgShow2;
 import com.battlelancer.seriesguide.shows.episodes.EpisodeFlags;
+import com.battlelancer.seriesguide.shows.tools.NextEpisodeUpdater;
 import com.battlelancer.seriesguide.shows.tools.ShowStatus;
 import com.battlelancer.seriesguide.shows.tools.ShowTools2;
-import com.battlelancer.seriesguide.shows.tools.NextEpisodeUpdater;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 
@@ -488,7 +489,7 @@ public interface SgShow2Columns extends BaseColumns {
          */
         String POSTER = "series_poster";
         /**
-         * Path to a small variant of the poster. Needs to be prefixed with the poster server URL.
+         * See {@link SgShow2#getPosterSmall()}.
          */
         String POSTER_SMALL = "series_poster_small";
 
@@ -499,6 +500,9 @@ public interface SgShow2Columns extends BaseColumns {
          */
         String STATUS = "series_status";
 
+        /**
+         * See {@link SgShow2#getRuntime()}.
+         */
         String RUNTIME = "series_runtime";
 
         /** See {@link SgShow2#getRatingTmdb()}. */
@@ -532,12 +536,7 @@ public interface SgShow2Columns extends BaseColumns {
         String FIRST_RELEASE = "series_firstaired";
 
         /**
-         * Local release time. Encoded as integer (hhmm).
-         *
-         * <pre>
-         * Example: 2035
-         * Default: -1
-         * </pre>
+         * See {@link SgShow2#getReleaseTime()}.
          */
         String RELEASE_TIME = "series_airstime";
 
@@ -941,7 +940,8 @@ interface ListItemsColumns {
             ListItemTypes.TVDB_SHOW,
             ListItemTypes.SEASON,
             ListItemTypes.EPISODE,
-            ListItemTypes.TMDB_SHOW
+            ListItemTypes.TMDB_SHOW,
+            ListItemTypes.TMDB_MOVIE
     })
     public @interface ListItemTypes {
         int TVDB_SHOW = 1;
@@ -954,9 +954,10 @@ interface ListItemsColumns {
          */
         int EPISODE = 3;
         int TMDB_SHOW = 4;
+        int TMDB_MOVIE = 5;
     }
 
-    interface MoviesColumns {
+    public interface MoviesColumns {
 
         String TITLE = "movies_title";
 
@@ -969,6 +970,9 @@ interface MoviesColumns {
 
         String TMDB_ID = "movies_tmdbid";
 
+        /**
+         * See {@link SgMovie#getPoster()}.
+         */
         String POSTER = "movies_poster";
 
         String GENRES = "movies_genres";
@@ -976,11 +980,13 @@ interface MoviesColumns {
         String OVERVIEW = "movies_overview";
 
         /**
-         * Release date in milliseconds. Store Long.MAX if unknown, as it is likely in the future
-         * (also helps correctly sorting movies by release date).
+         * See {@link SgMovie#getReleasedMsOrDefault()}.
          */
         String RELEASED_UTC_MS = "movies_released";
 
+        /**
+         * See {@link SgMovie#getRuntimeMin()}.
+         */
         String RUNTIME_MIN = "movies_runtime";
 
         String TRAILER = "movies_trailer";
@@ -1062,8 +1068,6 @@ interface JobsColumns {
 
     public static final String PATH_LIST_ITEMS = "listitems";
 
-    public static final String PATH_WITH_DETAILS = "with_details";
-
     public static final String PATH_MOVIES = "movies";
 
     public static final String PATH_JOBS = "jobs";
@@ -1135,14 +1139,6 @@ public static class ListItems implements ListItemsColumns, BaseColumns {
                 .appendPath(PATH_LIST_ITEMS)
                 .build();
 
-        /**
-         * List items table joined with shows, seasons and episodes table (depending on list item
-         * type). See {@link SeriesGuideProvider#LIST_ITEMS_WITH_DETAILS}.
-         */
-        public static final Uri CONTENT_WITH_DETAILS_URI = CONTENT_URI.buildUpon()
-                .appendPath(PATH_WITH_DETAILS)
-                .build();
-
         /**
          * Use if multiple items get returned
          */
@@ -1155,16 +1151,6 @@ public static class ListItems implements ListItemsColumns, BaseColumns {
                 = "vnd.android.cursor.item/vnd.seriesguide.listitem";
 
         public static final String SELECTION_LIST = Lists.LIST_ID + "=?";
-        public static final String SELECTION_TVDB_SHOWS =
-                ListItems.TYPE + "=" + ListItemTypes.TVDB_SHOW;
-        public static final String SELECTION_TMDB_SHOWS =
-                ListItems.TYPE + "=" + ListItemTypes.TMDB_SHOW;
-        public static final String SELECTION_SEASONS =
-                ListItems.TYPE + "=" + ListItemTypes.SEASON;
-        public static final String SELECTION_EPISODES =
-                ListItems.TYPE + "=" + ListItemTypes.EPISODE;
-
-        public static final String SORT_TYPE = ListItems.TYPE + " ASC";
 
         public static Uri buildListItemUri(String id) {
             return CONTENT_URI.buildUpon().appendPath(id).build();
@@ -1202,7 +1188,8 @@ public static boolean isValidItemType(int type) {
             return type == ListItemTypes.TVDB_SHOW
                     || type == ListItemTypes.SEASON
                     || type == ListItemTypes.EPISODE
-                    || type == ListItemTypes.TMDB_SHOW;
+                    || type == ListItemTypes.TMDB_SHOW
+                    || type == ListItemTypes.TMDB_MOVIE;
         }
     }
 
@@ -1219,14 +1206,9 @@ public static class Movies implements MoviesColumns, BaseColumns {
 
         public static final String SELECTION_COLLECTION = Movies.IN_COLLECTION + "=1";
 
-        public static final String SELECTION_NOT_COLLECTION = Movies.IN_COLLECTION + "=0";
-
         public static final String SELECTION_WATCHLIST = Movies.IN_WATCHLIST + "=1";
 
-        public static final String SELECTION_NOT_WATCHLIST = Movies.IN_WATCHLIST + "=0";
-
         public static final String SELECTION_WATCHED = Movies.WATCHED + "=1";
-        public static final String SELECTION_UNWATCHED = Movies.WATCHED + "=0";
 
         // Android provides the UNICODE collator,
         // use to correctly order characters with e.g. accents.
diff --git a/app/src/main/java/com/battlelancer/seriesguide/provider/SeriesGuideDatabase.java b/app/src/main/java/com/battlelancer/seriesguide/provider/SeriesGuideDatabase.java
index e48ea7bec2..7054819e1e 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/provider/SeriesGuideDatabase.java
+++ b/app/src/main/java/com/battlelancer/seriesguide/provider/SeriesGuideDatabase.java
@@ -4,7 +4,6 @@
 package com.battlelancer.seriesguide.provider;
 
 import static com.battlelancer.seriesguide.provider.SeriesGuideContract.ActivityColumns;
-import static com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItems;
 
 import android.content.Context;
 import android.database.Cursor;
@@ -14,7 +13,6 @@
 import androidx.annotation.NonNull;
 import androidx.annotation.VisibleForTesting;
 import androidx.sqlite.db.SupportSQLiteDatabase;
-import com.battlelancer.seriesguide.lists.database.SgListItemWithDetails;
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.Episodes;
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.EpisodesColumns;
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.JobsColumns;
@@ -24,14 +22,17 @@
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.MoviesColumns;
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.SeasonsColumns;
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.SgEpisode2Columns;
-import com.battlelancer.seriesguide.provider.SeriesGuideContract.SgSeason2Columns;
-import com.battlelancer.seriesguide.provider.SeriesGuideContract.SgShow2Columns;
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.Shows;
 import com.battlelancer.seriesguide.provider.SeriesGuideContract.ShowsColumns;
 import com.battlelancer.seriesguide.shows.database.SgShow2;
 import com.battlelancer.seriesguide.util.DBUtils;
 import timber.log.Timber;
 
+/**
+ * Database helper class. Most database related code has moved to {@link SgRoomDatabase} and helper
+ * classes for each table. This remains in addition to {@link SeriesGuideContract} to maintain a
+ * global reference to tables (and some legacy database code).
+ */
 public class SeriesGuideDatabase {
 
     public static final String DATABASE_NAME = "seriesdatabase";
@@ -135,23 +136,12 @@ public class SeriesGuideDatabase {
      */
     public static final int DBVER_42_JOBS = 42;
 
-    public static final int DATABASE_VERSION = DBVER_42_JOBS;
-
     /**
-     * Qualifies column names by prefixing their {@link Tables} name.
+     * This has been replaced by {@link SgRoomDatabase#VERSION}.
+     * <p>
+     * Kept for reference to the last non-Room database version.
      */
-    public interface Qualified {
-
-        String SHOWS_ID = Tables.SHOWS + "." + Shows._ID;
-        String SHOWS_LAST_EPISODE = Tables.SHOWS + "." + Shows.LASTWATCHEDID;
-        String SHOWS_NEXT_EPISODE = Tables.SHOWS + "." + Shows.NEXTEPISODE;
-        String EPISODES_ID = Tables.EPISODES + "." + Episodes._ID;
-        String EPISODES_SHOW_ID = Tables.EPISODES + "." + Shows.REF_SHOW_ID;
-        String LIST_ITEMS_REF_ID = Tables.LIST_ITEMS + "." + ListItems.ITEM_REF_ID;
-
-        String SG_SHOW_ID = Tables.SG_SHOW + "." + SgShow2Columns._ID;
-        String SG_EPISODE_ID = Tables.SG_EPISODE + "." + SgEpisode2Columns._ID;
-    }
+    public static final int DATABASE_VERSION = DBVER_42_JOBS;
 
     public interface Tables {
 
@@ -165,63 +155,12 @@ public interface Tables {
         String SG_SEASON = "sg_season";
         String SG_EPISODE = "sg_episode";
 
-        String SHOWS_JOIN_EPISODES_ON_LAST_EPISODE = SHOWS + " LEFT OUTER JOIN " + EPISODES
-                + " ON " + Qualified.SHOWS_LAST_EPISODE + "=" + Qualified.EPISODES_ID;
-
-        String SHOWS_JOIN_EPISODES_ON_NEXT_EPISODE = SHOWS + " LEFT OUTER JOIN " + EPISODES
-                + " ON " + Qualified.SHOWS_NEXT_EPISODE + "=" + Qualified.EPISODES_ID;
-
-        String EPISODES_JOIN_SHOWS = EPISODES + " LEFT OUTER JOIN " + SHOWS
-                + " ON " + Qualified.EPISODES_SHOW_ID + "=" + Qualified.SHOWS_ID;
-
         String EPISODES_SEARCH = "searchtable";
 
         String LISTS = "lists";
 
         String LIST_ITEMS = "listitems";
 
-        String SG_SEASON_JOIN_SG_SHOW = SG_SEASON + " LEFT OUTER JOIN " + SG_SHOW
-                + " ON " + Tables.SG_SEASON + "." + SgShow2Columns.REF_SHOW_ID
-                + "=" + Qualified.SG_SHOW_ID;
-        String SG_EPISODE_JOIN_SG_SHOW = SG_EPISODE + " LEFT OUTER JOIN " + SG_SHOW
-                + " ON " + Tables.SG_EPISODE + "." + SgShow2Columns.REF_SHOW_ID
-                + "=" + Qualified.SG_SHOW_ID;
-
-        /**
-         * Compare with {@link SgListItemWithDetails}.
-         */
-        String LIST_ITEMS_WITH_DETAILS = "("
-                // new TMDB shows
-                + ItemsQuery.SELECT_ITEMS_AND_SHOWS_COLUMNS + " FROM "
-                + "("
-                + ItemsQuery.SELECT_TMDB_SHOWS
-                + " LEFT OUTER JOIN " + Tables.SG_SHOW
-                + " ON " + Qualified.LIST_ITEMS_REF_ID + "=" + SgShow2Columns.TMDB_ID
-                + ")"
-                // legacy TVDB shows
-                + " UNION " + ItemsQuery.SELECT_ITEMS_AND_SHOWS_COLUMNS + " FROM "
-                + "("
-                + ItemsQuery.SELECT_TVDB_SHOWS
-                + " LEFT OUTER JOIN " + Tables.SG_SHOW
-                + " ON " + Qualified.LIST_ITEMS_REF_ID + "=" + SgShow2Columns.TVDB_ID
-                + ")"
-                // legacy TVDB seasons
-                + " UNION " + ItemsQuery.SELECT_ITEMS_AND_SHOWS_COLUMNS + " FROM "
-                + "("
-                + ItemsQuery.SELECT_TVDB_SEASONS
-                + " LEFT OUTER JOIN " + "(" + SG_SEASON_JOIN_SG_SHOW + ") AS " + Tables.SG_SEASON
-                + " ON " + Qualified.LIST_ITEMS_REF_ID + "=" + SgSeason2Columns.TVDB_ID
-                + ")"
-                // legacy TVDB episodes
-                + " UNION " + ItemsQuery.SELECT_ITEMS_AND_SHOWS_COLUMNS + " FROM "
-                + "("
-                + ItemsQuery.SELECT_TVDB_EPISODES
-                + " LEFT OUTER JOIN " + "(" + SG_EPISODE_JOIN_SG_SHOW + ") AS " + Tables.SG_EPISODE
-                + " ON " + Qualified.LIST_ITEMS_REF_ID + "=" + SgEpisode2Columns.TVDB_ID
-                + ")"
-                //
-                + ")";
-
         String MOVIES = "movies";
 
         String ACTIVITY = "activity";
@@ -229,56 +168,6 @@ public interface Tables {
         String JOBS = "jobs";
     }
 
-    private interface ItemsQuery {
-
-        String ITEMS_COLUMNS = ListItems.LIST_ITEM_ID + ","
-                + Lists.LIST_ID + ","
-                + ListItems.TYPE + ","
-                + ListItems.ITEM_REF_ID;
-
-        String SELECT_LIST_ITEMS_MAP_ROW_ID = "SELECT " + ListItems._ID + " as item_row_id,"
-                + ITEMS_COLUMNS
-                + " FROM " + Tables.LIST_ITEMS;
-
-        String SELECT_TMDB_SHOWS = "(" + SELECT_LIST_ITEMS_MAP_ROW_ID
-                + " WHERE " + ListItems.SELECTION_TMDB_SHOWS + ")"
-                + " AS " + Tables.LIST_ITEMS;
-
-        String SELECT_TVDB_SHOWS = "(" + SELECT_LIST_ITEMS_MAP_ROW_ID
-                + " WHERE " + ListItems.SELECTION_TVDB_SHOWS + ")"
-                + " AS " + Tables.LIST_ITEMS;
-
-        String SELECT_TVDB_SEASONS = "(" + SELECT_LIST_ITEMS_MAP_ROW_ID
-                + " WHERE " + ListItems.SELECTION_SEASONS + ")"
-                + " AS " + Tables.LIST_ITEMS;
-
-        String SELECT_TVDB_EPISODES = "(" + SELECT_LIST_ITEMS_MAP_ROW_ID
-                + " WHERE " + ListItems.SELECTION_EPISODES + ")"
-                + " AS " + Tables.LIST_ITEMS;
-
-        String SELECT_ITEMS_AND_SHOWS_COLUMNS = "SELECT item_row_id as " + ListItems._ID + ","
-                + ITEMS_COLUMNS + ","
-                + Qualified.SG_SHOW_ID + " as " + SgShow2Columns.REF_SHOW_ID + ","
-                + SgShow2Columns.RELEASE_TIME + ","
-                + SgShow2Columns.NEXTTEXT + ","
-                + SgShow2Columns.NEXTAIRDATEMS + ","
-                + SgShow2Columns.TITLE + ","
-                + SgShow2Columns.TITLE_NOARTICLE + ","
-                + SgShow2Columns.POSTER_SMALL + ","
-                + SgShow2Columns.NETWORK + ","
-                + SgShow2Columns.STATUS + ","
-                + SgShow2Columns.NEXTEPISODE + ","
-                + SgShow2Columns.FAVORITE + ","
-                + SgShow2Columns.RELEASE_WEEKDAY + ","
-                + SgShow2Columns.RELEASE_TIMEZONE + ","
-                + SgShow2Columns.RELEASE_COUNTRY + ","
-                + SgShow2Columns.CUSTOM_RELEASE_TIME + ","
-                + SgShow2Columns.CUSTOM_RELEASE_DAY_OFFSET + ","
-                + SgShow2Columns.CUSTOM_RELEASE_TIME_ZONE + ","
-                + SgShow2Columns.LASTWATCHED_MS + ","
-                + SgShow2Columns.UNWATCHED_COUNT;
-    }
-
     interface References {
 
         String SHOW_ID = "REFERENCES " + Tables.SHOWS + "(" + BaseColumns._ID + ")";
diff --git a/app/src/main/java/com/battlelancer/seriesguide/provider/SeriesGuideProvider.java b/app/src/main/java/com/battlelancer/seriesguide/provider/SeriesGuideProvider.java
index a8af2b0702..67281f8b16 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/provider/SeriesGuideProvider.java
+++ b/app/src/main/java/com/battlelancer/seriesguide/provider/SeriesGuideProvider.java
@@ -1,5 +1,5 @@
-// Copyright 2023 Uwe Trottmann
 // SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-FileCopyrightText: Copyright © 2011 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.provider;
 
@@ -47,8 +47,6 @@ public class SeriesGuideProvider extends ContentProvider {
 
     static final int LIST_ITEMS_ID = 601;
 
-    static final int LIST_ITEMS_WITH_DETAILS = 602;
-
     static final int MOVIES = 700;
 
     static final int MOVIES_ID = 701;
@@ -71,8 +69,6 @@ private static UriMatcher buildUriMatcher() {
 
         // List items
         matcher.addURI(authority, SeriesGuideContract.PATH_LIST_ITEMS, LIST_ITEMS);
-        matcher.addURI(authority, SeriesGuideContract.PATH_LIST_ITEMS + "/"
-                + SeriesGuideContract.PATH_WITH_DETAILS, LIST_ITEMS_WITH_DETAILS);
         matcher.addURI(authority, SeriesGuideContract.PATH_LIST_ITEMS + "/*", LIST_ITEMS_ID);
 
         // Movies
@@ -146,7 +142,6 @@ public String getType(@NonNull Uri uri) {
             case LISTS_ID:
                 return Lists.CONTENT_ITEM_TYPE;
             case LIST_ITEMS:
-            case LIST_ITEMS_WITH_DETAILS:
                 return ListItems.CONTENT_TYPE;
             case LIST_ITEMS_ID:
                 return ListItems.CONTENT_ITEM_TYPE;
@@ -416,9 +411,6 @@ private static SelectionBuilder buildSelection(Uri uri, int match) {
                 return builder.table(Tables.LIST_ITEMS).where(ListItems.LIST_ITEM_ID + "=?",
                         list_item_id);
             }
-            case LIST_ITEMS_WITH_DETAILS: {
-                return builder.table(Tables.LIST_ITEMS_WITH_DETAILS);
-            }
             case MOVIES: {
                 return builder.table(Tables.MOVIES);
             }
diff --git a/app/src/main/java/com/battlelancer/seriesguide/settings/DisplaySettings.kt b/app/src/main/java/com/battlelancer/seriesguide/settings/DisplaySettings.kt
index fe77fe0211..395b74c9f1 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/settings/DisplaySettings.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/settings/DisplaySettings.kt
@@ -21,7 +21,7 @@ object DisplaySettings {
     const val KEY_SHOWS_TIME_OFFSET = "com.battlelancer.seriesguide.timeoffset"
     const val KEY_NO_RELEASED_EPISODES = "onlyFutureEpisodes"
     const val KEY_HIDE_SPECIALS = "onlySeasonEpisodes"
-    const val KEY_SORT_IGNORE_ARTICLE = "com.battlelancer.seriesguide.sort.ignorearticle"
+    private const val KEY_SORT_IGNORE_ARTICLE = "com.battlelancer.seriesguide.sort.ignorearticle"
     const val KEY_DISPLAY_EXACT_DATE = "com.battlelancer.seriesguide.shows.exactdate"
     const val KEY_PREVENT_SPOILERS = "com.battlelancer.seriesguide.PREVENT_SPOILERS"
 
@@ -84,6 +84,12 @@ object DisplaySettings {
             .getBoolean(KEY_HIDE_SPECIALS, false)
     }
 
+    fun saveSortOrderIgnoringArticles(context: Context, value: Boolean) {
+        PreferenceManager.getDefaultSharedPreferences(context).edit {
+            putBoolean(KEY_SORT_IGNORE_ARTICLE, value)
+        }
+    }
+
     /**
      * Whether shows and movies sorted by title should ignore the leading article.
      */
diff --git a/app/src/main/java/com/battlelancer/seriesguide/shows/ShowMenuItemClickListener.kt b/app/src/main/java/com/battlelancer/seriesguide/shows/ShowMenuItemClickListener.kt
index e87c9792f6..5f9d2aa77b 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/shows/ShowMenuItemClickListener.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/shows/ShowMenuItemClickListener.kt
@@ -48,7 +48,7 @@ class ShowMenuItemClickListener(
                 return true
             }
             R.id.menu_action_shows_manage_lists -> {
-                ManageListsDialogFragment.show(fragmentManager, showId)
+                ManageListsDialogFragment.showForShow(fragmentManager, showId)
                 return true
             }
             R.id.menu_action_shows_update -> {
diff --git a/app/src/main/java/com/battlelancer/seriesguide/shows/ShowsDistillationSettings.kt b/app/src/main/java/com/battlelancer/seriesguide/shows/ShowsDistillationSettings.kt
index e588961c10..a5affe9117 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/shows/ShowsDistillationSettings.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/shows/ShowsDistillationSettings.kt
@@ -48,11 +48,8 @@ class ShowsDistillationSettings(
                 KEY_SORT_FAVORITES_FIRST,
                 showSortOrder.isSortFavoritesFirst
             )
-            putBoolean(
-                DisplaySettings.KEY_SORT_IGNORE_ARTICLE,
-                showSortOrder.isSortIgnoreArticles
-            )
         }
+        DisplaySettings.saveSortOrderIgnoringArticles(context, showSortOrder.isSortIgnoreArticles)
 
         // broadcast new sort order
         sortOrder.value = showSortOrder
@@ -106,6 +103,7 @@ class ShowsDistillationSettings(
         companion object {
 
             const val TITLE_ID = 0
+
             // @deprecated Only supporting alphabetical sort order going forward.
             // int TITLE_REVERSE_ID = 1;
             const val OLDEST_EPISODE_ID = 2
diff --git a/app/src/main/java/com/battlelancer/seriesguide/shows/database/SgEpisode2Helper.kt b/app/src/main/java/com/battlelancer/seriesguide/shows/database/SgEpisode2Helper.kt
index 99d6547535..6b910dada4 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/shows/database/SgEpisode2Helper.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/shows/database/SgEpisode2Helper.kt
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2021-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2021 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.shows.database
 
@@ -681,6 +681,11 @@ data class SgEpisode2WithShow(
         const val SELECT =
             "SELECT sg_episode._id, episode_title, episode_number, episode_season_number, episode_firstairedms, episode_watched, episode_collected, episode_description, series_title, series_network, series_poster_small FROM sg_episode LEFT OUTER JOIN sg_show ON sg_episode.series_id=sg_show._id"
 
+        /**
+         * Qualified name of episode ID column for use with [SELECT].
+         */
+        const val SG_EPISODE_ID = Tables.SG_EPISODE + "." + _ID
+
         private const val CALENDAR_DAY_LIMIT_MS = 31 * DateUtils.DAY_IN_MILLIS
 
         /**
diff --git a/app/src/main/java/com/battlelancer/seriesguide/shows/database/SgSeason2Helper.kt b/app/src/main/java/com/battlelancer/seriesguide/shows/database/SgSeason2Helper.kt
index d478819831..6347312507 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/shows/database/SgSeason2Helper.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/shows/database/SgSeason2Helper.kt
@@ -77,6 +77,12 @@ interface SgSeason2Helper {
     @Query("SELECT * FROM sg_season WHERE series_id = :showId ORDER BY season_number ASC")
     fun getSeasonsForExport(showId: Long): List<SgSeason2>
 
+    /**
+     * Counts the number of season rows in the database. Currently only used for testing.
+     */
+    @Query("SELECT COUNT(*) FROM sg_season")
+    fun countSeasons(): Long
+
     @Query("DELETE FROM sg_season WHERE series_id = :showId")
     suspend fun deleteSeasonsOfShow(showId: Long): Int
 }
diff --git a/app/src/main/java/com/battlelancer/seriesguide/shows/database/SgShow2.kt b/app/src/main/java/com/battlelancer/seriesguide/shows/database/SgShow2.kt
index 4df4eb90d2..4b9d0c80fc 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/shows/database/SgShow2.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/shows/database/SgShow2.kt
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2021-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2021 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.shows.database
 
@@ -84,10 +84,9 @@ data class SgShow2(
     /**
      * Local release time. Encoded as integer (hhmm).
      *
-     * ```
-     * Example: 2035
-     * Default: -1
-     * ```
+     * Example: `2035`
+     *
+     * Default: [UNKNOWN_RELEASE_TIME]
      */
     @ColumnInfo(name = RELEASE_TIME) val releaseTime: Int?,
     /**
@@ -189,6 +188,11 @@ data class SgShow2(
      * A poster path. Needs to be prefixed with the poster server URL.
      */
     @ColumnInfo(name = POSTER) val poster: String? = "",
+    /**
+     * For shows using TMDB data, the same as [poster].
+     *
+     * For shows using legacy TVDB data, path to a small variant of the poster.
+     */
     @ColumnInfo(name = POSTER_SMALL) val posterSmall: String? = "",
     @ColumnInfo(name = NEXTAIRDATEMS) val nextAirdateMs: Long? = NextEpisodeUpdater.UNKNOWN_NEXT_RELEASE_DATE,
     @ColumnInfo(name = NEXTTEXT) val nextText: String? = "",
@@ -276,7 +280,7 @@ data class SgShow2(
     @ColumnInfo(name = USER_NOTE_TRAKT_ID) val userNoteTraktId: Long?
 ) {
     val releaseTimeOrDefault: Int
-        get() = releaseTime ?: -1
+        get() = releaseTime ?: UNKNOWN_RELEASE_TIME
     val customReleaseTimeOrDefault: Int
         get() = customReleaseTime ?: CUSTOM_RELEASE_TIME_NOT_SET
     val customReleaseDayOffsetOrDefault: Int
@@ -297,6 +301,9 @@ data class SgShow2(
         get() = userNote?.ifBlank { "" } ?: ""
 
     companion object {
+
+        const val UNKNOWN_RELEASE_TIME = -1
+
         /**
          * Used if the number of remaining episodes to watch for a show is not (yet) known.
          *
diff --git a/app/src/main/java/com/battlelancer/seriesguide/shows/overview/OverviewActivityImpl.kt b/app/src/main/java/com/battlelancer/seriesguide/shows/overview/OverviewActivityImpl.kt
index a49b4ac862..25853a93e2 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/shows/overview/OverviewActivityImpl.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/shows/overview/OverviewActivityImpl.kt
@@ -16,7 +16,6 @@ import androidx.fragment.app.Fragment
 import androidx.lifecycle.lifecycleScope
 import androidx.viewpager2.widget.ViewPager2
 import com.battlelancer.seriesguide.R
-import com.battlelancer.seriesguide.lists.ManageListsDialogFragment
 import com.battlelancer.seriesguide.provider.SgRoomDatabase
 import com.battlelancer.seriesguide.shows.RemoveShowDialogFragment
 import com.battlelancer.seriesguide.shows.overview.OverviewActivityImpl.OverviewLayoutType.SINGLE_PANE
@@ -263,10 +262,6 @@ open class OverviewActivityImpl : BaseMessageActivity() {
             launchSearch()
             return true
         }
-        if (itemId == R.id.menu_show_manage_lists) {
-            ManageListsDialogFragment.show(supportFragmentManager, showId)
-            return true
-        }
         if (itemId == R.id.menu_overview_remove_show) {
             RemoveShowDialogFragment.show(showId, supportFragmentManager, this)
             return true
diff --git a/app/src/main/java/com/battlelancer/seriesguide/shows/overview/OverviewFragment.kt b/app/src/main/java/com/battlelancer/seriesguide/shows/overview/OverviewFragment.kt
index 15a99774c6..35f1cf9bb1 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/shows/overview/OverviewFragment.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/shows/overview/OverviewFragment.kt
@@ -36,6 +36,7 @@ import com.battlelancer.seriesguide.extensions.EpisodeActionsContract
 import com.battlelancer.seriesguide.extensions.EpisodeActionsLoader
 import com.battlelancer.seriesguide.extensions.ExtensionManager.EpisodeActionReceivedEvent
 import com.battlelancer.seriesguide.getSgAppContainer
+import com.battlelancer.seriesguide.lists.ManageListsDialogFragment
 import com.battlelancer.seriesguide.preferences.MoreOptionsActivity
 import com.battlelancer.seriesguide.settings.AppSettings
 import com.battlelancer.seriesguide.settings.AppSettings.setAskedForFeedback
@@ -152,6 +153,13 @@ class OverviewFragment() : Fragment(), EpisodeActionsContract {
                 }
             }
             buttonOverviewFavoriteShow.setOnClickListener { onButtonFavoriteClick() }
+            buttonOverviewManageLists.apply {
+                contentDescription = getString(R.string.list_item_manage)
+                TooltipCompat.setTooltipText(this, contentDescription)
+                setOnClickListener {
+                    ManageListsDialogFragment.showForShow(parentFragmentManager, showId)
+                }
+            }
 
             containerOverviewEpisodeCard.setOnClickListener { v: View ->
                 runIfHasEpisode { episode ->
diff --git a/app/src/main/java/com/battlelancer/seriesguide/shows/overview/ShowFragment.kt b/app/src/main/java/com/battlelancer/seriesguide/shows/overview/ShowFragment.kt
index f3d04a0d20..762be72d44 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/shows/overview/ShowFragment.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/shows/overview/ShowFragment.kt
@@ -29,6 +29,7 @@ import com.battlelancer.seriesguide.billing.BillingTools
 import com.battlelancer.seriesguide.comments.TraktCommentsActivity
 import com.battlelancer.seriesguide.databinding.LayoutRatingsBinding
 import com.battlelancer.seriesguide.getSgAppContainer
+import com.battlelancer.seriesguide.lists.ManageListsDialogFragment
 import com.battlelancer.seriesguide.notifications.NotificationService
 import com.battlelancer.seriesguide.people.Credits
 import com.battlelancer.seriesguide.people.PeopleListHelper
@@ -109,6 +110,7 @@ class ShowFragment() : Fragment() {
         val buttonNotify: MaterialButton
         val buttonHidden: MaterialButton
         val buttonEditReleaseTime: Button
+        val buttonManageLists: Button
         val buttonShortcut: MaterialButton
         val buttonLanguage: Button
         val buttonTrailer: Button
@@ -148,6 +150,7 @@ class ShowFragment() : Fragment() {
             buttonNotify = view.findViewById(R.id.buttonShowNotify)
             buttonHidden = view.findViewById(R.id.buttonShowHidden)
             buttonEditReleaseTime = view.findViewById(R.id.buttonEditReleaseTime)
+            buttonManageLists = view.findViewById(R.id.buttonShowManageLists)
             buttonShortcut = view.findViewById(R.id.buttonShowShortcut)
             buttonLanguage = view.findViewById(R.id.buttonShowLanguage)
             buttonTrailer = view.findViewById(R.id.buttonShowTrailer)
@@ -199,6 +202,11 @@ class ShowFragment() : Fragment() {
             }
         }
 
+        // Manage lists button
+        binding.buttonManageLists.setOnClickListener {
+            ManageListsDialogFragment.showForShow(parentFragmentManager, showId)
+        }
+
         // Edit note button
         binding.buttonEditNote.setOnClickListener {
             EditNoteDialog(showId).safeShow(parentFragmentManager, "edit-note")
diff --git a/app/src/main/java/com/battlelancer/seriesguide/shows/search/discover/ItemAddShowViewHolder.kt b/app/src/main/java/com/battlelancer/seriesguide/shows/search/discover/ItemAddShowViewHolder.kt
index 63500d8695..c233cec892 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/shows/search/discover/ItemAddShowViewHolder.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/shows/search/discover/ItemAddShowViewHolder.kt
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2024 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2024 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.shows.search.discover
 
@@ -74,7 +74,7 @@ class ItemAddShowViewHolder(
         }
 
         // poster
-        ImageTools.loadShowPosterUrlResizeCrop(context, binding.imageViewAddPoster, item.posterUrl)
+        ImageTools.loadAndResizeCropToShowPosterSize(context, binding.imageViewAddPoster, item.posterUrl)
 
         // context/long press listener and more options button
         val canBeAdded = item.state == SearchResult.STATE_ADD
diff --git a/app/src/main/java/com/battlelancer/seriesguide/shows/tools/AddUpdateShowTools.kt b/app/src/main/java/com/battlelancer/seriesguide/shows/tools/AddUpdateShowTools.kt
index 5ab595092c..067bcd8ddb 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/shows/tools/AddUpdateShowTools.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/shows/tools/AddUpdateShowTools.kt
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2019-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2019 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.shows.tools
 
@@ -13,18 +13,15 @@ import com.battlelancer.seriesguide.backend.HexagonTools
 import com.battlelancer.seriesguide.backend.settings.HexagonSettings
 import com.battlelancer.seriesguide.modules.ApplicationContext
 import com.battlelancer.seriesguide.provider.SgRoomDatabase
-import com.battlelancer.seriesguide.shows.ShowsSettings
-import com.battlelancer.seriesguide.shows.database.SgEpisode2
 import com.battlelancer.seriesguide.shows.database.SgEpisode2Ids
 import com.battlelancer.seriesguide.shows.database.SgEpisode2TmdbIdUpdate
-import com.battlelancer.seriesguide.shows.database.SgEpisode2Update
 import com.battlelancer.seriesguide.shows.database.SgSeason2
 import com.battlelancer.seriesguide.shows.database.SgSeason2Numbers
 import com.battlelancer.seriesguide.shows.database.SgSeason2TmdbIdUpdate
 import com.battlelancer.seriesguide.shows.database.SgSeason2Update
-import com.battlelancer.seriesguide.shows.database.SgShow2
 import com.battlelancer.seriesguide.shows.tools.AddUpdateShowTools.ShowService.HEXAGON
 import com.battlelancer.seriesguide.shows.tools.AddUpdateShowTools.ShowService.TMDB
+import com.battlelancer.seriesguide.shows.tools.GetEpisodesOfSeasonTools.ReleaseInfo
 import com.battlelancer.seriesguide.shows.tools.GetShowTools.GetShowError
 import com.battlelancer.seriesguide.shows.tools.GetShowTools.GetShowError.GetShowDoesNotExist
 import com.battlelancer.seriesguide.shows.tools.GetShowTools.GetShowError.GetShowRetry
@@ -40,8 +37,6 @@ import com.battlelancer.seriesguide.tmdbapi.TmdbTools3.TmdbError
 import com.battlelancer.seriesguide.tmdbapi.TmdbTools3.TmdbRetry
 import com.battlelancer.seriesguide.tmdbapi.TmdbTools3.TmdbStop
 import com.battlelancer.seriesguide.util.LanguageTools
-import com.battlelancer.seriesguide.util.TextTools
-import com.battlelancer.seriesguide.util.TimeTools
 import com.github.michaelbull.result.Err
 import com.github.michaelbull.result.Ok
 import com.github.michaelbull.result.Result
@@ -49,26 +44,41 @@ import com.github.michaelbull.result.andThen
 import com.github.michaelbull.result.getOrElse
 import com.github.michaelbull.result.mapError
 import com.uwetrottmann.seriesguide.backend.shows.model.SgCloudShow
-import com.uwetrottmann.tmdb2.entities.TvEpisode
 import com.uwetrottmann.tmdb2.entities.TvSeason
 import com.uwetrottmann.trakt5.entities.BaseShow
 import dagger.Lazy
 import kotlinx.coroutines.runBlocking
 import timber.log.Timber
-import java.util.TimeZone
 import javax.inject.Inject
 
 /**
  * Adds or updates a show and its seasons and episodes.
  */
-class AddUpdateShowTools @Inject constructor(
-    @param:ApplicationContext private val context: Context,
+class AddUpdateShowTools(
+    private val context: Context,
     private val getShowTools: GetShowTools,
     private val hexagonShowSync: Lazy<HexagonShowSync>,
     private val hexagonTools: Lazy<HexagonTools>,
-    private val showTools: Lazy<ShowTools2>
+    private val showTools: Lazy<ShowTools2>,
+    private val getEpisodesOfSeasonTools: GetEpisodesOfSeasonTools
 ) {
 
+    @Inject
+    constructor(
+        @ApplicationContext context: Context,
+        getShowTools: GetShowTools,
+        hexagonShowSync: Lazy<HexagonShowSync>,
+        hexagonTools: Lazy<HexagonTools>,
+        showTools: Lazy<ShowTools2>
+    ) : this(
+        context,
+        getShowTools,
+        hexagonShowSync,
+        hexagonTools,
+        showTools,
+        GetEpisodesOfSeasonTools(context)
+    )
+
     enum class ShowResult {
         SUCCESS,
         IN_DATABASE,
@@ -78,6 +88,8 @@ class AddUpdateShowTools @Inject constructor(
         DATABASE_ERROR
     }
 
+    private class AddShowDatabaseException(val result: ShowResult) : Exception(result.name)
+
     /**
      * Add a show to the database.
      *
@@ -141,48 +153,59 @@ class AddUpdateShowTools @Inject constructor(
             }
         }
 
-        // Run within transaction to avoid show ID foreign key constraint failures.
+        // Run within transaction to avoid show ID foreign key constraint failures and to be able to
+        // roll back all changes on failure (to avoid a partially inserted show, such as if adding a
+        // season fails).
         val database = SgRoomDatabase.getInstance(context)
-        var showId = -1L
-        val result = database.runInTransaction<ShowResult> {
-            // Store show to database to get row ID
-            showId = database.sgShow2Helper().insertShow(show)
-            if (showId == -1L) return@runInTransaction ShowResult.DATABASE_ERROR
-
-            // Store seasons to database to get row IDs
-            val seasons = mapToSgSeason2(showDetails.seasons, showId)
-            val seasonIds = database.sgSeason2Helper().insertSeasons(seasons)
-
-            // Download episodes by season and store to database
-            val episodeHelper = database.sgEpisode2Helper()
-            seasons.forEachIndexed { index, season ->
-                val seasonId = seasonIds[index]
-                if (seasonId == -1L) return@forEachIndexed
+        val showId: Long
+        try {
+            showId = database.runInTransaction<Long> {
+                // Store show to database to get row ID
+                val showId = database.sgShow2Helper().insertShow(show)
+                if (showId == -1L) {
+                    throw AddShowDatabaseException(ShowResult.DATABASE_ERROR)
+                }
 
-                val episodeDetails = getEpisodesOfSeason(
-                    ReleaseInfo(
-                        show.releaseTimeZone,
-                        show.releaseTimeOrDefault,
-                        show.customReleaseTimeZoneOrDefault,
-                        show.customReleaseTimeOrDefault,
-                        show.customReleaseDayOffsetOrDefault,
-                        show.releaseCountry,
-                        show.network
-                    ),
-                    showTmdbId,
-                    showId,
-                    season.number,
-                    seasonId,
-                    languageCode,
-                    null,
-                    null
-                ).getOrElse { return@runInTransaction ShowResult.TMDB_ERROR }
-                val episodes = episodeDetails.toInsert
-                episodeHelper.insertEpisodes(episodes)
+                // Store seasons to database to get row IDs
+                val seasons = mapToSgSeason2(showDetails.seasons, showId)
+                val seasonIds = database.sgSeason2Helper().insertSeasons(seasons)
+
+                // Download episodes by season and store to database
+                val episodeHelper = database.sgEpisode2Helper()
+                seasons.forEachIndexed { index, season ->
+                    val seasonId = seasonIds[index]
+                    if (seasonId == -1L) return@forEachIndexed
+
+                    val episodeDetails = getEpisodesOfSeasonTools.getEpisodesOfSeason(
+                        ReleaseInfo(
+                            show.releaseTimeZone,
+                            show.releaseTimeOrDefault,
+                            show.customReleaseTimeZoneOrDefault,
+                            show.customReleaseTimeOrDefault,
+                            show.customReleaseDayOffsetOrDefault,
+                            show.releaseCountry,
+                            show.network
+                        ),
+                        showTmdbId,
+                        showId,
+                        season.number,
+                        seasonId,
+                        languageCode,
+                        null,
+                        null
+                    ).getOrElse {
+                        // Roll back all changes, user should try again
+                        throw AddShowDatabaseException(ShowResult.TMDB_ERROR)
+                    }
+                    val episodes = episodeDetails.toInsert
+                    episodeHelper.insertEpisodes(episodes)
+                }
+
+                return@runInTransaction showId
             }
-            return@runInTransaction ShowResult.SUCCESS
+        } catch (e: AddShowDatabaseException) {
+            return e.result
         }
-        if (result != ShowResult.SUCCESS) return result
 
         // restore episode flags...
         if (hexagonEnabled) {
@@ -255,193 +278,6 @@ class AddUpdateShowTools @Inject constructor(
         )
     }
 
-    private fun getEpisodesOfSeason(
-        releaseInfo: ReleaseInfo,
-        showTmdbId: Int,
-        showId: Long,
-        seasonNumber: Int,
-        seasonId: Long,
-        language: String,
-        localEpisodesByTmdbId: MutableMap<Int, SgEpisode2Ids>?,
-        localEpisodesWithoutTmdbIdByNumber: MutableMap<Int, SgEpisode2Ids>?
-    ): Result<EpisodeDetails, TmdbError> {
-        val fallbackLanguage: String? = ShowsSettings.getShowsLanguageFallback(context)
-            .let { if (it != language) it else null }
-
-        val tmdbEpisodes = TmdbTools3.getSeason(showTmdbId, seasonNumber, language, context)
-            .getOrElse { return Err(it) }
-
-        val tmdbEpisodesFallback = if (fallbackLanguage != null
-            && tmdbEpisodes.find { it.name.isNullOrEmpty() || it.overview.isNullOrEmpty() } != null) {
-            // Also fetch in fallback language if some episodes have no name or overview.
-            TmdbTools3.getSeason(showTmdbId, seasonNumber, fallbackLanguage, context)
-                .getOrElse { return Err(it) }
-        } else {
-            null
-        }
-
-        val episodeDetails = mapToSgEpisode2(
-            tmdbEpisodes,
-            tmdbEpisodesFallback,
-            releaseInfo,
-            showId,
-            seasonId,
-            seasonNumber,
-            localEpisodesByTmdbId,
-            localEpisodesWithoutTmdbIdByNumber
-        )
-
-        return Ok(episodeDetails)
-    }
-
-    data class EpisodeDetails(
-        val toInsert: List<SgEpisode2>,
-        val toUpdate: List<SgEpisode2Update>,
-        val toRemove: List<Long>
-    )
-
-    data class ReleaseInfo(
-        val releaseTimeZone: String?,
-        val releaseTimeOrDefault: Int,
-        val customReleaseTimeZone: String,
-        val customReleaseTime: Int,
-        val customReleaseDayOffset: Int,
-        val releaseCountry: String?,
-        val network: String?
-    )
-
-    /**
-     * If [localEpisodesByTmdbId] is not null, will add update or delete info.
-     * Will choose to update episode if not found in [localEpisodesByTmdbId],
-     * but found in [localEpisodesWithoutTmdbIdByNumber].
-     */
-    private fun mapToSgEpisode2(
-        tmdbEpisodes: List<TvEpisode>,
-        tmdbEpisodesFallback: List<TvEpisode>?,
-        releaseInfo: ReleaseInfo,
-        showId: Long,
-        seasonId: Long,
-        seasonNumber: Int,
-        localEpisodesByTmdbId: MutableMap<Int, SgEpisode2Ids>?,
-        localEpisodesWithoutTmdbIdByNumber: MutableMap<Int, SgEpisode2Ids>?
-    ): EpisodeDetails {
-        // Only apply release time auto-corrections if not using a custom time.
-        val usingCustomTime = releaseInfo.customReleaseTime != SgShow2.CUSTOM_RELEASE_TIME_NOT_SET
-        // Prefer custom time zone and release time.
-        val showTimeZone = TimeTools.getDateTimeZone(
-            if (usingCustomTime) releaseInfo.customReleaseTimeZone else releaseInfo.releaseTimeZone
-        )
-        val showReleaseTime = TimeTools.getShowReleaseTime(
-            if (usingCustomTime) releaseInfo.customReleaseTime else releaseInfo.releaseTimeOrDefault
-        )
-        val deviceTimeZone = TimeZone.getDefault().id
-
-        val toInsert = mutableListOf<SgEpisode2>()
-        val toUpdate = mutableListOf<SgEpisode2Update>()
-        tmdbEpisodes.forEach { tmdbEpisode ->
-            val tmdbId = tmdbEpisode.id ?: return@forEach
-
-            // If name or overview are empty use fallback
-            val isMissingTitle = tmdbEpisode.name.isNullOrEmpty()
-            val isMissingOverview = tmdbEpisode.overview.isNullOrEmpty()
-            val fallbackEpisode = if (isMissingTitle || isMissingOverview) {
-                tmdbEpisodesFallback?.find { it.id == tmdbId }
-            } else {
-                null
-            }
-            val titleOrNull = if (isMissingTitle) fallbackEpisode?.name else tmdbEpisode.name
-            // Note: trim as contributors sometimes add pointless new lines.
-            val overviewOrNull =
-                (if (isMissingOverview) fallbackEpisode?.overview else tmdbEpisode.overview)?.trim()
-
-            // calculate release time
-            val releaseDateTime = TimeTools.parseEpisodeReleaseDate(
-                showTimeZone,
-                tmdbEpisode.air_date,
-                releaseInfo.customReleaseDayOffset,
-                showReleaseTime,
-                releaseInfo.releaseCountry,
-                releaseInfo.network,
-                deviceTimeZone,
-                applyCorrections = !usingCustomTime
-            )
-
-            val guestStars = tmdbEpisode.guest_stars?.mapNotNull { it.name } ?: emptyList()
-            val directors = tmdbEpisode.crew?.filter { it.job == "Director" }
-                ?.mapNotNull { it.name }
-                ?: emptyList()
-            val writers = tmdbEpisode.crew?.filter { it.job == "Writer" }
-                ?.mapNotNull { it.name }
-                ?: emptyList()
-
-            // Note: last edited time is not available on TMDB,
-            // so it and last updated time are currently not used
-            // to only update changed episodes.
-
-            // Update if episode with TMDb ID is in database, or if episode with same number is.
-            // Why same number? If legacy episodes get added to TMDb they would not get updated,
-            // but instead duplicates would be inserted. So instead add the TMDb ID and update
-            // the legacy episode.
-            val localEpisodeIdOrNull = localEpisodesByTmdbId?.get(tmdbId)
-                ?: tmdbEpisode.episode_number?.let { localEpisodesWithoutTmdbIdByNumber?.get(it) }
-            if (localEpisodeIdOrNull == null) {
-                // Insert
-                toInsert.add(
-                    SgEpisode2(
-                        showId = showId,
-                        seasonId = seasonId,
-                        tmdbId = tmdbEpisode.id,
-                        title = titleOrNull ?: "",
-                        overview = overviewOrNull,
-                        number = tmdbEpisode.episode_number ?: 0,
-                        order = tmdbEpisode.episode_number ?: 0,
-                        season = seasonNumber,
-                        image = tmdbEpisode.still_path,
-                        firstReleasedMs = releaseDateTime,
-                        directors = TextTools.buildPipeSeparatedString(directors),
-                        guestStars = TextTools.buildPipeSeparatedString(guestStars),
-                        writers = TextTools.buildPipeSeparatedString(writers),
-                        ratingTmdb = tmdbEpisode.vote_average,
-                        ratingTmdbVotes = tmdbEpisode.vote_count,
-                        // Trakt ratings loaded later by TraktRatingsFetcher
-                        ratingTrakt = null,
-                        ratingTraktVotes = null,
-                        // Added by TraktRatingsSync
-                        ratingUser = null
-                    )
-                )
-            } else {
-                // Update
-                // Note: update adds TMDb ID in case episode was matched by number.
-                toUpdate.add(
-                    SgEpisode2Update(
-                        id = localEpisodeIdOrNull.id,
-                        tmdbId = tmdbId,
-                        title = titleOrNull ?: "",
-                        overview = overviewOrNull,
-                        number = tmdbEpisode.episode_number ?: 0,
-                        order = tmdbEpisode.episode_number ?: 0,
-                        season = seasonNumber,
-                        directors = TextTools.buildPipeSeparatedString(directors),
-                        guestStars = TextTools.buildPipeSeparatedString(guestStars),
-                        writers = TextTools.buildPipeSeparatedString(writers),
-                        image = tmdbEpisode.still_path,
-                        firstReleasedMs = releaseDateTime,
-                        ratingTmdb = tmdbEpisode.vote_average,
-                        ratingTmdbVotes = tmdbEpisode.vote_count,
-                    )
-                )
-                // Remove from map so episode will not get deleted.
-                localEpisodesByTmdbId?.remove(tmdbId)
-            }
-        }
-
-        // Mark any local episodes that are no longer on TMDB for removal.
-        val toRemove = localEpisodesByTmdbId?.map { it.value.id } ?: emptyList()
-
-        return EpisodeDetails(toInsert, toUpdate, toRemove)
-    }
-
     /**
      * Updates a show. Adds new, updates changed and removes orphaned episodes.
      *
@@ -505,7 +341,7 @@ class AddUpdateShowTools @Inject constructor(
                 }
             }
 
-            val episodeDetails = getEpisodesOfSeason(
+            val episodeDetails = getEpisodesOfSeasonTools.getEpisodesOfSeason(
                 ReleaseInfo(
                     updatedShow.releaseTimeZone,
                     updatedShow.releaseTime,
diff --git a/app/src/main/java/com/battlelancer/seriesguide/shows/tools/GetEpisodesOfSeasonTools.kt b/app/src/main/java/com/battlelancer/seriesguide/shows/tools/GetEpisodesOfSeasonTools.kt
new file mode 100644
index 0000000000..7e9411ebdd
--- /dev/null
+++ b/app/src/main/java/com/battlelancer/seriesguide/shows/tools/GetEpisodesOfSeasonTools.kt
@@ -0,0 +1,218 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-FileCopyrightText: Copyright © 2026 Uwe Trottmann <uwe@uwetrottmann.com>
+
+package com.battlelancer.seriesguide.shows.tools
+
+import android.content.Context
+import com.battlelancer.seriesguide.shows.ShowsSettings
+import com.battlelancer.seriesguide.shows.database.SgEpisode2
+import com.battlelancer.seriesguide.shows.database.SgEpisode2Ids
+import com.battlelancer.seriesguide.shows.database.SgEpisode2Update
+import com.battlelancer.seriesguide.shows.database.SgShow2
+import com.battlelancer.seriesguide.tmdbapi.TmdbTools3
+import com.battlelancer.seriesguide.tmdbapi.TmdbTools3.TmdbError
+import com.battlelancer.seriesguide.util.TextTools
+import com.battlelancer.seriesguide.util.TimeTools
+import com.github.michaelbull.result.Err
+import com.github.michaelbull.result.Ok
+import com.github.michaelbull.result.Result
+import com.github.michaelbull.result.getOrElse
+import com.uwetrottmann.tmdb2.entities.TvEpisode
+import java.util.TimeZone
+import kotlin.collections.forEach
+
+/**
+ * Helps get episodes of a season from TMDB.
+ */
+class GetEpisodesOfSeasonTools(
+    private val context: Context
+) {
+
+    data class ReleaseInfo(
+        val releaseTimeZone: String?,
+        val releaseTimeOrDefault: Int,
+        val customReleaseTimeZone: String,
+        val customReleaseTime: Int,
+        val customReleaseDayOffset: Int,
+        val releaseCountry: String?,
+        val network: String?
+    )
+
+    data class EpisodeDetails(
+        val toInsert: List<SgEpisode2>,
+        val toUpdate: List<SgEpisode2Update>,
+        val toRemove: List<Long>
+    )
+
+    fun getEpisodesOfSeason(
+        releaseInfo: ReleaseInfo,
+        showTmdbId: Int,
+        showId: Long,
+        seasonNumber: Int,
+        seasonId: Long,
+        language: String,
+        localEpisodesByTmdbId: MutableMap<Int, SgEpisode2Ids>?,
+        localEpisodesWithoutTmdbIdByNumber: MutableMap<Int, SgEpisode2Ids>?
+    ): Result<EpisodeDetails, TmdbError> {
+        val fallbackLanguage: String? = ShowsSettings.getShowsLanguageFallback(context)
+            .let { if (it != language) it else null }
+
+        val tmdbEpisodes = TmdbTools3.getSeason(showTmdbId, seasonNumber, language, context)
+            .getOrElse { return Err(it) }
+
+        val tmdbEpisodesFallback = if (fallbackLanguage != null
+            && tmdbEpisodes.find { it.name.isNullOrEmpty() || it.overview.isNullOrEmpty() } != null) {
+            // Also fetch in fallback language if some episodes have no name or overview.
+            TmdbTools3.getSeason(showTmdbId, seasonNumber, fallbackLanguage, context)
+                .getOrElse { return Err(it) }
+        } else {
+            null
+        }
+
+        val episodeDetails = mapToSgEpisode2(
+            tmdbEpisodes,
+            tmdbEpisodesFallback,
+            releaseInfo,
+            showId,
+            seasonId,
+            seasonNumber,
+            localEpisodesByTmdbId,
+            localEpisodesWithoutTmdbIdByNumber
+        )
+
+        return Ok(episodeDetails)
+    }
+
+    /**
+     * If [localEpisodesByTmdbId] is not null, will add update or delete info.
+     * Will choose to update episode if not found in [localEpisodesByTmdbId],
+     * but found in [localEpisodesWithoutTmdbIdByNumber].
+     */
+    private fun mapToSgEpisode2(
+        tmdbEpisodes: List<TvEpisode>,
+        tmdbEpisodesFallback: List<TvEpisode>?,
+        releaseInfo: ReleaseInfo,
+        showId: Long,
+        seasonId: Long,
+        seasonNumber: Int,
+        localEpisodesByTmdbId: MutableMap<Int, SgEpisode2Ids>?,
+        localEpisodesWithoutTmdbIdByNumber: MutableMap<Int, SgEpisode2Ids>?
+    ): EpisodeDetails {
+        // Only apply release time auto-corrections if not using a custom time.
+        val usingCustomTime = releaseInfo.customReleaseTime != SgShow2.CUSTOM_RELEASE_TIME_NOT_SET
+        // Prefer custom time zone and release time.
+        val showTimeZone = TimeTools.getDateTimeZone(
+            if (usingCustomTime) releaseInfo.customReleaseTimeZone else releaseInfo.releaseTimeZone
+        )
+        val showReleaseTime = TimeTools.getShowReleaseTime(
+            if (usingCustomTime) releaseInfo.customReleaseTime else releaseInfo.releaseTimeOrDefault
+        )
+        val deviceTimeZone = TimeZone.getDefault().id
+
+        val toInsert = mutableListOf<SgEpisode2>()
+        val toUpdate = mutableListOf<SgEpisode2Update>()
+        tmdbEpisodes.forEach { tmdbEpisode ->
+            val tmdbId = tmdbEpisode.id ?: return@forEach
+
+            // If name or overview are empty use fallback
+            val isMissingTitle = tmdbEpisode.name.isNullOrEmpty()
+            val isMissingOverview = tmdbEpisode.overview.isNullOrEmpty()
+            val fallbackEpisode = if (isMissingTitle || isMissingOverview) {
+                tmdbEpisodesFallback?.find { it.id == tmdbId }
+            } else {
+                null
+            }
+            val titleOrNull = if (isMissingTitle) fallbackEpisode?.name else tmdbEpisode.name
+            // Note: trim as contributors sometimes add pointless new lines.
+            val overviewOrNull =
+                (if (isMissingOverview) fallbackEpisode?.overview else tmdbEpisode.overview)?.trim()
+
+            // calculate release time
+            val releaseDateTime = TimeTools.parseEpisodeReleaseDate(
+                showTimeZone,
+                tmdbEpisode.air_date,
+                releaseInfo.customReleaseDayOffset,
+                showReleaseTime,
+                releaseInfo.releaseCountry,
+                releaseInfo.network,
+                deviceTimeZone,
+                applyCorrections = !usingCustomTime
+            )
+
+            val guestStars = tmdbEpisode.guest_stars?.mapNotNull { it.name } ?: emptyList()
+            val directors = tmdbEpisode.crew?.filter { it.job == "Director" }
+                ?.mapNotNull { it.name }
+                ?: emptyList()
+            val writers = tmdbEpisode.crew?.filter { it.job == "Writer" }
+                ?.mapNotNull { it.name }
+                ?: emptyList()
+
+            // Note: last edited time is not available on TMDB,
+            // so it and last updated time are currently not used
+            // to only update changed episodes.
+
+            // Update if episode with TMDb ID is in database, or if episode with same number is.
+            // Why same number? If legacy episodes get added to TMDb they would not get updated,
+            // but instead duplicates would be inserted. So instead add the TMDb ID and update
+            // the legacy episode.
+            val localEpisodeIdOrNull = localEpisodesByTmdbId?.get(tmdbId)
+                ?: tmdbEpisode.episode_number?.let { localEpisodesWithoutTmdbIdByNumber?.get(it) }
+            if (localEpisodeIdOrNull == null) {
+                // Insert
+                toInsert.add(
+                    SgEpisode2(
+                        showId = showId,
+                        seasonId = seasonId,
+                        tmdbId = tmdbEpisode.id,
+                        title = titleOrNull ?: "",
+                        overview = overviewOrNull,
+                        number = tmdbEpisode.episode_number ?: 0,
+                        order = tmdbEpisode.episode_number ?: 0,
+                        season = seasonNumber,
+                        image = tmdbEpisode.still_path,
+                        firstReleasedMs = releaseDateTime,
+                        directors = TextTools.buildPipeSeparatedString(directors),
+                        guestStars = TextTools.buildPipeSeparatedString(guestStars),
+                        writers = TextTools.buildPipeSeparatedString(writers),
+                        ratingTmdb = tmdbEpisode.vote_average,
+                        ratingTmdbVotes = tmdbEpisode.vote_count,
+                        // Trakt ratings loaded later by TraktRatingsFetcher
+                        ratingTrakt = null,
+                        ratingTraktVotes = null,
+                        // Added by TraktRatingsSync
+                        ratingUser = null
+                    )
+                )
+            } else {
+                // Update
+                // Note: update adds TMDb ID in case episode was matched by number.
+                toUpdate.add(
+                    SgEpisode2Update(
+                        id = localEpisodeIdOrNull.id,
+                        tmdbId = tmdbId,
+                        title = titleOrNull ?: "",
+                        overview = overviewOrNull,
+                        number = tmdbEpisode.episode_number ?: 0,
+                        order = tmdbEpisode.episode_number ?: 0,
+                        season = seasonNumber,
+                        directors = TextTools.buildPipeSeparatedString(directors),
+                        guestStars = TextTools.buildPipeSeparatedString(guestStars),
+                        writers = TextTools.buildPipeSeparatedString(writers),
+                        image = tmdbEpisode.still_path,
+                        firstReleasedMs = releaseDateTime,
+                        ratingTmdb = tmdbEpisode.vote_average,
+                        ratingTmdbVotes = tmdbEpisode.vote_count,
+                    )
+                )
+                // Remove from map so episode will not get deleted.
+                localEpisodesByTmdbId?.remove(tmdbId)
+            }
+        }
+
+        // Mark any local episodes that are no longer on TMDB for removal.
+        val toRemove = localEpisodesByTmdbId?.map { it.value.id } ?: emptyList()
+
+        return EpisodeDetails(toInsert, toUpdate, toRemove)
+    }
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/battlelancer/seriesguide/shows/tools/LatestEpisodeUpdateTask.java b/app/src/main/java/com/battlelancer/seriesguide/shows/tools/LatestEpisodeUpdateTask.java
index 3f918637c0..4789b5d7ea 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/shows/tools/LatestEpisodeUpdateTask.java
+++ b/app/src/main/java/com/battlelancer/seriesguide/shows/tools/LatestEpisodeUpdateTask.java
@@ -1,12 +1,11 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2014-2024 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2014 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.shows.tools;
 
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.os.AsyncTask;
-import com.battlelancer.seriesguide.provider.SeriesGuideContract;
 import com.battlelancer.seriesguide.util.TaskManager;
 import timber.log.Timber;
 
@@ -45,10 +44,5 @@ public static void updateLatestEpisodeFor(Context context, Long showId) {
             Timber.d("Updating next episodes for all shows");
             new NextEpisodeUpdater(context).updateForShows(null);
         }
-
-        // Show cursors already notified
-        // List item cursors need to be notified manually as uri differs
-        context.getContentResolver()
-                .notifyChange(SeriesGuideContract.ListItems.CONTENT_WITH_DETAILS_URI, null);
     }
 }
diff --git a/app/src/main/java/com/battlelancer/seriesguide/shows/tools/ShowTools2.kt b/app/src/main/java/com/battlelancer/seriesguide/shows/tools/ShowTools2.kt
index 2f46855f54..4aa999e76d 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/shows/tools/ShowTools2.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/shows/tools/ShowTools2.kt
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2022-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2022 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.shows.tools
 
@@ -12,7 +12,6 @@ import com.battlelancer.seriesguide.backend.settings.HexagonSettings
 import com.battlelancer.seriesguide.enums.NetworkResult
 import com.battlelancer.seriesguide.modules.ApplicationContext
 import com.battlelancer.seriesguide.notifications.NotificationService
-import com.battlelancer.seriesguide.provider.SeriesGuideContract
 import com.battlelancer.seriesguide.provider.SeriesGuideDatabase
 import com.battlelancer.seriesguide.provider.SgRoomDatabase
 import com.battlelancer.seriesguide.shows.database.SgShow2
@@ -30,7 +29,6 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import org.greenrobot.eventbus.EventBus
 import javax.inject.Inject
-import kotlin.collections.set
 import com.battlelancer.seriesguide.enums.Result as SgResult
 
 /**
@@ -213,10 +211,6 @@ class ShowTools2 @Inject constructor(
         // Save to local database.
         withContext(Dispatchers.IO) {
             SgRoomDatabase.getInstance(context).sgShow2Helper().setShowFavorite(showId, isFavorite)
-
-            // Also notify URI used by lists.
-            context.contentResolver
-                .notifyChange(SeriesGuideContract.ListItems.CONTENT_WITH_DETAILS_URI, null)
         }
 
         // display info toast
diff --git a/app/src/main/java/com/battlelancer/seriesguide/sync/HexagonListsSync.kt b/app/src/main/java/com/battlelancer/seriesguide/sync/HexagonListsSync.kt
index 1f94398746..d0c1394aac 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/sync/HexagonListsSync.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/sync/HexagonListsSync.kt
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2017-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2017 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.sync
 
@@ -24,17 +24,33 @@ class HexagonListsSync(
     private val hexagonTools: HexagonTools
 ) {
 
+    /**
+     * Downloads all or if [hasMergedLists] is true and there is a last list sync time, lists
+     * changed since that time and updates the database accordingly.
+     *
+     * Note: does not add movies added to a custom list to the database. This is done during a later
+     * sync step.
+     */
     fun download(hasMergedLists: Boolean): Boolean {
-        val currentTime = System.currentTimeMillis()
-        val lastSyncTime = DateTime(HexagonSettings.getLastListsSyncTime(context))
-
+        val lastSyncTime = HexagonSettings.getLastListsSyncTime(context)?.let { DateTime(it) }
         if (hasMergedLists) {
-            Timber.d("download: lists changed since %s.", lastSyncTime)
+            if (lastSyncTime != null) {
+                Timber.d("download: NOT merging, get lists CHANGED since %s", lastSyncTime)
+            } else {
+                Timber.d("download: NOT merging, get ALL lists")
+            }
         } else {
-            Timber.d("download: all lists.")
+            Timber.d("download: MERGING, get ALL lists")
         }
 
+        // Store new last sync time before downloading to not miss any changes for the next sync
+        val newLastSyncTime = System.currentTimeMillis()
+
         val localListIds = ListsTools.getListIds(context)
+        if (localListIds == null) {
+            Timber.e("download: failed to get list IDs from database")
+            return false
+        }
         var lists: List<SgList>?
         var cursor: String? = null
         do {
@@ -44,7 +60,7 @@ class HexagonListsSync(
                     ?: return false // no longer signed in
 
                 val request = listsService.get() // use default server limit
-                if (hasMergedLists) {
+                if (hasMergedLists && lastSyncTime != null) {
                     request.updatedSince = lastSyncTime
                 }
                 if (!TextUtils.isEmpty(cursor)) {
@@ -78,7 +94,7 @@ class HexagonListsSync(
         } while (!TextUtils.isEmpty(cursor)) // fetch next batch
 
         if (hasMergedLists) {
-            HexagonSettings.setLastListsSyncTime(context, currentTime)
+            HexagonSettings.setLastListsSyncTime(context, newLastSyncTime)
         }
 
         return true
@@ -141,6 +157,9 @@ class HexagonListsSync(
                         continue // failed to extract item ref id or item type not known
                     }
 
+                    // Note: movies added to a custom list that are not in the database, yet, are
+                    // added in a later sync step.
+
                     // just insert the list item, if the id already exists it will be replaced
                     builder = ContentProviderOperation
                         .newInsert(SeriesGuideContract.ListItems.CONTENT_URI)
@@ -175,6 +194,13 @@ class HexagonListsSync(
         }
     }
 
+    /**
+     * Downloads list IDs and deletes any list and its items from the database if its ID isn't
+     * in the downloaded set of list IDs.
+     *
+     * Note: this doesn't remove movies from the database that are no longer in a custom or built-in
+     * list afterward, this is done during a later sync step.
+     */
     fun pruneRemovedLists(): Boolean {
         Timber.d("pruneRemovedLists")
         val localListIds = ListsTools.getListIds(context)
@@ -233,8 +259,10 @@ class HexagonListsSync(
         if (localListIds.isNotEmpty()) {
             val batch = ArrayList<ContentProviderOperation>()
             for (listId in localListIds) {
-                // note: this matches what RemoveListTask does
-                // delete all list items before the list to avoid violating foreign key constraints
+                // Note: this matches what DeleteListTask does
+                // Delete all list items before the list to avoid violating foreign key constraints.
+                // Note: movies that are no longer on any custom (or built-in) list after this will
+                // be deleted from the database during a later sync step.
                 batch.add(
                     ContentProviderOperation
                         .newDelete(SeriesGuideContract.ListItems.CONTENT_URI)
diff --git a/app/src/main/java/com/battlelancer/seriesguide/sync/HexagonMovieSync.kt b/app/src/main/java/com/battlelancer/seriesguide/sync/HexagonMovieSync.kt
index c0db1c3bc3..59c2f74220 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/sync/HexagonMovieSync.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/sync/HexagonMovieSync.kt
@@ -48,7 +48,7 @@ internal class HexagonMovieSync(
         val lastSyncTime = HexagonSettings.getLastMoviesSyncTime(context)?.let { DateTime(it) }
         if (hasMergedMovies) {
             if (lastSyncTime != null) {
-                Timber.d("download: NOT merging, get CHANGED since %s", lastSyncTime)
+                Timber.d("download: NOT merging, get movies CHANGED since %s", lastSyncTime)
             } else {
                 Timber.d("download: NOT merging, get ALL movies")
             }
@@ -56,10 +56,12 @@ internal class HexagonMovieSync(
             Timber.d("download: MERGING, get ALL movies")
         }
 
+        // Store new last sync time before downloading to not miss any changes for the next sync
+        val newLastSyncTime = System.currentTimeMillis()
+
         var movies: List<Movie>?
         var hasMoreMovies = true
         var cursor: String? = null
-        val currentTime = System.currentTimeMillis()
         var updatedCount = 0
         var removedCount = 0
 
@@ -195,7 +197,7 @@ internal class HexagonMovieSync(
         Timber.d("download: updated %d and removed %d movies", updatedCount, removedCount)
 
         if (hasMergedMovies) {
-            HexagonSettings.setLastMoviesSyncTime(context, currentTime)
+            HexagonSettings.setLastMoviesSyncTime(context, newLastSyncTime)
         }
 
         return true
diff --git a/app/src/main/java/com/battlelancer/seriesguide/sync/SgSyncAdapter.kt b/app/src/main/java/com/battlelancer/seriesguide/sync/SgSyncAdapter.kt
index 230f826198..b3c4a42932 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/sync/SgSyncAdapter.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/sync/SgSyncAdapter.kt
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2013-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2013 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.sync
 
@@ -21,7 +21,7 @@ import com.battlelancer.seriesguide.appwidget.ListWidgetProvider
 import com.battlelancer.seriesguide.backend.HexagonTools
 import com.battlelancer.seriesguide.backend.settings.HexagonSettings
 import com.battlelancer.seriesguide.jobs.NetworkJobProcessor
-import com.battlelancer.seriesguide.lists.ListsTools2
+import com.battlelancer.seriesguide.lists.ListsTools
 import com.battlelancer.seriesguide.movies.tools.MovieTools
 import com.battlelancer.seriesguide.notifications.NotificationService
 import com.battlelancer.seriesguide.provider.SeriesGuideDatabase
@@ -35,6 +35,7 @@ import com.battlelancer.seriesguide.util.TaskManager
 import com.uwetrottmann.androidutils.AndroidUtils
 import com.uwetrottmann.tmdb2.services.ConfigurationService
 import dagger.Lazy
+import kotlinx.coroutines.runBlocking
 import timber.log.Timber
 import javax.inject.Inject
 import kotlin.math.pow
@@ -141,7 +142,7 @@ class SgSyncAdapter(context: Context) : AbstractThreadedSyncAdapter(context, tru
 
         if (Thread.interrupted()) throw InterruptedException()
 
-        // Update show data.
+        // Update show and movie data.
         // If failed for at least one show, do not proceed with other sync steps to avoid
         // syncing with outdated show data. However, renew the search table and trigger the
         // notification service if at least one show was updated.
@@ -165,14 +166,6 @@ class SgSyncAdapter(context: Context) : AbstractThreadedSyncAdapter(context, tru
             if (showSync.isSyncMultiple) {
                 if (Thread.interrupted()) throw InterruptedException()
 
-                // update data of to be released movies
-                if (!tmdbSync.updateMovies(progress)) {
-                    progress.recordError()
-                }
-                Timber.d("Syncing: TMDB...DONE")
-
-                if (Thread.interrupted()) throw InterruptedException()
-
                 // sync with hexagon
                 val isHexagonEnabled = HexagonSettings.isEnabled(context)
                 if (isHexagonEnabled) {
@@ -198,7 +191,7 @@ class SgSyncAdapter(context: Context) : AbstractThreadedSyncAdapter(context, tru
 
                 // Migrate legacy list items
                 // Note: might send to Hexagon, so make sure to sync lists with Hexagon before
-                ListsTools2.migrateTvdbShowListItemsToTmdbIds(context)
+                ListsTools.migrateTvdbShowListItemsToTmdbIds(context)
 
                 if (Thread.interrupted()) throw InterruptedException()
 
@@ -225,6 +218,35 @@ class SgSyncAdapter(context: Context) : AbstractThreadedSyncAdapter(context, tru
                 // update next episodes for all shows
                 TaskManager.tryNextEpisodeUpdateTask(context)
 
+                // Movies
+
+                // Add movies that were added to custom lists (by Cloud or a lists only import), but
+                // aren't in the database, yet.
+                // Delete movies from the database that were removed from custom and built-in lists
+                // by Cloud, Trakt or the user deleting a whole list (through DeleteListTask or a
+                // lists only import).
+                // This is done here once to avoid having to implement this for every component
+                // mentioned above. Also, adding a movie may fail due to network or other issues,
+                // so this will ensure eventually all movies are added to the database and will
+                // appear in custom lists during a next sync. And waiting to delete until here
+                // should not have any consequences as movies not in any list aren't displayed in
+                // the UI (they would still get exported).
+                // This is also done before updating movies to avoid updating a to be deleted movie.
+                // Note: this uses runBlocking, so if the calling thread is interrupted this will
+                // throw InterruptedException.
+                runBlocking {
+                    movieTools.get().updateDatabaseAfterCustomListChange()
+                }
+                Timber.d("Syncing: updating movie database...DONE")
+
+                // Update data of to be released movies
+                // It is OK to do this after movies are synced with Cloud or Trakt as all required
+                // data exists by default (unlike for shows, where episodes might be missing).
+                if (!tmdbSync.updateMovies(progress)) {
+                    progress.recordError()
+                }
+                Timber.d("Syncing: TMDB movies...DONE")
+
                 updateTimeAndFailedCounter(prefs, resultCode)
             }
 
diff --git a/app/src/main/java/com/battlelancer/seriesguide/sync/TmdbSync.kt b/app/src/main/java/com/battlelancer/seriesguide/sync/TmdbSync.kt
index 615140e4a0..3e2c16db8f 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/sync/TmdbSync.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/sync/TmdbSync.kt
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2018-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2018 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.sync
 
@@ -117,7 +117,12 @@ class TmdbSync internal constructor(
 
             // try loading details from tmdb
             val detailsResult = runBlocking {
-                movieTools.getMovieDetails(languageCode, regionCode, movie.tmdbId, false)
+                movieTools.downloader.getMovieDetails(
+                    languageCode,
+                    regionCode,
+                    movie.tmdbId,
+                    false
+                )
             }
             val details = detailsResult.movieDetails
             if (details.tmdbMovie() != null) {
diff --git a/app/src/main/java/com/battlelancer/seriesguide/sync/TraktSync.kt b/app/src/main/java/com/battlelancer/seriesguide/sync/TraktSync.kt
index 4be43eb3da..65a03e2b29 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/sync/TraktSync.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/sync/TraktSync.kt
@@ -22,7 +22,6 @@ import timber.log.Timber
 /**
  * Syncs episode watched and collected state, episode ratings, show ratings,
  * watchlist, collection and watched movies and movie ratings with Trakt.
- * Removes movies not in any of these lists on Trakt.
  */
 class TraktSync(
     val context: Context,
@@ -46,6 +45,12 @@ class TraktSync(
     }
 
     /**
+     * Syncs episode watched and collected state, episode ratings, show ratings,
+     * watchlist, collection and watched movies and movie ratings with Trakt.
+     *
+     * Does not delete any movies from the database that are no longer on a built-in (or custom)
+     * list afterward, this is done in a later sync step.
+     *
      * To not conflict with Hexagon sync, can turn on [onlyRatings] so only
      * ratings are synced.
      *
@@ -120,8 +125,8 @@ class TraktSync(
                 progress.recordError()
                 return SgSyncAdapter.UpdateResult.INCOMPLETE
             }
-            // Clean up any useless movies (not watched or not in any list).
-            MovieTools.deleteUnusedMovies(context)
+            // Note: movies not in any list or not watched will be cleaned up as part of a later
+            // sync step.
         }
         // Download movie ratings.
         progress.publish(SyncProgress.Step.TRAKT_RATINGS)
diff --git a/app/src/main/java/com/battlelancer/seriesguide/util/AppUpgrade.kt b/app/src/main/java/com/battlelancer/seriesguide/util/AppUpgrade.kt
index 7d13422b0f..b6c97a8544 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/util/AppUpgrade.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/util/AppUpgrade.kt
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2021-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2021 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.util
 
@@ -129,6 +129,13 @@ class AppUpgrade(
                 context.deleteSharedPreferences("extension_amazon")
             }
         }
+
+        if (lastVersion < SgApp.RELEASE_VERSION_2026_2_0) {
+            // Support for movies in lists was added. When downloading list changes, Cloud skips
+            // items with unknown type. So reset lists sync, so items with the new movie type,
+            // potentially added by other, already upgraded devices, are added to lists.
+            HexagonSettings.resetLastListsSyncTime(context)
+        }
     }
 
     /**
diff --git a/app/src/main/java/com/battlelancer/seriesguide/util/ImageTools.kt b/app/src/main/java/com/battlelancer/seriesguide/util/ImageTools.kt
index de099c9cad..79e2114636 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/util/ImageTools.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/util/ImageTools.kt
@@ -11,6 +11,10 @@ import com.battlelancer.seriesguide.R
 import com.battlelancer.seriesguide.settings.AppSettings
 import com.battlelancer.seriesguide.settings.UpdateSettings
 import com.battlelancer.seriesguide.tmdbapi.TmdbTools
+import com.battlelancer.seriesguide.util.ImageTools.buildTmdbOrTvdbImageCacheUrl
+import com.battlelancer.seriesguide.util.ImageTools.isAllowedLargeDataConnection
+import com.battlelancer.seriesguide.util.ImageTools.loadShowPosterResizeCrop
+import com.battlelancer.seriesguide.util.ImageTools.tmdbOrTvdbPosterUrl
 import com.squareup.picasso.NetworkPolicy
 import com.squareup.picasso.Picasso
 import com.squareup.picasso.RequestCreator
@@ -92,43 +96,21 @@ object ImageTools {
     }
 
     /**
-     * Calls [buildTmdbOrTvdbImageCacheUrl] with small image and demo URLs for show posters.
+     * Calls [buildTmdbOrTvdbImageCacheUrl] configured for poster URLs built from
+     * [TmdbTools.getPosterBaseUrl] and [imagePath].
+     *
+     * If possible, use [ImageUrlTools.tmdbOrTvdbPosterUrl] instead.
      */
-    @JvmStatic
     fun tmdbOrTvdbPosterUrl(
         imagePath: String?,
         context: Context,
         originalSize: Boolean = false
     ): String? {
-        return buildTmdbOrTvdbImageCacheUrl(
-            imagePath, context, originalSize,
-            demoUrl = { nonNullImagePath ->
-                pickDemoPosterUrl(nonNullImagePath)
-            },
-            tmdbSmallImageUrl = { nonNullImagePath ->
-                "${TmdbTools.getPosterBaseUrl(context)}$nonNullImagePath"
-            }
-        )
+        return ImageUrlTools(context).tmdbOrTvdbPosterUrl(imagePath, originalSize)
     }
 
-    private val demoPosterUrls = listOf(
-        "https://seriesgui.de/demo/anime.jpg",
-        "https://seriesgui.de/demo/crime.jpg",
-        "https://seriesgui.de/demo/fantasy-2.jpg",
-        "https://seriesgui.de/demo/fantasy.jpg",
-        "https://seriesgui.de/demo/medical.jpg",
-        "https://seriesgui.de/demo/scifi-3.jpg",
-        "https://seriesgui.de/demo/scifi.jpg",
-        "https://seriesgui.de/demo/sitcom.jpg",
-    )
-
     private val demoEpisodeImageUrl = "https://seriesgui.de/demo/episode-anime.jpg"
 
-    private fun pickDemoPosterUrl(imagePath: String): String {
-        // Map an image path always to the same image
-        return demoPosterUrls[imagePath.hashCode().mod(demoPosterUrls.size)]
-    }
-
     /**
      * Calls [buildTmdbOrTvdbImageCacheUrl] with small image and demo URLs for episode images.
      */
@@ -149,12 +131,13 @@ object ImageTools {
     /**
      * Builds an image cache URL, or returns null if [imagePath] is null or empty.
      *
-     * Returns [demoUrl] if [AppSettings.isDemoModeEnabled] is enabled.
+     * If [imagePath] starts with `/` uses the URL returned by [tmdbSmallImageUrl].
+     * If [originalSize] is set, using [TmdbTools.buildOriginalSizeImageUrl] instead.
+     * Otherwise, a legacy TVDB URL.
      *
-     * If [imagePath] starts with `/` builds a TMDB episode image path with resolution depending on
-     * [originalSize]. Otherwise a legacy TVDB URL.
+     * Returns [demoUrl] if [AppSettings.isDemoModeEnabled] is enabled.
      */
-    private fun buildTmdbOrTvdbImageCacheUrl(
+    fun buildTmdbOrTvdbImageCacheUrl(
         imagePath: String?,
         context: Context,
         originalSize: Boolean = false,
@@ -267,22 +250,32 @@ object ImageTools {
      * The resize dimensions are those used for posters in the show list and change depending on
      * screen size.
      */
-    @JvmStatic
+    @Deprecated("Use ImageUrlTools to prebuild the URL and then load it later with loadAndResizeCropToShowPosterSize")
     fun loadShowPosterResizeCrop(
         context: Context,
         imageView: ImageView,
         posterPath: String?
     ) {
-        loadShowPosterUrlResizeCrop(context, imageView, tmdbOrTvdbPosterUrl(posterPath, context))
+        loadAndResizeCropToShowPosterSize(
+            context,
+            imageView,
+            tmdbOrTvdbPosterUrl(posterPath, context)
+        )
     }
 
+    /**
+     * Resizes to `show_poster_width` and `show_poster_height` dimensions used in shows and list
+     * items layouts.
+     *
+     * The [posterUrl] can be built with [tmdbOrTvdbPosterUrl].
+     */
     @JvmStatic
-    fun loadShowPosterUrlResizeCrop(
+    fun loadAndResizeCropToShowPosterSize(
         context: Context,
         imageView: ImageView,
-        url: String?
+        posterUrl: String?
     ) {
-        loadWithPicasso(context, url)
+        loadWithPicasso(context, posterUrl)
             .resizeDimen(R.dimen.show_poster_width, R.dimen.show_poster_height)
             .centerCrop()
             .error(R.drawable.ic_photo_gray_24dp)
@@ -343,4 +336,52 @@ object ImageTools {
             .into(imageView)
     }
 
-}
\ No newline at end of file
+}
+
+/**
+ * Helps efficiently build image URLs by caching the base URL. Use this to construct the final image
+ * URL on a background thread and then only load it on the UI thread.
+ */
+class ImageUrlTools(
+    private val context: Context
+) {
+
+    private val posterBaseUrlTmdb = TmdbTools.getPosterBaseUrl(context)
+
+    /**
+     * Calls [buildTmdbOrTvdbImageCacheUrl] configured for poster URLs built from
+     * [TmdbTools.getPosterBaseUrl] and [imagePath].
+     */
+    fun tmdbOrTvdbPosterUrl(
+        imagePath: String?,
+        originalSize: Boolean = false
+    ): String? {
+        return buildTmdbOrTvdbImageCacheUrl(
+            imagePath, context, originalSize,
+            demoUrl = { nonNullImagePath ->
+                pickDemoPosterUrl(nonNullImagePath)
+            },
+            tmdbSmallImageUrl = { nonNullImagePath ->
+                posterBaseUrlTmdb + nonNullImagePath
+            }
+        )
+    }
+
+    companion object {
+        private fun pickDemoPosterUrl(imagePath: String): String {
+            // Map an image path always to the same image
+            return demoPosterUrls[imagePath.hashCode().mod(demoPosterUrls.size)]
+        }
+
+        private val demoPosterUrls = listOf(
+            "https://seriesgui.de/demo/anime.jpg",
+            "https://seriesgui.de/demo/crime.jpg",
+            "https://seriesgui.de/demo/fantasy-2.jpg",
+            "https://seriesgui.de/demo/fantasy.jpg",
+            "https://seriesgui.de/demo/medical.jpg",
+            "https://seriesgui.de/demo/scifi-3.jpg",
+            "https://seriesgui.de/demo/scifi.jpg",
+            "https://seriesgui.de/demo/sitcom.jpg",
+        )
+    }
+}
diff --git a/app/src/main/java/com/battlelancer/seriesguide/util/SgPicassoRequestHandler.kt b/app/src/main/java/com/battlelancer/seriesguide/util/SgPicassoRequestHandler.kt
index 1fa3a5380e..61b466a08b 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/util/SgPicassoRequestHandler.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/util/SgPicassoRequestHandler.kt
@@ -11,6 +11,7 @@ import android.content.Context
 import android.net.Uri
 import androidx.core.net.toUri
 import com.battlelancer.seriesguide.SgApp
+import com.battlelancer.seriesguide.movies.tools.MoviePosterDownloader
 import com.battlelancer.seriesguide.tmdbapi.TmdbTools
 import com.battlelancer.seriesguide.tmdbapi.TmdbTools2
 import com.squareup.picasso.Downloader
@@ -67,8 +68,8 @@ class SgPicassoRequestHandler(
 
             val posterPath: String? = try {
                 runBlocking {
-                    SgApp.getServicesComponent(context).movieTools()
-                        .getMoviePosterPath(movieTmdbId)
+                    val tmdbMovies = SgApp.getServicesComponent(context).moviesService()
+                    MoviePosterDownloader(context, tmdbMovies).getMoviePosterPath(movieTmdbId)
                 }
             } catch (e: InterruptedException) {
                 null // Do nothing
diff --git a/app/src/main/java/com/battlelancer/seriesguide/util/TimeTools.kt b/app/src/main/java/com/battlelancer/seriesguide/util/TimeTools.kt
index 572daacb7c..2c32801095 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/util/TimeTools.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/util/TimeTools.kt
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2014-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2014 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.util
 
@@ -133,11 +133,12 @@ object TimeTools {
      * Parses a ISO 8601 time string (e.g. "20:30") and encodes it into an integer with format
      * "hhmm" (e.g. 2030).
      *
-     *  If time is invalid returns -1. Performs no extensive formatting check, though.
+     *  If time is invalid returns [SgShow2.UNKNOWN_RELEASE_TIME]. Performs no extensive formatting
+     *  check, though.
      */
     fun parseShowReleaseTime(localTime: String?): Int {
         if (localTime == null || localTime.length != 5) {
-            return -1
+            return SgShow2.UNKNOWN_RELEASE_TIME
         }
 
         // extract hour and minute, example: "20:30" => hour = 20, minute = 30
@@ -476,7 +477,7 @@ object TimeTools {
                 null, null,
                 applyCorrections = false
             )
-        } else if (releaseTime != null && releaseTime != -1) {
+        } else if (releaseTime != null && releaseTime != SgShow2.UNKNOWN_RELEASE_TIME) {
             return getShowReleaseDateTime(
                 context,
                 releaseTime,
@@ -763,13 +764,21 @@ object TimeTools {
      *
      * @see formatToLocalDate
      */
-    fun formatToLocalDateShort(context: Context, dateTime: Date): String =
+    fun formatToLocalDateShort(context: Context, timeInMillis: Long): String =
         DateUtils.formatDateTime(
             context,
-            dateTime.time,
+            timeInMillis,
             DateUtils.FORMAT_SHOW_DATE or DateUtils.FORMAT_ABBREV_ALL
         )
 
+    /**
+     * Formats to a date like "Oct 31", or if the date is not in the current year "Oct 31, 2010".
+     *
+     * @see formatToLocalDate
+     */
+    fun formatToLocalDateShort(context: Context, dateTime: Date): String =
+        formatToLocalDateShort(context, dateTime.time)
+
     /**
      * Formats to a date, time zone and week day (e.g. "2014/02/04 CET (Mon)") as defined by the
      * devices locale. If the date time is today, uses the local equivalent of "today" instead of a
diff --git a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/AddListTask.java b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/AddListTask.java
index aa888e37e8..4035c2c9d0 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/AddListTask.java
+++ b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/AddListTask.java
@@ -38,7 +38,7 @@ protected boolean isSendingToTrakt() {
     }
 
     @Override
-    protected Integer doBackgroundAction(Void... params) {
+    protected int doBackgroundAction(Void... params) {
         String listId = getListId();
 
         if (isSendingToHexagon()) {
diff --git a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/BaseActionTask.kt b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/BaseActionTask.kt
index ed815b7fc5..82daafc284 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/BaseActionTask.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/BaseActionTask.kt
@@ -78,7 +78,7 @@ abstract class BaseActionTask(context: Context) : AsyncTask<Void?, Void?, Int?>(
         return doBackgroundAction(*params)
     }
 
-    protected abstract fun doBackgroundAction(vararg params: Void?): Int?
+    protected abstract fun doBackgroundAction(vararg params: Void?): Int
 
     interface ResponseCallback<T> {
         fun handleSuccessfulResponse(body: T): Int
diff --git a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/BaseRateItemTask.kt b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/BaseRateItemTask.kt
index a2279babdc..aa0eb644eb 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/BaseRateItemTask.kt
+++ b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/BaseRateItemTask.kt
@@ -24,7 +24,7 @@ abstract class BaseRateItemTask(
     override val isSendingToHexagon: Boolean
         get() = false // Hexagon does not support ratings.
 
-    override fun doBackgroundAction(vararg params: Void?): Int? {
+    override fun doBackgroundAction(vararg params: Void?): Int {
         if (isSendingToTrakt) {
             if (!TraktCredentials.get(context).hasCredentials()) {
                 return ERROR_TRAKT_AUTH
diff --git a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/BaseShowActionTask.java b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/BaseShowActionTask.java
index 99c2c5fbc7..e520e476c5 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/BaseShowActionTask.java
+++ b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/BaseShowActionTask.java
@@ -34,7 +34,7 @@ protected boolean isSendingToHexagon() {
     }
 
     @Override
-    protected Integer doBackgroundAction(Void... params) {
+    protected int doBackgroundAction(Void... params) {
         if (isSendingToTrakt()) {
             if (!TraktCredentials.get(getContext()).hasCredentials()) {
                 return ERROR_TRAKT_AUTH;
diff --git a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/ChangeListItemListsTask.java b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/ChangeListItemListsTask.java
deleted file mode 100644
index 7bbaf85319..0000000000
--- a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/ChangeListItemListsTask.java
+++ /dev/null
@@ -1,157 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2016-2019, 2021, 2023 Uwe Trottmann
-
-package com.battlelancer.seriesguide.util.tasks;
-
-import android.content.ContentProviderOperation;
-import android.content.Context;
-import android.content.OperationApplicationException;
-import androidx.annotation.NonNull;
-import com.battlelancer.seriesguide.R;
-import com.battlelancer.seriesguide.SgApp;
-import com.battlelancer.seriesguide.backend.HexagonTools;
-import com.battlelancer.seriesguide.provider.SeriesGuideContract;
-import com.battlelancer.seriesguide.util.DBUtils;
-import com.battlelancer.seriesguide.util.Errors;
-import com.uwetrottmann.seriesguide.backend.lists.Lists;
-import com.uwetrottmann.seriesguide.backend.lists.model.SgList;
-import com.uwetrottmann.seriesguide.backend.lists.model.SgListItem;
-import com.uwetrottmann.seriesguide.backend.lists.model.SgListList;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-import timber.log.Timber;
-
-/**
- * Task to add or remove an item to and from lists.
- */
-public class ChangeListItemListsTask extends BaseActionTask {
-
-    private final int itemStableId;
-    private final int itemType;
-    private final List<String> addToTheseLists;
-    private final List<String> removeFromTheseLists;
-
-    public ChangeListItemListsTask(@NonNull Context context, int itemStableId, int itemType,
-            @NonNull List<String> addToTheseLists, @NonNull List<String> removeFromTheseLists) {
-        super(context);
-        this.itemStableId = itemStableId;
-        this.itemType = itemType;
-        this.addToTheseLists = addToTheseLists;
-        this.removeFromTheseLists = removeFromTheseLists;
-    }
-
-    @Override
-    protected boolean isSendingToTrakt() {
-        return false;
-    }
-
-    @Override
-    protected Integer doBackgroundAction(Void... params) {
-        if (isSendingToHexagon()) {
-            HexagonTools hexagonTools = SgApp.getServicesComponent(getContext()).hexagonTools();
-            Lists listsService = hexagonTools.getListsService();
-            if (listsService == null) {
-                return ERROR_HEXAGON_API;
-            }
-
-            SgListList wrapper = new SgListList();
-            if (addToTheseLists.size() > 0) {
-                List<SgList> lists = buildListItemLists(addToTheseLists);
-                wrapper.setLists(lists);
-
-                try {
-                    listsService.save(wrapper).execute();
-                } catch (IOException e) {
-                    Errors.logAndReportHexagon("add list items", e);
-                    return ERROR_HEXAGON_API;
-                }
-            }
-
-            if (removeFromTheseLists.size() > 0) {
-                List<SgList> lists = buildListItemLists(removeFromTheseLists);
-                wrapper.setLists(lists);
-
-                try {
-                    listsService.removeItems(wrapper).execute();
-                } catch (IOException e) {
-                    Errors.logAndReportHexagon("remove list items", e);
-                    return ERROR_HEXAGON_API;
-                }
-            }
-        }
-
-        // update local state
-        if (!doDatabaseUpdate()) {
-            return ERROR_DATABASE;
-        }
-
-        return SUCCESS;
-    }
-
-    @NonNull
-    private List<SgList> buildListItemLists(List<String> listsToChange) {
-        List<SgList> lists = new ArrayList<>(listsToChange.size());
-        for (String listId : listsToChange) {
-            SgList list = new SgList();
-            list.setListId(listId);
-            lists.add(list);
-
-            List<SgListItem> items = new ArrayList<>(1);
-            list.setListItems(items);
-
-            String listItemId = SeriesGuideContract.ListItems
-                    .generateListItemId(itemStableId, itemType, listId);
-            SgListItem item = new SgListItem();
-            items.add(item);
-            item.setListItemId(listItemId);
-        }
-        return lists;
-    }
-
-    private boolean doDatabaseUpdate() {
-        ArrayList<ContentProviderOperation> batch = new ArrayList<>(
-                addToTheseLists.size() + removeFromTheseLists.size());
-        for (String listId : addToTheseLists) {
-            String listItemId = SeriesGuideContract.ListItems.generateListItemId(itemStableId,
-                    itemType, listId);
-            batch.add(ContentProviderOperation
-                    .newInsert(SeriesGuideContract.ListItems.CONTENT_URI)
-                    .withValue(SeriesGuideContract.ListItems.LIST_ITEM_ID, listItemId)
-                    .withValue(SeriesGuideContract.ListItems.ITEM_REF_ID, itemStableId)
-                    .withValue(SeriesGuideContract.ListItems.TYPE, itemType)
-                    .withValue(SeriesGuideContract.Lists.LIST_ID, listId)
-                    .build());
-        }
-        for (String listId : removeFromTheseLists) {
-            String listItemId = SeriesGuideContract.ListItems.generateListItemId(itemStableId,
-                    itemType, listId);
-            batch.add(ContentProviderOperation
-                    .newDelete(SeriesGuideContract.ListItems.buildListItemUri(listItemId))
-                    .build());
-        }
-
-        // apply ops
-        try {
-            DBUtils.applyInSmallBatches(getContext(), batch);
-        } catch (OperationApplicationException e) {
-            Timber.e(e, "Applying list changes failed");
-            return false;
-        }
-
-        // notify URI used by list fragments
-        getContext().getContentResolver()
-                .notifyChange(SeriesGuideContract.ListItems.CONTENT_WITH_DETAILS_URI, null);
-
-        return true;
-    }
-
-    @Override
-    protected int getSuccessTextResId() {
-        if (isSendingToHexagon()) {
-            return R.string.ack_list_item_manage;
-        } else {
-            return 0;
-        }
-    }
-}
diff --git a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/ChangeListItemListsTask.kt b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/ChangeListItemListsTask.kt
new file mode 100644
index 0000000000..b3756c6b4a
--- /dev/null
+++ b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/ChangeListItemListsTask.kt
@@ -0,0 +1,150 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-FileCopyrightText: Copyright © 2016 Uwe Trottmann <uwe@uwetrottmann.com>
+
+package com.battlelancer.seriesguide.util.tasks
+
+import android.content.ContentProviderOperation
+import android.content.Context
+import android.content.OperationApplicationException
+import com.battlelancer.seriesguide.R
+import com.battlelancer.seriesguide.SgApp
+import com.battlelancer.seriesguide.provider.SeriesGuideContract
+import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItemTypes
+import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItems
+import com.battlelancer.seriesguide.util.DBUtils
+import com.battlelancer.seriesguide.util.Errors
+import com.uwetrottmann.seriesguide.backend.lists.model.SgList
+import com.uwetrottmann.seriesguide.backend.lists.model.SgListItem
+import com.uwetrottmann.seriesguide.backend.lists.model.SgListList
+import kotlinx.coroutines.runBlocking
+import timber.log.Timber
+import java.io.IOException
+
+/**
+ * Task to add or remove an item to and from lists.
+ *
+ * If the [itemType] is a movie, also adds to or deletes it from the database depending on if it
+ * is on a custom list or built-in list after the list changes.
+ */
+class ChangeListItemListsTask(
+    context: Context,
+    private val itemTmdbId: Int,
+    @ListItemTypes private val itemType: Int,
+    private val addToTheseLists: List<String>,
+    private val removeFromTheseLists: List<String>
+) : BaseActionTask(context) {
+
+    override val isSendingToTrakt: Boolean = false
+
+    override fun doBackgroundAction(vararg params: Void?): Int {
+        if (isSendingToHexagon) {
+            val hexagonTools = SgApp.getServicesComponent(context).hexagonTools()
+            val listsService = hexagonTools.listsService
+                ?: return ERROR_HEXAGON_API
+
+            val wrapper = SgListList()
+            if (addToTheseLists.isNotEmpty()) {
+                val lists = buildListItemLists(addToTheseLists)
+                wrapper.setLists(lists)
+
+                try {
+                    listsService.save(wrapper).execute()
+                } catch (e: IOException) {
+                    Errors.logAndReportHexagon("add list items", e)
+                    return ERROR_HEXAGON_API
+                }
+            }
+
+            if (removeFromTheseLists.isNotEmpty()) {
+                val lists = buildListItemLists(removeFromTheseLists)
+                wrapper.setLists(lists)
+
+                try {
+                    listsService.removeItems(wrapper).execute()
+                } catch (e: IOException) {
+                    Errors.logAndReportHexagon("remove list items", e)
+                    return ERROR_HEXAGON_API
+                }
+            }
+        }
+
+        // update local state
+        if (!doDatabaseUpdate()) {
+            return ERROR_DATABASE
+        }
+
+        return SUCCESS
+    }
+
+    private fun buildListItemLists(listsToChange: List<String>): List<SgList> {
+        return listsToChange.map { listId ->
+            SgList().also { list ->
+                list.setListId(listId)
+
+                val item = SgListItem().also {
+                    val listItemId = ListItems.generateListItemId(itemTmdbId, itemType, listId)
+                    it.setListItemId(listItemId)
+                }
+
+                list.setListItems(listOf(item))
+            }
+        }
+    }
+
+    private fun doDatabaseUpdate(): Boolean {
+        val batch = ArrayList<ContentProviderOperation>(
+            addToTheseLists.size + removeFromTheseLists.size
+        )
+        for (listId in addToTheseLists) {
+            val listItemId = ListItems.generateListItemId(itemTmdbId, itemType, listId)
+
+            batch.add(
+                ContentProviderOperation
+                    .newInsert(ListItems.CONTENT_URI)
+                    .withValue(ListItems.LIST_ITEM_ID, listItemId)
+                    .withValue(ListItems.ITEM_REF_ID, itemTmdbId)
+                    .withValue(ListItems.TYPE, itemType)
+                    .withValue(SeriesGuideContract.Lists.LIST_ID, listId)
+                    .build()
+            )
+        }
+        for (listId in removeFromTheseLists) {
+            val listItemId = ListItems.generateListItemId(itemTmdbId, itemType, listId)
+            batch.add(
+                ContentProviderOperation
+                    .newDelete(ListItems.buildListItemUri(listItemId))
+                    .build()
+            )
+        }
+
+        // apply ops
+        try {
+            DBUtils.applyInSmallBatches(context, batch)
+        } catch (e: OperationApplicationException) {
+            Timber.e(e, "Applying list changes failed")
+            return false
+        }
+
+        // For a movie, also add it to or delete it from the database depending on if it is on
+        // any custom lists or built-in lists after the above list changes.
+        if (itemType == ListItemTypes.TMDB_MOVIE) {
+            try {
+                val success: Boolean = runBlocking {
+                    SgApp.getServicesComponent(context).movieTools()
+                        .addToOrDeleteFromDatabaseAfterCustomListChange(itemTmdbId)
+                }
+                if (!success) {
+                    return false
+                }
+            } catch (e: InterruptedException) {
+                Timber.e(e, "Adding to or deleting movie from database interrupted")
+                return false
+            }
+        }
+
+        return true
+    }
+
+    override val successTextResId: Int
+        get() = if (isSendingToHexagon) R.string.ack_list_item_manage else 0
+}
diff --git a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/DeleteListTask.java b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/DeleteListTask.java
deleted file mode 100644
index b51176b2a5..0000000000
--- a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/DeleteListTask.java
+++ /dev/null
@@ -1,82 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2016-2019, 2021, 2023 Uwe Trottmann
-
-package com.battlelancer.seriesguide.util.tasks;
-
-import android.content.Context;
-import androidx.annotation.NonNull;
-import com.battlelancer.seriesguide.R;
-import com.battlelancer.seriesguide.SgApp;
-import com.battlelancer.seriesguide.backend.HexagonTools;
-import com.battlelancer.seriesguide.provider.SeriesGuideContract;
-import com.battlelancer.seriesguide.util.Errors;
-import com.uwetrottmann.seriesguide.backend.lists.Lists;
-import java.io.IOException;
-
-/**
- * Task to delete a list and its items.
- */
-public class DeleteListTask extends BaseActionTask {
-
-    @NonNull protected final String listId;
-
-    public DeleteListTask(@NonNull Context context, @NonNull String listId) {
-        super(context);
-        this.listId = listId;
-    }
-
-    @Override
-    protected boolean isSendingToTrakt() {
-        return false;
-    }
-
-    @Override
-    protected Integer doBackgroundAction(Void... params) {
-        if (isSendingToHexagon()) {
-            HexagonTools hexagonTools = SgApp.getServicesComponent(getContext()).hexagonTools();
-            Lists listsService = hexagonTools.getListsService();
-            if (listsService == null) {
-                return ERROR_HEXAGON_API; // no longer signed in
-            }
-
-            // send list to be removed from hexagon
-            try {
-                listsService.remove(listId).execute();
-            } catch (IOException e) {
-                Errors.logAndReportHexagon("remove list", e);
-                return ERROR_HEXAGON_API;
-            }
-        }
-
-        // update local state
-        if (!doDatabaseUpdate()) {
-            return ERROR_DATABASE;
-        }
-
-        return SUCCESS;
-    }
-
-    private boolean doDatabaseUpdate() {
-        // delete all items of the list before list to avoid violating foreign key constraints
-        getContext().getContentResolver()
-                .delete(SeriesGuideContract.ListItems.CONTENT_URI,
-                        SeriesGuideContract.ListItems.SELECTION_LIST, new String[] {
-                                listId
-                        });
-        // count of deleted items is not returned, so do not check
-
-        // delete the list
-        int deleted = getContext().getContentResolver()
-                .delete(SeriesGuideContract.Lists.buildListUri(listId), null, null);
-        return deleted != 0;
-    }
-
-    @Override
-    protected int getSuccessTextResId() {
-        if (isSendingToHexagon()) {
-            return R.string.ack_list_removed;
-        } else {
-            return 0;
-        }
-    }
-}
diff --git a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/DeleteListTask.kt b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/DeleteListTask.kt
new file mode 100644
index 0000000000..ec174e8d15
--- /dev/null
+++ b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/DeleteListTask.kt
@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-FileCopyrightText: Copyright © 2016 Uwe Trottmann <uwe@uwetrottmann.com>
+
+package com.battlelancer.seriesguide.util.tasks
+
+import android.content.Context
+import com.battlelancer.seriesguide.R
+import com.battlelancer.seriesguide.SgApp
+import com.battlelancer.seriesguide.provider.SeriesGuideContract
+import com.battlelancer.seriesguide.util.Errors
+import java.io.IOException
+
+/**
+ * Task to delete a list and its items.
+ */
+class DeleteListTask(
+    context: Context,
+    private val listId: String
+) : BaseActionTask(context) {
+
+    override val isSendingToTrakt: Boolean = false
+
+    override fun doBackgroundAction(vararg params: Void?): Int {
+        if (isSendingToHexagon) {
+            val hexagonTools = SgApp.getServicesComponent(context).hexagonTools()
+            val listsService = hexagonTools.listsService
+                ?: return ERROR_HEXAGON_API // no longer signed in
+
+            // send list to be removed from hexagon
+            try {
+                listsService.remove(listId).execute()
+            } catch (e: IOException) {
+                Errors.logAndReportHexagon("remove list", e)
+                return ERROR_HEXAGON_API
+            }
+        }
+
+        // update local state
+        if (!doDatabaseUpdate()) {
+            return ERROR_DATABASE
+        }
+
+        return SUCCESS
+    }
+
+    private fun doDatabaseUpdate(): Boolean {
+        // Note: movies that are no longer on any custom or built-in list after this will be deleted
+        // from the database during the next sync.
+
+        // delete all items of the list before list to avoid violating foreign key constraints
+        context.contentResolver
+            .delete(
+                SeriesGuideContract.ListItems.CONTENT_URI,
+                SeriesGuideContract.ListItems.SELECTION_LIST,
+                arrayOf(listId)
+            )
+        // count of deleted items is not returned, so do not check
+
+        // delete the list
+        val deleted = context.contentResolver
+            .delete(SeriesGuideContract.Lists.buildListUri(listId), null, null)
+        return deleted != 0
+    }
+
+    override val successTextResId: Int
+        get() = if (isSendingToHexagon) R.string.ack_list_removed else 0
+
+}
diff --git a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/RemoveListItemTask.java b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/RemoveListItemTask.java
deleted file mode 100644
index dd3d798ac9..0000000000
--- a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/RemoveListItemTask.java
+++ /dev/null
@@ -1,112 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2016-2019, 2023 Uwe Trottmann
-
-package com.battlelancer.seriesguide.util.tasks;
-
-import android.content.Context;
-import androidx.annotation.NonNull;
-import com.battlelancer.seriesguide.R;
-import com.battlelancer.seriesguide.SgApp;
-import com.battlelancer.seriesguide.backend.HexagonTools;
-import com.battlelancer.seriesguide.provider.SeriesGuideContract;
-import com.battlelancer.seriesguide.util.Errors;
-import com.uwetrottmann.seriesguide.backend.lists.Lists;
-import com.uwetrottmann.seriesguide.backend.lists.model.SgList;
-import com.uwetrottmann.seriesguide.backend.lists.model.SgListItem;
-import com.uwetrottmann.seriesguide.backend.lists.model.SgListList;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Task to remove an item from a single list (basically delete the list item).
- */
-public class RemoveListItemTask extends BaseActionTask {
-
-    private final String listItemId;
-
-    public RemoveListItemTask(@NonNull Context context, @NonNull String listItemId) {
-        super(context);
-        this.listItemId = listItemId;
-    }
-
-    @Override
-    protected boolean isSendingToTrakt() {
-        return false;
-    }
-
-    @Override
-    protected Integer doBackgroundAction(Void... params) {
-        if (isSendingToHexagon()) {
-            HexagonTools hexagonTools = SgApp.getServicesComponent(getContext()).hexagonTools();
-            Lists listsService = hexagonTools.getListsService();
-            if (listsService == null) {
-                return ERROR_HEXAGON_API; // no longer signed in
-            }
-
-            // extract the list id of this list item
-            String[] splitListItemId = SeriesGuideContract.ListItems.splitListItemId(listItemId);
-            if (splitListItemId == null) {
-                return ERROR_DATABASE;
-            }
-            String removeFromListId = splitListItemId[2];
-
-            // send the item to be removed from hexagon
-            SgListList wrapper = new SgListList();
-            List<SgList> lists = buildListItemLists(removeFromListId, listItemId);
-            wrapper.setLists(lists);
-            try {
-                listsService.removeItems(wrapper).execute();
-            } catch (IOException e) {
-                Errors.logAndReportHexagon("remove list item", e);
-                return ERROR_HEXAGON_API;
-            }
-        }
-
-        // update local state
-        if (!doDatabaseUpdate()) {
-            return ERROR_DATABASE;
-        }
-
-        return SUCCESS;
-    }
-
-    @NonNull
-    private static List<SgList> buildListItemLists(String listId, String listItemId) {
-        List<SgList> lists = new ArrayList<>(1);
-        SgList list = new SgList();
-        list.setListId(listId);
-        lists.add(list);
-
-        List<SgListItem> items = new ArrayList<>(1);
-        list.setListItems(items);
-
-        SgListItem item = new SgListItem();
-        items.add(item);
-        item.setListItemId(listItemId);
-        return lists;
-    }
-
-    private boolean doDatabaseUpdate() {
-        int deleted = getContext().getContentResolver()
-                .delete(SeriesGuideContract.ListItems.buildListItemUri(listItemId), null, null);
-        if (deleted == 0) {
-            return false; // nothing got deleted
-        }
-
-        // notify URI used by list fragments
-        getContext().getContentResolver()
-                .notifyChange(SeriesGuideContract.ListItems.CONTENT_WITH_DETAILS_URI, null);
-
-        return true;
-    }
-
-    @Override
-    protected int getSuccessTextResId() {
-        if (isSendingToHexagon()) {
-            return R.string.ack_list_item_removed;
-        } else {
-            return 0;
-        }
-    }
-}
diff --git a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/RemoveListItemTask.kt b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/RemoveListItemTask.kt
new file mode 100644
index 0000000000..7706b93415
--- /dev/null
+++ b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/RemoveListItemTask.kt
@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-FileCopyrightText: Copyright © 2016 Uwe Trottmann <uwe@uwetrottmann.com>
+
+package com.battlelancer.seriesguide.util.tasks
+
+import android.content.Context
+import com.battlelancer.seriesguide.R
+import com.battlelancer.seriesguide.SgApp
+import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItems
+import com.battlelancer.seriesguide.util.Errors
+import com.uwetrottmann.seriesguide.backend.lists.model.SgList
+import com.uwetrottmann.seriesguide.backend.lists.model.SgListItem
+import com.uwetrottmann.seriesguide.backend.lists.model.SgListList
+import java.io.IOException
+
+/**
+ * Task to remove an item from a single list (basically delete the list item).
+ *
+ * Note: does not delete a movie from the database if it is no longer on a custom (or built-in) list
+ * afterward, this is done during the next sync.
+ */
+class RemoveListItemTask(
+    context: Context,
+    private val listItemId: String
+) : BaseActionTask(context) {
+
+    override val isSendingToTrakt: Boolean = false
+
+    override fun doBackgroundAction(vararg params: Void?): Int {
+        if (isSendingToHexagon) {
+            val hexagonTools = SgApp.getServicesComponent(context).hexagonTools()
+            val listsService = hexagonTools.listsService
+                ?: return ERROR_HEXAGON_API // no longer signed in
+
+            // extract the list id of this list item
+            val splitListItemId = ListItems.splitListItemId(listItemId)
+                ?: return ERROR_DATABASE
+            val removeFromListId = splitListItemId[2]
+
+            // send the item to be removed from hexagon
+            val wrapper = SgListList()
+            val lists = buildListItemLists(removeFromListId, listItemId)
+            wrapper.setLists(lists)
+            try {
+                listsService.removeItems(wrapper).execute()
+            } catch (e: IOException) {
+                Errors.logAndReportHexagon("remove list item", e)
+                return ERROR_HEXAGON_API
+            }
+        }
+
+        // update local state
+        if (!doDatabaseUpdate()) {
+            return ERROR_DATABASE
+        }
+
+        return SUCCESS
+    }
+
+    private fun buildListItemLists(listId: String, listItemId: String): List<SgList> {
+        val list = SgList().also { list ->
+            list.setListId(listId)
+
+            val item = SgListItem()
+                .also { it.setListItemId(listItemId) }
+            list.setListItems(listOf(item))
+        }
+        return listOf(list)
+    }
+
+    private fun doDatabaseUpdate(): Boolean {
+        val deleted = context.contentResolver
+            .delete(ListItems.buildListItemUri(listItemId), null, null)
+        return deleted != 0 // if 0 nothing got deleted
+    }
+
+    override val successTextResId: Int
+        get() = if (isSendingToHexagon) R.string.ack_list_item_removed else 0
+
+}
diff --git a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/ReorderListsTask.java b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/ReorderListsTask.java
index 5633e11427..cce6de39d9 100644
--- a/app/src/main/java/com/battlelancer/seriesguide/util/tasks/ReorderListsTask.java
+++ b/app/src/main/java/com/battlelancer/seriesguide/util/tasks/ReorderListsTask.java
@@ -42,7 +42,7 @@ protected boolean isSendingToTrakt() {
     }
 
     @Override
-    protected Integer doBackgroundAction(Void... params) {
+    protected int doBackgroundAction(Void... params) {
         if (isSendingToHexagon()) {
             HexagonTools hexagonTools = SgApp.getServicesComponent(getContext()).hexagonTools();
             Lists listsService = hexagonTools.getListsService();
diff --git a/app/src/main/res/layout/buttons_movie.xml b/app/src/main/res/layout/buttons_movie.xml
index 4fb1dae0e1..8958ebe29d 100644
--- a/app/src/main/res/layout/buttons_movie.xml
+++ b/app/src/main/res/layout/buttons_movie.xml
@@ -57,7 +57,7 @@
         <androidx.constraintlayout.helper.widget.Flow
             android:layout_width="0dp"
             android:layout_height="wrap_content"
-            app:constraint_referenced_ids="buttonMovieCheckIn,buttonMovieTrailer,buttonMovieReleaseDates,buttonMovieCollection,buttonMovieSimilar,buttonMovieShare,buttonMovieCalendar,buttonMovieComments,buttonMovieMetacritic,buttonMovieStreamingSearch,buttonMovieStreamingSearchInfo"
+            app:constraint_referenced_ids="buttonMovieCheckIn,buttonMovieManageLists,buttonMovieTrailer,buttonMovieReleaseDates,buttonMovieCollection,buttonMovieSimilar,buttonMovieShare,buttonMovieCalendar,buttonMovieComments,buttonMovieMetacritic,buttonMovieStreamingSearch,buttonMovieStreamingSearchInfo"
             app:flow_horizontalBias="0"
             app:flow_horizontalGap="4dp"
             app:flow_horizontalStyle="packed"
@@ -77,6 +77,16 @@
             app:icon="@drawable/ic_checkin_black_24dp"
             app:iconGravity="start" />
 
+        <Button
+            android:id="@+id/buttonMovieManageLists"
+            style="@style/Widget.SeriesGuide.Button.Outlined.Icon"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:contentDescription="@string/list_item_manage"
+            android:text="@string/list_item_manage"
+            app:icon="@drawable/ic_list_white_24dp"
+            app:iconGravity="start" />
+
         <Button
             android:id="@+id/buttonMovieTrailer"
             style="@style/Widget.SeriesGuide.Button.Outlined.Icon"
diff --git a/app/src/main/res/layout/dialog_lists_sort.xml b/app/src/main/res/layout/dialog_lists_sort.xml
new file mode 100644
index 0000000000..e17095407c
--- /dev/null
+++ b/app/src/main/res/layout/dialog_lists_sort.xml
@@ -0,0 +1,68 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!-- SPDX-License-Identifier: GPL-3.0-or-later -->
+<!-- SPDX-FileCopyrightText: Copyright © 2026 Uwe Trottmann <uwe@uwetrottmann.com> -->
+
+<androidx.core.widget.NestedScrollView xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:scrollbars="vertical">
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="vertical">
+
+        <RadioGroup
+            android:id="@+id/radioGroupListsSort"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="vertical">
+
+            <RadioButton
+                android:id="@+id/radioListsSortTitle"
+                style="@style/Widget.SeriesGuide.DistillationItem"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/action_shows_sort_title" />
+
+            <RadioButton
+                android:id="@+id/radioListsSortLatestReleaseDate"
+                style="@style/Widget.SeriesGuide.DistillationItem"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/action_lists_sort_latest_release_date" />
+
+            <RadioButton
+                android:id="@+id/radioListsSortOldestReleaseDate"
+                style="@style/Widget.SeriesGuide.DistillationItem"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/action_lists_sort_oldest_release_date" />
+
+            <RadioButton
+                android:id="@+id/radioListsSortLastWatched"
+                style="@style/Widget.SeriesGuide.DistillationItem"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/action_shows_sort_last_watched" />
+
+            <RadioButton
+                android:id="@+id/radioListsSortRemaining"
+                style="@style/Widget.SeriesGuide.DistillationItem"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/action_shows_sort_remaining" />
+
+        </RadioGroup>
+
+        <CheckBox
+            android:id="@+id/checkboxListsSortIgnoreArticles"
+            style="@style/Widget.SeriesGuide.DistillationItem"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="@string/action_sort_ignore_articles" />
+
+    </LinearLayout>
+
+</androidx.core.widget.NestedScrollView>
diff --git a/app/src/main/res/layout/fragment_overview.xml b/app/src/main/res/layout/fragment_overview.xml
index 7df745edaa..573df9780a 100644
--- a/app/src/main/res/layout/fragment_overview.xml
+++ b/app/src/main/res/layout/fragment_overview.xml
@@ -78,14 +78,26 @@
                     android:layout_width="48dp"
                     android:layout_height="wrap_content"
                     android:layout_marginTop="6dp"
-                    android:layout_marginEnd="8dp"
                     android:background="?attr/selectableItemBackgroundBorderless"
                     android:contentDescription="@null"
-                    app:layout_constraintEnd_toEndOf="parent"
+                    app:layout_constraintEnd_toStartOf="@id/buttonOverviewManageLists"
                     app:layout_constraintTop_toTopOf="parent"
                     tools:src="@drawable/ic_star_black_24dp"
                     tools:tint="?attr/sgColorIcon" />
 
+                <ImageButton
+                    android:id="@+id/buttonOverviewManageLists"
+                    style="?attr/borderlessButtonStyle"
+                    android:layout_width="48dp"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="6dp"
+                    android:layout_marginEnd="8dp"
+                    android:background="?attr/selectableItemBackgroundBorderless"
+                    android:contentDescription="@null"
+                    app:layout_constraintEnd_toEndOf="parent"
+                    app:layout_constraintTop_toTopOf="parent"
+                    app:srcCompat="@drawable/ic_list_white_24dp" />
+
             </androidx.constraintlayout.widget.ConstraintLayout>
 
             <ViewStub
diff --git a/app/src/main/res/layout/fragment_show_narrow.xml b/app/src/main/res/layout/fragment_show_narrow.xml
index 7883ef4636..91da9ba8bb 100644
--- a/app/src/main/res/layout/fragment_show_narrow.xml
+++ b/app/src/main/res/layout/fragment_show_narrow.xml
@@ -192,7 +192,7 @@
             <androidx.constraintlayout.helper.widget.Flow
                 android:layout_width="0dp"
                 android:layout_height="wrap_content"
-                app:constraint_referenced_ids="buttonShowTrailer,buttonShowSimilar,buttonShowShare,buttonShowComments,buttonShowWebSearch,buttonShowMetacritic,buttonShowShortcut"
+                app:constraint_referenced_ids="buttonShowManageLists,buttonShowTrailer,buttonShowSimilar,buttonShowShare,buttonShowComments,buttonShowWebSearch,buttonShowMetacritic,buttonShowShortcut"
                 app:flow_horizontalBias="0"
                 app:flow_horizontalGap="4dp"
                 app:flow_horizontalStyle="packed"
@@ -202,6 +202,15 @@
                 app:layout_constraintStart_toStartOf="parent"
                 app:layout_constraintTop_toTopOf="parent" />
 
+            <Button
+                android:id="@+id/buttonShowManageLists"
+                style="@style/Widget.SeriesGuide.Button.Outlined.Icon"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="@string/list_item_manage"
+                app:icon="@drawable/ic_list_white_24dp"
+                app:iconGravity="start" />
+
             <Button
                 android:id="@+id/buttonShowTrailer"
                 style="@style/Widget.SeriesGuide.Button.Outlined.Icon"
diff --git a/app/src/main/res/layout/fragment_show_regular.xml b/app/src/main/res/layout/fragment_show_regular.xml
index 7849962ff5..328b59fb27 100644
--- a/app/src/main/res/layout/fragment_show_regular.xml
+++ b/app/src/main/res/layout/fragment_show_regular.xml
@@ -181,7 +181,7 @@
             <androidx.constraintlayout.helper.widget.Flow
                 android:layout_width="0dp"
                 android:layout_height="wrap_content"
-                app:constraint_referenced_ids="buttonShowTrailer,buttonShowSimilar,buttonShowShare,buttonShowComments,buttonShowWebSearch,buttonShowMetacritic,buttonShowShortcut"
+                app:constraint_referenced_ids="buttonShowManageLists,buttonShowTrailer,buttonShowSimilar,buttonShowShare,buttonShowComments,buttonShowWebSearch,buttonShowMetacritic,buttonShowShortcut"
                 app:flow_horizontalBias="0"
                 app:flow_horizontalGap="4dp"
                 app:flow_horizontalStyle="packed"
@@ -191,6 +191,15 @@
                 app:layout_constraintStart_toStartOf="parent"
                 app:layout_constraintTop_toTopOf="parent" />
 
+            <Button
+                android:id="@+id/buttonShowManageLists"
+                style="@style/Widget.SeriesGuide.Button.Outlined.Icon"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="@string/list_item_manage"
+                app:icon="@drawable/ic_list_white_24dp"
+                app:iconGravity="start" />
+
             <Button
                 android:id="@+id/buttonShowTrailer"
                 style="@style/Widget.SeriesGuide.Button.Outlined.Icon"
diff --git a/app/src/main/res/menu/lists_menu.xml b/app/src/main/res/menu/lists_menu.xml
index 32337197eb..1cd42aa3d3 100644
--- a/app/src/main/res/menu/lists_menu.xml
+++ b/app/src/main/res/menu/lists_menu.xml
@@ -24,29 +24,7 @@
         android:icon="@drawable/ic_sort_white_24dp"
         android:orderInCategory="3"
         android:title="@string/sort"
-        app:showAsAction="never">
-        <menu>
-            <item
-                android:id="@+id/menu_action_lists_sort_title"
-                android:title="@string/action_shows_sort_title" />
-            <item
-                android:id="@+id/menu_action_lists_sort_latest_episode"
-                android:title="@string/action_shows_sort_latest_episode" />
-            <item
-                android:id="@+id/menu_action_lists_sort_oldest_episode"
-                android:title="@string/action_shows_sort_oldest_episode" />
-            <item
-                android:id="@+id/menu_action_lists_sort_last_watched"
-                android:title="@string/action_shows_sort_last_watched" />
-            <item
-                android:id="@+id/menu_action_lists_sort_remaining"
-                android:title="@string/action_shows_sort_remaining" />
-            <item
-                android:id="@+id/menu_action_lists_sort_ignore_articles"
-                android:checkable="true"
-                android:title="@string/action_sort_ignore_articles" />
-        </menu>
-    </item>
+        app:showAsAction="never" />
     <item
         android:id="@+id/menu_action_lists_reorder"
         android:orderInCategory="4"
diff --git a/app/src/main/res/menu/overview_activity_menu.xml b/app/src/main/res/menu/overview_activity_menu.xml
index 09034bbff9..10922a8cc5 100644
--- a/app/src/main/res/menu/overview_activity_menu.xml
+++ b/app/src/main/res/menu/overview_activity_menu.xml
@@ -9,12 +9,6 @@
         android:title="@string/search_hint"
         app:showAsAction="ifRoom" />
 
-    <item
-        android:id="@+id/menu_show_manage_lists"
-        android:orderInCategory="2"
-        android:title="@string/list_item_manage"
-        app:showAsAction="never" />
-
     <item
         android:id="@+id/menu_overview_remove_show"
         android:orderInCategory="9"
diff --git a/app/src/main/res/values-ar/strings.xml b/app/src/main/res/values-ar/strings.xml
index 71b64db1cd..0506ea7bca 100644
--- a/app/src/main/res/values-ar/strings.xml
+++ b/app/src/main/res/values-ar/strings.xml
@@ -287,10 +287,12 @@
     <string name="ack_list_item_manage">Lists updated</string>
     <string name="list_item_remove">إزالة من القائمة</string>
     <string name="ack_list_item_removed">Removed from list</string>
-    <string name="list_empty">يمكنك إضافة مسلسلات إلى هذه القائمة</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">إعادة ترتيب القوائم</string>
     <string name="ack_lists_reordered">Lists reordered</string>
     <string name="error_name_already_exists">يوجد بالفعل قائمة بهذا الإسم</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">الإصدارات الرقمية</string>
     <string name="title_disc_releases">إصدارات القرص</string>
@@ -355,7 +357,7 @@
     <string name="feature_sync">نقل بيانات</string>
     <!-- Hexagon -->
     <string name="hexagon_description">يساعد سيرايس جايد كلاود على حفظ مسلسلاتك و افلامك على حسابك الخاص اونلاين.</string>
-    <string name="hexagon_warning_trakt">عندما تسجل الدخول لسيرايس كلاود سيتم فقد بعض خصائص موقع تراكت.</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">تسجيل الدخول</string>
     <string name="hexagon_signout">تسجيل الخروج</string>
     <string name="hexagon_setup_incomplete">لم يتم إكمال إعداد سحابة SeriesGuide.</string>
diff --git a/app/src/main/res/values-b+sr+Latn/strings.xml b/app/src/main/res/values-b+sr+Latn/strings.xml
index 04fd7693db..234cc10832 100644
--- a/app/src/main/res/values-b+sr+Latn/strings.xml
+++ b/app/src/main/res/values-b+sr+Latn/strings.xml
@@ -266,10 +266,12 @@
     <string name="ack_list_item_manage">Lista ažurirana</string>
     <string name="list_item_remove">Ukloni sa liste</string>
     <string name="ack_list_item_removed">Uklonjeno sa liste</string>
-    <string name="list_empty">Možete dodati serije na ovu listu</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Preuredite liste</string>
     <string name="ack_lists_reordered">Liste su preuređene</string>
     <string name="error_name_already_exists">Lista sa ovim imenom već postoji</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Digitalna izdanja</string>
     <string name="title_disc_releases">Disk izdanja</string>
diff --git a/app/src/main/res/values-bg/strings.xml b/app/src/main/res/values-bg/strings.xml
index e22b28ce1e..675afb8508 100644
--- a/app/src/main/res/values-bg/strings.xml
+++ b/app/src/main/res/values-bg/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Списъкът е обновен</string>
     <string name="list_item_remove">Премахване от списъка</string>
     <string name="ack_list_item_removed">Премахнато от списъка</string>
-    <string name="list_empty">Добавете сериали в този списък</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Пренареждане на списъците</string>
     <string name="ack_lists_reordered">Списъците са подредени</string>
     <string name="error_name_already_exists">Списък с това име вече съществува</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Дихитални издания</string>
     <string name="title_disc_releases">Излезли на диск</string>
@@ -315,7 +317,7 @@
     <string name="feature_sync">Синхронизирай</string>
     <!-- Hexagon -->
     <string name="hexagon_description">SeriesGuide Cloud ти помага да създадеш копие на твоите сериали, списъци и филми и да ги синхронизираш</string>
-    <string name="hexagon_warning_trakt">Докато си вписан с SeriesGuide Cloud някои от функциите на trakt не са достъпни</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">Вписване</string>
     <string name="hexagon_signout">Отписване</string>
     <string name="hexagon_setup_incomplete">Настройването на SeriesGuide облака не беше завършено.</string>
diff --git a/app/src/main/res/values-ca/strings.xml b/app/src/main/res/values-ca/strings.xml
index 00ae3bf033..a99153ba8c 100644
--- a/app/src/main/res/values-ca/strings.xml
+++ b/app/src/main/res/values-ca/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Llistes actualitzades</string>
     <string name="list_item_remove">Esborra de la llista</string>
     <string name="ack_list_item_removed">Eliminada de la llista</string>
-    <string name="list_empty">Pots afegir sèries a aquesta llista</string>
+    <string name="list_empty">Podeu afegir sèries o pel·lícules a aquesta llista</string>
     <string name="action_lists_reorder">Reordenar les llistes</string>
     <string name="ack_lists_reordered">Llistes reordenades</string>
     <string name="error_name_already_exists">Ja existeix una llista amb aquest nom</string>
+    <string name="action_lists_sort_latest_release_date">Darrera data d\'estrena</string>
+    <string name="action_lists_sort_oldest_release_date">Data d\'estrena més antiga</string>
     <!-- Movies -->
     <string name="title_digital_releases">Publicació digital</string>
     <string name="title_disc_releases">Publicació en disc</string>
diff --git a/app/src/main/res/values-cs/strings.xml b/app/src/main/res/values-cs/strings.xml
index e1e07f96a3..9a52544ae2 100644
--- a/app/src/main/res/values-cs/strings.xml
+++ b/app/src/main/res/values-cs/strings.xml
@@ -273,10 +273,12 @@
     <string name="ack_list_item_manage">Seznamy aktualizovány</string>
     <string name="list_item_remove">Odebrat ze seznamu</string>
     <string name="ack_list_item_removed">Odstraněno ze seznamu</string>
-    <string name="list_empty">Můžete přidat seriály do tohoto seznamu</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Uspořádat seznamy</string>
     <string name="ack_lists_reordered">Řazení seznamů změněno</string>
     <string name="error_name_already_exists">Seznam s tímto názvem již existuje</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Digitální vydání</string>
     <string name="title_disc_releases">Vydání na discích</string>
@@ -335,7 +337,7 @@
     <string name="feature_sync">Synchronizace</string>
     <!-- Hexagon -->
     <string name="hexagon_description">SeriesGuide Cloud pomáhá zálohovat a synchronizovat vaše seriály, seznamy a filmy.</string>
-    <string name="hexagon_warning_trakt">Pokud jste přihlášení přes SeriesGuide Cloud, některé funkce trakt.tv nemusí být k dispozici.</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">Přihlásit se</string>
     <string name="hexagon_signout">Odhlásit se</string>
     <string name="hexagon_setup_incomplete">Nastavení SeriesGuide cloudu nebylo dokončeno</string>
diff --git a/app/src/main/res/values-cy/strings.xml b/app/src/main/res/values-cy/strings.xml
index b98891a3ed..0bce85f085 100644
--- a/app/src/main/res/values-cy/strings.xml
+++ b/app/src/main/res/values-cy/strings.xml
@@ -287,10 +287,12 @@
     <string name="ack_list_item_manage">Lists updated</string>
     <string name="list_item_remove">Tynnu o\'r rhestr</string>
     <string name="ack_list_item_removed">Removed from list</string>
-    <string name="list_empty">Gallwch ychwanegu sioeau at y rhestr hon</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Rhestrau ail-archebu</string>
     <string name="ack_lists_reordered">Lists reordered</string>
     <string name="error_name_already_exists">Mae rhestr gyda\'r enw hwn eisoes yn bodoli</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Datganiadau digidol</string>
     <string name="title_disc_releases">Datganiadau disg</string>
@@ -355,7 +357,7 @@
     <string name="feature_sync">Cydamseru</string>
     <!-- Hexagon -->
     <string name="hexagon_description">Mae SeriesGuide Cloud yn helpu i wneud copi wrth gefn a sync eich sioeau, rhestrau a ffilmiau</string>
-    <string name="hexagon_warning_trakt">Er eu bod wedi mewngofnodi gyda SeriesGuide Cloud nid yw rhai o nodweddion Trakt ar gael</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">Mewngofnodi</string>
     <string name="hexagon_signout">Llofnodi</string>
     <string name="hexagon_setup_incomplete">Ni chwblhawyd sefydlu SeriesGuide Cloud</string>
diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml
index a09105415d..78f7a78103 100644
--- a/app/src/main/res/values-da/strings.xml
+++ b/app/src/main/res/values-da/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Lister opdateret</string>
     <string name="list_item_remove">Fjern fra liste</string>
     <string name="ack_list_item_removed">Fjernet fra listen</string>
-    <string name="list_empty">Du kan tilføje serier til denne liste</string>
+    <string name="list_empty">Du kan tilføje serier eller film til denne liste</string>
     <string name="action_lists_reorder">Omarrangér lister</string>
     <string name="ack_lists_reordered">Lister omarrangeret</string>
     <string name="error_name_already_exists">En liste med dette navn findes allerede</string>
+    <string name="action_lists_sort_latest_release_date">Seneste udgivelsesdato</string>
+    <string name="action_lists_sort_oldest_release_date">Ældste udgivelsesdato</string>
     <!-- Movies -->
     <string name="title_digital_releases">Digitale udgivelser</string>
     <string name="title_disc_releases">Disk udgivelser</string>
diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml
index 3de0aee35f..107ebf0eab 100644
--- a/app/src/main/res/values-de/strings.xml
+++ b/app/src/main/res/values-de/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Liste aktualisiert</string>
     <string name="list_item_remove">Von Liste entfernen</string>
     <string name="ack_list_item_removed">Von Liste entfernt</string>
-    <string name="list_empty">Sie können Serien zu dieser Liste hinzufügen</string>
+    <string name="list_empty">Sie können Serien oder Filme zu dieser Liste hinzufügen</string>
     <string name="action_lists_reorder">Listen anordnen</string>
     <string name="ack_lists_reordered">Listen neu angeordnet</string>
     <string name="error_name_already_exists">Eine Liste mit diesem Namen ist bereits vorhanden</string>
+    <string name="action_lists_sort_latest_release_date">Neuestes Erscheinungsdatum</string>
+    <string name="action_lists_sort_oldest_release_date">Ältestes Erscheinungsdatum</string>
     <!-- Movies -->
     <string name="title_digital_releases">Neues in Digital</string>
     <string name="title_disc_releases">Neues auf Disc</string>
diff --git a/app/src/main/res/values-el/strings.xml b/app/src/main/res/values-el/strings.xml
index e099d384ce..fd9564a0eb 100644
--- a/app/src/main/res/values-el/strings.xml
+++ b/app/src/main/res/values-el/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Οι λίστες ενημερώθηκαν</string>
     <string name="list_item_remove">Κατάργηση από τη λίστα</string>
     <string name="ack_list_item_removed">Αφαιρέθηκε από τη λίστα</string>
-    <string name="list_empty">Μπορείτε να προσθέσετε σειρές σε αυτή τη λίστα</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Ταξινομημένες λίστες</string>
     <string name="ack_lists_reordered">Οι λίστες αναδιατάχθηκαν</string>
     <string name="error_name_already_exists">Υπάρχει ήδη μία λίστα με αυτό το όνομα</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Ψηφιακές κυκλοφορίες</string>
     <string name="title_disc_releases">Κυκλοφορίες δίσκων</string>
diff --git a/app/src/main/res/values-eo/strings.xml b/app/src/main/res/values-eo/strings.xml
index 27df478b37..fd9499ddcb 100644
--- a/app/src/main/res/values-eo/strings.xml
+++ b/app/src/main/res/values-eo/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Lists updated</string>
     <string name="list_item_remove">Forigi el listo</string>
     <string name="ack_list_item_removed">Removed from list</string>
-    <string name="list_empty">Vi povas aldoni televidaĵojn al ĉi tiu listo</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Reordigi listojn</string>
     <string name="ack_lists_reordered">Lists reordered</string>
     <string name="error_name_already_exists">Listo kun ĉi tiu nomo jam ekzistas</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Bitaj eldonoj</string>
     <string name="title_disc_releases">Diskaj eldonoj</string>
diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml
index 23595947c7..0fa13b49df 100644
--- a/app/src/main/res/values-es/strings.xml
+++ b/app/src/main/res/values-es/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Listas actualizadas</string>
     <string name="list_item_remove">Eliminar de la lista</string>
     <string name="ack_list_item_removed">Eliminado de la lista</string>
-    <string name="list_empty">Puedes añadir series a esta lista</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Reordenar listas</string>
     <string name="ack_lists_reordered">Listas reordenadas</string>
     <string name="error_name_already_exists">Ya existe una lista con este nombre</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Estrenos digitales</string>
     <string name="title_disc_releases">Estrenos en disco</string>
diff --git a/app/src/main/res/values-fa/strings.xml b/app/src/main/res/values-fa/strings.xml
index 9fe1cb4bee..344c19509a 100644
--- a/app/src/main/res/values-fa/strings.xml
+++ b/app/src/main/res/values-fa/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">سیاهه به‌روز شد</string>
     <string name="list_item_remove">برداشتن از فهرست</string>
     <string name="ack_list_item_removed">از سیاهه برداشته شد</string>
-    <string name="list_empty">می‌توانید نمایش‌ها را به این فهرست بیفزایید</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">بازچینی فهرست‌ها</string>
     <string name="ack_lists_reordered">ترتیب سیاهه عوض شد</string>
     <string name="error_name_already_exists">فهرستی با این اسم موجود است</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">نسخه های دیجیتال</string>
     <string name="title_disc_releases">منتشر شده روی دیسک</string>
@@ -315,7 +317,7 @@
     <string name="feature_sync">همگام‌‌سازی</string>
     <!-- Hexagon -->
     <string name="hexagon_description">SeriesGuide Cloud به همگام‌سازی و پشتیبان‌گیری برنامه‌ها، لیست‌ها و فیلم‌های شما کمک می‌کند</string>
-    <string name="hexagon_warning_trakt">هنگام ورود با SeriesGuide Cloud برخی از ویژگی‌های Trakt در دسترس نیست</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">ورود</string>
     <string name="hexagon_signout">خروج از سیستم</string>
     <string name="hexagon_setup_incomplete">راه اندازی فضای ابری SeriesGuide کامل نشد.</string>
diff --git a/app/src/main/res/values-fi/strings.xml b/app/src/main/res/values-fi/strings.xml
index 48817d8c7a..d7ebad34bc 100644
--- a/app/src/main/res/values-fi/strings.xml
+++ b/app/src/main/res/values-fi/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Listat päivitettiin</string>
     <string name="list_item_remove">Poista listalta</string>
     <string name="ack_list_item_removed">Poistettiin listasta</string>
-    <string name="list_empty">Voit lisätä ohjelmia tähän listaan</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Järjestä listat uudelleen</string>
     <string name="ack_lists_reordered">Listat uudelleenjärjestettiin</string>
     <string name="error_name_already_exists">Samanniminen lista on jo olemassa</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Digitaaliset julkaisut</string>
     <string name="title_disc_releases">Levyjulkaisut</string>
diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml
index ff8ae92115..b5d303d065 100644
--- a/app/src/main/res/values-fr/strings.xml
+++ b/app/src/main/res/values-fr/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Listes mises à jour</string>
     <string name="list_item_remove">Retirer de la liste</string>
     <string name="ack_list_item_removed">Retiré de la liste</string>
-    <string name="list_empty">Vous pouvez ajouter des séries à cette liste.</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Réorganiser les listes</string>
     <string name="ack_lists_reordered">Listes réordonnées</string>
     <string name="error_name_already_exists">Une liste portant ce nom existe déjà</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Versions numériques</string>
     <string name="title_disc_releases">Sorties DVD</string>
@@ -315,7 +317,7 @@
     <string name="feature_sync">Synchronisation</string>
     <!-- Hexagon -->
     <string name="hexagon_description">Le cloud SeriesGuide permet de sauvegarder et de synchroniser vos listes, émissions et films.</string>
-    <string name="hexagon_warning_trakt">Quand vous êtes connecté a SeriesGuide Cloud certaines fonctions de Trakt sont indisponibles.</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">Connexion</string>
     <string name="hexagon_signout">Déconnexion</string>
     <string name="hexagon_setup_incomplete">La configuration du cloud SeriesGuide n\'était pas terminée.</string>
diff --git a/app/src/main/res/values-gl/strings.xml b/app/src/main/res/values-gl/strings.xml
index 55008ca63b..465723e8bb 100644
--- a/app/src/main/res/values-gl/strings.xml
+++ b/app/src/main/res/values-gl/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Lists updated</string>
     <string name="list_item_remove">Eliminar da lista</string>
     <string name="ack_list_item_removed">Removed from list</string>
-    <string name="list_empty">You can add shows to this list</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Reordear listas</string>
     <string name="ack_lists_reordered">Lists reordered</string>
     <string name="error_name_already_exists">Xa existe unha lista con este nome</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Lanzamentos dixitais</string>
     <string name="title_disc_releases">Lanzamentos físicos</string>
@@ -315,7 +317,7 @@
     <string name="feature_sync">Sincronizar</string>
     <!-- Hexagon -->
     <string name="hexagon_description">SeriesGuide Cloud axúdache a facer unha copia de seguridade e sincronizar as túas series, listas e filmes</string>
-    <string name="hexagon_warning_trakt">Mentres esteas identificado en SeriesGuide Cloud, algunhas funcións de trakt non estarán dispoñibles</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">Iniciar sesión</string>
     <string name="hexagon_signout">Pechar sesión</string>
     <string name="hexagon_setup_incomplete">A configuración de SeriesGuide cloud non se completou</string>
diff --git a/app/src/main/res/values-hr/strings.xml b/app/src/main/res/values-hr/strings.xml
index ff7a2600f2..2fdfaf9788 100644
--- a/app/src/main/res/values-hr/strings.xml
+++ b/app/src/main/res/values-hr/strings.xml
@@ -266,10 +266,12 @@
     <string name="ack_list_item_manage">Lists updated</string>
     <string name="list_item_remove">Ukloni s popisa</string>
     <string name="ack_list_item_removed">Removed from list</string>
-    <string name="list_empty">You can add shows to this list</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Promijeni redoslijed popisa</string>
     <string name="ack_lists_reordered">Lists reordered</string>
     <string name="error_name_already_exists">Popis sa ovim nazivom već postoji</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Digitalna izdanja</string>
     <string name="title_disc_releases">Disk izdanja</string>
@@ -325,7 +327,7 @@
     <string name="feature_sync">Sinkronizacija</string>
     <!-- Hexagon -->
     <string name="hexagon_description">SeriesGuide Oblak vam pomaže sigurnosno kopirati i sinkronizirati vaše serije, popise i filmove.</string>
-    <string name="hexagon_warning_trakt">Dok ste prijavljeni na SeriesGuide Oblak neke trakt značajke nisu dostupne.</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">Prijava</string>
     <string name="hexagon_signout">Odjava</string>
     <string name="hexagon_setup_incomplete">Postavljanje SeriesGuide oblaka nije dovršena.</string>
diff --git a/app/src/main/res/values-hu/strings.xml b/app/src/main/res/values-hu/strings.xml
index 90f2690957..87e3822771 100644
--- a/app/src/main/res/values-hu/strings.xml
+++ b/app/src/main/res/values-hu/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Lists updated</string>
     <string name="list_item_remove">Eltávolítás a listáról</string>
     <string name="ack_list_item_removed">Removed from list</string>
-    <string name="list_empty">Sorozatokat adhat hozzá a listhoz</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Listák újrarendezése</string>
     <string name="ack_lists_reordered">Lists reordered</string>
     <string name="error_name_already_exists">Már létezik egy lista ezzel a névvel</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Digitalis megjelenések</string>
     <string name="title_disc_releases">Lemez megjelenések</string>
@@ -315,7 +317,7 @@
     <string name="feature_sync">Szinkronizálás</string>
     <!-- Hexagon -->
     <string name="hexagon_description">A SeriesGuide Felhő segít a sorozatok, listák és filmek biztonsági mentésében és szinkronizálásban.</string>
-    <string name="hexagon_warning_trakt">Amíg a SeriesGuide Felhőbe vagy bejelentkezve, néhány trakt funkció nem lesz elérhető.</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">Bejelentkezés</string>
     <string name="hexagon_signout">Kijelentkezés</string>
     <string name="hexagon_setup_incomplete">A SeriesGuide Cloud beállítása nem fejeződött be.</string>
diff --git a/app/src/main/res/values-in/strings.xml b/app/src/main/res/values-in/strings.xml
index 6ab7413bd7..0f55418fdb 100644
--- a/app/src/main/res/values-in/strings.xml
+++ b/app/src/main/res/values-in/strings.xml
@@ -252,10 +252,12 @@
     <string name="ack_list_item_manage">Lists updated</string>
     <string name="list_item_remove">Hapus dari daftar</string>
     <string name="ack_list_item_removed">Removed from list</string>
-    <string name="list_empty">Kau bisa menambahkan acara ke daftar ini</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Susun ulang daftar</string>
     <string name="ack_lists_reordered">Lists reordered</string>
     <string name="error_name_already_exists">Daftar dengan nama ini sudah ada</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Rilisan digital</string>
     <string name="title_disc_releases">Rilisan cakram</string>
@@ -305,7 +307,7 @@
     <string name="feature_sync">Sync</string>
     <!-- Hexagon -->
     <string name="hexagon_description">SeriesGuide Cloud membantumu untuk mencadangkan dan menyelaraskan acara, daftar, dan film anda.</string>
-    <string name="hexagon_warning_trakt">Selama masuk menggunakan SeriesGuide Cloud beberapa fitur trakt tidak tersedia.</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">Masuk</string>
     <string name="hexagon_signout">Keluar</string>
     <string name="hexagon_setup_incomplete">Pengaturan SeriesGuide Cloud Tidak selesai.</string>
diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml
index 1801c0a9ad..842bb208e7 100644
--- a/app/src/main/res/values-it/strings.xml
+++ b/app/src/main/res/values-it/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Lista aggiornata</string>
     <string name="list_item_remove">Rimuovi dalla lista</string>
     <string name="ack_list_item_removed">Rimosso dalla lista</string>
-    <string name="list_empty">Puoi aggiungere delle serie a questa lista</string>
+    <string name="list_empty">Puoi aggiungere serie TV o film a questa lista</string>
     <string name="action_lists_reorder">Riordina le liste</string>
     <string name="ack_lists_reordered">Lista riordinata</string>
     <string name="error_name_already_exists">Una lista con questo nome esiste già</string>
+    <string name="action_lists_sort_latest_release_date">Data di uscita più recente</string>
+    <string name="action_lists_sort_oldest_release_date">Data di uscita meno recente</string>
     <!-- Movies -->
     <string name="title_digital_releases">Uscite in digitale</string>
     <string name="title_disc_releases">Uscite su disco</string>
diff --git a/app/src/main/res/values-iw/strings.xml b/app/src/main/res/values-iw/strings.xml
index 6f4b66df88..ef28ab04ed 100644
--- a/app/src/main/res/values-iw/strings.xml
+++ b/app/src/main/res/values-iw/strings.xml
@@ -273,10 +273,12 @@
     <string name="ack_list_item_manage">עודכנו הרשימות</string>
     <string name="list_item_remove">הסר מהרשימה</string>
     <string name="ack_list_item_removed">הוסר מהרשימה</string>
-    <string name="list_empty">אפשר להוסיף סדרות לרשימה זו</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">סדר מחדש רשימות</string>
     <string name="ack_lists_reordered">הרשימות סודרו מחדש</string>
     <string name="error_name_already_exists">רשימה עם השם הזה כבר קיימת</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">הפצה דיגיטלית</string>
     <string name="title_disc_releases">הפצת דיסק</string>
diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml
index 4b458dc8d3..df3a242ce7 100644
--- a/app/src/main/res/values-ja/strings.xml
+++ b/app/src/main/res/values-ja/strings.xml
@@ -252,10 +252,12 @@
     <string name="ack_list_item_manage">Lists updated</string>
     <string name="list_item_remove">リストから削除</string>
     <string name="ack_list_item_removed">Removed from list</string>
-    <string name="list_empty">You can add shows to this list</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">リストの再並べ替え</string>
     <string name="ack_lists_reordered">Lists reordered</string>
     <string name="error_name_already_exists">この名前のリストがすでに存在します</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">デジタル リリース</string>
     <string name="title_disc_releases">ディスク リリース</string>
@@ -305,7 +307,7 @@
     <string name="feature_sync">同期</string>
     <!-- Hexagon -->
     <string name="hexagon_description">SeriesGuide Cloud は番組、リスト、映画をバックアップおよび同期するのに役立ちます</string>
-    <string name="hexagon_warning_trakt">SeriesGuide Cloud でログインすると、一部の Trakt の機能が利用できません</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">サインイン</string>
     <string name="hexagon_signout">サインアウト</string>
     <string name="hexagon_setup_incomplete">SeriesGuide クラウドのセットアップは完了しませんでした。</string>
diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml
index 14ee0a5b35..ee9a96fc7a 100644
--- a/app/src/main/res/values-ko/strings.xml
+++ b/app/src/main/res/values-ko/strings.xml
@@ -252,10 +252,12 @@
     <string name="ack_list_item_manage">목록이 업데이트됨</string>
     <string name="list_item_remove">목록에서 제거</string>
     <string name="ack_list_item_removed">목록에서 삭제됨</string>
-    <string name="list_empty">이 목록에 프로그램을 추가할 수 있습니다</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">목록 재정렬</string>
     <string name="ack_lists_reordered">목록이 재정렬됨</string>
     <string name="error_name_already_exists">이 이름을 가진 목록이 이미 존재합니다</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">디지털 출시</string>
     <string name="title_disc_releases">디스크 출시</string>
diff --git a/app/src/main/res/values-mk/strings.xml b/app/src/main/res/values-mk/strings.xml
index e9f0bed078..ac4a962eef 100644
--- a/app/src/main/res/values-mk/strings.xml
+++ b/app/src/main/res/values-mk/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Lists updated</string>
     <string name="list_item_remove">Избриши од листа</string>
     <string name="ack_list_item_removed">Removed from list</string>
-    <string name="list_empty">You can add shows to this list</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Поново сортирајте листа</string>
     <string name="ack_lists_reordered">Lists reordered</string>
     <string name="error_name_already_exists">Една група со ова име веќе постои</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Дигитално издание</string>
     <string name="title_disc_releases">Диск изданија</string>
diff --git a/app/src/main/res/values-nb/strings.xml b/app/src/main/res/values-nb/strings.xml
index aaab57e755..1841a9c610 100644
--- a/app/src/main/res/values-nb/strings.xml
+++ b/app/src/main/res/values-nb/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Lists updated</string>
     <string name="list_item_remove">Fjern fra liste</string>
     <string name="ack_list_item_removed">Removed from list</string>
-    <string name="list_empty">Du kan legge til serier i denne listen</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Omorganiser lister</string>
     <string name="ack_lists_reordered">Lists reordered</string>
     <string name="error_name_already_exists">En liste med dette navnet finnes allerede</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Digitale utgaver</string>
     <string name="title_disc_releases">Utgaver på disc</string>
@@ -315,7 +317,7 @@
     <string name="feature_sync">Synkroniser</string>
     <!-- Hexagon -->
     <string name="hexagon_description">SeriesGuide Cloud hjelper deg å sikkerhetskopiere og synkronisere dine serier, lister og filmer</string>
-    <string name="hexagon_warning_trakt">Enkelte traktfunksjoner er ikke tilgjengelig når du er innlogget på SeriesGuide Cloud</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">Logg inn</string>
     <string name="hexagon_signout">Logg ut</string>
     <string name="hexagon_setup_incomplete">Oppsettet av SeriesGuide Cloud er ikke fullført.</string>
diff --git a/app/src/main/res/values-nl/strings.xml b/app/src/main/res/values-nl/strings.xml
index fbae278379..02e58ce94f 100644
--- a/app/src/main/res/values-nl/strings.xml
+++ b/app/src/main/res/values-nl/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Lijsten bijgewerkt</string>
     <string name="list_item_remove">Verwijderen uit lijst</string>
     <string name="ack_list_item_removed">Verwijderd uit lijst</string>
-    <string name="list_empty">U kunt series toevoegen aan deze lijst</string>
+    <string name="list_empty">U kunt series of films toevoegen aan deze lijst</string>
     <string name="action_lists_reorder">Lijsten opnieuw ordenen</string>
     <string name="ack_lists_reordered">Lijsten gerangschikt</string>
     <string name="error_name_already_exists">Een lijst met deze naam bestaat al</string>
+    <string name="action_lists_sort_latest_release_date">Nieuwste uitgavedatum</string>
+    <string name="action_lists_sort_oldest_release_date">Oudste uitgavedatum</string>
     <!-- Movies -->
     <string name="title_digital_releases">Digitale releases</string>
     <string name="title_disc_releases">Releases op schijf</string>
diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml
index 97ed3e892e..be953062c3 100644
--- a/app/src/main/res/values-pl/strings.xml
+++ b/app/src/main/res/values-pl/strings.xml
@@ -273,10 +273,12 @@
     <string name="ack_list_item_manage">Lista zaktualizowana</string>
     <string name="list_item_remove">Usuń z listy</string>
     <string name="ack_list_item_removed">Usunięto z listy</string>
-    <string name="list_empty">Możesz dodać seriale do tej listy</string>
+    <string name="list_empty">Możesz dodawać seriale lub filmy do tej listy</string>
     <string name="action_lists_reorder">Zmień kolejność list</string>
     <string name="ack_lists_reordered">Lista przeorganizowana</string>
     <string name="error_name_already_exists">Lista o tej nazwie już istnieje</string>
+    <string name="action_lists_sort_latest_release_date">Data ostatniego wydania</string>
+    <string name="action_lists_sort_oldest_release_date">Data najstarszego wydania</string>
     <!-- Movies -->
     <string name="title_digital_releases">Wydania cyfrowe</string>
     <string name="title_disc_releases">Na płytach</string>
diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml
index 57b8cf37ab..7e6ba17fad 100644
--- a/app/src/main/res/values-pt-rBR/strings.xml
+++ b/app/src/main/res/values-pt-rBR/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Listas atualizadas</string>
     <string name="list_item_remove">Remover da lista</string>
     <string name="ack_list_item_removed">Removido da lista</string>
-    <string name="list_empty">Você pode adicionar séries à lista</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Reordenar listas</string>
     <string name="ack_lists_reordered">Listas reordenadas</string>
     <string name="error_name_already_exists">Já existe uma lista com este nome</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Lançamentos digitais</string>
     <string name="title_disc_releases">Lançamentos em disco</string>
diff --git a/app/src/main/res/values-pt-rPT/strings.xml b/app/src/main/res/values-pt-rPT/strings.xml
index 75df1fe7ae..37aefb4be2 100644
--- a/app/src/main/res/values-pt-rPT/strings.xml
+++ b/app/src/main/res/values-pt-rPT/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Listas atualizadas</string>
     <string name="list_item_remove">Remover da lista</string>
     <string name="ack_list_item_removed">Removido da lista</string>
-    <string name="list_empty">Podes adicionar séries à esta lista</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Reordenar listas</string>
     <string name="ack_lists_reordered">Listas reordenadas</string>
     <string name="error_name_already_exists">Já existe uma lista com este nome</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Lançamentos Digitais</string>
     <string name="title_disc_releases">Lançamentos Físicos</string>
diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml
index d56ba3988c..172b8cdee8 100644
--- a/app/src/main/res/values-ro/strings.xml
+++ b/app/src/main/res/values-ro/strings.xml
@@ -266,10 +266,12 @@
     <string name="ack_list_item_manage">Lists updated</string>
     <string name="list_item_remove">Șterge din listă</string>
     <string name="ack_list_item_removed">Removed from list</string>
-    <string name="list_empty">You can add shows to this list</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Reordonaţi lista</string>
     <string name="ack_lists_reordered">Lists reordered</string>
     <string name="error_name_already_exists">O listă cu acest nume deja există</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Lansări digitale</string>
     <string name="title_disc_releases">Lansări pe disc</string>
@@ -325,7 +327,7 @@
     <string name="feature_sync">Sincronizare</string>
     <!-- Hexagon -->
     <string name="hexagon_description">SeriesGuide Cloud ajuta la creerea unei copii de rezerva și sincronizarea serialelor, listelor și filmelor.</string>
-    <string name="hexagon_warning_trakt">Cat timp sunteți autentificat cu SeriesGuide Cloud unele funcții oferite de trakt nu sunt disponibile.</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">Conectare</string>
     <string name="hexagon_signout">Deconectare</string>
     <string name="hexagon_setup_incomplete">Setarea Series Guide cloud nu a putut fi finalizată.</string>
diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml
index 7f629e7c8e..8044e8c2dc 100644
--- a/app/src/main/res/values-ru/strings.xml
+++ b/app/src/main/res/values-ru/strings.xml
@@ -248,7 +248,7 @@
     <string name="title_new_episodes">Новые эпизоды</string>
     <string name="watched_shows">Просмотрено</string>
     <string name="shows_collection">Коллекция</string>
-    <string name="title_library">Library</string>
+    <string name="title_library">Библиотека</string>
     <string name="watchlist">Список просмотра</string>
     <!-- Similar shows -->
     <string name="action_similar">Похожие</string>
@@ -273,10 +273,12 @@
     <string name="ack_list_item_manage">Список обновлён</string>
     <string name="list_item_remove">Удалить из списка</string>
     <string name="ack_list_item_removed">Удалено из списка</string>
-    <string name="list_empty">Вы можете добавить сериалы в этот список</string>
+    <string name="list_empty">Вы можете добавить сериалы или фильмы в этот список</string>
     <string name="action_lists_reorder">Сортировка списков</string>
     <string name="ack_lists_reordered">Списки переупорядочены</string>
     <string name="error_name_already_exists">Список с таким именем уже существует</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Цифровые версии</string>
     <string name="title_disc_releases">Диски</string>
@@ -590,7 +592,7 @@
     <string name="support_the_dev">Поддержать разработчика?</string>
     <string name="support_the_dev_other_ways">Другие способы поддержки</string>
     <!-- Diagnostics -->
-    <string name="title_debug_log">Debug log</string>
+    <string name="title_debug_log">Журнал отладки</string>
     <string name="status_saving_file_success">Файл сохранен</string>
     <string name="status_saving_file_failed">Не удалось сохранить файл</string>
     <!-- Streaming info -->
diff --git a/app/src/main/res/values-sk/strings.xml b/app/src/main/res/values-sk/strings.xml
index 530af2dd9c..c9c933f367 100644
--- a/app/src/main/res/values-sk/strings.xml
+++ b/app/src/main/res/values-sk/strings.xml
@@ -273,10 +273,12 @@
     <string name="ack_list_item_manage">Zoznam aktualizovaný</string>
     <string name="list_item_remove">Odstrániť zo zoznamu</string>
     <string name="ack_list_item_removed">Odstránené zo zoznamu</string>
-    <string name="list_empty">Môžete pridať seriály do tohto zoznamu</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Zoradiť zoznamy</string>
     <string name="ack_lists_reordered">Poradie zoznamov zmenené</string>
     <string name="error_name_already_exists">Zoznam s týmto názvom už existuje</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Digitálne médiá</string>
     <string name="title_disc_releases">Diskové médiá</string>
@@ -335,7 +337,7 @@
     <string name="feature_sync">Synchronizácia</string>
     <!-- Hexagon -->
     <string name="hexagon_description">SeriesGuide Cloud pomáha zálohovať a synchronizovať vaše seriály, zoznamy a filmy.</string>
-    <string name="hexagon_warning_trakt">Keď ste prihlásený na SeriesGuide Cloud niektoré trakt funkcie nie sú dostupné.</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">Prihlásiť sa</string>
     <string name="hexagon_signout">Odhlásiť sa</string>
     <string name="hexagon_setup_incomplete">Nastavenie SeriesGuide Cloud nebolo dokončené.</string>
diff --git a/app/src/main/res/values-sr/strings.xml b/app/src/main/res/values-sr/strings.xml
index a685128427..97664a3429 100644
--- a/app/src/main/res/values-sr/strings.xml
+++ b/app/src/main/res/values-sr/strings.xml
@@ -266,10 +266,12 @@
     <string name="ack_list_item_manage">Листа ажурирана</string>
     <string name="list_item_remove">Уклони са листе</string>
     <string name="ack_list_item_removed">Уклоњено са листе</string>
-    <string name="list_empty">Можете додати емисије на ову листу</string>
+    <string name="list_empty">Можете додати серије или филмове на ову листу</string>
     <string name="action_lists_reorder">Поново сортирајте листе</string>
     <string name="ack_lists_reordered">Листе су преуређене</string>
     <string name="error_name_already_exists">Листа са овим именом већ постоји</string>
+    <string name="action_lists_sort_latest_release_date">Најновији датум издавања</string>
+    <string name="action_lists_sort_oldest_release_date">Најстарији датум издавања</string>
     <!-- Movies -->
     <string name="title_digital_releases">Дигитална издања</string>
     <string name="title_disc_releases">Диск издања</string>
diff --git a/app/src/main/res/values-sv/strings.xml b/app/src/main/res/values-sv/strings.xml
index 6e19b142b2..4d0af9a08f 100644
--- a/app/src/main/res/values-sv/strings.xml
+++ b/app/src/main/res/values-sv/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Listor uppdaterade</string>
     <string name="list_item_remove">Ta bort från lista</string>
     <string name="ack_list_item_removed">Borttagen från lista</string>
-    <string name="list_empty">Du kan lägga till serier i denna lista</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Sortera om listor</string>
     <string name="ack_lists_reordered">Listor omordnade</string>
     <string name="error_name_already_exists">En lista med detta namn finns redan</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Digitala utgivningar</string>
     <string name="title_disc_releases">Utgivningar på skiva</string>
@@ -315,7 +317,7 @@
     <string name="feature_sync">Synk</string>
     <!-- Hexagon -->
     <string name="hexagon_description">SeriesGuide Cloud hjälper till att säkerhetskopiera och synkronisera dina, listor och filmer.</string>
-    <string name="hexagon_warning_trakt">Väl inloggad med SeriesGuide Cloud så är vissa trakt-funktioner inte tillgängliga.</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">Logga in</string>
     <string name="hexagon_signout">Logga ut</string>
     <string name="hexagon_setup_incomplete">Inställning av SeriesGuide Cloud slutfördes inte.</string>
diff --git a/app/src/main/res/values-ta/strings.xml b/app/src/main/res/values-ta/strings.xml
index fffb3f0f34..68fbbb4988 100644
--- a/app/src/main/res/values-ta/strings.xml
+++ b/app/src/main/res/values-ta/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Lists updated</string>
     <string name="list_item_remove">பட்டியலில் இருந்து அகற்று</string>
     <string name="ack_list_item_removed">Removed from list</string>
-    <string name="list_empty">You can add shows to this list</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">பட்டியல்களை மறு வரிசையாக்க இழுத்து</string>
     <string name="ack_lists_reordered">Lists reordered</string>
     <string name="error_name_already_exists">இந்த பட்டியலை ஏற்கனவே உள்ளது</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Digital releases</string>
     <string name="title_disc_releases">Disc releases</string>
diff --git a/app/src/main/res/values-th/strings.xml b/app/src/main/res/values-th/strings.xml
index 4794aff34a..fb23dca18a 100644
--- a/app/src/main/res/values-th/strings.xml
+++ b/app/src/main/res/values-th/strings.xml
@@ -252,10 +252,12 @@
     <string name="ack_list_item_manage">Lists updated</string>
     <string name="list_item_remove">ลบออกจากรายการ</string>
     <string name="ack_list_item_removed">Removed from list</string>
-    <string name="list_empty">คุณสามารถเพิ่มซีรีส์นี้ไปยังรายการ</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">เรียงรายการใหม่</string>
     <string name="ack_lists_reordered">Lists reordered</string>
     <string name="error_name_already_exists">มีรายการชื่อนี้อยู่แล้ว</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">ออกเป็นดิจิทัล</string>
     <string name="title_disc_releases">ออกเป็นแผ่น</string>
@@ -305,7 +307,7 @@
     <string name="feature_sync">ซิงค์</string>
     <!-- Hexagon -->
     <string name="hexagon_description">SeriesGuide Cloud ช่วยสำรองข้อมูลและซิงค์ซีรีส์, รายการ และภาพยนตร์ของคุณ</string>
-    <string name="hexagon_warning_trakt">ขณะเข้าสู่ระบบ SeriesGuide Cloud คุณสมบัติบางอย่างของ trakt จะใช้งานไม่ได้</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">เข้าสู่ระบบ</string>
     <string name="hexagon_signout">ออกจากระบบ</string>
     <string name="hexagon_setup_incomplete">การตั้งค่า SeriesGuide Cloud ไม่เสร็จสมบูรณ์</string>
diff --git a/app/src/main/res/values-tr/strings.xml b/app/src/main/res/values-tr/strings.xml
index e9c0605e77..86ef4122ad 100644
--- a/app/src/main/res/values-tr/strings.xml
+++ b/app/src/main/res/values-tr/strings.xml
@@ -259,10 +259,12 @@
     <string name="ack_list_item_manage">Listeler güncellendi</string>
     <string name="list_item_remove">Listeden kaldır</string>
     <string name="ack_list_item_removed">Listeden kaldırıldı</string>
-    <string name="list_empty">Bu listeye dizi ekleyebilirsiniz</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Listeleri tekrar sırala</string>
     <string name="ack_lists_reordered">Listeler yeniden sıralandı</string>
     <string name="error_name_already_exists">Bu ada sahip bir liste zaten var</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">Dijital Yayınlanan</string>
     <string name="title_disc_releases">Disk\'i Yayınlanan</string>
@@ -315,7 +317,7 @@
     <string name="feature_sync">Senkronizasyon</string>
     <!-- Hexagon -->
     <string name="hexagon_description">SeriesGuide Cloud, dizilerinizi, listelerinizi ve filmlerinizi yedeklemenizi ve senkronize etmenizi sağlar.</string>
-    <string name="hexagon_warning_trakt">SeriesGuide Cloud ile oturum açıldığında bazı Trakt özellikleri kullanılamaz.</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">Giriş</string>
     <string name="hexagon_signout">Çıkış</string>
     <string name="hexagon_setup_incomplete">Series Guide Bulut kurulumu tamamlanmadı.</string>
diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml
index e1c0c0f3ac..7e61719319 100644
--- a/app/src/main/res/values-uk/strings.xml
+++ b/app/src/main/res/values-uk/strings.xml
@@ -273,10 +273,12 @@
     <string name="ack_list_item_manage">Список оновлено</string>
     <string name="list_item_remove">Видалити зі списку</string>
     <string name="ack_list_item_removed">Усунено зі списку</string>
-    <string name="list_empty">Ви можете додати серіали в цей список</string>
+    <string name="list_empty">Ви можете додавати серіали або фільми до цього списку</string>
     <string name="action_lists_reorder">Впорядкувати список</string>
     <string name="ack_lists_reordered">Список перевпорядковано</string>
     <string name="error_name_already_exists">Список з таким іменем вже існує</string>
+    <string name="action_lists_sort_latest_release_date">Датою найновішого випуску</string>
+    <string name="action_lists_sort_oldest_release_date">Датою найдавнішого випуску</string>
     <!-- Movies -->
     <string name="title_digital_releases">Цифрові видання</string>
     <string name="title_disc_releases">Видання на диску</string>
diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml
index 544a5e7099..e61d394748 100644
--- a/app/src/main/res/values-zh-rCN/strings.xml
+++ b/app/src/main/res/values-zh-rCN/strings.xml
@@ -252,10 +252,12 @@
     <string name="ack_list_item_manage">列表已更新</string>
     <string name="list_item_remove">从列表中移除</string>
     <string name="ack_list_item_removed">已从列表中删除</string>
-    <string name="list_empty">您可以添加节目到此列表</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">对列表重新排序</string>
     <string name="ack_lists_reordered">列表已重新排序</string>
     <string name="error_name_already_exists">已存在同名列表</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">数字发行</string>
     <string name="title_disc_releases">光盘发行</string>
@@ -305,7 +307,7 @@
     <string name="feature_sync">同步</string>
     <!-- Hexagon -->
     <string name="hexagon_description">SeriesGuide Cloud 可帮您备份并同步您的节目、列表和电影</string>
-    <string name="hexagon_warning_trakt">当登录到 SeriesGuide Cloud 时，Trakt 的某些功能将无法使用</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">登录</string>
     <string name="hexagon_signout">注销</string>
     <string name="hexagon_setup_incomplete">未完成对 SeriesGuide Cloud 的设置。</string>
diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml
index 0a75d30327..642446490e 100644
--- a/app/src/main/res/values-zh-rTW/strings.xml
+++ b/app/src/main/res/values-zh-rTW/strings.xml
@@ -252,10 +252,12 @@
     <string name="ack_list_item_manage">Lists updated</string>
     <string name="list_item_remove">從清單中移除</string>
     <string name="ack_list_item_removed">Removed from list</string>
-    <string name="list_empty">您可以新增節目到此列表</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">重新排序清單</string>
     <string name="ack_lists_reordered">Lists reordered</string>
     <string name="error_name_already_exists">此名稱的清單已存在。</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
     <!-- Movies -->
     <string name="title_digital_releases">數位發行</string>
     <string name="title_disc_releases">碟片版本</string>
@@ -305,7 +307,7 @@
     <string name="feature_sync">同步</string>
     <!-- Hexagon -->
     <string name="hexagon_description">SeriesGuide Cloud helps to back up and sync your shows, lists and movies</string>
-    <string name="hexagon_warning_trakt">若登入 SeriesGuide Cloud，部分 Trakt 的功能將無法使用</string>
+    <string name="hexagon_warning_trakt">While signed in with SeriesGuide Cloud, some Trakt features are disabled and changes are only sent to your Trakt account, not retrieved.</string>
     <string name="hexagon_signin">登入</string>
     <string name="hexagon_signout">登出</string>
     <string name="hexagon_setup_incomplete">SeriesGuide Cloud未完成設置。</string>
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index c3fb7d0153..04c83f0ee9 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -279,10 +279,12 @@
     <string name="ack_list_item_manage">Lists updated</string>
     <string name="list_item_remove">Remove from list</string>
     <string name="ack_list_item_removed">Removed from list</string>
-    <string name="list_empty">You can add shows to this list</string>
+    <string name="list_empty">You can add shows or movies to this list</string>
     <string name="action_lists_reorder">Reorder lists</string>
     <string name="ack_lists_reordered">Lists reordered</string>
     <string name="error_name_already_exists">A list with this name already exists</string>
+    <string name="action_lists_sort_latest_release_date">Latest release date</string>
+    <string name="action_lists_sort_oldest_release_date">Oldest release date</string>
 
     <!-- Movies -->
     <string name="title_digital_releases">Digital releases</string>
diff --git a/app/src/test/java/com/battlelancer/seriesguide/dataliberation/JsonExportTaskTest.kt b/app/src/test/java/com/battlelancer/seriesguide/dataliberation/JsonExportTaskTest.kt
index 213a5246b2..b004b71ff5 100644
--- a/app/src/test/java/com/battlelancer/seriesguide/dataliberation/JsonExportTaskTest.kt
+++ b/app/src/test/java/com/battlelancer/seriesguide/dataliberation/JsonExportTaskTest.kt
@@ -13,6 +13,7 @@ import com.battlelancer.seriesguide.lists.database.SgListItem
 import com.battlelancer.seriesguide.movies.database.MovieHelper
 import com.battlelancer.seriesguide.movies.database.SgMovie
 import com.battlelancer.seriesguide.provider.SeriesGuideContract
+import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItems
 import com.battlelancer.seriesguide.shows.database.SgEpisode2
 import com.battlelancer.seriesguide.shows.database.SgEpisode2Helper
 import com.battlelancer.seriesguide.shows.database.SgSeason2
@@ -123,6 +124,8 @@ class JsonExportTaskTest {
     }
 
     companion object {
+        const val TEST_LIST_1 = "list-1"
+
         val listOfTestShows = listOf(
             SgShow2(
                 id = 1,
@@ -261,6 +264,77 @@ class JsonExportTaskTest {
                 ratingUser = null
             )
         )
+
+        val listOfTestLists = listOf(
+            SgList(
+                listId = TEST_LIST_1,
+                name = "First List",
+                order = 0
+            ),
+            SgList(
+                listId = "list-2",
+                name = "Empty List",
+                order = 1
+            )
+        )
+
+        fun buildTestListItem(itemRefId: String, type: Int) = SgListItem(
+            listId = TEST_LIST_1,
+            listItemId = ListItems.generateListItemId(itemRefId, type, TEST_LIST_1),
+            itemRefId = itemRefId,
+            type = type
+        )
+
+        val listOfTestListItems = listOf(
+            buildTestListItem("item-ref-1", SeriesGuideContract.ListItemTypes.TMDB_SHOW),
+            buildTestListItem("item-ref-2", SeriesGuideContract.ListItemTypes.TVDB_SHOW),
+            buildTestListItem("item-ref-3", SeriesGuideContract.ListItemTypes.SEASON),
+            buildTestListItem("item-ref-4", SeriesGuideContract.ListItemTypes.EPISODE),
+            buildTestListItem("item-ref-5", SeriesGuideContract.ListItemTypes.TMDB_MOVIE)
+        )
+
+        @Language("json")
+        val expectedJsonLists =
+            """
+            [
+            {"list_id":"list-1","name":"First List","order":0,"items":[{"list_item_id":"item-ref-1-4-list-1","externalId":"item-ref-1","type":"tmdb-show"},{"list_item_id":"item-ref-2-1-list-1","externalId":"item-ref-2","type":"show"},{"list_item_id":"item-ref-3-2-list-1","externalId":"item-ref-3","type":"season"},{"list_item_id":"item-ref-4-3-list-1","externalId":"item-ref-4","type":"episode"},{"list_item_id":"item-ref-5-5-list-1","externalId":"item-ref-5","type":"movie"}]}
+            ,{"list_id":"list-2","name":"Empty List","order":1,"items":[]}
+            ]
+            """.trimIndent()
+
+        val testMovieWithValues = SgMovie(
+            tmdbId = 1,
+            imdbId = "imdbidvalue",
+            title = "First Movie",
+            releasedMs = 1234567890,
+            runtimeMin = 123,
+            poster = "/path/to/poster.jpg",
+            overview = "This is a movie description.",
+            inCollection = true,
+            inWatchlist = true,
+            plays = 2,
+            watched = true,
+            lastUpdated = 1234567890
+        )
+
+        val testMovieMinimal = SgMovie(
+            tmdbId = 2,
+            title = "Second Movie"
+        )
+
+        val listOfTestMovies = listOf(
+            testMovieWithValues,
+            testMovieMinimal
+        )
+
+        @Language("json")
+        val expectedJsonMovies =
+            """
+            [
+            {"tmdb_id":1,"imdb_id":"imdbidvalue","title":"First Movie","released_utc_ms":1234567890,"runtime_min":123,"poster":"/path/to/poster.jpg","overview":"This is a movie description.","in_collection":true,"in_watchlist":true,"watched":true,"plays":2,"last_updated_ms":1234567890}
+            ,{"tmdb_id":2,"title":"Second Movie","released_utc_ms":9223372036854775807,"runtime_min":0,"in_collection":false,"in_watchlist":false,"watched":false,"plays":0,"last_updated_ms":0}
+            ]
+            """.trimIndent()
     }
 
     @Test
@@ -294,7 +368,7 @@ class JsonExportTaskTest {
 
         // With data
         `when`(sgListHelper.getListsForExport()).thenReturn(listOfTestLists)
-        `when`(sgListHelper.getListItemsForExport("list-1")).thenReturn(listOfTestListItems)
+        `when`(sgListHelper.getListItemsForExport(TEST_LIST_1)).thenReturn(listOfTestListItems)
 
         val withDataResult = exportTask.run(export)
         assertThat(exportTask.errorCause).isNull()
@@ -303,55 +377,9 @@ class JsonExportTaskTest {
         val exportWithData = exportFile.readText()
         println("Export with data")
         println(exportWithData)
-        assertThat(exportWithData).isEqualTo(
-            """
-            [
-            {"list_id":"list-1","name":"First List","order":0,"items":[{"list_item_id":"list-1-item-1","tvdb_id":0,"externalId":"item-ref-1","type":"tmdb-show"},{"list_item_id":"list-1-item-2","tvdb_id":0,"externalId":"item-ref-2","type":"show"},{"list_item_id":"list-1-item-3","tvdb_id":0,"externalId":"item-ref-3","type":"season"},{"list_item_id":"list-1-item-4","tvdb_id":0,"externalId":"item-ref-4","type":"episode"}]}
-            ,{"list_id":"list-2","name":"Empty List","order":1,"items":[]}
-            ]
-            """.trimIndent()
-        )
+        assertThat(exportWithData).isEqualTo(expectedJsonLists)
     }
 
-    private val listOfTestLists = listOf(
-        SgList(
-            listId = "list-1",
-            name = "First List",
-            order = 0
-        ),
-        SgList(
-            listId = "list-2",
-            name = "Empty List",
-            order = 1
-        )
-    )
-
-    private val listOfTestListItems = listOf(
-        SgListItem(
-            listId = "list-1",
-            listItemId = "list-1-item-1",
-            itemRefId = "item-ref-1",
-            type = SeriesGuideContract.ListItemTypes.TMDB_SHOW
-        ),
-        SgListItem(
-            listId = "list-1",
-            listItemId = "list-1-item-2",
-            itemRefId = "item-ref-2",
-            type = SeriesGuideContract.ListItemTypes.TVDB_SHOW,
-        ),
-        SgListItem(
-            listId = "list-1",
-            listItemId = "list-1-item-3",
-            itemRefId = "item-ref-3",
-            type = SeriesGuideContract.ListItemTypes.SEASON,
-        ),
-        SgListItem(
-            listId = "list-1",
-            listItemId = "list-1-item-4",
-            itemRefId = "item-ref-4",
-            type = SeriesGuideContract.ListItemTypes.EPISODE
-        )
-    )
 
     @Test
     fun exportMovies_jsonAsExpected() = runTest {
@@ -391,35 +419,7 @@ class JsonExportTaskTest {
         val exportWithData = exportFile.readText()
         println("Export with data")
         println(exportWithData)
-        assertThat(exportWithData).isEqualTo(
-            """
-            [
-            {"tmdb_id":1,"imdb_id":"imdbidvalue","title":"First Movie","released_utc_ms":1234567890,"runtime_min":123,"poster":"/path/to/poster.jpg","overview":"This is a movie description.","in_collection":true,"in_watchlist":true,"watched":true,"plays":2,"last_updated_ms":1234567890}
-            ,{"tmdb_id":2,"title":"Second Movie","released_utc_ms":9223372036854775807,"runtime_min":0,"in_collection":false,"in_watchlist":false,"watched":false,"plays":0,"last_updated_ms":0}
-            ]
-            """.trimIndent()
-        )
+        assertThat(exportWithData).isEqualTo(expectedJsonMovies)
     }
 
-    private val listOfTestMovies = listOf(
-        SgMovie(
-            tmdbId = 1,
-            imdbId = "imdbidvalue",
-            title = "First Movie",
-            releasedMs = 1234567890,
-            runtimeMin = 123,
-            poster = "/path/to/poster.jpg",
-            overview = "This is a movie description.",
-            inCollection = true,
-            inWatchlist = true,
-            plays = 2,
-            watched = true,
-            lastUpdated = 1234567890
-        ),
-        SgMovie(
-            tmdbId = 2,
-            title = "Second Movie"
-        )
-    )
-
 }
\ No newline at end of file
diff --git a/app/src/test/java/com/battlelancer/seriesguide/dataliberation/JsonImportTaskTest.kt b/app/src/test/java/com/battlelancer/seriesguide/dataliberation/JsonImportTaskTest.kt
index 080ca16b35..be74727cc5 100644
--- a/app/src/test/java/com/battlelancer/seriesguide/dataliberation/JsonImportTaskTest.kt
+++ b/app/src/test/java/com/battlelancer/seriesguide/dataliberation/JsonImportTaskTest.kt
@@ -1,11 +1,15 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2021-2024 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2021 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.dataliberation
 
 import android.content.Context
 import androidx.test.core.app.ApplicationProvider
 import com.battlelancer.seriesguide.EmptyTestApplication
+import com.battlelancer.seriesguide.lists.database.SgList
+import com.battlelancer.seriesguide.lists.database.SgListHelper
+import com.battlelancer.seriesguide.movies.database.MovieHelper
+import com.battlelancer.seriesguide.movies.database.SgMovie
 import com.battlelancer.seriesguide.provider.SgRoomDatabase
 import com.battlelancer.seriesguide.shows.database.SgEpisode2Helper
 import com.battlelancer.seriesguide.shows.database.SgSeason2
@@ -14,6 +18,9 @@ import com.battlelancer.seriesguide.shows.database.SgShow2
 import com.battlelancer.seriesguide.shows.database.SgShow2Helper
 import com.google.common.truth.Truth.assertThat
 import kotlinx.coroutines.test.runTest
+import org.intellij.lang.annotations.Language
+import org.junit.After
+import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.mockito.Mockito
@@ -30,6 +37,19 @@ import kotlin.io.path.writeText
 class JsonImportTaskTest {
 
     private val context = ApplicationProvider.getApplicationContext<Context>()
+    private lateinit var testDb: SgRoomDatabase
+
+    @Before
+    fun switchToInMemoryDb() {
+        // Use an in-memory database for testing with Room
+        SgRoomDatabase.switchToInMemory(context)
+        testDb = SgRoomDatabase.getInstance(context)
+    }
+
+    @After
+    fun closeDb() {
+        testDb.close()
+    }
 
     /**
      * Mockito.any returns null causing Kotlin null check to throw,
@@ -37,7 +57,6 @@ class JsonImportTaskTest {
      */
     private fun <T> anyNotNull(type: Class<T>): T = Mockito.any(type)
 
-    @Suppress("BlockingMethodInNonBlockingContext")
     @Test
     fun importShow_modelAsExpected() = runTest {
         val sgShow2Helper = mock(SgShow2Helper::class.java)
@@ -52,7 +71,9 @@ class JsonImportTaskTest {
             mock(SgRoomDatabase::class.java),
             sgShow2Helper,
             sgSeason2Helper,
-            sgEpisode2Helper
+            sgEpisode2Helper,
+            mock(SgListHelper::class.java),
+            mock(MovieHelper::class.java)
         )
 
         // Test data from export task test: single show, two seasons, each with two episodes.
@@ -114,4 +135,114 @@ class JsonImportTaskTest {
         verify(sgEpisode2Helper).insertEpisodes(listOf(expectedEpisode3, expectedEpisode4))
     }
 
+    @Test
+    fun importList_modelAsExpected() = runTest {
+        val sgListHelper = mock(SgListHelper::class.java)
+
+        val importTask = JsonImportTask(
+            context,
+            importShows = false,
+            importLists = true,
+            importMovies = false,
+            mock(SgRoomDatabase::class.java),
+            mock(SgShow2Helper::class.java),
+            mock(SgSeason2Helper::class.java),
+            mock(SgEpisode2Helper::class.java),
+            sgListHelper,
+            mock(MovieHelper::class.java)
+        )
+
+        // Test data from export task test: two lists, the first with one item of each type.
+        val testBackupFile = Files.createTempFile("seriesguide-lists-json", null)
+        testBackupFile.writeText(JsonExportTaskTest.expectedJsonLists)
+        importTask.testBackupFile = testBackupFile.toFile()
+
+        val result = importTask.run()
+        assertThat(importTask.errorCause).isNull()
+        assertThat(result).isEqualTo(JsonImportTask.SUCCESS)
+
+        // List 1 with items
+        verify(sgListHelper).insertList(
+            SgList(listId = "list-1", name = "First List", order = 0)
+        )
+        val expectedListItems = JsonExportTaskTest.listOfTestListItems
+        verify(sgListHelper).insertListItems(expectedListItems)
+
+        // List 2 has no items
+        verify(sgListHelper).insertList(
+            SgList(listId = "list-2", name = "Empty List", order = 1)
+        )
+    }
+
+    private suspend fun importMovies(json: String) {
+        val importTask = JsonImportTask(
+            context,
+            importShows = false,
+            importLists = false,
+            importMovies = true
+        )
+
+        @Suppress("BlockingMethodInNonBlockingContext")
+        val testBackupFile = Files.createTempFile("seriesguide-movies-json", null)
+        testBackupFile.writeText(json)
+        importTask.testBackupFile = testBackupFile.toFile()
+
+        val result = importTask.run()
+        assertThat(importTask.errorCause).isNull()
+        assertThat(result).isEqualTo(JsonImportTask.SUCCESS)
+    }
+
+    @Test
+    fun importMovie_modelAsExpected() = runTest {
+        importMovies(JsonExportTaskTest.expectedJsonMovies)
+
+        // Two movies, second one with only TMDB ID and title
+        val insertedMovies = testDb.movieHelper().getAllMovies()
+        assertThat(insertedMovies).hasSize(2)
+
+        val testMovieWithValues = JsonExportTaskTest.testMovieWithValues
+        val insertedMovieWithValues =
+            insertedMovies.first { it.tmdbId == testMovieWithValues.tmdbId }
+        // Check a primary key was assigned
+        assertThat(insertedMovieWithValues.id).isGreaterThan(0)
+        assertThat(insertedMovieWithValues)
+            .isEqualTo(
+                testMovieWithValues.copy(
+                    id = insertedMovieWithValues.id,
+                    titleNoArticle = testMovieWithValues.title
+                )
+            )
+
+        val testMovieMinimal = JsonExportTaskTest.testMovieMinimal
+        val insertedMovieMinimal =
+            insertedMovies.first { it.tmdbId == testMovieMinimal.tmdbId }
+        // Check a primary key was assigned
+        assertThat(insertedMovieMinimal.id).isGreaterThan(0)
+        assertThat(insertedMovieMinimal)
+            .isEqualTo(
+                testMovieMinimal.copy(
+                    id = insertedMovieMinimal.id,
+                    titleNoArticle = testMovieMinimal.title,
+                    releasedMs = SgMovie.RELEASED_MS_UNKNOWN,
+                    lastUpdated = 0
+                )
+            )
+    }
+
+    @Test
+    fun importMovie_missingRequired_notImported() = runTest {
+        @Language("json")
+        val jsonMovieMissingRequiredValues =
+            """
+            [
+            {"imdb_id":"imdbidvalue","title":"First Movie"}
+            ]
+            """.trimIndent()
+
+        importMovies(jsonMovieMissingRequiredValues)
+
+        // Nothing is imported
+        assertThat(testDb.movieHelper().getAllMovies()).hasSize(0)
+    }
+
 }
\ No newline at end of file
diff --git a/app/src/test/java/com/battlelancer/seriesguide/movies/tools/MovieToolsTest.kt b/app/src/test/java/com/battlelancer/seriesguide/movies/tools/MovieToolsTest.kt
index d42d93583c..7958321c4f 100644
--- a/app/src/test/java/com/battlelancer/seriesguide/movies/tools/MovieToolsTest.kt
+++ b/app/src/test/java/com/battlelancer/seriesguide/movies/tools/MovieToolsTest.kt
@@ -1,18 +1,427 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Copyright 2022-2025 Uwe Trottmann
+// SPDX-FileCopyrightText: Copyright © 2022 Uwe Trottmann <uwe@uwetrottmann.com>
 
 package com.battlelancer.seriesguide.movies.tools
 
+import android.content.Context
+import androidx.test.core.app.ApplicationProvider
+import com.battlelancer.seriesguide.EmptyTestApplication
+import com.battlelancer.seriesguide.lists.database.SgList
+import com.battlelancer.seriesguide.lists.database.SgListHelper
+import com.battlelancer.seriesguide.lists.database.SgListItem
+import com.battlelancer.seriesguide.movies.database.MovieHelper
+import com.battlelancer.seriesguide.movies.database.SgMovie
+import com.battlelancer.seriesguide.movies.details.MovieDetails
+import com.battlelancer.seriesguide.movies.tools.MovieTools.Lists
+import com.battlelancer.seriesguide.provider.SeriesGuideContract.ListItemTypes
+import com.battlelancer.seriesguide.provider.SgRoomDatabase
 import com.google.common.truth.Truth.assertThat
 import com.uwetrottmann.tmdb2.entities.Movie
 import com.uwetrottmann.tmdb2.entities.ReleaseDate
 import com.uwetrottmann.tmdb2.entities.ReleaseDatesResult
 import com.uwetrottmann.tmdb2.entities.ReleaseDatesResults
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Before
 import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.ArgumentMatchers.anyBoolean
+import org.mockito.ArgumentMatchers.anyInt
+import org.mockito.Mockito.mock
+import org.mockito.Mockito.never
+import org.mockito.Mockito.verify
+import org.mockito.Mockito.`when`
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
 import java.util.Date
 
+@RunWith(RobolectricTestRunner::class)
+@Config(application = EmptyTestApplication::class)
 class MovieToolsTest {
 
+    private val context = ApplicationProvider.getApplicationContext<Context>()
+    private lateinit var testDb: SgRoomDatabase
+
+    @Before
+    fun switchToInMemoryDb() {
+        // Use an in-memory database for testing with Room
+        SgRoomDatabase.switchToInMemory(context)
+        testDb = SgRoomDatabase.getInstance(context)
+    }
+
+    @After
+    fun closeDb() {
+        testDb.close()
+    }
+
+    class MovieToolsTestEnv(context: Context, db: SgRoomDatabase) {
+        val databaseHelper: MovieHelper = db.movieHelper()
+        val listDatabaseHelper: SgListHelper = db.sgListHelper()
+        val downloader: MovieDownloader = mock()
+
+        val movieTools = MovieTools(
+            context,
+            databaseHelper,
+            listDatabaseHelper,
+            downloader
+        )
+
+        fun insertTestMovie() {
+            databaseHelper.insertMovie(TEST_MOVIE)
+        }
+
+        suspend fun downloaderReturnsTestMovie() {
+            `when`(downloader.getMovieDetailsWithDefaults(TEST_MOVIE_TMDBID, false))
+                .thenReturn(
+                    MovieDownloader.MovieDetailsResult(
+                        MovieDetails().apply {
+                            tmdbMovie(Movie())
+                        },
+                        isNotFoundOnTmdb = false
+                    )
+                )
+        }
+
+        fun insertTestListItem() {
+            // Note: must insert list first to not violate foreign key constraint for list ID
+            listDatabaseHelper.insertList(TEST_LIST)
+            listDatabaseHelper.insertListItems(listOf(TEST_LIST_ITEM))
+        }
+
+        fun getTestMovie(): SgMovie? = databaseHelper.getMovie(TEST_MOVIE_TMDBID)
+
+        fun assertTestMovieIsDeleted() {
+            assertThat(getTestMovie()).isNull()
+        }
+
+        fun assertTestMovieExists() {
+            assertThat(getTestMovie()).isNotNull()
+        }
+
+        fun assertTestMovieIsInDatabaseButNotOnBuiltInLists() {
+            val movieInDb = getTestMovie()
+            assertThat(movieInDb).isNotNull()
+            assertThat(movieInDb!!.tmdbId).isEqualTo(TEST_MOVIE_TMDBID)
+
+            assertThat(movieInDb.inCollection).isFalse()
+            assertThat(movieInDb.inWatchlist).isFalse()
+            assertThat(movieInDb.watched).isFalse()
+            assertThat(movieInDb.plays).isEqualTo(0)
+        }
+
+        fun assertTestMovieIsOnlyOnList(list: Lists) {
+            val movieInDb = getTestMovie()!!
+            assertThat(movieInDb.inCollection).isEqualTo(list == Lists.COLLECTION)
+            assertThat(movieInDb.inWatchlist).isEqualTo(list == Lists.WATCHLIST)
+            assertThat(movieInDb.watched).isEqualTo(list == Lists.WATCHED)
+            assertThat(movieInDb.plays).isEqualTo(if (list == Lists.WATCHED) 1 else 0)
+        }
+    }
+
+    private suspend fun addToListAndAssert(testEnv: MovieToolsTestEnv, list: Lists) {
+        assertThat(
+            testEnv.movieTools
+                .addToList(TEST_MOVIE_TMDBID, list)
+        ).isTrue()
+
+        // Verify movie is in the database with expected list boolean set true
+        testEnv.assertTestMovieExists()
+        testEnv.assertTestMovieIsOnlyOnList(list)
+    }
+
+    private fun addToList_isInDatabase_isUpdated(list: Lists) =
+        runTest {
+            val testEnv = MovieToolsTestEnv(context, testDb)
+                .apply {
+                    // So isMovieInDatabase returns true
+                    insertTestMovie()
+                }
+
+            addToListAndAssert(testEnv, list)
+        }
+
+    @Test
+    fun addToList_collection_isInDatabase_isUpdated() {
+        addToList_isInDatabase_isUpdated(Lists.COLLECTION)
+    }
+
+    @Test
+    fun addToList_watchlist_isInDatabase_isUpdated() {
+        addToList_isInDatabase_isUpdated(Lists.WATCHLIST)
+    }
+
+    @Test
+    fun addToList_watched_isInDatabase_isUpdated() {
+        addToList_isInDatabase_isUpdated(Lists.WATCHED)
+    }
+
+    private fun addToList_notInDatabase_isAdded(list: Lists) =
+        runTest {
+            val testEnv = MovieToolsTestEnv(context, testDb)
+                .apply {
+                    // So addMovie returns true
+                    downloaderReturnsTestMovie()
+                }
+
+            addToListAndAssert(testEnv, list)
+        }
+
+    @Test
+    fun addToList_collection_notInDatabase_isAdded() {
+        addToList_notInDatabase_isAdded(Lists.COLLECTION)
+    }
+
+    @Test
+    fun addToList_watchlist_notInDatabase_isAdded() {
+        addToList_notInDatabase_isAdded(Lists.WATCHLIST)
+    }
+
+    @Test
+    fun addToList_watched_notInDatabase_isAdded() {
+        addToList_notInDatabase_isAdded(Lists.WATCHED)
+    }
+
+    @Test
+    fun removeFromList_notOnAnyList_isRemoved() = runTest {
+        val testEnv = MovieToolsTestEnv(context, testDb)
+            .apply {
+                // So addMovie returns true
+                downloaderReturnsTestMovie()
+                movieTools.addToList(TEST_MOVIE_TMDBID, Lists.COLLECTION)
+            }
+
+        assertThat(
+            testEnv.movieTools.removeFromList(TEST_MOVIE_TMDBID, Lists.COLLECTION)
+        ).isTrue()
+
+        testEnv.assertTestMovieIsDeleted()
+    }
+
+    @Test
+    fun removeFromList_stillOnCustomList_isUpdated() = runTest {
+        val testEnv = MovieToolsTestEnv(context, testDb)
+            .apply {
+                insertTestMovie()
+                insertTestListItem()
+                movieTools.addToList(TEST_MOVIE_TMDBID, Lists.COLLECTION)
+            }
+
+        assertThat(
+            testEnv.movieTools.removeFromList(TEST_MOVIE_TMDBID, Lists.COLLECTION)
+        ).isTrue()
+
+        // Not deleted, but updated instead
+        val updatedMovie = testEnv.getTestMovie()
+        assertThat(updatedMovie).isNotNull()
+        assertThat(updatedMovie!!.inCollection).isEqualTo(false)
+    }
+
+    private fun removeFromList_stillOnBuiltInList_isUpdated(removeFromList: Lists) = runTest {
+        val testEnv = MovieToolsTestEnv(context, testDb)
+            .apply {
+                // So addMovie returns true
+                downloaderReturnsTestMovie()
+                // For simplicity add to all lists
+                movieTools.addToList(TEST_MOVIE_TMDBID, Lists.COLLECTION)
+                movieTools.addToList(TEST_MOVIE_TMDBID, Lists.WATCHLIST)
+                movieTools.addToList(TEST_MOVIE_TMDBID, Lists.WATCHED)
+            }
+
+        assertThat(
+            testEnv.movieTools.removeFromList(TEST_MOVIE_TMDBID, removeFromList)
+        ).isTrue()
+
+        val updatedMovie = testEnv.getTestMovie()
+        assertThat(updatedMovie).isNotNull()
+        assertThat(updatedMovie!!.inCollection).isEqualTo(removeFromList != Lists.COLLECTION)
+        assertThat(updatedMovie.inWatchlist).isEqualTo(removeFromList != Lists.WATCHLIST)
+        assertThat(updatedMovie.watched).isEqualTo(removeFromList != Lists.WATCHED)
+        assertThat(updatedMovie.plays).isEqualTo(if (removeFromList != Lists.WATCHED) 1 else 0)
+    }
+
+    @Test
+    fun removeFromList_collection_stillOnOtherList_isUpdated() {
+        removeFromList_stillOnBuiltInList_isUpdated(Lists.COLLECTION)
+    }
+
+    @Test
+    fun removeFromList_watchlist_stillOnOtherList_isUpdated() {
+        removeFromList_stillOnBuiltInList_isUpdated(Lists.WATCHLIST)
+    }
+
+    @Test
+    fun removeFromList_watched_stillOnOtherList_isUpdated() {
+        removeFromList_stillOnBuiltInList_isUpdated(Lists.WATCHED)
+    }
+
+    @Test
+    fun addToOrDeleteFromDatabaseAfterCustomListChange_notInCustomOrBuiltInList_isDeleted() =
+        runTest {
+            val testEnv = MovieToolsTestEnv(context, testDb)
+                .apply {
+                    insertTestMovie()
+                }
+
+            assertThat(
+                testEnv.movieTools
+                    .addToOrDeleteFromDatabaseAfterCustomListChange(TEST_MOVIE_TMDBID)
+            ).isTrue()
+
+            testEnv.assertTestMovieIsDeleted()
+        }
+
+    private suspend fun addToOrDeleteFromDatabaseAfterCustomListChange_assertNotDeleted(testEnv: MovieToolsTestEnv) {
+        assertThat(
+            testEnv.movieTools
+                .addToOrDeleteFromDatabaseAfterCustomListChange(TEST_MOVIE_TMDBID)
+        ).isTrue()
+
+        testEnv.assertTestMovieExists()
+
+        // Indirectly verify that movie is not added, because addMovie would call the downloader
+        verify(testEnv.downloader, never())
+            .getMovieDetailsWithDefaults(anyInt(), anyBoolean())
+    }
+
+    private fun addToOrDeleteFromDatabaseAfterCustomListChange_notDeleted(
+        addToList: Lists
+    ) = runTest {
+        val testEnv = MovieToolsTestEnv(context, testDb)
+            .apply {
+                insertTestMovie() // To be able to add to built-in list without "downloading"
+                movieTools.addToList(TEST_MOVIE_TMDBID, addToList)
+            }
+
+        addToOrDeleteFromDatabaseAfterCustomListChange_assertNotDeleted(testEnv)
+
+        // Also verify movie remains on custom list (incl. not overwritten if incorrectly re-added)
+        testEnv.assertTestMovieIsOnlyOnList(addToList)
+    }
+
+    @Test
+    fun addToOrDeleteFromDatabaseAfterCustomListChange_inCollection_notDeleted() {
+        addToOrDeleteFromDatabaseAfterCustomListChange_notDeleted(Lists.COLLECTION)
+    }
+
+    @Test
+    fun addToOrDeleteFromDatabaseAfterCustomListChange_onWatchlist_notDeleted() {
+        addToOrDeleteFromDatabaseAfterCustomListChange_notDeleted(Lists.WATCHLIST)
+    }
+
+    @Test
+    fun addToOrDeleteFromDatabaseAfterCustomListChange_isWatched_notDeleted() {
+        addToOrDeleteFromDatabaseAfterCustomListChange_notDeleted(Lists.WATCHED)
+    }
+
+    @Test
+    fun addToOrDeleteFromDatabaseAfterCustomListChange_inCustomList_notDeleted() = runTest {
+        val testEnv = MovieToolsTestEnv(context, testDb)
+            .apply {
+                insertTestMovie()
+                insertTestListItem()
+            }
+
+        addToOrDeleteFromDatabaseAfterCustomListChange_assertNotDeleted(testEnv)
+    }
+
+    @Test
+    fun addToOrDeleteFromDatabaseAfterCustomListChange_inCustomListNotInDatabase_isAdded() =
+        runTest {
+            val testEnv = MovieToolsTestEnv(context, testDb)
+                .apply {
+                    insertTestListItem()
+                    downloaderReturnsTestMovie()
+                }
+
+            assertThat(
+                testEnv.movieTools
+                    .addToOrDeleteFromDatabaseAfterCustomListChange(TEST_MOVIE_TMDBID)
+            ).isTrue()
+
+            testEnv.assertTestMovieIsInDatabaseButNotOnBuiltInLists()
+        }
+
+    @Test
+    fun updateDatabaseAfterCustomListChange_movieInCustomList_isAdded() = runTest {
+        val testEnv = MovieToolsTestEnv(context, testDb)
+            .apply {
+                insertTestListItem()
+                downloaderReturnsTestMovie()
+            }
+
+        assertThat(
+            testEnv.movieTools.updateDatabaseAfterCustomListChange()
+        ).isTrue()
+
+        testEnv.assertTestMovieIsInDatabaseButNotOnBuiltInLists()
+    }
+
+    @Test
+    fun updateDatabaseAfterCustomListChange_movieInDatabase_notAdded() = runTest {
+        val testEnv = MovieToolsTestEnv(context, testDb)
+            .apply {
+                insertTestMovie()
+                insertTestListItem()
+            }
+
+        assertThat(
+            testEnv.movieTools.updateDatabaseAfterCustomListChange()
+        ).isTrue()
+
+        // Indirectly verify that movie is not added, because addMovie would call the downloader
+        verify(testEnv.downloader, never())
+            .getMovieDetailsWithDefaults(anyInt(), anyBoolean())
+
+        // Check movie is not deleted either
+        testEnv.assertTestMovieIsInDatabaseButNotOnBuiltInLists()
+    }
+
+    @Test
+    fun updateDatabaseAfterCustomListChange_movieNotOnAnyList_isDeleted() = runTest {
+        val testEnv = MovieToolsTestEnv(context, testDb)
+            .apply {
+                insertTestMovie()
+            }
+
+        assertThat(
+            testEnv.movieTools.updateDatabaseAfterCustomListChange()
+        ).isTrue()
+
+        testEnv.assertTestMovieIsDeleted()
+    }
+
+    private fun updateDatabaseAfterCustomListChange_onBuiltInList_notDeleted(list: Lists) =
+        runTest {
+            val testEnv = MovieToolsTestEnv(context, testDb)
+                .apply {
+                    insertTestMovie()
+                    movieTools.addToList(TEST_MOVIE_TMDBID, list)
+                }
+
+            assertThat(
+                testEnv.movieTools.updateDatabaseAfterCustomListChange()
+            ).isTrue()
+
+            testEnv.assertTestMovieExists()
+            // Also verify movie is not re-added which would re-set list flags
+            testEnv.assertTestMovieIsOnlyOnList(list)
+        }
+
+    @Test
+    fun updateDatabaseAfterCustomListChange_inCollection_notDeleted() {
+        updateDatabaseAfterCustomListChange_onBuiltInList_notDeleted(Lists.COLLECTION)
+    }
+
+    @Test
+    fun updateDatabaseAfterCustomListChange_onWatchlist_notDeleted() {
+        updateDatabaseAfterCustomListChange_onBuiltInList_notDeleted(Lists.WATCHLIST)
+    }
+
+    @Test
+    fun updateDatabaseAfterCustomListChange_watched_notDeleted() {
+        updateDatabaseAfterCustomListChange_onBuiltInList_notDeleted(Lists.WATCHED)
+    }
+
     @Test
     fun updateReleaseDateForRegion() {
         val movie = Movie()
@@ -60,4 +469,21 @@ class MovieToolsTest {
         // Picks single US date.
         assertThat(movie.release_date).isEqualTo(Date(123456))
     }
+
+    companion object {
+        private const val TEST_MOVIE_TMDBID = 12345
+        private val TEST_MOVIE = SgMovie(
+            tmdbId = TEST_MOVIE_TMDBID
+        )
+        private val TEST_LIST_ID = "test-list"
+        private val TEST_LIST = SgList(
+            listId = TEST_LIST_ID,
+            name = "Test List"
+        )
+        private val TEST_LIST_ITEM = SgListItem(
+            itemRefId = TEST_MOVIE_TMDBID,
+            type = ListItemTypes.TMDB_MOVIE,
+            listId = TEST_LIST_ID
+        )
+    }
 }
\ No newline at end of file
diff --git a/app/src/test/java/com/battlelancer/seriesguide/shows/tools/AddUpdateShowToolsTest.kt b/app/src/test/java/com/battlelancer/seriesguide/shows/tools/AddUpdateShowToolsTest.kt
new file mode 100644
index 0000000000..a8689f30f8
--- /dev/null
+++ b/app/src/test/java/com/battlelancer/seriesguide/shows/tools/AddUpdateShowToolsTest.kt
@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-FileCopyrightText: Copyright © 2026 Uwe Trottmann <uwe@uwetrottmann.com>
+
+package com.battlelancer.seriesguide.shows.tools
+
+import android.content.Context
+import androidx.test.core.app.ApplicationProvider
+import com.battlelancer.seriesguide.EmptyTestApplication
+import com.battlelancer.seriesguide.billing.BillingTools
+import com.battlelancer.seriesguide.provider.SgRoomDatabase
+import com.battlelancer.seriesguide.tmdbapi.TmdbTools3.TmdbError
+import com.battlelancer.seriesguide.tmdbapi.TmdbTools3.TmdbStop
+import com.github.michaelbull.result.Err
+import com.github.michaelbull.result.Ok
+import com.google.common.truth.Truth.assertThat
+import com.uwetrottmann.tmdb2.entities.TvSeason
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mockito.mock
+import org.mockito.kotlin.any
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.isNull
+import org.mockito.kotlin.whenever
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(application = EmptyTestApplication::class)
+class AddUpdateShowToolsTest {
+
+    private val context = ApplicationProvider.getApplicationContext<Context>()
+    private lateinit var testDb: SgRoomDatabase
+
+    @Before
+    fun switchToInMemoryDb() {
+        // Use an in-memory database for testing with Room
+        SgRoomDatabase.switchToInMemory(context)
+        testDb = SgRoomDatabase.getInstance(context)
+    }
+
+    @After
+    fun closeDb() {
+        testDb.close()
+    }
+
+    // Note: could also test for failing to insert show or season, but would have to mock database
+    // helpers to simulate failure. Which then won't allow testing if the database changes are
+    // actually not applied.
+    @Test
+    fun addShow_getEpisodesOfSeasonFails_rollsBackChanges() {
+        val testShow = ShowTestHelper.showToInsert()
+        val testTmdbId = testShow.tmdbId!!
+        val testLanguage = "en"
+
+        // So getShowDetails returns an OK result and the show and season are inserted
+        val showTools = ShowTools2(context, mock())
+        val getShowTools: GetShowTools = mock()
+        whenever(
+            getShowTools.getShowDetails(
+                testTmdbId,
+                testLanguage
+            )
+        ).thenReturn(
+            Ok(
+                GetShowTools.ShowDetails(
+                    show = testShow,
+                    seasons = listOf(TEST_TMDB_SEASON)
+                )
+            )
+        )
+
+        // So HexagonSettings.isEnabled(context) returns false and fetching from Cloud is skipped
+        BillingTools.updateUnlockState(context)
+
+        // Fail getting episodes for season call
+        val getEpisodesOfSeasonTools: GetEpisodesOfSeasonTools = mock()
+        whenever(
+            getEpisodesOfSeasonTools.getEpisodesOfSeason(
+                any(),
+                eq(testTmdbId),
+                any(),
+                any(),
+                any(),
+                any(),
+                isNull(),
+                isNull()
+            )
+        ).thenReturn(Err<TmdbError>(TmdbStop))
+
+        val addUpdateShowTools = AddUpdateShowTools(
+            context,
+            getShowTools,
+            mock(),
+            mock(),
+            { showTools },
+            getEpisodesOfSeasonTools
+        )
+
+        val result = addUpdateShowTools.addShow(
+            testTmdbId,
+            testLanguage,
+            null,
+            null,
+            mock()
+        )
+
+        assertThat(result).isEqualTo(AddUpdateShowTools.ShowResult.TMDB_ERROR)
+        // Inserted show and season should not be persisted
+        assertThat(testDb.sgShow2Helper().getShowsForExport()).isEmpty()
+        assertThat(testDb.sgSeason2Helper().countSeasons()).isEqualTo(0);
+    }
+
+    companion object {
+        private val TEST_TMDB_SEASON = TvSeason().apply {
+            id = 1234
+            season_number = 1
+            name = "Test Season 1"
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/build.gradle.kts b/build.gradle.kts
index 86acf11190..5a84eb4182 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -24,9 +24,9 @@ buildscript {
     // YYYY.<release-of-year>.<build> - like 2024.1.0
     // - allows to more easily judge how old a release is
     // - allows multiple releases per month (though currently unlikely)
-    val sgVersionName by extra("2026.1.5")
+    val sgVersionName by extra("2026.2.2")
     // version 23yyrrbb -> min SDK 23, year yy, release rr, build bb
-    val sgVersionCode by extra(23260106)
+    val sgVersionCode by extra(23260202)
 
     val isCiBuild by extra { System.getenv("CI") == "true" }
 
diff --git a/docs/backup-json-schema.md b/docs/backup-json-schema.md
index 15dfbaa430..335cd82647 100644
--- a/docs/backup-json-schema.md
+++ b/docs/backup-json-schema.md
@@ -3,6 +3,9 @@
 _SeriesGuide can [export and import your data](https://www.seriesgui.de/help/how-to/backup/backup)
 using JSON text files._
 
+> [!NOTE]
+> Migrating from TV Time? Check [the forum post](https://discuss.seriesgui.de/t/tv-time-shutdown-and-importing-into-seriesguide/2807) on how to convert to the SeriesGuide format.
+
 The expected format and values are documented here.
 
 To see an example file, export your data from SeriesGuide. Note that unlike the examples below the
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 09a553adf7..2ee8f23824 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -124,7 +124,7 @@ picasso = "com.squareup.picasso:picasso:2.8" # https://github.com/square/picasso
 retrofit2-gson = "com.squareup.retrofit2:converter-gson:3.0.0"
 retrofit2 = "com.squareup.retrofit2:retrofit:3.0.0"
 tmdb-java = "com.uwetrottmann.tmdb2:tmdb-java:2.13.0" # https://github.com/UweTrottmann/tmdb-java/blob/main/CHANGELOG.md
-trakt-java = "com.uwetrottmann.trakt5:trakt-java:6.20.0" # https://github.com/UweTrottmann/trakt-java/blob/main/CHANGELOG.md
+trakt-java = "com.uwetrottmann.trakt5:trakt-java:6.20.1" # https://github.com/UweTrottmann/trakt-java/blob/main/CHANGELOG.md
 
 # Billing
 amazon-appstore-sdk = "com.amazon.device:amazon-appstore-sdk:3.0.8" # https://developer.amazon.com/docs/in-app-purchasing/iap-whats-new.html
@@ -135,9 +135,11 @@ billing = "com.android.billingclient:billing-ktx:8.0.0"
 junit = "junit:junit:4.13.2"
 # https://github.com/google/truth/releases
 truth = "com.google.truth:truth:1.4.5"
+# Mockito: Kotlin artifact should include matching core version
 # https://github.com/mockito/mockito/releases
-# mockito 5 requires JDK 11
-mockito = "org.mockito:mockito-core:4.11.0"
+mockito = "org.mockito:mockito-core:5.23.0"
+# https://github.com/mockito/mockito-kotlin/releases
+mockito-kotlin = "org.mockito.kotlin:mockito-kotlin:6.3.0"
 # https://github.com/robolectric/robolectric/releases/
 robolectric = "org.robolectric:robolectric:4.16"
 # https://developer.android.com/jetpack/androidx/releases/test