[AndroidTV] Fix selecting PeerTube instance in navigation drawer

Fixes #10020

.github/CONTRIBUTING.md

@@ -1,3 +1,5 @@
+### Please do **not** open pull requests for *new features* now, as we are planning to rewrite large chunks of the code. Only bugfix PRs will be accepted. More details will be announced soon!
+
 NewPipe contribution guidelines
 ===============================
 
@@ -22,6 +24,7 @@ You'll see *exactly* what is sent, be able to add **your comments**, and then se
 
 * NewPipe is translated via [Weblate](https://hosted.weblate.org/projects/newpipe/strings/). Log in there with your GitHub account, or register.
 * Add the language you want to translate if it is not there already: see [How to add a new language](https://github.com/TeamNewPipe/NewPipe/wiki/How-to-add-a-new-language-to-NewPipe) in the wiki.
+* NewPipe uses the [PrettyTime](https://github.com/ocpsoft/prettytime) library to display localized versions of dates and times. It needs to be translated, too. Read [these instructions to add a new language](https://www.ocpsoft.org/prettytime/#section-14) and [this issue](https://github.com/TeamNewPipe/NewPipe/issues/9134) for more info.
 
 ## Code contribution
 

.github/DISCUSSION_TEMPLATE/questions.yml

@@ -1,11 +1,11 @@
 name: Question
 description: Ask about anything NewPipe-related
-labels: [question, needs triage]
+labels: [question]
 body:
   - type: markdown
     attributes:
       value: |
-        Thanks for taking the time to fill out this issue! :hugs:
+        Thanks for taking the time to fill out this form! :hugs:
 
         Note that you can also ask questions on our [IRC channel](https://web.libera.chat/#newpipe).
 
@@ -14,7 +14,7 @@ body:
     attributes:
       label: "Checklist"
       options:
-        - label: "I made sure that there are *no existing issues* - [open](https://github.com/TeamNewPipe/NewPipe/issues) or [closed](https://github.com/TeamNewPipe/NewPipe/issues?q=is%3Aissue+is%3Aclosed) - which I could contribute my information to."
+        - label: "I made sure that there are *no existing issues or discussions* - [open](https://github.com/TeamNewPipe/NewPipe/issues) or [closed](https://github.com/TeamNewPipe/NewPipe/issues?q=is%3Aissue+is%3Aclosed) - which I could contribute my information to."
           required: true
         - label: "I have read the [FAQ](https://newpipe.net/FAQ/) and my question isn't listed."
           required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +1,8 @@
 blank_issues_enabled: false
 contact_links:
+  - name: ❓ Question
+    url: https://github.com/TeamNewPipe/NewPipe/discussions/new?category=questions
+    about: Ask about anything NewPipe-related
   - name: 💬 IRC
     url: https://web.libera.chat/#newpipe
     about: Chat with us via IRC for quick Q/A

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,6 +1,6 @@
 name: Feature request
 description: Suggest an idea for this project
-labels: [enhancement, needs triage]
+labels: [feature request, needs triage]
 body:
   - type: markdown
     attributes:

.github/PULL_REQUEST_TEMPLATE.md

@@ -28,7 +28,7 @@
 #### APK testing
 <!-- Use a new, meaningfully named branch. The name is used as a suffix for the app ID to allow installing and testing multiple versions of NewPipe, e.g. "commentfix", if your PR implements a bugfix for comments. (No names like "patch-0" and "feature-1".)  -->
 <!-- Remove the following line if you directly link the APK created by the CI pipeline. Directly linking is preferred if you need to let users test.-->
-The APK can be found by going to the "Checks" tab below the title. On the left pane, click on "CI", scroll down to "artifacts" and click "app" to download the zip file which contains the debug APK of this PR.
+The APK can be found by going to the "Checks" tab below the title. On the left pane, click on "CI", scroll down to "artifacts" and click "app" to download the zip file which contains the debug APK of this PR. You can find more info and a video demonstration [on this wiki page](https://github.com/TeamNewPipe/NewPipe/wiki/Download-APK-for-PR).
 
 #### Due diligence
 - [ ] I read the [contribution guidelines](https://github.com/TeamNewPipe/NewPipe/blob/HEAD/.github/CONTRIBUTING.md).

.github/workflows/ci.yml

@@ -42,12 +42,14 @@ jobs:
       - name: create and checkout branch
         # push events already checked out the branch
         if: github.event_name == 'pull_request'
-        run: git checkout -B ${{ github.head_ref }}
+        env:
+          BRANCH: ${{ github.head_ref }}
+        run: git checkout -B "$BRANCH"
 
-      - name: set up JDK 11
+      - name: set up JDK 17
         uses: actions/setup-java@v3
         with:
-          java-version: 11
+          java-version: 17
           distribution: "temurin"
           cache: 'gradle'
 
@@ -66,8 +68,13 @@ jobs:
     timeout-minutes: 20
     strategy:
       matrix:
-        # api-level 19 is min sdk, but throws errors related to desugaring
-        api-level: [ 21, 29 ]
+        include:
+          - api-level: 21
+            target: default
+            arch: x86
+          - api-level: 33
+            target: google_apis # emulator API 33 only exists with Google APIs
+            arch: x86_64
 
     permissions:
       contents: read
@@ -75,10 +82,10 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
-      - name: set up JDK 11
+      - name: set up JDK 17
         uses: actions/setup-java@v3
         with:
-          java-version: 11
+          java-version: 17
           distribution: "temurin"
           cache: 'gradle'
 
@@ -86,8 +93,8 @@ jobs:
         uses: reactivecircus/android-emulator-runner@v2
         with:
           api-level: ${{ matrix.api-level }}
-          # workaround to emulator bug: https://github.com/ReactiveCircus/android-emulator-runner/issues/160
-          emulator-build: 7425822
+          target: ${{ matrix.target }}
+          arch: ${{ matrix.arch }}
           script: ./gradlew connectedCheck --stacktrace
 
       - name: Upload test report when tests fail # because the printed out stacktrace (console) is too short, see also #7553
@@ -108,10 +115,10 @@ jobs:
         with:
           fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
 
-      - name: Set up JDK 11
+      - name: Set up JDK 17
         uses: actions/setup-java@v3
         with:
-          java-version: 11 # Sonar requires JDK 11
+          java-version: 17
           distribution: "temurin"
           cache: 'gradle'
 
@@ -126,4 +133,4 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}  # Needed to get PR information, if any
           SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
-        run: ./gradlew build sonarqube --info
+        run: ./gradlew build sonar --info

.github/workflows/image-minimizer.js

@@ -30,10 +30,12 @@ module.exports = async ({github, context}) => {
     }
 
     // Regex for finding images (simple variant) ![ALT_TEXT](https://*.githubusercontent.com/<number>/<variousHexStringsAnd->.<fileExtension>)
-    const REGEX_IMAGE_LOOKUP = /\!\[(.*)\]\((https:\/\/[-a-z0-9]+\.githubusercontent\.com\/\d+\/[-0-9a-f]{32,512}\.(jpg|gif|png))\)/gm;
+    const REGEX_USER_CONTENT_IMAGE_LOOKUP = /\!\[(.*)\]\((https:\/\/[-a-z0-9]+\.githubusercontent\.com\/\d+\/[-0-9a-f]{32,512}\.(jpg|gif|png))\)/gm;
+    const REGEX_ASSETS_IMAGE_LOCKUP = /\!\[(.*)\]\((https:\/\/github\.com\/[-\w\d]+\/[-\w\d]+\/assets\/\d+\/[\-0-9a-f]{32,512})\)/gm;
 
     // Check if we found something
-    let foundSimpleImages = REGEX_IMAGE_LOOKUP.test(initialBody);
+    let foundSimpleImages = REGEX_USER_CONTENT_IMAGE_LOOKUP.test(initialBody)
+        || REGEX_ASSETS_IMAGE_LOCKUP.test(initialBody);
     if (!foundSimpleImages) {
         console.log('Found no simple images to process');
         return;
@@ -47,51 +49,8 @@ module.exports = async ({github, context}) => {
     var wasMatchModified = false;
 
     // Try to find and replace the images with minimized ones
-    let newBody = await replaceAsync(initialBody, REGEX_IMAGE_LOOKUP, async (match, g1, g2) => {
-        console.log(`Found match '${match}'`);
-        
-        if (g1.endsWith(IGNORE_ALT_NAME_END)) {
-            console.log(`Ignoring match '${match}': IGNORE_ALT_NAME_END`);
-            return match;
-        }
-        
-        let shouldModify = false;
-        try {
-            console.log(`Probing ${g2}`);
-            let probeResult = await probe(g2);
-            if (probeResult == null) {
-                throw 'No probeResult';
-            }
-            if (probeResult.hUnits != 'px') {
-                throw `Unexpected probeResult.hUnits (expected px but got ${probeResult.hUnits})`;
-            }
-            if (probeResult.height <= 0) {
-                throw `Unexpected probeResult.height (height is invalid: ${probeResult.height})`;
-            }
-            if (probeResult.wUnits != 'px') {
-                throw `Unexpected probeResult.wUnits (expected px but got ${probeResult.wUnits})`;
-            }
-            if (probeResult.width <= 0) {
-                throw `Unexpected probeResult.width (width is invalid: ${probeResult.width})`;
-            }
-            console.log(`Probing resulted in ${probeResult.width}x${probeResult.height}px`);
-            
-            shouldModify = probeResult.height > IMG_MAX_HEIGHT_PX && (probeResult.width / probeResult.height) < MIN_ASPECT_RATIO;
-        } catch(e) {
-            console.log('Probing failed:', e);
-            // Immediately abort
-            return match;
-        }
-        
-        if (shouldModify) {
-            wasMatchModified = true;
-            console.log(`Modifying match '${match}'`);
-            return `<img alt="${g1}" src="${g2}" height=${IMG_MAX_HEIGHT_PX} />`;
-        }
-        
-        console.log(`Match '${match}' is ok/will not be modified`);
-        return match;
-    });
+    let newBody = await replaceAsync(initialBody, REGEX_USER_CONTENT_IMAGE_LOOKUP, minimizeAsync);
+    newBody = await replaceAsync(newBody, REGEX_ASSETS_IMAGE_LOCKUP, minimizeAsync);
     
     if (!wasMatchModified) {
         console.log('Nothing was modified. Skipping update');
@@ -127,4 +86,52 @@ module.exports = async ({github, context}) => {
         const data = await Promise.all(promises);
         return str.replace(regex, () => data.shift());
     }
+
+    async function minimizeAsync(match, g1, g2) {
+            console.log(`Found match '${match}'`);
+
+            if (g1.endsWith(IGNORE_ALT_NAME_END)) {
+                console.log(`Ignoring match '${match}': IGNORE_ALT_NAME_END`);
+                return match;
+            }
+
+            let probeAspectRatio = 0;
+            let shouldModify = false;
+            try {
+                console.log(`Probing ${g2}`);
+                let probeResult = await probe(g2);
+                if (probeResult == null) {
+                    throw 'No probeResult';
+                }
+                if (probeResult.hUnits != 'px') {
+                    throw `Unexpected probeResult.hUnits (expected px but got ${probeResult.hUnits})`;
+                }
+                if (probeResult.height <= 0) {
+                    throw `Unexpected probeResult.height (height is invalid: ${probeResult.height})`;
+                }
+                if (probeResult.wUnits != 'px') {
+                    throw `Unexpected probeResult.wUnits (expected px but got ${probeResult.wUnits})`;
+                }
+                if (probeResult.width <= 0) {
+                    throw `Unexpected probeResult.width (width is invalid: ${probeResult.width})`;
+                }
+                console.log(`Probing resulted in ${probeResult.width}x${probeResult.height}px`);
+
+                probeAspectRatio = probeResult.width / probeResult.height;
+                shouldModify = probeResult.height > IMG_MAX_HEIGHT_PX && probeAspectRatio < MIN_ASPECT_RATIO;
+            } catch(e) {
+                console.log('Probing failed:', e);
+                // Immediately abort
+                return match;
+            }
+
+            if (shouldModify) {
+                wasMatchModified = true;
+                console.log(`Modifying match '${match}'`);
+                return `<img alt="${g1}" src="${g2}" width=${Math.min(600, (IMG_MAX_HEIGHT_PX * probeAspectRatio).toFixed(0))} />`;
+            }
+
+            console.log(`Match '${match}' is ok/will not be modified`);
+            return match;
+        }
 }

README.md

@@ -1,3 +1,6 @@
+<h3 align="center">We are planning to <i>rewrite</i> large chunks of the codebase, to bring about <a href="https://github.com/TeamNewPipe/NewPipe/discussions/10118">a new, modern and stable NewPipe</a>!</h3>
+<h4 align="center">Please do <b>not</b> open pull requests for <i>new features</i> now, only bugfix PRs will be accepted.</h4>
+
 <p align="center"><a href="https://newpipe.net"><img src="assets/new_pipe_icon_5.png" width="150"></a></p> 
 <h2 align="center"><b>NewPipe</b></h2>
 <h4 align="center">A libre lightweight streaming front-end for Android.</h4>
@@ -25,18 +28,18 @@
 
 ## Screenshots
 
-[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/shot_01.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/shot_01.png)
-[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/shot_02.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/shot_02.png)
-[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/shot_03.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/shot_03.png)
-[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/shot_04.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/shot_04.png)
-[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/shot_05.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/shot_05.png)
-[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/shot_06.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/shot_06.png)
-[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/shot_07.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/shot_07.png)
-[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/shot_08.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/shot_08.png)
-[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/shot_09.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/shot_09.png)
-[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/shot_10.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/shot_10.png)
-[<img src="fastlane/metadata/android/en-US/images/tenInchScreenshots/shot_11.png" width=405>](fastlane/metadata/android/en-US/images/tenInchScreenshots/shot_11.png)
-[<img src="fastlane/metadata/android/en-US/images/tenInchScreenshots/shot_12.png" width=405>](fastlane/metadata/android/en-US/images/tenInchScreenshots/shot_12.png)
+[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/00.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/00.png)
+[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/01.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/01.png)
+[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/02.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/02.png)
+[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/03.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/03.png)
+[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/04.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/04.png)
+[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/05.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/05.png)
+[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/06.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/06.png)
+[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/07.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/07.png)
+[<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/08.png" width=160>](fastlane/metadata/android/en-US/images/phoneScreenshots/08.png)
+<br/><br/>
+[<img src="fastlane/metadata/android/en-US/images/tenInchScreenshots/09.png" width=405>](fastlane/metadata/android/en-US/images/tenInchScreenshots/09.png)
+[<img src="fastlane/metadata/android/en-US/images/tenInchScreenshots/10.png" width=405>](fastlane/metadata/android/en-US/images/tenInchScreenshots/10.png)
 
 ### Supported Services
 

app/build.gradle

@@ -1,23 +1,27 @@
+import com.android.tools.profgen.ArtProfileKt
+import com.android.tools.profgen.ArtProfileSerializer
+import com.android.tools.profgen.DexFile
+
 plugins {
     id "com.android.application"
     id "kotlin-android"
     id "kotlin-kapt"
     id "kotlin-parcelize"
     id "checkstyle"
-    id "org.sonarqube" version "3.3"
+    id "org.sonarqube" version "4.0.0.2929"
 }
 
 android {
-    compileSdk 31
-    buildToolsVersion '31.0.0'
+    compileSdk 33
+    namespace 'org.schabi.newpipe'
 
     defaultConfig {
         applicationId "org.schabi.newpipe"
         resValue "string", "app_name", "NewPipe"
         minSdk 21
-        targetSdk 29
-        versionCode 990
-        versionName "0.24.0"
+        targetSdk 33
+        versionCode 993
+        versionName "0.25.1"
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 
@@ -76,13 +80,13 @@ android {
         // Flag to enable support for the new language APIs
         coreLibraryDesugaringEnabled true
 
-        sourceCompatibility JavaVersion.VERSION_11
-        targetCompatibility JavaVersion.VERSION_11
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
         encoding 'utf-8'
     }
 
     kotlinOptions {
-        jvmTarget = JavaVersion.VERSION_11
+        jvmTarget = JavaVersion.VERSION_17
     }
 
     sourceSets {
@@ -92,25 +96,32 @@ android {
     buildFeatures {
         viewBinding true
     }
+
+    packagingOptions {
+        resources {
+            // remove two files which belong to jsoup
+            // no idea how they ended up in the META-INF dir...
+            excludes += ['META-INF/README.md', 'META-INF/CHANGES']
+        }
+    }
 }
 
 ext {
-    checkstyleVersion = '10.3.1'
+    checkstyleVersion = '10.12.1'
 
     androidxLifecycleVersion = '2.5.1'
     androidxRoomVersion = '2.4.3'
     androidxWorkVersion = '2.7.1'
 
     icepickVersion = '3.2.0'
-    exoPlayerVersion = '2.18.1'
+    exoPlayerVersion = '2.18.7'
     googleAutoServiceVersion = '1.0.1'
     groupieVersion = '2.10.1'
     markwonVersion = '4.6.2'
 
-    leakCanaryVersion = '2.5'
+    leakCanaryVersion = '2.9.1'
     stethoVersion = '1.6.0'
     mockitoVersion = '4.0.0'
-    assertJVersion = '3.23.1'
 }
 
 configurations {
@@ -152,6 +163,7 @@ task runKtlint(type: JavaExec) {
     getMainClass().set("com.pinterest.ktlint.Main")
     classpath = configurations.ktlint
     args "src/**/*.kt"
+    jvmArgs("--add-opens", "java.base/java.lang=ALL-UNNAMED")
 }
 
 task formatKtlint(type: JavaExec) {
@@ -160,6 +172,7 @@ task formatKtlint(type: JavaExec) {
     getMainClass().set("com.pinterest.ktlint.Main")
     classpath = configurations.ktlint
     args "-F", "src/**/*.kt"
+    jvmArgs("--add-opens", "java.base/java.lang=ALL-UNNAMED")
 }
 
 afterEvaluate {
@@ -169,7 +182,7 @@ afterEvaluate {
     preDebugBuild.dependsOn runCheckstyle, runKtlint
 }
 
-sonarqube {
+sonar {
     properties {
         property "sonar.projectKey", "TeamNewPipe_NewPipe"
         property "sonar.organization", "teamnewpipe"
@@ -179,7 +192,7 @@ sonarqube {
 
 dependencies {
 /** Desugaring **/
-    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:1.1.6'
+    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.0.3'
 
 /** NewPipe libraries **/
     // You can use a local version by uncommenting a few lines in settings.gradle
@@ -187,7 +200,7 @@ dependencies {
     // name and the commit hash with the commit hash of the (pushed) commit you want to test
     // This works thanks to JitPack: https://jitpack.io/
     implementation 'com.github.TeamNewPipe:nanojson:1d9e1aea9049fc9f85e68b43ba39fe7be1c1f751'
-    implementation 'com.github.TeamNewPipe:NewPipeExtractor:5c710da160f488bb40ab2cf4469bec9bd4cefd38'
+    implementation 'com.github.TeamNewPipe:NewPipeExtractor:8495ad619e'
     implementation 'com.github.TeamNewPipe:NoNonsense-FilePicker:5.0.0'
 
 /** Checkstyle **/
@@ -198,10 +211,10 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:${kotlin_version}"
 
 /** AndroidX **/
-    implementation 'androidx.appcompat:appcompat:1.4.2'
+    implementation 'androidx.appcompat:appcompat:1.5.1'
     implementation 'androidx.cardview:cardview:1.0.0'
     implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
-    implementation 'androidx.core:core-ktx:1.8.0'
+    implementation 'androidx.core:core-ktx:1.10.0'
     implementation 'androidx.documentfile:documentfile:1.0.1'
     implementation 'androidx.fragment:fragment-ktx:1.4.1'
     implementation "androidx.lifecycle:lifecycle-livedata-ktx:${androidxLifecycleVersion}"
@@ -227,10 +240,10 @@ dependencies {
     kapt "frankiesardo:icepick-processor:${icepickVersion}"
 
     // HTML parser
-    implementation "org.jsoup:jsoup:1.15.3"
+    implementation "org.jsoup:jsoup:1.16.1"
 
     // HTTP client
-    implementation "com.squareup.okhttp3:okhttp:4.10.0"
+    implementation "com.squareup.okhttp3:okhttp:4.11.0"
 
     // Media player
     implementation "com.google.android.exoplayer:exoplayer-core:${exoPlayerVersion}"
@@ -259,19 +272,19 @@ dependencies {
     implementation "io.noties.markwon:linkify:${markwonVersion}"
 
     // Crash reporting
-    implementation "ch.acra:acra-core:5.9.3"
+    implementation "ch.acra:acra-core:5.10.1"
 
     // Properly restarting
     implementation 'com.jakewharton:process-phoenix:2.1.2'
 
     // Reactive extensions for Java VM
-    implementation "io.reactivex.rxjava3:rxjava:3.0.13"
-    implementation "io.reactivex.rxjava3:rxandroid:3.0.0"
+    implementation "io.reactivex.rxjava3:rxjava:3.1.6"
+    implementation "io.reactivex.rxjava3:rxandroid:3.0.2"
     // RxJava binding APIs for Android UI widgets
     implementation "com.jakewharton.rxbinding4:rxbinding:4.0.0"
 
     // Date and time formatting
-    implementation "org.ocpsoft.prettytime:prettytime:5.0.3.Final"
+    implementation "org.ocpsoft.prettytime:prettytime:5.0.6.Final"
 
 /** Debugging **/
     // Memory leak detection
@@ -287,10 +300,10 @@ dependencies {
     testImplementation "org.mockito:mockito-core:${mockitoVersion}"
     testImplementation "org.mockito:mockito-inline:${mockitoVersion}"
 
-    androidTestImplementation "androidx.test.ext:junit:1.1.3"
-    androidTestImplementation "androidx.test:runner:1.4.0"
+    androidTestImplementation "androidx.test.ext:junit:1.1.5"
+    androidTestImplementation "androidx.test:runner:1.5.2"
     androidTestImplementation "androidx.room:room-testing:${androidxRoomVersion}"
-    androidTestImplementation "org.assertj:assertj-core:${assertJVersion}"
+    androidTestImplementation "org.assertj:assertj-core:3.23.1"
 }
 
 static String getGitWorkingBranch() {
@@ -308,3 +321,25 @@ static String getGitWorkingBranch() {
         return ""
     }
 }
+
+// fix reproducible builds
+project.afterEvaluate {
+    tasks.compileReleaseArtProfile.doLast {
+        outputs.files.each { file ->
+            if (file.toString().endsWith(".profm")) {
+                println("Sorting ${file} ...")
+                def version = ArtProfileSerializer.valueOf("METADATA_0_0_2")
+                def profile = ArtProfileKt.ArtProfile(file)
+                def keys = new ArrayList(profile.profileData.keySet())
+                def sortedData = new LinkedHashMap()
+                Collections.sort keys, new DexFile.Companion()
+                keys.each { key -> sortedData[key] = profile.profileData[key] }
+                new FileOutputStream(file).with {
+                    write(version.magicBytes$profgen)
+                    write(version.versionBytes$profgen)
+                    version.write$profgen(it, sortedData, "")
+                }
+            }
+        }
+    }
+}

app/proguard-rules.pro

@@ -1,32 +1,18 @@
-# Add project specific ProGuard rules here.
-# By default, the flags in this file are appended to flags specified
-# in /home/the-scrabi/bin/Android/Sdk/tools/proguard/proguard-android.txt
-# You can edit the include path and order by changing the proguardFiles
-# directive in build.gradle.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
-
-# Add any project specific keep options here:
-
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}
+# https://developer.android.com/build/shrink-code
 
+## Helps debug release versions
 -dontobfuscate
+
+## Rules for NewPipeExtractor
 -keep class org.schabi.newpipe.extractor.timeago.patterns.** { *; }
-
 -keep class org.mozilla.javascript.** { *; }
-
 -keep class org.mozilla.classfile.ClassFileWriter
--keep class com.google.android.exoplayer2.** { *; }
-
 -dontwarn org.mozilla.javascript.tools.**
 
-# Rules for icepick. Copy paste from https://github.com/frankiesardo/icepick
+## Rules for ExoPlayer
+-keep class com.google.android.exoplayer2.** { *; }
+
+## Rules for Icepick. Copy pasted from https://github.com/frankiesardo/icepick
 -dontwarn icepick.**
 -keep class icepick.** { *; }
 -keep class **$$Icepick { *; }
@@ -35,11 +21,11 @@
 }
 -keepnames class * { @icepick.State *;}
 
-## Rules for OkHttp. Copy paste from https://github.com/square/okhttp
+## Rules for OkHttp. Copy pasted from https://github.com/square/okhttp
 -dontwarn okhttp3.**
 -dontwarn okio.**
-##
 
+## See https://github.com/TeamNewPipe/NewPipe/pull/1441
 -keepclassmembers class * implements java.io.Serializable {
     static final long serialVersionUID;
     !static !transient <fields>;
@@ -47,5 +33,5 @@
     private void readObject(java.io.ObjectInputStream);
 }
 
-# for some reason NotificationModeConfigFragment wasn't kept (only referenced in a preference xml)
+## For some reason NotificationModeConfigFragment wasn't kept (only referenced in a preference xml)
 -keep class org.schabi.newpipe.settings.notifications.** { *; }

app/sampledata/channels.json

@@ -0,0 +1,19 @@
+{
+  "data": [
+    {
+      "name": "BBC",
+      "additional": "12K subscribers•233 videos",
+      "description": "The BBC is the world’s leading public service broadcaster. We’re impartial and independent, and every day we create distinctive, world-class programmes and content which inform, educate and entertain millions of people in the UK and around the world. SUBSCRIBE to our YouTube channel to get the best of BBC entertainment and comedy programmes, stories from science and nature documentaries, and much more! https://bit.ly/2IXqEIn Get ALL your fresh TV, and sofa-hugging box sets on iPlayer https://bbc.in/2J18jYJ"
+    },
+    {
+      "name": "Linus Tech Tips",
+      "additional": "1M subscribers•233 videos",
+      "description": "Looking for a Tech YouTuber?\n\nLinus Tech Tips is a passionate team of \"professionally curious\" experts in consumer technology and video production which aims to inform and educate people of all ages through our entertaining videos. We create product reviews, step-by-step computer build guides, and a variety of other tech-focused content.\n\nSchedule:\nNew videos every Saturday to Thursday @ 10:00am Pacific\nLive WAN Show podcasts every Friday @ ~5:00pm Pacific"
+    },
+    {
+      "name": "Marques Brownlee",
+      "additional": "13 subscribers•12K videos",
+      "description": "MKBHD: Quality Tech Videos | YouTuber | Geek | Consumer Electronics | Tech Head | Internet Personality!\n\nbusiness@MKBHD.com\n\nNYC"
+    }
+  ]
+}

app/schemas/org.schabi.newpipe.database.AppDatabase/6.json

@@ -0,0 +1,737 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 6,
+    "identityHash": "4084aa342aef315dc7b558770a7755a9",
+    "entities": [
+      {
+        "tableName": "subscriptions",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`uid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `service_id` INTEGER NOT NULL, `url` TEXT, `name` TEXT, `avatar_url` TEXT, `subscriber_count` INTEGER, `description` TEXT, `notification_mode` INTEGER NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "uid",
+            "columnName": "uid",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "service_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "url",
+            "columnName": "url",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "avatarUrl",
+            "columnName": "avatar_url",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "subscriberCount",
+            "columnName": "subscriber_count",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "description",
+            "columnName": "description",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "notificationMode",
+            "columnName": "notification_mode",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "uid"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_subscriptions_service_id_url",
+            "unique": true,
+            "columnNames": [
+              "service_id",
+              "url"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_subscriptions_service_id_url` ON `${TABLE_NAME}` (`service_id`, `url`)"
+          }
+        ],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "search_history",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`creation_date` INTEGER, `service_id` INTEGER NOT NULL, `search` TEXT, `id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "creationDate",
+            "columnName": "creation_date",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "service_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "search",
+            "columnName": "search",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_search_history_search",
+            "unique": false,
+            "columnNames": [
+              "search"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_search_history_search` ON `${TABLE_NAME}` (`search`)"
+          }
+        ],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "streams",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`uid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `service_id` INTEGER NOT NULL, `url` TEXT NOT NULL, `title` TEXT NOT NULL, `stream_type` TEXT NOT NULL, `duration` INTEGER NOT NULL, `uploader` TEXT NOT NULL, `uploader_url` TEXT, `thumbnail_url` TEXT, `view_count` INTEGER, `textual_upload_date` TEXT, `upload_date` INTEGER, `is_upload_date_approximation` INTEGER)",
+        "fields": [
+          {
+            "fieldPath": "uid",
+            "columnName": "uid",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "service_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "url",
+            "columnName": "url",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "title",
+            "columnName": "title",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "streamType",
+            "columnName": "stream_type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "duration",
+            "columnName": "duration",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "uploader",
+            "columnName": "uploader",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "uploaderUrl",
+            "columnName": "uploader_url",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "thumbnailUrl",
+            "columnName": "thumbnail_url",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "viewCount",
+            "columnName": "view_count",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "textualUploadDate",
+            "columnName": "textual_upload_date",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "uploadDate",
+            "columnName": "upload_date",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "isUploadDateApproximation",
+            "columnName": "is_upload_date_approximation",
+            "affinity": "INTEGER",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "uid"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_streams_service_id_url",
+            "unique": true,
+            "columnNames": [
+              "service_id",
+              "url"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_streams_service_id_url` ON `${TABLE_NAME}` (`service_id`, `url`)"
+          }
+        ],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "stream_history",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`stream_id` INTEGER NOT NULL, `access_date` INTEGER NOT NULL, `repeat_count` INTEGER NOT NULL, PRIMARY KEY(`stream_id`, `access_date`), FOREIGN KEY(`stream_id`) REFERENCES `streams`(`uid`) ON UPDATE CASCADE ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "streamUid",
+            "columnName": "stream_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "accessDate",
+            "columnName": "access_date",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "repeatCount",
+            "columnName": "repeat_count",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "stream_id",
+            "access_date"
+          ],
+          "autoGenerate": false
+        },
+        "indices": [
+          {
+            "name": "index_stream_history_stream_id",
+            "unique": false,
+            "columnNames": [
+              "stream_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_stream_history_stream_id` ON `${TABLE_NAME}` (`stream_id`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "streams",
+            "onDelete": "CASCADE",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "stream_id"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "stream_state",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`stream_id` INTEGER NOT NULL, `progress_time` INTEGER NOT NULL, PRIMARY KEY(`stream_id`), FOREIGN KEY(`stream_id`) REFERENCES `streams`(`uid`) ON UPDATE CASCADE ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "streamUid",
+            "columnName": "stream_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "progressMillis",
+            "columnName": "progress_time",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "stream_id"
+          ],
+          "autoGenerate": false
+        },
+        "indices": [],
+        "foreignKeys": [
+          {
+            "table": "streams",
+            "onDelete": "CASCADE",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "stream_id"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "playlists",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`uid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT, `thumbnail_url` TEXT, `is_thumbnail_permanent` INTEGER NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "uid",
+            "columnName": "uid",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "thumbnailUrl",
+            "columnName": "thumbnail_url",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "isThumbnailPermanent",
+            "columnName": "is_thumbnail_permanent",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "uid"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_playlists_name",
+            "unique": false,
+            "columnNames": [
+              "name"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_playlists_name` ON `${TABLE_NAME}` (`name`)"
+          }
+        ],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "playlist_stream_join",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`playlist_id` INTEGER NOT NULL, `stream_id` INTEGER NOT NULL, `join_index` INTEGER NOT NULL, PRIMARY KEY(`playlist_id`, `join_index`), FOREIGN KEY(`playlist_id`) REFERENCES `playlists`(`uid`) ON UPDATE CASCADE ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, FOREIGN KEY(`stream_id`) REFERENCES `streams`(`uid`) ON UPDATE CASCADE ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED)",
+        "fields": [
+          {
+            "fieldPath": "playlistUid",
+            "columnName": "playlist_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "streamUid",
+            "columnName": "stream_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "index",
+            "columnName": "join_index",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "playlist_id",
+            "join_index"
+          ],
+          "autoGenerate": false
+        },
+        "indices": [
+          {
+            "name": "index_playlist_stream_join_playlist_id_join_index",
+            "unique": true,
+            "columnNames": [
+              "playlist_id",
+              "join_index"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_playlist_stream_join_playlist_id_join_index` ON `${TABLE_NAME}` (`playlist_id`, `join_index`)"
+          },
+          {
+            "name": "index_playlist_stream_join_stream_id",
+            "unique": false,
+            "columnNames": [
+              "stream_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_playlist_stream_join_stream_id` ON `${TABLE_NAME}` (`stream_id`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "playlists",
+            "onDelete": "CASCADE",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "playlist_id"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          },
+          {
+            "table": "streams",
+            "onDelete": "CASCADE",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "stream_id"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "remote_playlists",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`uid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `service_id` INTEGER NOT NULL, `name` TEXT, `url` TEXT, `thumbnail_url` TEXT, `uploader` TEXT, `stream_count` INTEGER)",
+        "fields": [
+          {
+            "fieldPath": "uid",
+            "columnName": "uid",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "service_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "url",
+            "columnName": "url",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "thumbnailUrl",
+            "columnName": "thumbnail_url",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "uploader",
+            "columnName": "uploader",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "streamCount",
+            "columnName": "stream_count",
+            "affinity": "INTEGER",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "uid"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_remote_playlists_name",
+            "unique": false,
+            "columnNames": [
+              "name"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_remote_playlists_name` ON `${TABLE_NAME}` (`name`)"
+          },
+          {
+            "name": "index_remote_playlists_service_id_url",
+            "unique": true,
+            "columnNames": [
+              "service_id",
+              "url"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_remote_playlists_service_id_url` ON `${TABLE_NAME}` (`service_id`, `url`)"
+          }
+        ],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "feed",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`stream_id` INTEGER NOT NULL, `subscription_id` INTEGER NOT NULL, PRIMARY KEY(`stream_id`, `subscription_id`), FOREIGN KEY(`stream_id`) REFERENCES `streams`(`uid`) ON UPDATE CASCADE ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, FOREIGN KEY(`subscription_id`) REFERENCES `subscriptions`(`uid`) ON UPDATE CASCADE ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED)",
+        "fields": [
+          {
+            "fieldPath": "streamId",
+            "columnName": "stream_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "subscriptionId",
+            "columnName": "subscription_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "stream_id",
+            "subscription_id"
+          ],
+          "autoGenerate": false
+        },
+        "indices": [
+          {
+            "name": "index_feed_subscription_id",
+            "unique": false,
+            "columnNames": [
+              "subscription_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_feed_subscription_id` ON `${TABLE_NAME}` (`subscription_id`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "streams",
+            "onDelete": "CASCADE",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "stream_id"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          },
+          {
+            "table": "subscriptions",
+            "onDelete": "CASCADE",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "subscription_id"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "feed_group",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`uid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `icon_id` INTEGER NOT NULL, `sort_order` INTEGER NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "uid",
+            "columnName": "uid",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "icon",
+            "columnName": "icon_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "sortOrder",
+            "columnName": "sort_order",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "uid"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_feed_group_sort_order",
+            "unique": false,
+            "columnNames": [
+              "sort_order"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_feed_group_sort_order` ON `${TABLE_NAME}` (`sort_order`)"
+          }
+        ],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "feed_group_subscription_join",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`group_id` INTEGER NOT NULL, `subscription_id` INTEGER NOT NULL, PRIMARY KEY(`group_id`, `subscription_id`), FOREIGN KEY(`group_id`) REFERENCES `feed_group`(`uid`) ON UPDATE CASCADE ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, FOREIGN KEY(`subscription_id`) REFERENCES `subscriptions`(`uid`) ON UPDATE CASCADE ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED)",
+        "fields": [
+          {
+            "fieldPath": "feedGroupId",
+            "columnName": "group_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "subscriptionId",
+            "columnName": "subscription_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "group_id",
+            "subscription_id"
+          ],
+          "autoGenerate": false
+        },
+        "indices": [
+          {
+            "name": "index_feed_group_subscription_join_subscription_id",
+            "unique": false,
+            "columnNames": [
+              "subscription_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_feed_group_subscription_join_subscription_id` ON `${TABLE_NAME}` (`subscription_id`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "feed_group",
+            "onDelete": "CASCADE",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "group_id"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          },
+          {
+            "table": "subscriptions",
+            "onDelete": "CASCADE",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "subscription_id"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "feed_last_updated",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`subscription_id` INTEGER NOT NULL, `last_updated` INTEGER, PRIMARY KEY(`subscription_id`), FOREIGN KEY(`subscription_id`) REFERENCES `subscriptions`(`uid`) ON UPDATE CASCADE ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED)",
+        "fields": [
+          {
+            "fieldPath": "subscriptionId",
+            "columnName": "subscription_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastUpdated",
+            "columnName": "last_updated",
+            "affinity": "INTEGER",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "subscription_id"
+          ],
+          "autoGenerate": false
+        },
+        "indices": [],
+        "foreignKeys": [
+          {
+            "table": "subscriptions",
+            "onDelete": "CASCADE",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "subscription_id"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          }
+        ]
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '4084aa342aef315dc7b558770a7755a9')"
+    ]
+  }
+}

app/schemas/org.schabi.newpipe.database.AppDatabase/7.json

@@ -0,0 +1,737 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 7,
+    "identityHash": "012fc8e7ad3333f1597347f34e76a513",
+    "entities": [
+      {
+        "tableName": "subscriptions",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`uid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `service_id` INTEGER NOT NULL, `url` TEXT, `name` TEXT, `avatar_url` TEXT, `subscriber_count` INTEGER, `description` TEXT, `notification_mode` INTEGER NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "uid",
+            "columnName": "uid",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "service_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "url",
+            "columnName": "url",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "avatarUrl",
+            "columnName": "avatar_url",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "subscriberCount",
+            "columnName": "subscriber_count",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "description",
+            "columnName": "description",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "notificationMode",
+            "columnName": "notification_mode",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "uid"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_subscriptions_service_id_url",
+            "unique": true,
+            "columnNames": [
+              "service_id",
+              "url"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_subscriptions_service_id_url` ON `${TABLE_NAME}` (`service_id`, `url`)"
+          }
+        ],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "search_history",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`creation_date` INTEGER, `service_id` INTEGER NOT NULL, `search` TEXT, `id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "creationDate",
+            "columnName": "creation_date",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "service_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "search",
+            "columnName": "search",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_search_history_search",
+            "unique": false,
+            "columnNames": [
+              "search"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_search_history_search` ON `${TABLE_NAME}` (`search`)"
+          }
+        ],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "streams",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`uid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `service_id` INTEGER NOT NULL, `url` TEXT NOT NULL, `title` TEXT NOT NULL, `stream_type` TEXT NOT NULL, `duration` INTEGER NOT NULL, `uploader` TEXT NOT NULL, `uploader_url` TEXT, `thumbnail_url` TEXT, `view_count` INTEGER, `textual_upload_date` TEXT, `upload_date` INTEGER, `is_upload_date_approximation` INTEGER)",
+        "fields": [
+          {
+            "fieldPath": "uid",
+            "columnName": "uid",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "service_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "url",
+            "columnName": "url",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "title",
+            "columnName": "title",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "streamType",
+            "columnName": "stream_type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "duration",
+            "columnName": "duration",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "uploader",
+            "columnName": "uploader",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "uploaderUrl",
+            "columnName": "uploader_url",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "thumbnailUrl",
+            "columnName": "thumbnail_url",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "viewCount",
+            "columnName": "view_count",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "textualUploadDate",
+            "columnName": "textual_upload_date",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "uploadDate",
+            "columnName": "upload_date",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "isUploadDateApproximation",
+            "columnName": "is_upload_date_approximation",
+            "affinity": "INTEGER",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "uid"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_streams_service_id_url",
+            "unique": true,
+            "columnNames": [
+              "service_id",
+              "url"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_streams_service_id_url` ON `${TABLE_NAME}` (`service_id`, `url`)"
+          }
+        ],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "stream_history",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`stream_id` INTEGER NOT NULL, `access_date` INTEGER NOT NULL, `repeat_count` INTEGER NOT NULL, PRIMARY KEY(`stream_id`, `access_date`), FOREIGN KEY(`stream_id`) REFERENCES `streams`(`uid`) ON UPDATE CASCADE ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "streamUid",
+            "columnName": "stream_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "accessDate",
+            "columnName": "access_date",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "repeatCount",
+            "columnName": "repeat_count",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "stream_id",
+            "access_date"
+          ],
+          "autoGenerate": false
+        },
+        "indices": [
+          {
+            "name": "index_stream_history_stream_id",
+            "unique": false,
+            "columnNames": [
+              "stream_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_stream_history_stream_id` ON `${TABLE_NAME}` (`stream_id`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "streams",
+            "onDelete": "CASCADE",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "stream_id"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "stream_state",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`stream_id` INTEGER NOT NULL, `progress_time` INTEGER NOT NULL, PRIMARY KEY(`stream_id`), FOREIGN KEY(`stream_id`) REFERENCES `streams`(`uid`) ON UPDATE CASCADE ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "streamUid",
+            "columnName": "stream_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "progressMillis",
+            "columnName": "progress_time",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "stream_id"
+          ],
+          "autoGenerate": false
+        },
+        "indices": [],
+        "foreignKeys": [
+          {
+            "table": "streams",
+            "onDelete": "CASCADE",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "stream_id"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "playlists",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`uid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT, `is_thumbnail_permanent` INTEGER NOT NULL, `thumbnail_stream_id` INTEGER NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "uid",
+            "columnName": "uid",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "isThumbnailPermanent",
+            "columnName": "is_thumbnail_permanent",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "thumbnailStreamId",
+            "columnName": "thumbnail_stream_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "uid"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_playlists_name",
+            "unique": false,
+            "columnNames": [
+              "name"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_playlists_name` ON `${TABLE_NAME}` (`name`)"
+          }
+        ],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "playlist_stream_join",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`playlist_id` INTEGER NOT NULL, `stream_id` INTEGER NOT NULL, `join_index` INTEGER NOT NULL, PRIMARY KEY(`playlist_id`, `join_index`), FOREIGN KEY(`playlist_id`) REFERENCES `playlists`(`uid`) ON UPDATE CASCADE ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, FOREIGN KEY(`stream_id`) REFERENCES `streams`(`uid`) ON UPDATE CASCADE ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED)",
+        "fields": [
+          {
+            "fieldPath": "playlistUid",
+            "columnName": "playlist_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "streamUid",
+            "columnName": "stream_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "index",
+            "columnName": "join_index",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "playlist_id",
+            "join_index"
+          ],
+          "autoGenerate": false
+        },
+        "indices": [
+          {
+            "name": "index_playlist_stream_join_playlist_id_join_index",
+            "unique": true,
+            "columnNames": [
+              "playlist_id",
+              "join_index"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_playlist_stream_join_playlist_id_join_index` ON `${TABLE_NAME}` (`playlist_id`, `join_index`)"
+          },
+          {
+            "name": "index_playlist_stream_join_stream_id",
+            "unique": false,
+            "columnNames": [
+              "stream_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_playlist_stream_join_stream_id` ON `${TABLE_NAME}` (`stream_id`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "playlists",
+            "onDelete": "CASCADE",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "playlist_id"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          },
+          {
+            "table": "streams",
+            "onDelete": "CASCADE",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "stream_id"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "remote_playlists",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`uid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `service_id` INTEGER NOT NULL, `name` TEXT, `url` TEXT, `thumbnail_url` TEXT, `uploader` TEXT, `stream_count` INTEGER)",
+        "fields": [
+          {
+            "fieldPath": "uid",
+            "columnName": "uid",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "service_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "url",
+            "columnName": "url",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "thumbnailUrl",
+            "columnName": "thumbnail_url",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "uploader",
+            "columnName": "uploader",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "streamCount",
+            "columnName": "stream_count",
+            "affinity": "INTEGER",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "uid"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_remote_playlists_name",
+            "unique": false,
+            "columnNames": [
+              "name"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_remote_playlists_name` ON `${TABLE_NAME}` (`name`)"
+          },
+          {
+            "name": "index_remote_playlists_service_id_url",
+            "unique": true,
+            "columnNames": [
+              "service_id",
+              "url"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_remote_playlists_service_id_url` ON `${TABLE_NAME}` (`service_id`, `url`)"
+          }
+        ],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "feed",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`stream_id` INTEGER NOT NULL, `subscription_id` INTEGER NOT NULL, PRIMARY KEY(`stream_id`, `subscription_id`), FOREIGN KEY(`stream_id`) REFERENCES `streams`(`uid`) ON UPDATE CASCADE ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, FOREIGN KEY(`subscription_id`) REFERENCES `subscriptions`(`uid`) ON UPDATE CASCADE ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED)",
+        "fields": [
+          {
+            "fieldPath": "streamId",
+            "columnName": "stream_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "subscriptionId",
+            "columnName": "subscription_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "stream_id",
+            "subscription_id"
+          ],
+          "autoGenerate": false
+        },
+        "indices": [
+          {
+            "name": "index_feed_subscription_id",
+            "unique": false,
+            "columnNames": [
+              "subscription_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_feed_subscription_id` ON `${TABLE_NAME}` (`subscription_id`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "streams",
+            "onDelete": "CASCADE",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "stream_id"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          },
+          {
+            "table": "subscriptions",
+            "onDelete": "CASCADE",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "subscription_id"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "feed_group",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`uid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `icon_id` INTEGER NOT NULL, `sort_order` INTEGER NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "uid",
+            "columnName": "uid",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "icon",
+            "columnName": "icon_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "sortOrder",
+            "columnName": "sort_order",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "uid"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_feed_group_sort_order",
+            "unique": false,
+            "columnNames": [
+              "sort_order"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_feed_group_sort_order` ON `${TABLE_NAME}` (`sort_order`)"
+          }
+        ],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "feed_group_subscription_join",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`group_id` INTEGER NOT NULL, `subscription_id` INTEGER NOT NULL, PRIMARY KEY(`group_id`, `subscription_id`), FOREIGN KEY(`group_id`) REFERENCES `feed_group`(`uid`) ON UPDATE CASCADE ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, FOREIGN KEY(`subscription_id`) REFERENCES `subscriptions`(`uid`) ON UPDATE CASCADE ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED)",
+        "fields": [
+          {
+            "fieldPath": "feedGroupId",
+            "columnName": "group_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "subscriptionId",
+            "columnName": "subscription_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "group_id",
+            "subscription_id"
+          ],
+          "autoGenerate": false
+        },
+        "indices": [
+          {
+            "name": "index_feed_group_subscription_join_subscription_id",
+            "unique": false,
+            "columnNames": [
+              "subscription_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_feed_group_subscription_join_subscription_id` ON `${TABLE_NAME}` (`subscription_id`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "feed_group",
+            "onDelete": "CASCADE",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "group_id"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          },
+          {
+            "table": "subscriptions",
+            "onDelete": "CASCADE",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "subscription_id"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "feed_last_updated",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`subscription_id` INTEGER NOT NULL, `last_updated` INTEGER, PRIMARY KEY(`subscription_id`), FOREIGN KEY(`subscription_id`) REFERENCES `subscriptions`(`uid`) ON UPDATE CASCADE ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED)",
+        "fields": [
+          {
+            "fieldPath": "subscriptionId",
+            "columnName": "subscription_id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastUpdated",
+            "columnName": "last_updated",
+            "affinity": "INTEGER",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "subscription_id"
+          ],
+          "autoGenerate": false
+        },
+        "indices": [],
+        "foreignKeys": [
+          {
+            "table": "subscriptions",
+            "onDelete": "CASCADE",
+            "onUpdate": "CASCADE",
+            "columns": [
+              "subscription_id"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          }
+        ]
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '012fc8e7ad3333f1597347f34e76a513')"
+    ]
+  }
+}

app/src/androidTest/java/org/schabi/newpipe/database/DatabaseMigrationTest.kt

@@ -33,7 +33,8 @@ class DatabaseMigrationTest {
     @get:Rule
     val testHelper = MigrationTestHelper(
         InstrumentationRegistry.getInstrumentation(),
-        AppDatabase::class.java.canonicalName, FrameworkSQLiteOpenHelperFactory()
+        AppDatabase::class.java.canonicalName,
+        FrameworkSQLiteOpenHelperFactory()
     )
 
     @Test
@@ -42,7 +43,8 @@ class DatabaseMigrationTest {
 
         databaseInV2.run {
             insert(
-                "streams", SQLiteDatabase.CONFLICT_FAIL,
+                "streams",
+                SQLiteDatabase.CONFLICT_FAIL,
                 ContentValues().apply {
                     put("service_id", DEFAULT_SERVICE_ID)
                     put("url", DEFAULT_URL)
@@ -54,14 +56,16 @@ class DatabaseMigrationTest {
                 }
             )
             insert(
-                "streams", SQLiteDatabase.CONFLICT_FAIL,
+                "streams",
+                SQLiteDatabase.CONFLICT_FAIL,
                 ContentValues().apply {
                     put("service_id", DEFAULT_SECOND_SERVICE_ID)
                     put("url", DEFAULT_SECOND_URL)
                 }
             )
             insert(
-                "streams", SQLiteDatabase.CONFLICT_FAIL,
+                "streams",
+                SQLiteDatabase.CONFLICT_FAIL,
                 ContentValues().apply {
                     put("service_id", DEFAULT_SERVICE_ID)
                 }
@@ -70,18 +74,38 @@ class DatabaseMigrationTest {
         }
 
         testHelper.runMigrationsAndValidate(
-            AppDatabase.DATABASE_NAME, Migrations.DB_VER_3,
-            true, Migrations.MIGRATION_2_3
+            AppDatabase.DATABASE_NAME,
+            Migrations.DB_VER_3,
+            true,
+            Migrations.MIGRATION_2_3
         )
 
         testHelper.runMigrationsAndValidate(
-            AppDatabase.DATABASE_NAME, Migrations.DB_VER_4,
-            true, Migrations.MIGRATION_3_4
+            AppDatabase.DATABASE_NAME,
+            Migrations.DB_VER_4,
+            true,
+            Migrations.MIGRATION_3_4
         )
 
         testHelper.runMigrationsAndValidate(
-            AppDatabase.DATABASE_NAME, Migrations.DB_VER_5,
-            true, Migrations.MIGRATION_4_5
+            AppDatabase.DATABASE_NAME,
+            Migrations.DB_VER_5,
+            true,
+            Migrations.MIGRATION_4_5
+        )
+
+        testHelper.runMigrationsAndValidate(
+            AppDatabase.DATABASE_NAME,
+            Migrations.DB_VER_6,
+            true,
+            Migrations.MIGRATION_5_6
+        )
+
+        testHelper.runMigrationsAndValidate(
+            AppDatabase.DATABASE_NAME,
+            Migrations.DB_VER_7,
+            true,
+            Migrations.MIGRATION_6_7
         )
 
         val migratedDatabaseV3 = getMigratedDatabase()
@@ -121,7 +145,8 @@ class DatabaseMigrationTest {
     private fun getMigratedDatabase(): AppDatabase {
         val database: AppDatabase = Room.databaseBuilder(
             ApplicationProvider.getApplicationContext(),
-            AppDatabase::class.java, AppDatabase.DATABASE_NAME
+            AppDatabase::class.java,
+            AppDatabase.DATABASE_NAME
         )
             .build()
         testHelper.closeWhenFinished(database)

app/src/androidTest/java/org/schabi/newpipe/util/StreamItemAdapterTest.kt

@@ -1,12 +1,12 @@
 package org.schabi.newpipe.util
 
 import android.content.Context
-import android.util.SparseArray
 import android.view.View
 import android.view.View.GONE
 import android.view.View.INVISIBLE
 import android.view.View.VISIBLE
 import android.widget.Spinner
+import androidx.collection.SparseArrayCompat
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.filters.MediumTest
@@ -39,9 +39,7 @@ class StreamItemAdapterTest {
     @Test
     fun videoStreams_noSecondaryStream() {
         val adapter = StreamItemAdapter<VideoStream, AudioStream>(
-            context,
-            getVideoStreams(true, true, true, true),
-            null
+            getVideoStreams(true, true, true, true)
         )
 
         spinner.adapter = adapter
@@ -54,7 +52,6 @@ class StreamItemAdapterTest {
     @Test
     fun videoStreams_hasSecondaryStream() {
         val adapter = StreamItemAdapter(
-            context,
             getVideoStreams(false, true, false, true),
             getAudioStreams(false, true, false, true)
         )
@@ -69,7 +66,6 @@ class StreamItemAdapterTest {
     @Test
     fun videoStreams_Mixed() {
         val adapter = StreamItemAdapter(
-            context,
             getVideoStreams(true, true, true, true, true, false, true, true),
             getAudioStreams(false, true, false, false, false, true, true, true)
         )
@@ -88,7 +84,6 @@ class StreamItemAdapterTest {
     @Test
     fun subtitleStreams_noIcon() {
         val adapter = StreamItemAdapter<SubtitlesStream, Stream>(
-            context,
             StreamItemAdapter.StreamSizeWrapper(
                 (0 until 5).map {
                     SubtitlesStream.Builder()
@@ -99,8 +94,7 @@ class StreamItemAdapterTest {
                         .build()
                 },
                 context
-            ),
-            null
+            )
         )
         spinner.adapter = adapter
         for (i in 0 until spinner.count) {
@@ -111,7 +105,6 @@ class StreamItemAdapterTest {
     @Test
     fun audioStreams_noIcon() {
         val adapter = StreamItemAdapter<AudioStream, Stream>(
-            context,
             StreamItemAdapter.StreamSizeWrapper(
                 (0 until 5).map {
                     AudioStream.Builder()
@@ -122,8 +115,7 @@ class StreamItemAdapterTest {
                         .build()
                 },
                 context
-            ),
-            null
+            )
         )
         spinner.adapter = adapter
         for (i in 0 until spinner.count) {
@@ -200,7 +192,7 @@ class StreamItemAdapterTest {
      * Helper function that builds a secondary stream list.
      */
     private fun <T : Stream> getSecondaryStreamsFromList(streams: List<T?>) =
-        SparseArray<SecondaryStreamHelper<T>?>(streams.size).apply {
+        SparseArrayCompat<SecondaryStreamHelper<T>?>(streams.size).apply {
             streams.forEachIndexed { index, stream ->
                 val secondaryStreamHelper: SecondaryStreamHelper<T>? = stream?.let {
                     SecondaryStreamHelper(

app/src/debug/AndroidManifest.xml

@@ -1,8 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools"
-    package="org.schabi.newpipe">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
 
     <application
         android:name=".DebugApp"

app/src/main/AndroidManifest.xml

@@ -1,7 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools"
-    package="org.schabi.newpipe"
     android:installLocation="auto">
 
     <uses-permission android:name="android.permission.INTERNET" />
@@ -10,10 +9,22 @@
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
     <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
+
+    <!-- We need to be able to open links in the browser on API 30+ -->
+    <queries>
+        <intent>
+            <action android:name="android.intent.action.VIEW" />
+            <data android:scheme="http" />
+        </intent>
+    </queries>
 
     <uses-feature
         android:name="android.hardware.touchscreen"
         android:required="false" />
+    <uses-feature
+        android:name="android.software.leanback"
+        android:required="false" />
 
     <application
         android:name=".App"
@@ -22,11 +33,12 @@
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
         android:logo="@mipmap/ic_launcher"
-        android:theme="@style/OpeningTheme"
         android:resizeableActivity="true"
+        android:theme="@style/OpeningTheme"
         tools:ignore="AllowBackup">
         <activity
             android:name=".MainActivity"
+            android:exported="true"
             android:label="@string/app_name"
             android:launchMode="singleTask">
             <intent-filter>
@@ -37,7 +49,9 @@
             </intent-filter>
         </activity>
 
-        <receiver android:name="androidx.media.session.MediaButtonReceiver">
+        <receiver
+            android:name="androidx.media.session.MediaButtonReceiver"
+            android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.MEDIA_BUTTON" />
             </intent-filter>
@@ -45,7 +59,7 @@
 
         <service
             android:name=".player.PlayerService"
-            android:exported="false"
+            android:exported="true"
             android:foregroundServiceType="mediaPlayback">
             <intent-filter>
                 <action android:name="android.intent.action.MEDIA_BUTTON" />
@@ -54,15 +68,18 @@
 
         <activity
             android:name=".player.PlayQueueActivity"
+            android:exported="false"
             android:label="@string/title_activity_play_queue"
             android:launchMode="singleTask" />
 
         <activity
             android:name=".settings.SettingsActivity"
+            android:exported="false"
             android:label="@string/settings" />
 
         <activity
             android:name=".about.AboutActivity"
+            android:exported="false"
             android:label="@string/title_activity_about" />
 
         <service android:name=".local.subscription.services.SubscriptionsImportService" />
@@ -71,6 +88,7 @@
 
         <activity
             android:name=".PanicResponderActivity"
+            android:exported="true"
             android:launchMode="singleInstance"
             android:noHistory="true"
             android:theme="@android:style/Theme.NoDisplay">
@@ -83,13 +101,18 @@
 
         <activity
             android:name=".ExitActivity"
+            android:exported="false"
             android:label="@string/general_error"
             android:theme="@android:style/Theme.NoDisplay" />
-        <activity android:name=".error.ErrorActivity" />
+
+        <activity
+            android:name=".error.ErrorActivity"
+            android:exported="false" />
 
         <!-- giga get related -->
         <activity
             android:name=".download.DownloadActivity"
+            android:exported="false"
             android:label="@string/app_name"
             android:launchMode="singleTask" />
 
@@ -97,6 +120,7 @@
 
         <activity
             android:name=".util.FilePickerActivityHelper"
+            android:exported="true"
             android:label="@string/app_name"
             android:theme="@style/FilePickerThemeDark">
             <intent-filter>
@@ -107,6 +131,7 @@
 
         <activity
             android:name=".error.ReCaptchaActivity"
+            android:exported="false"
             android:label="@string/recaptcha" />
 
         <provider
@@ -122,6 +147,7 @@
         <activity
             android:name=".RouterActivity"
             android:excludeFromRecents="true"
+            android:exported="true"
             android:label="@string/preferred_open_action_share_menu_title"
             android:taskAffinity=""
             android:theme="@style/RouterActivityThemeDark">
@@ -147,10 +173,12 @@
                 <data android:pathPrefix="/watch" />
                 <data android:pathPrefix="/attribution_link" />
                 <data android:pathPrefix="/shorts/" />
+                <data android:pathPrefix="/live/" />
                 <!-- channel prefix -->
                 <data android:pathPrefix="/channel/" />
                 <data android:pathPrefix="/user/" />
                 <data android:pathPrefix="/c/" />
+                <data android:pathPrefix="/@" />
                 <!-- playlist prefix -->
                 <data android:pathPrefix="/playlist" />
             </intent-filter>
@@ -329,16 +357,16 @@
                 <data android:host="eduvid.org" />
                 <data android:host="framatube.org" />
                 <data android:host="media.assassinate-you.net" />
+                <data android:host="media.fsfe.org" />
                 <data android:host="peertube.co.uk" />
                 <data android:host="peertube.cpy.re" />
-                <data android:host="peertube.mastodon.host" />
                 <data android:host="peertube.fr" />
-                <data android:host="tilvids.com" />
-                <data android:host="tube.privacytools.io" />
-                <data android:host="video.ploud.fr" />
-                <data android:host="video.lqdn.fr" />
+                <data android:host="peertube.mastodon.host" />
+                <data android:host="peertube.stream" />
                 <data android:host="skeptikon.fr" />
-                <data android:host="media.fsfe.org" />
+                <data android:host="tilvids.com" />
+                <data android:host="video.lqdn.fr" />
+                <data android:host="video.ploud.fr" />
 
                 <data android:pathPrefix="/videos/" /> <!-- it contains playlists -->
                 <data android:pathPrefix="/w/" /> <!-- short video URLs -->
@@ -351,30 +379,30 @@
 
             <!-- Bandcamp filter for tracks, albums and playlists -->
             <intent-filter>
-                <action android:name="android.intent.action.VIEW"/>
-                <action android:name="android.media.action.MEDIA_PLAY_FROM_SEARCH"/>
-                <action android:name="android.nfc.action.NDEF_DISCOVERED"/>
+                <action android:name="android.intent.action.VIEW" />
+                <action android:name="android.media.action.MEDIA_PLAY_FROM_SEARCH" />
+                <action android:name="android.nfc.action.NDEF_DISCOVERED" />
 
-                <category android:name="android.intent.category.DEFAULT"/>
-                <category android:name="android.intent.category.BROWSABLE"/>
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
 
-                <data android:scheme="http"/>
-                <data android:scheme="https"/>
-                <data android:host="*.bandcamp.com"/>
+                <data android:scheme="http" />
+                <data android:scheme="https" />
+                <data android:host="*.bandcamp.com" />
             </intent-filter>
 
             <!-- Bandcamp filter for radio -->
             <intent-filter>
-                <action android:name="android.intent.action.VIEW"/>
-                <action android:name="android.media.action.MEDIA_PLAY_FROM_SEARCH"/>
-                <action android:name="android.nfc.action.NDEF_DISCOVERED"/>
+                <action android:name="android.intent.action.VIEW" />
+                <action android:name="android.media.action.MEDIA_PLAY_FROM_SEARCH" />
+                <action android:name="android.nfc.action.NDEF_DISCOVERED" />
 
-                <category android:name="android.intent.category.DEFAULT"/>
-                <category android:name="android.intent.category.BROWSABLE"/>
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
 
-                <data android:scheme="http"/>
-                <data android:scheme="https"/>
-                <data android:sspPattern="bandcamp.com/?show=*"/>
+                <data android:scheme="http" />
+                <data android:scheme="https" />
+                <data android:sspPattern="bandcamp.com/?show=*" />
             </intent-filter>
 
         </activity>
@@ -383,11 +411,17 @@
             android:exported="false" />
 
         <!-- opting out of sending metrics to Google in Android System WebView -->
-        <meta-data android:name="android.webkit.WebView.MetricsOptOut" android:value="true" />
+        <meta-data
+            android:name="android.webkit.WebView.MetricsOptOut"
+            android:value="true" />
         <!-- see https://github.com/TeamNewPipe/NewPipe/issues/3947 -->
         <!-- Version < 3.0. DeX Mode and Screen Mirroring support -->
-        <meta-data android:name="com.samsung.android.keepalive.density" android:value="true"/>
+        <meta-data
+            android:name="com.samsung.android.keepalive.density"
+            android:value="true" />
         <!-- Version >= 3.0. DeX Dual Mode support -->
-        <meta-data android:name="com.samsung.android.multidisplay.keep_process_alive" android:value="true"/>
+        <meta-data
+            android:name="com.samsung.android.multidisplay.keep_process_alive"
+            android:value="true" />
     </application>
 </manifest>

app/src/main/java/org/schabi/newpipe/MainActivity.java

@@ -63,6 +63,7 @@ import org.schabi.newpipe.databinding.InstanceSpinnerLayoutBinding;
 import org.schabi.newpipe.databinding.ToolbarLayoutBinding;
 import org.schabi.newpipe.error.ErrorUtil;
 import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.ServiceList;
 import org.schabi.newpipe.extractor.StreamingService;
 import org.schabi.newpipe.extractor.exceptions.ExtractionException;
 import org.schabi.newpipe.extractor.services.peertube.PeertubeInstance;
@@ -157,9 +158,12 @@ public class MainActivity extends AppCompatActivity {
         }
         openMiniPlayerUponPlayerStarted();
 
-        // Schedule worker for checking for new streams and creating corresponding notifications
-        // if this is enabled by the user.
-        NotificationWorker.initialize(this);
+        if (PermissionHelper.checkPostNotificationsPermission(this,
+                PermissionHelper.POST_NOTIFICATIONS_REQUEST_CODE)) {
+            // Schedule worker for checking for new streams and creating corresponding notifications
+            // if this is enabled by the user.
+            NotificationWorker.initialize(this);
+        }
     }
 
     @Override
@@ -172,7 +176,7 @@ public class MainActivity extends AppCompatActivity {
         if (prefs.getBoolean(app.getString(R.string.update_app_key), true)) {
             // Start the worker which is checking all conditions
             // and eventually searching for a new version.
-            NewVersionWorker.enqueueNewVersionCheckingWork(app);
+            NewVersionWorker.enqueueNewVersionCheckingWork(app, false);
         }
     }
 
@@ -232,7 +236,7 @@ public class MainActivity extends AppCompatActivity {
                 .setIcon(R.drawable.ic_tv);
         drawerLayoutBinding.navigation.getMenu()
                 .add(R.id.menu_tabs_group, ITEM_ID_FEED, ORDER, R.string.fragment_feed_title)
-                .setIcon(R.drawable.ic_rss_feed);
+                .setIcon(R.drawable.ic_subscriptions);
         drawerLayoutBinding.navigation.getMenu()
                 .add(R.id.menu_tabs_group, ITEM_ID_BOOKMARKS, ORDER, R.string.tab_bookmarks)
                 .setIcon(R.drawable.ic_bookmark);
@@ -255,8 +259,15 @@ public class MainActivity extends AppCompatActivity {
     private boolean drawerItemSelected(final MenuItem item) {
         switch (item.getGroupId()) {
             case R.id.menu_services_group:
-                changeService(item);
-                break;
+                if (item.getItemId() == ServiceList.PeerTube.getServiceId()
+                        && DeviceUtils.isTv(getApplicationContext())
+                        && !item.isActionViewExpanded()) {
+                    ((Spinner) item.getActionView()).performClick();
+                    return true;
+                } else {
+                    changeService(item);
+                    break;
+                }
             case R.id.menu_tabs_group:
                 try {
                     tabSelected(item);
@@ -380,8 +391,8 @@ public class MainActivity extends AppCompatActivity {
                     .add(R.id.menu_services_group, s.getServiceId(), ORDER, title)
                     .setIcon(ServiceHelper.getIcon(s.getServiceId()));
 
-            // peertube specifics
-            if (s.getServiceId() == 3) {
+            // PeerTube specifics
+            if (s == ServiceList.PeerTube) {
                 enhancePeertubeMenu(menuItem);
             }
         }
@@ -599,6 +610,9 @@ public class MainActivity extends AppCompatActivity {
                     ((VideoDetailFragment) fragment).openDownloadDialog();
                 }
                 break;
+            case PermissionHelper.POST_NOTIFICATIONS_REQUEST_CODE:
+                NotificationWorker.initialize(this);
+                break;
         }
     }
 

app/src/main/java/org/schabi/newpipe/NewPipeDatabase.java

@@ -5,6 +5,8 @@ import static org.schabi.newpipe.database.Migrations.MIGRATION_1_2;
 import static org.schabi.newpipe.database.Migrations.MIGRATION_2_3;
 import static org.schabi.newpipe.database.Migrations.MIGRATION_3_4;
 import static org.schabi.newpipe.database.Migrations.MIGRATION_4_5;
+import static org.schabi.newpipe.database.Migrations.MIGRATION_5_6;
+import static org.schabi.newpipe.database.Migrations.MIGRATION_6_7;
 
 import android.content.Context;
 import android.database.Cursor;
@@ -24,7 +26,8 @@ public final class NewPipeDatabase {
     private static AppDatabase getDatabase(final Context context) {
         return Room
                 .databaseBuilder(context.getApplicationContext(), AppDatabase.class, DATABASE_NAME)
-                .addMigrations(MIGRATION_1_2, MIGRATION_2_3, MIGRATION_3_4, MIGRATION_4_5)
+                .addMigrations(MIGRATION_1_2, MIGRATION_2_3, MIGRATION_3_4, MIGRATION_4_5,
+                        MIGRATION_5_6, MIGRATION_6_7)
                 .build();
     }
 

app/src/main/java/org/schabi/newpipe/NewVersionWorker.kt

@@ -1,19 +1,21 @@
 package org.schabi.newpipe
 
-import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
 import android.util.Log
+import android.widget.Toast
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
+import androidx.core.app.PendingIntentCompat
+import androidx.core.content.ContextCompat
 import androidx.core.content.edit
 import androidx.core.net.toUri
 import androidx.preference.PreferenceManager
-import androidx.work.OneTimeWorkRequest
+import androidx.work.OneTimeWorkRequestBuilder
 import androidx.work.WorkManager
-import androidx.work.WorkRequest
 import androidx.work.Worker
 import androidx.work.WorkerParameters
+import androidx.work.workDataOf
 import com.grack.nanojson.JsonParser
 import com.grack.nanojson.JsonParserException
 import org.schabi.newpipe.extractor.downloader.Response
@@ -42,26 +44,40 @@ class NewVersionWorker(
         versionCode: Int
     ) {
         if (BuildConfig.VERSION_CODE >= versionCode) {
+            if (inputData.getBoolean(IS_MANUAL, false)) {
+                // Show toast stating that the app is up-to-date if the update check was manual.
+                ContextCompat.getMainExecutor(applicationContext).execute {
+                    Toast.makeText(
+                        applicationContext, R.string.app_update_unavailable_toast,
+                        Toast.LENGTH_SHORT
+                    ).show()
+                }
+            }
             return
         }
-        val app = App.getApp()
 
         // A pending intent to open the apk location url in the browser.
         val intent = Intent(Intent.ACTION_VIEW, apkLocationUrl?.toUri())
         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        val pendingIntent = PendingIntent.getActivity(app, 0, intent, 0)
-        val channelId = app.getString(R.string.app_update_notification_channel_id)
-        val notificationBuilder = NotificationCompat.Builder(app, channelId)
+        val pendingIntent = PendingIntentCompat.getActivity(
+            applicationContext, 0, intent, 0, false
+        )
+        val channelId = applicationContext.getString(R.string.app_update_notification_channel_id)
+        val notificationBuilder = NotificationCompat.Builder(applicationContext, channelId)
             .setSmallIcon(R.drawable.ic_newpipe_update)
             .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-            .setContentIntent(pendingIntent)
             .setAutoCancel(true)
-            .setContentTitle(app.getString(R.string.app_update_notification_content_title))
-            .setContentText(
-                app.getString(R.string.app_update_notification_content_text) +
-                    " " + versionName
+            .setContentIntent(pendingIntent)
+            .setContentTitle(
+                applicationContext.getString(R.string.app_update_available_notification_title)
             )
-        val notificationManager = NotificationManagerCompat.from(app)
+            .setContentText(
+                applicationContext.getString(
+                    R.string.app_update_available_notification_text, versionName
+                )
+            )
+
+        val notificationManager = NotificationManagerCompat.from(applicationContext)
         notificationManager.notify(2000, notificationBuilder.build())
     }
 
@@ -72,12 +88,14 @@ class NewVersionWorker(
             return
         }
 
-        val prefs = PreferenceManager.getDefaultSharedPreferences(applicationContext)
-        // Check if the last request has happened a certain time ago
-        // to reduce the number of API requests.
-        val expiry = prefs.getLong(applicationContext.getString(R.string.update_expiry_key), 0)
-        if (!isLastUpdateCheckExpired(expiry)) {
-            return
+        if (!inputData.getBoolean(IS_MANUAL, false)) {
+            val prefs = PreferenceManager.getDefaultSharedPreferences(applicationContext)
+            // Check if the last request has happened a certain time ago
+            // to reduce the number of API requests.
+            val expiry = prefs.getLong(applicationContext.getString(R.string.update_expiry_key), 0)
+            if (!isLastUpdateCheckExpired(expiry)) {
+                return
+            }
         }
 
         // Make a network request to get latest NewPipe data.
@@ -120,43 +138,42 @@ class NewVersionWorker(
     }
 
     override fun doWork(): Result {
-        try {
+        return try {
             checkNewVersion()
+            Result.success()
         } catch (e: IOException) {
             Log.w(TAG, "Could not fetch NewPipe API: probably network problem", e)
-            return Result.failure()
+            Result.failure()
         } catch (e: ReCaptchaException) {
             Log.e(TAG, "ReCaptchaException should never happen here.", e)
-            return Result.failure()
+            Result.failure()
         }
-        return Result.success()
     }
 
     companion object {
         private val DEBUG = MainActivity.DEBUG
         private val TAG = NewVersionWorker::class.java.simpleName
         private const val NEWPIPE_API_URL = "https://newpipe.net/api/data.json"
+        private const val IS_MANUAL = "isManual"
 
         /**
-         * Start a new worker which
-         * checks if all conditions for performing a version check are met,
-         * fetches the API endpoint [.NEWPIPE_API_URL] containing info
-         * about the latest NewPipe version
-         * and displays a notification about ana available update.
+         * Start a new worker which checks if all conditions for performing a version check are met,
+         * fetches the API endpoint [.NEWPIPE_API_URL] containing info about the latest NewPipe
+         * version and displays a notification about an available update if one is available.
          * <br></br>
-         * Following conditions need to be met, before data is request from the server:
+         * Following conditions need to be met, before data is requested from the server:
          *
          *  *  The app is signed with the correct signing key (by TeamNewPipe / schabi).
          * If the signing key differs from the one used upstream, the update cannot be installed.
          *  * The user enabled searching for and notifying about updates in the settings.
          *  * The app did not recently check for updates.
          * We do not want to make unnecessary connections and DOS our servers.
-         *
          */
         @JvmStatic
-        fun enqueueNewVersionCheckingWork(context: Context) {
-            val workRequest: WorkRequest =
-                OneTimeWorkRequest.Builder(NewVersionWorker::class.java).build()
+        fun enqueueNewVersionCheckingWork(context: Context, isManual: Boolean) {
+            val workRequest = OneTimeWorkRequestBuilder<NewVersionWorker>()
+                .setInputData(workDataOf(IS_MANUAL to isManual))
+                .build()
             WorkManager.getInstance(context).enqueue(workRequest)
         }
     }

app/src/main/java/org/schabi/newpipe/QueueItemMenuUtil.java

@@ -1,5 +1,6 @@
 package org.schabi.newpipe;
 
+import static org.schabi.newpipe.util.SparseItemUtil.fetchStreamInfoAndSaveToDatabase;
 import static org.schabi.newpipe.util.external_communication.ShareUtils.shareText;
 
 import android.content.Context;
@@ -10,6 +11,7 @@ import android.widget.PopupMenu;
 import androidx.fragment.app.FragmentManager;
 
 import org.schabi.newpipe.database.stream.model.StreamEntity;
+import org.schabi.newpipe.download.DownloadDialog;
 import org.schabi.newpipe.local.dialog.PlaylistDialog;
 import org.schabi.newpipe.player.playqueue.PlayQueue;
 import org.schabi.newpipe.player.playqueue.PlayQueueItem;
@@ -75,6 +77,14 @@ public final class QueueItemMenuUtil {
                     shareText(context, item.getTitle(), item.getUrl(),
                             item.getThumbnailUrl());
                     return true;
+                case R.id.menu_item_download:
+                    fetchStreamInfoAndSaveToDatabase(context, item.getServiceId(), item.getUrl(),
+                            info -> {
+                                final DownloadDialog downloadDialog = new DownloadDialog(context,
+                                        info);
+                                downloadDialog.show(fragmentManager, "downloadDialog");
+                            });
+                    return true;
             }
             return false;
         });

app/src/main/java/org/schabi/newpipe/RouterActivity.java

@@ -10,12 +10,14 @@ import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.SharedPreferences;
 import android.content.pm.PackageManager;
+import android.os.Build;
 import android.os.Bundle;
 import android.text.TextUtils;
 import android.view.ContextThemeWrapper;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.WindowManager;
 import android.widget.Button;
 import android.widget.RadioButton;
 import android.widget.RadioGroup;
@@ -31,7 +33,12 @@ import androidx.appcompat.content.res.AppCompatResources;
 import androidx.core.app.NotificationCompat;
 import androidx.core.app.ServiceCompat;
 import androidx.core.math.MathUtils;
+import androidx.fragment.app.DialogFragment;
+import androidx.fragment.app.Fragment;
 import androidx.fragment.app.FragmentManager;
+import androidx.lifecycle.DefaultLifecycleObserver;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleOwner;
 import androidx.preference.PreferenceManager;
 
 import org.schabi.newpipe.database.stream.model.StreamEntity;
@@ -80,9 +87,13 @@ import org.schabi.newpipe.util.urlfinder.UrlFinder;
 import org.schabi.newpipe.views.FocusOverlayView;
 
 import java.io.Serializable;
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Optional;
+import java.util.function.Consumer;
 
 import icepick.Icepick;
 import icepick.State;
@@ -91,7 +102,6 @@ import io.reactivex.rxjava3.core.Observable;
 import io.reactivex.rxjava3.core.Single;
 import io.reactivex.rxjava3.disposables.CompositeDisposable;
 import io.reactivex.rxjava3.disposables.Disposable;
-import io.reactivex.rxjava3.functions.Consumer;
 import io.reactivex.rxjava3.schedulers.Schedulers;
 
 /**
@@ -111,12 +121,57 @@ public class RouterActivity extends AppCompatActivity {
     private boolean selectionIsDownload = false;
     private boolean selectionIsAddToPlaylist = false;
     private AlertDialog alertDialogChoice = null;
+    private FragmentManager.FragmentLifecycleCallbacks dismissListener = null;
 
     @Override
     protected void onCreate(final Bundle savedInstanceState) {
+        ThemeHelper.setDayNightMode(this);
+        setTheme(ThemeHelper.isLightThemeSelected(this)
+                ? R.style.RouterActivityThemeLight : R.style.RouterActivityThemeDark);
+        Localization.assureCorrectAppLanguage(this);
+
+        // Pass-through touch events to background activities
+        // so that our transparent window won't lock UI in the mean time
+        // network request is underway before showing PlaylistDialog or DownloadDialog
+        // (ref: https://stackoverflow.com/a/10606141)
+        getWindow().addFlags(WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
+                | WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
+                | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE);
+
+        // Android never fails to impress us with a list of new restrictions per API.
+        // Starting with S (Android 12) one of the prerequisite conditions has to be met
+        // before the FLAG_NOT_TOUCHABLE flag is allowed to kick in:
+        // @see WindowManager.LayoutParams#FLAG_NOT_TOUCHABLE
+        // For our present purpose it seems we can just set LayoutParams.alpha to 0
+        // on the strength of "4. Fully transparent windows" without affecting the scrim of dialogs
+        final WindowManager.LayoutParams params = getWindow().getAttributes();
+        params.alpha = 0f;
+        getWindow().setAttributes(params);
+
         super.onCreate(savedInstanceState);
         Icepick.restoreInstanceState(this, savedInstanceState);
 
+        // FragmentManager will take care to recreate (Playlist|Download)Dialog when screen rotates
+        // We used to .setOnDismissListener(dialog -> finish()); when creating these DialogFragments
+        // but those callbacks won't survive a config change
+        // Try an alternate approach to hook into FragmentManager instead, to that effect
+        // (ref: https://stackoverflow.com/a/44028453)
+        final FragmentManager fm = getSupportFragmentManager();
+        if (dismissListener == null) {
+            dismissListener = new FragmentManager.FragmentLifecycleCallbacks() {
+                @Override
+                public void onFragmentDestroyed(@NonNull final FragmentManager fm,
+                                                @NonNull final Fragment f) {
+                    super.onFragmentDestroyed(fm, f);
+                    if (f instanceof DialogFragment && fm.getFragments().isEmpty()) {
+                        // No more DialogFragments, we're done
+                        finish();
+                    }
+                }
+            };
+        }
+        fm.registerFragmentLifecycleCallbacks(dismissListener, false);
+
         if (TextUtils.isEmpty(currentUrl)) {
             currentUrl = getUrl(getIntent());
 
@@ -125,11 +180,6 @@ public class RouterActivity extends AppCompatActivity {
                 finish();
             }
         }
-
-        ThemeHelper.setDayNightMode(this);
-        setTheme(ThemeHelper.isLightThemeSelected(this)
-                ? R.style.RouterActivityThemeLight : R.style.RouterActivityThemeDark);
-        Localization.assureCorrectAppLanguage(this);
     }
 
     @Override
@@ -151,16 +201,34 @@ public class RouterActivity extends AppCompatActivity {
     protected void onStart() {
         super.onStart();
 
-        handleUrl(currentUrl);
+        // Don't overlap the DialogFragment after rotating the screen
+        // If there's no DialogFragment, we're either starting afresh
+        // or we didn't make it to PlaylistDialog or DownloadDialog before the orientation change
+        if (getSupportFragmentManager().getFragments().isEmpty()) {
+            // Start over from scratch
+            handleUrl(currentUrl);
+        }
     }
 
     @Override
     protected void onDestroy() {
         super.onDestroy();
 
+        if (dismissListener != null) {
+            getSupportFragmentManager().unregisterFragmentLifecycleCallbacks(dismissListener);
+        }
+
         disposables.clear();
     }
 
+    @Override
+    public void finish() {
+        // allow the activity to recreate in case orientation changes
+        if (!isChangingConfigurations()) {
+            super.finish();
+        }
+    }
+
     private void handleUrl(final String url) {
         disposables.add(Observable
                 .fromCallable(() -> {
@@ -240,7 +308,7 @@ public class RouterActivity extends AppCompatActivity {
         }
     }
 
-    private void showUnsupportedUrlDialog(final String url) {
+    protected void showUnsupportedUrlDialog(final String url) {
         final Context context = getThemeWrapperContext();
         new AlertDialog.Builder(context)
                 .setTitle(R.string.unsupported_url)
@@ -527,7 +595,7 @@ public class RouterActivity extends AppCompatActivity {
         return returnedItems;
     }
 
-    private Context getThemeWrapperContext() {
+    protected Context getThemeWrapperContext() {
         return new ContextThemeWrapper(this, ThemeHelper.isLightThemeSelected(this)
                 ? R.style.LightTheme : R.style.DarkTheme);
     }
@@ -563,8 +631,7 @@ public class RouterActivity extends AppCompatActivity {
         }
 
         if (selectedChoiceKey.equals(getString(R.string.popup_player_key))
-                && !PermissionHelper.isPopupEnabled(this)) {
-            PermissionHelper.showPopupEnablementToast(this);
+                && !PermissionHelper.isPopupEnabledElseAsk(this)) {
             finish();
             return;
         }
@@ -634,54 +701,179 @@ public class RouterActivity extends AppCompatActivity {
         return playerType == null || playerType == PlayerType.MAIN;
     }
 
-    private void openAddToPlaylistDialog() {
-        // Getting the stream info usually takes a moment
-        // Notifying the user here to ensure that no confusion arises
-        Toast.makeText(
-                getApplicationContext(),
-                getString(R.string.processing_may_take_a_moment),
-                Toast.LENGTH_SHORT)
-                .show();
+    public static class PersistentFragment extends Fragment {
+        private WeakReference<AppCompatActivity> weakContext;
+        private final CompositeDisposable disposables = new CompositeDisposable();
+        private int running = 0;
 
-        disposables.add(ExtractorHelper.getStreamInfo(currentServiceId, currentUrl, false)
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
-                .subscribe(
-                        info -> PlaylistDialog.createCorrespondingDialog(
-                                getThemeWrapperContext(),
-                                List.of(new StreamEntity(info)),
-                                playlistDialog -> {
-                                    playlistDialog.setOnDismissListener(dialog -> finish());
+        private synchronized void inFlight(final boolean started) {
+            if (started) {
+                running++;
+            } else {
+                running--;
+                if (running <= 0) {
+                    getActivityContext().ifPresent(context -> context.getSupportFragmentManager()
+                            .beginTransaction().remove(this).commit());
+                }
+            }
+        }
 
-                                    playlistDialog.show(
-                                            this.getSupportFragmentManager(),
-                                            "addToPlaylistDialog"
-                                    );
-                                }
-                        ),
-                        throwable -> handleError(this, new ErrorInfo(
-                                throwable,
-                                UserAction.REQUESTED_STREAM,
-                                "Tried to add " + currentUrl + " to a playlist",
-                                currentService.getServiceId())
-                        )
-                )
-        );
+        @Override
+        public void onAttach(@NonNull final Context activityContext) {
+            super.onAttach(activityContext);
+            weakContext = new WeakReference<>((AppCompatActivity) activityContext);
+        }
+
+        @Override
+        public void onDetach() {
+            super.onDetach();
+            weakContext = null;
+        }
+
+        @SuppressWarnings("deprecation")
+        @Override
+        public void onCreate(final Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+            setRetainInstance(true);
+        }
+
+        @Override
+        public void onDestroy() {
+            super.onDestroy();
+            disposables.clear();
+        }
+
+        /**
+         * @return the activity context, if there is one and the activity is not finishing
+         */
+        private Optional<AppCompatActivity> getActivityContext() {
+            return Optional.ofNullable(weakContext)
+                    .map(Reference::get)
+                    .filter(context -> !context.isFinishing());
+        }
+
+        // guard against IllegalStateException in calling DialogFragment.show() whilst in background
+        // (which could happen, say, when the user pressed the home button while waiting for
+        // the network request to return) when it internally calls FragmentTransaction.commit()
+        // after the FragmentManager has saved its states (isStateSaved() == true)
+        // (ref: https://stackoverflow.com/a/39813506)
+        private void runOnVisible(final Consumer<AppCompatActivity> runnable) {
+            getActivityContext().ifPresentOrElse(context -> {
+                if (getLifecycle().getCurrentState().isAtLeast(Lifecycle.State.STARTED)) {
+                    context.runOnUiThread(() -> {
+                        runnable.accept(context);
+                        inFlight(false);
+                    });
+                } else {
+                    getLifecycle().addObserver(new DefaultLifecycleObserver() {
+                        @Override
+                        public void onResume(@NonNull final LifecycleOwner owner) {
+                            getLifecycle().removeObserver(this);
+                            getActivityContext().ifPresentOrElse(context ->
+                                    context.runOnUiThread(() -> {
+                                        runnable.accept(context);
+                                        inFlight(false);
+                                    }),
+                                    () -> inFlight(false)
+                            );
+                        }
+                    });
+                    // this trick doesn't seem to work on Android 10+ (API 29)
+                    // which places restrictions on starting activities from the background
+                    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q
+                            && !context.isChangingConfigurations()) {
+                        // try to bring the activity back to front if minimised
+                        final Intent i = new Intent(context, RouterActivity.class);
+                        i.setFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
+                        startActivity(i);
+                    }
+                }
+
+            }, () -> {
+                // this branch is executed if there is no activity context
+                inFlight(false);
+            });
+        }
+
+        <T> Single<T> pleaseWait(final Single<T> single) {
+            // 'abuse' ambWith() here to cancel the toast for us when the wait is over
+            return single.ambWith(Single.create(emitter -> getActivityContext().ifPresent(context ->
+                    context.runOnUiThread(() -> {
+                        // Getting the stream info usually takes a moment
+                        // Notifying the user here to ensure that no confusion arises
+                        final Toast toast = Toast.makeText(context,
+                                getString(R.string.processing_may_take_a_moment),
+                                Toast.LENGTH_LONG);
+                        toast.show();
+                        emitter.setCancellable(toast::cancel);
+            }))));
+        }
+
+        @SuppressLint("CheckResult")
+        private void openDownloadDialog(final int currentServiceId, final String currentUrl) {
+            inFlight(true);
+            disposables.add(ExtractorHelper.getStreamInfo(currentServiceId, currentUrl, true)
+                    .subscribeOn(Schedulers.io())
+                    .observeOn(AndroidSchedulers.mainThread())
+                    .compose(this::pleaseWait)
+                    .subscribe(result ->
+                        runOnVisible(ctx -> {
+                            final FragmentManager fm = ctx.getSupportFragmentManager();
+                            final DownloadDialog downloadDialog = new DownloadDialog(ctx, result);
+                            // dismiss listener to be handled by FragmentManager
+                            downloadDialog.show(fm, "downloadDialog");
+                        }
+                    ), throwable -> runOnVisible(ctx ->
+                            ((RouterActivity) ctx).showUnsupportedUrlDialog(currentUrl))));
+        }
+
+        private void openAddToPlaylistDialog(final int currentServiceId, final String currentUrl) {
+            inFlight(true);
+            disposables.add(ExtractorHelper.getStreamInfo(currentServiceId, currentUrl, false)
+                    .subscribeOn(Schedulers.io())
+                    .observeOn(AndroidSchedulers.mainThread())
+                    .compose(this::pleaseWait)
+                    .subscribe(
+                            info -> getActivityContext().ifPresent(context ->
+                                    PlaylistDialog.createCorrespondingDialog(context,
+                                            List.of(new StreamEntity(info)),
+                                            playlistDialog -> runOnVisible(ctx -> {
+                                                // dismiss listener to be handled by FragmentManager
+                                                final FragmentManager fm =
+                                                        ctx.getSupportFragmentManager();
+                                                playlistDialog.show(fm, "addToPlaylistDialog");
+                                            })
+                                    )),
+                            throwable -> runOnVisible(ctx -> handleError(ctx, new ErrorInfo(
+                                    throwable,
+                                    UserAction.REQUESTED_STREAM,
+                                    "Tried to add " + currentUrl + " to a playlist",
+                                    ((RouterActivity) ctx).currentService.getServiceId())
+                            ))
+                    )
+            );
+        }
     }
 
-    @SuppressLint("CheckResult")
-    private void openDownloadDialog() {
-        disposables.add(ExtractorHelper.getStreamInfo(currentServiceId, currentUrl, true)
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
-                .subscribe(result -> {
-                    final DownloadDialog downloadDialog = new DownloadDialog(this, result);
-                    downloadDialog.setOnDismissListener(dialog -> finish());
+    private void openAddToPlaylistDialog() {
+        getPersistFragment().openAddToPlaylistDialog(currentServiceId, currentUrl);
+    }
 
-                    final FragmentManager fm = getSupportFragmentManager();
-                    downloadDialog.show(fm, "downloadDialog");
-                    fm.executePendingTransactions();
-                }, throwable -> showUnsupportedUrlDialog(currentUrl)));
+    private void openDownloadDialog() {
+        getPersistFragment().openDownloadDialog(currentServiceId, currentUrl);
+    }
+
+    private PersistentFragment getPersistFragment() {
+        final FragmentManager fm = getSupportFragmentManager();
+        PersistentFragment persistFragment =
+                (PersistentFragment) fm.findFragmentByTag("PERSIST_FRAGMENT");
+        if (persistFragment == null) {
+            persistFragment = new PersistentFragment();
+            fm.beginTransaction()
+                    .add(persistFragment, "PERSIST_FRAGMENT")
+                    .commitNow();
+        }
+        return persistFragment;
     }
 
     @Override

app/src/main/java/org/schabi/newpipe/about/AboutActivity.kt

@@ -6,6 +6,7 @@ import android.view.MenuItem
 import android.view.View
 import android.view.ViewGroup
 import android.widget.Button
+import androidx.annotation.StringRes
 import androidx.appcompat.app.AppCompatActivity
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentActivity
@@ -57,13 +58,9 @@ class AboutActivity : AppCompatActivity() {
      * A placeholder fragment containing a simple view.
      */
     class AboutFragment : Fragment() {
-        private fun Button.openLink(url: Int) {
+        private fun Button.openLink(@StringRes url: Int) {
             setOnClickListener {
-                ShareUtils.openUrlInBrowser(
-                    context,
-                    requireContext().getString(url),
-                    false
-                )
+                ShareUtils.openUrlInApp(context, requireContext().getString(url))
             }
         }
 
@@ -78,6 +75,7 @@ class AboutActivity : AppCompatActivity() {
                 aboutDonationLink.openLink(R.string.donation_url)
                 aboutWebsiteLink.openLink(R.string.website_url)
                 aboutPrivacyPolicyLink.openLink(R.string.privacy_policy_url)
+                faqLink.openLink(R.string.faq_url)
                 return root
             }
         }

app/src/main/java/org/schabi/newpipe/about/LicenseFragmentHelper.kt

@@ -66,7 +66,7 @@ fun showLicense(context: Context?, component: SoftwareComponent): Disposable {
             dialog.dismiss()
         }
         setNeutralButton(R.string.open_website_license) { _, _ ->
-            ShareUtils.openUrlInBrowser(context!!, component.link)
+            ShareUtils.openUrlInApp(context!!, component.link)
         }
     }
 }

app/src/main/java/org/schabi/newpipe/database/AppDatabase.java

@@ -1,6 +1,6 @@
 package org.schabi.newpipe.database;
 
-import static org.schabi.newpipe.database.Migrations.DB_VER_5;
+import static org.schabi.newpipe.database.Migrations.DB_VER_7;
 
 import androidx.room.Database;
 import androidx.room.RoomDatabase;
@@ -38,7 +38,7 @@ import org.schabi.newpipe.database.subscription.SubscriptionEntity;
                 FeedEntity.class, FeedGroupEntity.class, FeedGroupSubscriptionEntity.class,
                 FeedLastUpdatedEntity.class
         },
-        version = DB_VER_5
+        version = DB_VER_7
 )
 public abstract class AppDatabase extends RoomDatabase {
     public static final String DATABASE_NAME = "newpipe.db";

app/src/main/java/org/schabi/newpipe/database/Migrations.java

@@ -23,6 +23,8 @@ public final class Migrations {
     public static final int DB_VER_3 = 3;
     public static final int DB_VER_4 = 4;
     public static final int DB_VER_5 = 5;
+    public static final int DB_VER_6 = 6;
+    public static final int DB_VER_7 = 7;
 
     private static final String TAG = Migrations.class.getName();
     public static final boolean DEBUG = MainActivity.DEBUG;
@@ -188,6 +190,51 @@ public final class Migrations {
         }
     };
 
+    public static final Migration MIGRATION_5_6 = new Migration(DB_VER_5, DB_VER_6) {
+        @Override
+        public void migrate(@NonNull final SupportSQLiteDatabase database) {
+            database.execSQL("ALTER TABLE `playlists` ADD COLUMN `is_thumbnail_permanent` "
+                    + "INTEGER NOT NULL DEFAULT 0");
+        }
+    };
+
+    public static final Migration MIGRATION_6_7 = new Migration(DB_VER_6, DB_VER_7) {
+        @Override
+        public void migrate(@NonNull final SupportSQLiteDatabase database) {
+            // Create a new column thumbnail_stream_id
+            database.execSQL("ALTER TABLE `playlists` ADD COLUMN `thumbnail_stream_id` "
+                    + "INTEGER NOT NULL DEFAULT -1");
+
+            // Migrate the thumbnail_url to the thumbnail_stream_id
+            database.execSQL("UPDATE playlists SET thumbnail_stream_id = ("
+                    + " SELECT CASE WHEN COUNT(*) != 0 then stream_uid ELSE -1 END"
+                    + " FROM ("
+                    + " SELECT p.uid AS playlist_uid, s.uid AS stream_uid"
+                    + " FROM playlists p"
+                    + " LEFT JOIN playlist_stream_join ps ON p.uid = ps.playlist_id"
+                    + " LEFT JOIN streams s ON s.uid = ps.stream_id"
+                    + " WHERE s.thumbnail_url = p.thumbnail_url) AS temporary_table"
+                    + " WHERE playlist_uid = playlists.uid)");
+
+            // Remove the thumbnail_url field in the playlist table
+            database.execSQL("CREATE TABLE IF NOT EXISTS `playlists_new`"
+                    + "(uid INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "
+                    + "name TEXT, "
+                    + "is_thumbnail_permanent INTEGER NOT NULL, "
+                    + "thumbnail_stream_id INTEGER NOT NULL)");
+
+            database.execSQL("INSERT INTO playlists_new"
+                    + " SELECT uid, name, is_thumbnail_permanent, thumbnail_stream_id "
+                    + " FROM playlists");
+
+
+            database.execSQL("DROP TABLE playlists");
+            database.execSQL("ALTER TABLE playlists_new RENAME TO playlists");
+            database.execSQL("CREATE INDEX IF NOT EXISTS "
+                    + "`index_playlists_name` ON `playlists` (`name`)");
+        }
+    };
+
     private Migrations() {
     }
 }

app/src/main/java/org/schabi/newpipe/database/feed/dao/FeedDAO.kt

@@ -32,6 +32,7 @@ abstract class FeedDAO {
      * @return the feed streams filtered according to the conditions provided in the parameters
      * @see StreamStateEntity.isFinished()
      * @see StreamStateEntity.PLAYBACK_FINISHED_END_MILLISECONDS
+     * @see StreamStateEntity.PLAYBACK_SAVE_THRESHOLD_START_MILLISECONDS
      */
     @Query(
         """
@@ -48,7 +49,10 @@ abstract class FeedDAO {
         ON s.uid = f.stream_id
 
         LEFT JOIN feed_group_subscription_join fgs
-        ON fgs.subscription_id = f.subscription_id
+        ON (
+            :groupId <> ${FeedGroupEntity.GROUP_ALL_ID}
+            AND fgs.subscription_id = f.subscription_id
+        )
 
         WHERE (
             :groupId = ${FeedGroupEntity.GROUP_ALL_ID}
@@ -63,6 +67,15 @@ abstract class FeedDAO {
             OR s.stream_type = 'LIVE_STREAM'
             OR s.stream_type = 'AUDIO_LIVE_STREAM'
         )
+        AND (
+            :includePartiallyPlayed
+            OR sh.stream_id IS NULL
+            OR sst.stream_id IS NULL
+            OR (sst.progress_time <= ${StreamStateEntity.PLAYBACK_SAVE_THRESHOLD_START_MILLISECONDS}
+            AND sst.progress_time <= s.duration * 1000 / 4)
+            OR (sst.progress_time >= s.duration * 1000 - ${StreamStateEntity.PLAYBACK_FINISHED_END_MILLISECONDS}
+            AND sst.progress_time >= s.duration * 1000 * 3 / 4)
+        )
         AND (
             :uploadDateBefore IS NULL
             OR s.upload_date IS NULL
@@ -76,6 +89,7 @@ abstract class FeedDAO {
     abstract fun getStreams(
         groupId: Long,
         includePlayed: Boolean,
+        includePartiallyPlayed: Boolean,
         uploadDateBefore: OffsetDateTime?
     ): Maybe<List<StreamWithState>>
 

app/src/main/java/org/schabi/newpipe/database/playlist/PlaylistDuplicatesEntry.java

@@ -0,0 +1,24 @@
+package org.schabi.newpipe.database.playlist;
+
+import androidx.room.ColumnInfo;
+
+/**
+ * This class adds a field to {@link PlaylistMetadataEntry} that contains an integer representing
+ * how many times a specific stream is already contained inside a local playlist. Used to be able
+ * to grey out playlists which already contain the current stream in the playlist append dialog.
+ * @see org.schabi.newpipe.local.playlist.LocalPlaylistManager#getPlaylistDuplicates(String)
+ */
+public class PlaylistDuplicatesEntry extends PlaylistMetadataEntry {
+    public static final String PLAYLIST_TIMES_STREAM_IS_CONTAINED = "timesStreamIsContained";
+    @ColumnInfo(name = PLAYLIST_TIMES_STREAM_IS_CONTAINED)
+    public final long timesStreamIsContained;
+
+    public PlaylistDuplicatesEntry(final long uid,
+                                   final String name,
+                                   final String thumbnailUrl,
+                                   final long streamCount,
+                                   final long timesStreamIsContained) {
+        super(uid, name, thumbnailUrl, streamCount);
+        this.timesStreamIsContained = timesStreamIsContained;
+    }
+}

app/src/main/java/org/schabi/newpipe/database/playlist/dao/PlaylistStreamDAO.java

@@ -6,18 +6,23 @@ import androidx.room.RewriteQueriesToDropUnusedColumns;
 import androidx.room.Transaction;
 
 import org.schabi.newpipe.database.BasicDAO;
+import org.schabi.newpipe.database.playlist.PlaylistDuplicatesEntry;
 import org.schabi.newpipe.database.playlist.PlaylistMetadataEntry;
 import org.schabi.newpipe.database.playlist.PlaylistStreamEntry;
+import org.schabi.newpipe.database.playlist.model.PlaylistEntity;
 import org.schabi.newpipe.database.playlist.model.PlaylistStreamEntity;
 
 import java.util.List;
 
 import io.reactivex.rxjava3.core.Flowable;
 
+import static org.schabi.newpipe.database.playlist.PlaylistDuplicatesEntry.PLAYLIST_TIMES_STREAM_IS_CONTAINED;
 import static org.schabi.newpipe.database.playlist.PlaylistMetadataEntry.PLAYLIST_STREAM_COUNT;
+import static org.schabi.newpipe.database.playlist.model.PlaylistEntity.DEFAULT_THUMBNAIL;
 import static org.schabi.newpipe.database.playlist.model.PlaylistEntity.PLAYLIST_ID;
 import static org.schabi.newpipe.database.playlist.model.PlaylistEntity.PLAYLIST_NAME;
 import static org.schabi.newpipe.database.playlist.model.PlaylistEntity.PLAYLIST_TABLE;
+import static org.schabi.newpipe.database.playlist.model.PlaylistEntity.PLAYLIST_THUMBNAIL_STREAM_ID;
 import static org.schabi.newpipe.database.playlist.model.PlaylistEntity.PLAYLIST_THUMBNAIL_URL;
 import static org.schabi.newpipe.database.playlist.model.PlaylistStreamEntity.JOIN_INDEX;
 import static org.schabi.newpipe.database.playlist.model.PlaylistStreamEntity.JOIN_PLAYLIST_ID;
@@ -25,6 +30,8 @@ import static org.schabi.newpipe.database.playlist.model.PlaylistStreamEntity.JO
 import static org.schabi.newpipe.database.playlist.model.PlaylistStreamEntity.PLAYLIST_STREAM_JOIN_TABLE;
 import static org.schabi.newpipe.database.stream.model.StreamEntity.STREAM_ID;
 import static org.schabi.newpipe.database.stream.model.StreamEntity.STREAM_TABLE;
+import static org.schabi.newpipe.database.stream.model.StreamEntity.STREAM_THUMBNAIL_URL;
+import static org.schabi.newpipe.database.stream.model.StreamEntity.STREAM_URL;
 import static org.schabi.newpipe.database.stream.model.StreamStateEntity.JOIN_STREAM_ID_ALIAS;
 import static org.schabi.newpipe.database.stream.model.StreamStateEntity.STREAM_PROGRESS_MILLIS;
 import static org.schabi.newpipe.database.stream.model.StreamStateEntity.STREAM_STATE_TABLE;
@@ -53,6 +60,16 @@ public interface PlaylistStreamDAO extends BasicDAO<PlaylistStreamEntity> {
             + " WHERE " + JOIN_PLAYLIST_ID + " = :playlistId")
     Flowable<Integer> getMaximumIndexOf(long playlistId);
 
+    @Query("SELECT CASE WHEN COUNT(*) != 0 then " + STREAM_ID
+            + " ELSE " + PlaylistEntity.DEFAULT_THUMBNAIL_ID + " END"
+            + " FROM " + STREAM_TABLE
+            + " LEFT JOIN " + PLAYLIST_STREAM_JOIN_TABLE
+            + " ON " + STREAM_ID + " = " + JOIN_STREAM_ID
+            + " WHERE " + JOIN_PLAYLIST_ID + " = :playlistId "
+            + " LIMIT 1"
+    )
+    Flowable<Long> getAutomaticThumbnailStreamId(long playlistId);
+
     @RewriteQueriesToDropUnusedColumns
     @Transaction
     @Query("SELECT * FROM " + STREAM_TABLE + " INNER JOIN "
@@ -74,13 +91,64 @@ public interface PlaylistStreamDAO extends BasicDAO<PlaylistStreamEntity> {
     Flowable<List<PlaylistStreamEntry>> getOrderedStreamsOf(long playlistId);
 
     @Transaction
-    @Query("SELECT " + PLAYLIST_ID + ", " + PLAYLIST_NAME + ", " + PLAYLIST_THUMBNAIL_URL + ", "
+    @Query("SELECT " + PLAYLIST_ID + ", " + PLAYLIST_NAME + ","
+
+            + " CASE WHEN " + PLAYLIST_THUMBNAIL_STREAM_ID + " = "
+            + PlaylistEntity.DEFAULT_THUMBNAIL_ID + " THEN " + "'" + DEFAULT_THUMBNAIL + "'"
+            + " ELSE (SELECT " + STREAM_THUMBNAIL_URL
+            + " FROM " + STREAM_TABLE
+            + " WHERE " + STREAM_TABLE + "." + STREAM_ID + " = " + PLAYLIST_THUMBNAIL_STREAM_ID
+            + " ) END AS " + PLAYLIST_THUMBNAIL_URL + ", "
+
             + "COALESCE(COUNT(" + JOIN_PLAYLIST_ID + "), 0) AS " + PLAYLIST_STREAM_COUNT
+            + " FROM " + PLAYLIST_TABLE
+            + " LEFT JOIN " + PLAYLIST_STREAM_JOIN_TABLE
+            + " ON " + PLAYLIST_TABLE + "." + PLAYLIST_ID + " = " + JOIN_PLAYLIST_ID
+            + " GROUP BY " + PLAYLIST_ID
+            + " ORDER BY " + PLAYLIST_NAME + " COLLATE NOCASE ASC")
+    Flowable<List<PlaylistMetadataEntry>> getPlaylistMetadata();
+
+    @RewriteQueriesToDropUnusedColumns
+    @Transaction
+    @Query("SELECT *, MIN(" + JOIN_INDEX + ")"
+            + " FROM " + STREAM_TABLE + " INNER JOIN"
+            + " (SELECT " + JOIN_STREAM_ID + "," + JOIN_INDEX
+            + " FROM " + PLAYLIST_STREAM_JOIN_TABLE
+            + " WHERE " + JOIN_PLAYLIST_ID + " = :playlistId)"
+            + " ON " + STREAM_ID + " = " + JOIN_STREAM_ID
+            + " LEFT JOIN "
+            + "(SELECT " + JOIN_STREAM_ID + " AS " + JOIN_STREAM_ID_ALIAS + ", "
+            + STREAM_PROGRESS_MILLIS
+            + " FROM " + STREAM_STATE_TABLE + " )"
+            + " ON " + STREAM_ID + " = " + JOIN_STREAM_ID_ALIAS
+            + " GROUP BY " + STREAM_ID
+            + " ORDER BY MIN(" + JOIN_INDEX + ") ASC")
+    Flowable<List<PlaylistStreamEntry>> getStreamsWithoutDuplicates(long playlistId);
+
+    @Transaction
+    @Query("SELECT " + PLAYLIST_TABLE + "." + PLAYLIST_ID + ", "
+            + PLAYLIST_NAME + ", "
+
+            + " CASE WHEN " + PLAYLIST_THUMBNAIL_STREAM_ID + " = "
+            + PlaylistEntity.DEFAULT_THUMBNAIL_ID + " THEN " + "'" + DEFAULT_THUMBNAIL + "'"
+            + " ELSE (SELECT " + STREAM_THUMBNAIL_URL
+            + " FROM " + STREAM_TABLE
+            + " WHERE " + STREAM_TABLE + "." + STREAM_ID + " = " + PLAYLIST_THUMBNAIL_STREAM_ID
+            + " ) END AS " + PLAYLIST_THUMBNAIL_URL + ", "
+
+            + "COALESCE(COUNT(" + JOIN_PLAYLIST_ID + "), 0) AS " + PLAYLIST_STREAM_COUNT + ", "
+            + "COALESCE(SUM(" + STREAM_URL + " = :streamUrl), 0) AS "
+                + PLAYLIST_TIMES_STREAM_IS_CONTAINED
 
             + " FROM " + PLAYLIST_TABLE
             + " LEFT JOIN " + PLAYLIST_STREAM_JOIN_TABLE
-            + " ON " + PLAYLIST_ID + " = " + JOIN_PLAYLIST_ID
+            + " ON " + PLAYLIST_TABLE + "." + PLAYLIST_ID + " = " + JOIN_PLAYLIST_ID
+
+            + " LEFT JOIN " + STREAM_TABLE
+            + " ON " + STREAM_TABLE + "." + STREAM_ID + " = " + JOIN_STREAM_ID
+            + " AND :streamUrl = :streamUrl"
+
             + " GROUP BY " + JOIN_PLAYLIST_ID
             + " ORDER BY " + PLAYLIST_NAME + " COLLATE NOCASE ASC")
-    Flowable<List<PlaylistMetadataEntry>> getPlaylistMetadata();
+    Flowable<List<PlaylistDuplicatesEntry>> getPlaylistDuplicatesMetadata(String streamUrl);
 }

app/src/main/java/org/schabi/newpipe/database/playlist/model/PlaylistEntity.java

@@ -8,13 +8,22 @@ import androidx.room.PrimaryKey;
 import static org.schabi.newpipe.database.playlist.model.PlaylistEntity.PLAYLIST_NAME;
 import static org.schabi.newpipe.database.playlist.model.PlaylistEntity.PLAYLIST_TABLE;
 
+import org.schabi.newpipe.R;
+
 @Entity(tableName = PLAYLIST_TABLE,
         indices = {@Index(value = {PLAYLIST_NAME})})
 public class PlaylistEntity {
+
+    public static final String DEFAULT_THUMBNAIL = "drawable://"
+            + R.drawable.placeholder_thumbnail_playlist;
+    public static final long DEFAULT_THUMBNAIL_ID = -1;
+
     public static final String PLAYLIST_TABLE = "playlists";
     public static final String PLAYLIST_ID = "uid";
     public static final String PLAYLIST_NAME = "name";
     public static final String PLAYLIST_THUMBNAIL_URL = "thumbnail_url";
+    public static final String PLAYLIST_THUMBNAIL_PERMANENT = "is_thumbnail_permanent";
+    public static final String PLAYLIST_THUMBNAIL_STREAM_ID = "thumbnail_stream_id";
 
     @PrimaryKey(autoGenerate = true)
     @ColumnInfo(name = PLAYLIST_ID)
@@ -23,12 +32,17 @@ public class PlaylistEntity {
     @ColumnInfo(name = PLAYLIST_NAME)
     private String name;
 
-    @ColumnInfo(name = PLAYLIST_THUMBNAIL_URL)
-    private String thumbnailUrl;
+    @ColumnInfo(name = PLAYLIST_THUMBNAIL_PERMANENT)
+    private boolean isThumbnailPermanent;
 
-    public PlaylistEntity(final String name, final String thumbnailUrl) {
+    @ColumnInfo(name = PLAYLIST_THUMBNAIL_STREAM_ID)
+    private long thumbnailStreamId;
+
+    public PlaylistEntity(final String name, final boolean isThumbnailPermanent,
+                          final long thumbnailStreamId) {
         this.name = name;
-        this.thumbnailUrl = thumbnailUrl;
+        this.isThumbnailPermanent = isThumbnailPermanent;
+        this.thumbnailStreamId = thumbnailStreamId;
     }
 
     public long getUid() {
@@ -47,11 +61,20 @@ public class PlaylistEntity {
         this.name = name;
     }
 
-    public String getThumbnailUrl() {
-        return thumbnailUrl;
+    public long getThumbnailStreamId() {
+        return thumbnailStreamId;
     }
 
-    public void setThumbnailUrl(final String thumbnailUrl) {
-        this.thumbnailUrl = thumbnailUrl;
+    public void setThumbnailStreamId(final long thumbnailStreamId) {
+        this.thumbnailStreamId = thumbnailStreamId;
     }
+
+    public boolean getIsThumbnailPermanent() {
+        return isThumbnailPermanent;
+    }
+
+    public void setIsThumbnailPermanent(final boolean isThumbnailSet) {
+        this.isThumbnailPermanent = isThumbnailSet;
+    }
+
 }

app/src/main/java/org/schabi/newpipe/database/stream/model/StreamStateEntity.java

@@ -30,7 +30,7 @@ public class StreamStateEntity {
     /**
      * Playback state will not be saved, if playback time is less than this threshold (5000ms = 5s).
      */
-    private static final long PLAYBACK_SAVE_THRESHOLD_START_MILLISECONDS = 5000;
+    public static final long PLAYBACK_SAVE_THRESHOLD_START_MILLISECONDS = 5000;
 
     /**
      * Stream will be considered finished if the playback time left exceeds this threshold

app/src/main/java/org/schabi/newpipe/download/DownloadDialog.java

@@ -17,7 +17,6 @@ import android.os.Bundle;
 import android.os.Environment;
 import android.os.IBinder;
 import android.util.Log;
-import android.util.SparseArray;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
@@ -36,6 +35,7 @@ import androidx.annotation.StringRes;
 import androidx.appcompat.app.AlertDialog;
 import androidx.appcompat.view.menu.ActionMenuItemView;
 import androidx.appcompat.widget.Toolbar;
+import androidx.collection.SparseArrayCompat;
 import androidx.documentfile.provider.DocumentFile;
 import androidx.fragment.app.DialogFragment;
 import androidx.preference.PreferenceManager;
@@ -68,6 +68,8 @@ import org.schabi.newpipe.util.SecondaryStreamHelper;
 import org.schabi.newpipe.util.SimpleOnSeekBarChangeListener;
 import org.schabi.newpipe.util.StreamItemAdapter;
 import org.schabi.newpipe.util.StreamItemAdapter.StreamSizeWrapper;
+import org.schabi.newpipe.util.AudioTrackAdapter;
+import org.schabi.newpipe.util.AudioTrackAdapter.AudioTracksWrapper;
 import org.schabi.newpipe.util.ThemeHelper;
 
 import java.io.File;
@@ -75,6 +77,7 @@ import java.io.IOException;
 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
+import java.util.Optional;
 
 import icepick.Icepick;
 import icepick.State;
@@ -94,12 +97,14 @@ public class DownloadDialog extends DialogFragment
     @State
     StreamInfo currentInfo;
     @State
-    StreamSizeWrapper<AudioStream> wrappedAudioStreams;
-    @State
     StreamSizeWrapper<VideoStream> wrappedVideoStreams;
     @State
     StreamSizeWrapper<SubtitlesStream> wrappedSubtitleStreams;
     @State
+    AudioTracksWrapper wrappedAudioTracks;
+    @State
+    int selectedAudioTrackIndex;
+    @State
     int selectedVideoIndex; // set in the constructor
     @State
     int selectedAudioIndex = 0; // default to the first item
@@ -116,6 +121,7 @@ public class DownloadDialog extends DialogFragment
     private Context context;
     private boolean askForSavePath;
 
+    private AudioTrackAdapter audioTrackAdapter;
     private StreamItemAdapter<AudioStream, Stream> audioStreamsAdapter;
     private StreamItemAdapter<VideoStream, AudioStream> videoStreamsAdapter;
     private StreamItemAdapter<SubtitlesStream, Stream> subtitleStreamsAdapter;
@@ -145,6 +151,12 @@ public class DownloadDialog extends DialogFragment
     // Instance creation
     //////////////////////////////////////////////////////////////////////////*/
 
+    public DownloadDialog() {
+        // Just an empty default no-arg ctor to keep Fragment.instantiate() happy
+        // otherwise InstantiationException will be thrown when fragment is recreated
+        // TODO: Maybe use a custom FragmentFactory instead?
+    }
+
     /**
      * Create a new download dialog with the video, audio and subtitle streams from the provided
      * stream info. Video streams and video-only streams will be put into a single list menu,
@@ -153,21 +165,29 @@ public class DownloadDialog extends DialogFragment
      * @param context the context to use just to obtain preferences and strings (will not be stored)
      * @param info    the info from which to obtain downloadable streams and other info (e.g. title)
      */
-    public DownloadDialog(final Context context, @NonNull final StreamInfo info) {
+    public DownloadDialog(@NonNull final Context context, @NonNull final StreamInfo info) {
         this.currentInfo = info;
 
+        final List<AudioStream> audioStreams =
+                getStreamsOfSpecifiedDelivery(info.getAudioStreams(), PROGRESSIVE_HTTP);
+        final List<List<AudioStream>> groupedAudioStreams =
+                ListHelper.getGroupedAudioStreams(context, audioStreams);
+        this.wrappedAudioTracks = new AudioTracksWrapper(groupedAudioStreams, context);
+        this.selectedAudioTrackIndex =
+                ListHelper.getDefaultAudioTrackGroup(context, groupedAudioStreams);
+
         // TODO: Adapt this code when the downloader support other types of stream deliveries
         final List<VideoStream> videoStreams = ListHelper.getSortedStreamVideosList(
                 context,
                 getStreamsOfSpecifiedDelivery(info.getVideoStreams(), PROGRESSIVE_HTTP),
                 getStreamsOfSpecifiedDelivery(info.getVideoOnlyStreams(), PROGRESSIVE_HTTP),
                 false,
-                false
+                // If there are multiple languages available, prefer streams without audio
+                // to allow language selection
+                wrappedAudioTracks.size() > 1
         );
 
         this.wrappedVideoStreams = new StreamSizeWrapper<>(videoStreams, context);
-        this.wrappedAudioStreams = new StreamSizeWrapper<>(
-                getStreamsOfSpecifiedDelivery(info.getAudioStreams(), PROGRESSIVE_HTTP), context);
         this.wrappedSubtitleStreams = new StreamSizeWrapper<>(
                 getStreamsOfSpecifiedDelivery(info.getSubtitles(), PROGRESSIVE_HTTP), context);
 
@@ -205,35 +225,9 @@ public class DownloadDialog extends DialogFragment
         setStyle(STYLE_NO_TITLE, ThemeHelper.getDialogTheme(context));
         Icepick.restoreInstanceState(this, savedInstanceState);
 
-        final SparseArray<SecondaryStreamHelper<AudioStream>> secondaryStreams =
-                new SparseArray<>(4);
-        final List<VideoStream> videoStreams = wrappedVideoStreams.getStreamsList();
-
-        for (int i = 0; i < videoStreams.size(); i++) {
-            if (!videoStreams.get(i).isVideoOnly()) {
-                continue;
-            }
-            final AudioStream audioStream = SecondaryStreamHelper
-                    .getAudioStreamFor(wrappedAudioStreams.getStreamsList(), videoStreams.get(i));
-
-            if (audioStream != null) {
-                secondaryStreams.append(i, new SecondaryStreamHelper<>(wrappedAudioStreams,
-                        audioStream));
-            } else if (DEBUG) {
-                final MediaFormat mediaFormat = videoStreams.get(i).getFormat();
-                if (mediaFormat != null) {
-                    Log.w(TAG, "No audio stream candidates for video format "
-                            + mediaFormat.name());
-                } else {
-                    Log.w(TAG, "No audio stream candidates for unknown video format");
-                }
-            }
-        }
-
-        this.videoStreamsAdapter = new StreamItemAdapter<>(context, wrappedVideoStreams,
-                secondaryStreams);
-        this.audioStreamsAdapter = new StreamItemAdapter<>(context, wrappedAudioStreams);
-        this.subtitleStreamsAdapter = new StreamItemAdapter<>(context, wrappedSubtitleStreams);
+        this.audioTrackAdapter = new AudioTrackAdapter(wrappedAudioTracks);
+        this.subtitleStreamsAdapter = new StreamItemAdapter<>(wrappedSubtitleStreams);
+        updateSecondaryStreams();
 
         final Intent intent = new Intent(context, DownloadManagerService.class);
         context.startService(intent);
@@ -260,6 +254,39 @@ public class DownloadDialog extends DialogFragment
         }, Context.BIND_AUTO_CREATE);
     }
 
+    /**
+     * Update the displayed video streams based on the selected audio track.
+     */
+    private void updateSecondaryStreams() {
+        final StreamSizeWrapper<AudioStream> audioStreams = getWrappedAudioStreams();
+        final var secondaryStreams = new SparseArrayCompat<SecondaryStreamHelper<AudioStream>>(4);
+        final List<VideoStream> videoStreams = wrappedVideoStreams.getStreamsList();
+        wrappedVideoStreams.resetSizes();
+
+        for (int i = 0; i < videoStreams.size(); i++) {
+            if (!videoStreams.get(i).isVideoOnly()) {
+                continue;
+            }
+            final AudioStream audioStream = SecondaryStreamHelper
+                    .getAudioStreamFor(audioStreams.getStreamsList(), videoStreams.get(i));
+
+            if (audioStream != null) {
+                secondaryStreams.append(i, new SecondaryStreamHelper<>(audioStreams, audioStream));
+            } else if (DEBUG) {
+                final MediaFormat mediaFormat = videoStreams.get(i).getFormat();
+                if (mediaFormat != null) {
+                    Log.w(TAG, "No audio stream candidates for video format "
+                            + mediaFormat.name());
+                } else {
+                    Log.w(TAG, "No audio stream candidates for unknown video format");
+                }
+            }
+        }
+
+        this.videoStreamsAdapter = new StreamItemAdapter<>(wrappedVideoStreams, secondaryStreams);
+        this.audioStreamsAdapter = new StreamItemAdapter<>(audioStreams);
+    }
+
     @Override
     public View onCreateView(@NonNull final LayoutInflater inflater,
                              final ViewGroup container,
@@ -280,13 +307,13 @@ public class DownloadDialog extends DialogFragment
 
         dialogBinding.fileName.setText(FilenameUtils.createFilename(getContext(),
                 currentInfo.getName()));
-        selectedAudioIndex = ListHelper
-                .getDefaultAudioFormat(getContext(), wrappedAudioStreams.getStreamsList());
+        selectedAudioIndex = ListHelper.getDefaultAudioFormat(getContext(),
+                getWrappedAudioStreams().getStreamsList());
 
         selectedSubtitleIndex = getSubtitleIndexBy(subtitleStreamsAdapter.getAll());
 
         dialogBinding.qualitySpinner.setOnItemSelectedListener(this);
-
+        dialogBinding.audioTrackSpinner.setOnItemSelectedListener(this);
         dialogBinding.videoAudioGroup.setOnCheckedChangeListener(this);
 
         initToolbar(dialogBinding.toolbarLayout.toolbar);
@@ -378,7 +405,7 @@ public class DownloadDialog extends DialogFragment
                         new ErrorInfo(throwable, UserAction.DOWNLOAD_OPEN_DIALOG,
                                 "Downloading video stream size",
                                 currentInfo.getServiceId()))));
-        disposables.add(StreamSizeWrapper.fetchSizeForWrapper(wrappedAudioStreams)
+        disposables.add(StreamSizeWrapper.fetchSizeForWrapper(getWrappedAudioStreams())
                 .subscribe(result -> {
                     if (dialogBinding.videoAudioGroup.getCheckedRadioButtonId()
                             == R.id.audio_button) {
@@ -400,14 +427,28 @@ public class DownloadDialog extends DialogFragment
                                 currentInfo.getServiceId()))));
     }
 
+    private void setupAudioTrackSpinner() {
+        if (getContext() == null) {
+            return;
+        }
+
+        dialogBinding.audioTrackSpinner.setAdapter(audioTrackAdapter);
+        dialogBinding.audioTrackSpinner.setSelection(selectedAudioTrackIndex);
+    }
+
     private void setupAudioSpinner() {
         if (getContext() == null) {
             return;
         }
 
-        dialogBinding.qualitySpinner.setAdapter(audioStreamsAdapter);
-        dialogBinding.qualitySpinner.setSelection(selectedAudioIndex);
+        dialogBinding.qualitySpinner.setVisibility(View.GONE);
         setRadioButtonsState(true);
+        dialogBinding.audioStreamSpinner.setAdapter(audioStreamsAdapter);
+        dialogBinding.audioStreamSpinner.setSelection(selectedAudioIndex);
+        dialogBinding.audioStreamSpinner.setVisibility(View.VISIBLE);
+        dialogBinding.audioTrackSpinner.setVisibility(
+                wrappedAudioTracks.size() > 1 ? View.VISIBLE : View.GONE);
+        dialogBinding.audioTrackPresentInVideoText.setVisibility(View.GONE);
     }
 
     private void setupVideoSpinner() {
@@ -417,7 +458,19 @@ public class DownloadDialog extends DialogFragment
 
         dialogBinding.qualitySpinner.setAdapter(videoStreamsAdapter);
         dialogBinding.qualitySpinner.setSelection(selectedVideoIndex);
+        dialogBinding.qualitySpinner.setVisibility(View.VISIBLE);
         setRadioButtonsState(true);
+        dialogBinding.audioStreamSpinner.setVisibility(View.GONE);
+        onVideoStreamSelected();
+    }
+
+    private void onVideoStreamSelected() {
+        final boolean isVideoOnly = videoStreamsAdapter.getItem(selectedVideoIndex).isVideoOnly();
+
+        dialogBinding.audioTrackSpinner.setVisibility(
+                isVideoOnly && wrappedAudioTracks.size() > 1 ? View.VISIBLE : View.GONE);
+        dialogBinding.audioTrackPresentInVideoText.setVisibility(
+                !isVideoOnly && wrappedAudioTracks.size() > 1 ? View.VISIBLE : View.GONE);
     }
 
     private void setupSubtitleSpinner() {
@@ -427,7 +480,11 @@ public class DownloadDialog extends DialogFragment
 
         dialogBinding.qualitySpinner.setAdapter(subtitleStreamsAdapter);
         dialogBinding.qualitySpinner.setSelection(selectedSubtitleIndex);
+        dialogBinding.qualitySpinner.setVisibility(View.VISIBLE);
         setRadioButtonsState(true);
+        dialogBinding.audioStreamSpinner.setVisibility(View.GONE);
+        dialogBinding.audioTrackSpinner.setVisibility(View.GONE);
+        dialogBinding.audioTrackPresentInVideoText.setVisibility(View.GONE);
     }
 
 
@@ -545,16 +602,62 @@ public class DownloadDialog extends DialogFragment
                     + "parent = [" + parent + "], view = [" + view + "], "
                     + "position = [" + position + "], id = [" + id + "]");
         }
-        switch (dialogBinding.videoAudioGroup.getCheckedRadioButtonId()) {
-            case R.id.audio_button:
+
+        switch (parent.getId()) {
+            case R.id.quality_spinner:
+                switch (dialogBinding.videoAudioGroup.getCheckedRadioButtonId()) {
+                    case R.id.video_button:
+                        selectedVideoIndex = position;
+                        onVideoStreamSelected();
+                        break;
+                    case R.id.subtitle_button:
+                        selectedSubtitleIndex = position;
+                        break;
+                }
+                onItemSelectedSetFileName();
+                break;
+            case R.id.audio_track_spinner:
+                final boolean trackChanged = selectedAudioTrackIndex != position;
+                selectedAudioTrackIndex = position;
+                if (trackChanged) {
+                    updateSecondaryStreams();
+                    fetchStreamsSize();
+                }
+                break;
+            case R.id.audio_stream_spinner:
                 selectedAudioIndex = position;
-                break;
-            case R.id.video_button:
-                selectedVideoIndex = position;
-                break;
-            case R.id.subtitle_button:
-                selectedSubtitleIndex = position;
-                break;
+        }
+    }
+
+    private void onItemSelectedSetFileName() {
+        final String fileName = FilenameUtils.createFilename(getContext(), currentInfo.getName());
+        final String prevFileName = Optional.ofNullable(dialogBinding.fileName.getText())
+                .map(Object::toString)
+                .orElse("");
+
+        if (prevFileName.isEmpty()
+                || prevFileName.equals(fileName)
+                || prevFileName.startsWith(getString(R.string.caption_file_name, fileName, ""))) {
+            // only update the file name field if it was not edited by the user
+
+            switch (dialogBinding.videoAudioGroup.getCheckedRadioButtonId()) {
+                case R.id.audio_button:
+                case R.id.video_button:
+                    if (!prevFileName.equals(fileName)) {
+                        // since the user might have switched between audio and video, the correct
+                        // text might already be in place, so avoid resetting the cursor position
+                        dialogBinding.fileName.setText(fileName);
+                    }
+                    break;
+
+                case R.id.subtitle_button:
+                    final String setSubtitleLanguageCode = subtitleStreamsAdapter
+                            .getItem(selectedSubtitleIndex).getLanguageTag();
+                    // this will reset the cursor position, which is bad UX, but it can't be avoided
+                    dialogBinding.fileName.setText(getString(
+                            R.string.caption_file_name, fileName, setSubtitleLanguageCode));
+                    break;
+            }
         }
     }
 
@@ -569,6 +672,7 @@ public class DownloadDialog extends DialogFragment
 
     protected void setupDownloadOptions() {
         setRadioButtonsState(false);
+        setupAudioTrackSpinner();
 
         final boolean isVideoStreamsAvailable = videoStreamsAdapter.getCount() > 0;
         final boolean isAudioStreamsAvailable = audioStreamsAdapter.getCount() > 0;
@@ -619,6 +723,13 @@ public class DownloadDialog extends DialogFragment
         dialogBinding.subtitleButton.setEnabled(enabled);
     }
 
+    private StreamSizeWrapper<AudioStream> getWrappedAudioStreams() {
+        if (selectedAudioTrackIndex < 0 || selectedAudioTrackIndex > wrappedAudioTracks.size()) {
+            return StreamSizeWrapper.empty();
+        }
+        return wrappedAudioTracks.getTracksList().get(selectedAudioTrackIndex);
+    }
+
     private int getSubtitleIndexBy(@NonNull final List<SubtitlesStream> streams) {
         final Localization preferredLocalization = NewPipe.getPreferredLocalization();
 
@@ -659,7 +770,6 @@ public class DownloadDialog extends DialogFragment
                 .setTitle(R.string.general_error)
                 .setMessage(msg)
                 .setNegativeButton(getString(R.string.ok), null)
-                .create()
                 .show();
     }
 
@@ -872,7 +982,7 @@ public class DownloadDialog extends DialogFragment
                     break;
             }
 
-            askDialog.create().show();
+            askDialog.show();
             return;
         }
 
@@ -916,7 +1026,7 @@ public class DownloadDialog extends DialogFragment
             }
         });
 
-        askDialog.create().show();
+        askDialog.show();
     }
 
     private void continueSelectedDownload(@NonNull final StoredFileHelper storage) {
@@ -975,7 +1085,6 @@ public class DownloadDialog extends DialogFragment
                         psName = Postprocessing.ALGORITHM_WEBM_MUXER;
                     }
 
-                    psArgs = null;
                     final long videoSize = wrappedVideoStreams.getSizeInBytes(
                             (VideoStream) selectedStream);
 

app/src/main/java/org/schabi/newpipe/error/ErrorActivity.java

@@ -160,7 +160,7 @@ public class ErrorActivity extends AppCompatActivity {
                 .setMessage(R.string.start_accept_privacy_policy)
                 .setCancelable(false)
                 .setNeutralButton(R.string.read_privacy_policy, (dialog, which) ->
-                        ShareUtils.openUrlInBrowser(context,
+                        ShareUtils.openUrlInApp(context,
                                 context.getString(R.string.privacy_policy_url)))
                 .setPositiveButton(R.string.accept, (dialog, which) -> {
                     if (action.equals("EMAIL")) { // send on email
@@ -171,14 +171,12 @@ public class ErrorActivity extends AppCompatActivity {
                                         + getString(R.string.app_name) + " "
                                         + BuildConfig.VERSION_NAME)
                                 .putExtra(Intent.EXTRA_TEXT, buildJson());
-                        ShareUtils.openIntentInApp(context, i, true);
+                        ShareUtils.openIntentInApp(context, i);
                     } else if (action.equals("GITHUB")) { // open the NewPipe issue page on GitHub
-                        ShareUtils.openUrlInBrowser(this, ERROR_GITHUB_ISSUE_URL, false);
+                        ShareUtils.openUrlInApp(this, ERROR_GITHUB_ISSUE_URL);
                     }
                 })
-                .setNegativeButton(R.string.decline, (dialog, which) -> {
-                    // do nothing
-                })
+                .setNegativeButton(R.string.decline, null)
                 .show();
     }
 

app/src/main/java/org/schabi/newpipe/error/ErrorPanelHelper.kt

@@ -6,7 +6,6 @@ import android.util.Log
 import android.view.View
 import android.widget.Button
 import android.widget.TextView
-import androidx.annotation.Nullable
 import androidx.annotation.StringRes
 import androidx.core.view.isVisible
 import androidx.fragment.app.Fragment
@@ -30,6 +29,7 @@ import org.schabi.newpipe.ktx.animate
 import org.schabi.newpipe.ktx.isInterruptedCaused
 import org.schabi.newpipe.ktx.isNetworkRelated
 import org.schabi.newpipe.util.ServiceHelper
+import org.schabi.newpipe.util.external_communication.ShareUtils
 import java.util.concurrent.TimeUnit
 
 class ErrorPanelHelper(
@@ -52,6 +52,8 @@ class ErrorPanelHelper(
         errorPanelRoot.findViewById(R.id.error_action_button)
     private val errorRetryButton: Button =
         errorPanelRoot.findViewById(R.id.error_retry_button)
+    private val errorOpenInBrowserButton: Button =
+        errorPanelRoot.findViewById(R.id.error_open_in_browser)
 
     private var errorDisposable: Disposable? = null
 
@@ -69,6 +71,7 @@ class ErrorPanelHelper(
         errorServiceExplanationTextView.isVisible = false
         errorActionButton.isVisible = false
         errorRetryButton.isVisible = false
+        errorOpenInBrowserButton.isVisible = false
     }
 
     fun showError(errorInfo: ErrorInfo) {
@@ -99,6 +102,7 @@ class ErrorPanelHelper(
             }
 
             errorRetryButton.isVisible = true
+            showAndSetOpenInBrowserButtonAction(errorInfo)
         } else if (errorInfo.throwable is AccountTerminatedException) {
             errorTextView.setText(R.string.account_terminated)
 
@@ -128,6 +132,7 @@ class ErrorPanelHelper(
                 // show retry button only for content which is not unavailable or unsupported
                 errorRetryButton.isVisible = true
             }
+            showAndSetOpenInBrowserButtonAction(errorInfo)
         }
 
         setRootVisible()
@@ -138,13 +143,22 @@ class ErrorPanelHelper(
      */
     private fun showAndSetErrorButtonAction(
         @StringRes resid: Int,
-        @Nullable listener: View.OnClickListener
+        listener: View.OnClickListener
     ) {
         errorActionButton.isVisible = true
         errorActionButton.setText(resid)
         errorActionButton.setOnClickListener(listener)
     }
 
+    fun showAndSetOpenInBrowserButtonAction(
+        errorInfo: ErrorInfo
+    ) {
+        errorOpenInBrowserButton.isVisible = true
+        errorOpenInBrowserButton.setOnClickListener {
+            ShareUtils.openUrlInBrowser(context, errorInfo.request)
+        }
+    }
+
     fun showTextError(errorString: String) {
         ensureDefaultVisibility()
 

app/src/main/java/org/schabi/newpipe/error/ErrorUtil.kt

@@ -5,11 +5,11 @@ import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
 import android.graphics.Color
-import android.os.Build
 import android.view.View
 import android.widget.Toast
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
+import androidx.core.app.PendingIntentCompat
 import androidx.fragment.app.Fragment
 import com.google.android.material.snackbar.Snackbar
 import org.schabi.newpipe.R
@@ -104,11 +104,6 @@ class ErrorUtil {
          */
         @JvmStatic
         fun createNotification(context: Context, errorInfo: ErrorInfo) {
-            var pendingIntentFlags = PendingIntent.FLAG_UPDATE_CURRENT
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-                pendingIntentFlags = pendingIntentFlags or PendingIntent.FLAG_IMMUTABLE
-            }
-
             val notificationBuilder: NotificationCompat.Builder =
                 NotificationCompat.Builder(
                     context,
@@ -119,11 +114,12 @@ class ErrorUtil {
                     .setContentText(context.getString(errorInfo.messageStringId))
                     .setAutoCancel(true)
                     .setContentIntent(
-                        PendingIntent.getActivity(
+                        PendingIntentCompat.getActivity(
                             context,
                             0,
                             getErrorActivityIntent(context, errorInfo),
-                            pendingIntentFlags
+                            PendingIntent.FLAG_UPDATE_CURRENT,
+                            false
                         )
                     )
 

app/src/main/java/org/schabi/newpipe/error/ReCaptchaActivity.java

@@ -20,14 +20,14 @@ import androidx.appcompat.app.AppCompatActivity;
 import androidx.core.app.NavUtils;
 import androidx.preference.PreferenceManager;
 
-import org.schabi.newpipe.databinding.ActivityRecaptchaBinding;
 import org.schabi.newpipe.DownloaderImpl;
 import org.schabi.newpipe.MainActivity;
 import org.schabi.newpipe.R;
+import org.schabi.newpipe.databinding.ActivityRecaptchaBinding;
+import org.schabi.newpipe.extractor.utils.Utils;
 import org.schabi.newpipe.util.ThemeHelper;
 
 import java.io.UnsupportedEncodingException;
-import java.net.URLDecoder;
 
 /*
  * Created by beneth <bmauduit@beneth.fr> on 06.12.16.
@@ -188,7 +188,7 @@ public class ReCaptchaActivity extends AppCompatActivity {
 
             try {
                 String abuseCookie = url.substring(abuseStart + 13, abuseEnd);
-                abuseCookie = URLDecoder.decode(abuseCookie, "UTF-8");
+                abuseCookie = Utils.decodeUrlUtf8(abuseCookie);
                 handleCookies(abuseCookie);
             } catch (UnsupportedEncodingException | StringIndexOutOfBoundsException e) {
                 if (MainActivity.DEBUG) {

app/src/main/java/org/schabi/newpipe/fragments/detail/DescriptionFragment.java

@@ -3,6 +3,8 @@ package org.schabi.newpipe.fragments.detail;
 import static android.text.TextUtils.isEmpty;
 import static org.schabi.newpipe.extractor.stream.StreamExtractor.NO_AGE_LIMIT;
 import static org.schabi.newpipe.extractor.utils.Utils.isBlank;
+import static org.schabi.newpipe.util.Localization.getAppLocale;
+import static org.schabi.newpipe.util.text.TextLinkifier.SET_LINK_MOVEMENT_METHOD;
 
 import android.os.Bundle;
 import android.view.LayoutInflater;
@@ -28,7 +30,7 @@ import org.schabi.newpipe.extractor.stream.StreamInfo;
 import org.schabi.newpipe.util.Localization;
 import org.schabi.newpipe.util.NavigationHelper;
 import org.schabi.newpipe.util.external_communication.ShareUtils;
-import org.schabi.newpipe.util.external_communication.TextLinkifier;
+import org.schabi.newpipe.util.text.TextLinkifier;
 
 import icepick.State;
 import io.reactivex.rxjava3.disposables.CompositeDisposable;
@@ -111,7 +113,10 @@ public class DescriptionFragment extends BaseFragment {
 
     private void disableDescriptionSelection() {
         // show description content again, otherwise some links are not clickable
-        loadDescriptionContent();
+        TextLinkifier.fromDescription(binding.detailDescriptionView,
+                streamInfo.getDescription(), HtmlCompat.FROM_HTML_MODE_LEGACY,
+                streamInfo.getService(), streamInfo.getUrl(),
+                descriptionDisposables, SET_LINK_MOVEMENT_METHOD);
 
         binding.detailDescriptionNoteView.setVisibility(View.GONE);
         binding.detailDescriptionView.setTextIsSelectable(false);
@@ -122,52 +127,32 @@ public class DescriptionFragment extends BaseFragment {
         binding.detailSelectDescriptionButton.setImageResource(R.drawable.ic_select_all);
     }
 
-    private void loadDescriptionContent() {
-        final Description description = streamInfo.getDescription();
-        switch (description.getType()) {
-            case Description.HTML:
-                TextLinkifier.createLinksFromHtmlBlock(binding.detailDescriptionView,
-                        description.getContent(), HtmlCompat.FROM_HTML_MODE_LEGACY, streamInfo,
-                        descriptionDisposables);
-                break;
-            case Description.MARKDOWN:
-                TextLinkifier.createLinksFromMarkdownText(binding.detailDescriptionView,
-                        description.getContent(), streamInfo, descriptionDisposables);
-                break;
-            case Description.PLAIN_TEXT: default:
-                TextLinkifier.createLinksFromPlainText(binding.detailDescriptionView,
-                        description.getContent(), streamInfo, descriptionDisposables);
-                break;
-        }
-    }
-
-
     private void setupMetadata(final LayoutInflater inflater,
                                final LinearLayout layout) {
-        addMetadataItem(inflater, layout, false,
-                R.string.metadata_category, streamInfo.getCategory());
+        addMetadataItem(inflater, layout, false, R.string.metadata_category,
+                streamInfo.getCategory());
 
-        addMetadataItem(inflater, layout, false,
-                R.string.metadata_licence, streamInfo.getLicence());
+        addMetadataItem(inflater, layout, false, R.string.metadata_licence,
+                streamInfo.getLicence());
 
         addPrivacyMetadataItem(inflater, layout);
 
         if (streamInfo.getAgeLimit() != NO_AGE_LIMIT) {
-            addMetadataItem(inflater, layout, false,
-                    R.string.metadata_age_limit, String.valueOf(streamInfo.getAgeLimit()));
+            addMetadataItem(inflater, layout, false, R.string.metadata_age_limit,
+                    String.valueOf(streamInfo.getAgeLimit()));
         }
 
         if (streamInfo.getLanguageInfo() != null) {
-            addMetadataItem(inflater, layout, false,
-                    R.string.metadata_language, streamInfo.getLanguageInfo().getDisplayLanguage());
+            addMetadataItem(inflater, layout, false, R.string.metadata_language,
+                    streamInfo.getLanguageInfo().getDisplayLanguage(getAppLocale(getContext())));
         }
 
-        addMetadataItem(inflater, layout, true,
-                R.string.metadata_support, streamInfo.getSupportInfo());
-        addMetadataItem(inflater, layout, true,
-                R.string.metadata_host, streamInfo.getHost());
-        addMetadataItem(inflater, layout, true,
-                R.string.metadata_thumbnail_url, streamInfo.getThumbnailUrl());
+        addMetadataItem(inflater, layout, true, R.string.metadata_support,
+                streamInfo.getSupportInfo());
+        addMetadataItem(inflater, layout, true, R.string.metadata_host,
+                streamInfo.getHost());
+        addMetadataItem(inflater, layout, true, R.string.metadata_thumbnail_url,
+                streamInfo.getThumbnailUrl());
 
         addTagsMetadataItem(inflater, layout);
     }
@@ -191,12 +176,14 @@ public class DescriptionFragment extends BaseFragment {
         });
 
         if (linkifyContent) {
-            TextLinkifier.createLinksFromPlainText(itemBinding.metadataContentView, content, null,
-                    descriptionDisposables);
+            TextLinkifier.fromPlainText(itemBinding.metadataContentView, content, null, null,
+                    descriptionDisposables, SET_LINK_MOVEMENT_METHOD);
         } else {
             itemBinding.metadataContentView.setText(content);
         }
 
+        itemBinding.metadataContentView.setClickable(true);
+
         layout.addView(itemBinding.getRoot());
     }
 
@@ -245,14 +232,15 @@ public class DescriptionFragment extends BaseFragment {
                 case INTERNAL:
                     contentRes = R.string.metadata_privacy_internal;
                     break;
-                case OTHER: default:
+                case OTHER:
+                default:
                     contentRes = 0;
                     break;
             }
 
             if (contentRes != 0) {
-                addMetadataItem(inflater, layout, false,
-                        R.string.metadata_privacy, getString(contentRes));
+                addMetadataItem(inflater, layout, false, R.string.metadata_privacy,
+                        getString(contentRes));
             }
         }
     }

app/src/main/java/org/schabi/newpipe/fragments/detail/VideoDetailFragment.java

@@ -7,11 +7,13 @@ import static org.schabi.newpipe.ktx.ViewUtils.animate;
 import static org.schabi.newpipe.ktx.ViewUtils.animateRotation;
 import static org.schabi.newpipe.player.helper.PlayerHelper.globalScreenOrientationLocked;
 import static org.schabi.newpipe.player.helper.PlayerHelper.isClearingQueueConfirmationRequired;
-import static org.schabi.newpipe.player.playqueue.PlayQueueItem.RECOVERY_UNSET;
+import static org.schabi.newpipe.util.DependentPreferenceHelper.getResumePlaybackEnabled;
 import static org.schabi.newpipe.util.ExtractorHelper.showMetaInfoInTextView;
 import static org.schabi.newpipe.util.ListHelper.getUrlAndNonTorrentStreams;
+import static org.schabi.newpipe.util.NavigationHelper.openPlayQueue;
 
 import android.animation.ValueAnimator;
+import android.annotation.SuppressLint;
 import android.app.Activity;
 import android.content.BroadcastReceiver;
 import android.content.Context;
@@ -59,7 +61,6 @@ import com.google.android.exoplayer2.PlaybackParameters;
 import com.google.android.material.appbar.AppBarLayout;
 import com.google.android.material.bottomsheet.BottomSheetBehavior;
 import com.google.android.material.tabs.TabLayout;
-import com.squareup.picasso.Callback;
 
 import org.schabi.newpipe.App;
 import org.schabi.newpipe.R;
@@ -119,6 +120,7 @@ import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
 
 import icepick.State;
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
@@ -129,9 +131,6 @@ import io.reactivex.rxjava3.schedulers.Schedulers;
 public final class VideoDetailFragment
         extends BaseStateFragment<StreamInfo>
         implements BackPressable,
-        SharedPreferences.OnSharedPreferenceChangeListener,
-        View.OnClickListener,
-        View.OnLongClickListener,
         PlayerServiceExtendedEventListener,
         OnKeyDownListener {
     public static final String KEY_SWITCHING_PLAYERS = "switching_players";
@@ -162,11 +161,29 @@ public final class VideoDetailFragment
     private boolean showRelatedItems;
     private boolean showDescription;
     private String selectedTabTag;
-    @AttrRes @NonNull final List<Integer> tabIcons = new ArrayList<>();
-    @StringRes @NonNull final List<Integer> tabContentDescriptions = new ArrayList<>();
+    @AttrRes
+    @NonNull
+    final List<Integer> tabIcons = new ArrayList<>();
+    @StringRes
+    @NonNull
+    final List<Integer> tabContentDescriptions = new ArrayList<>();
     private boolean tabSettingsChanged = false;
     private int lastAppBarVerticalOffset = Integer.MAX_VALUE; // prevents useless updates
 
+    private final SharedPreferences.OnSharedPreferenceChangeListener preferenceChangeListener =
+            (sharedPreferences, key) -> {
+                if (getString(R.string.show_comments_key).equals(key)) {
+                    showComments = sharedPreferences.getBoolean(key, true);
+                    tabSettingsChanged = true;
+                } else if (getString(R.string.show_next_video_key).equals(key)) {
+                    showRelatedItems = sharedPreferences.getBoolean(key, true);
+                    tabSettingsChanged = true;
+                } else if (getString(R.string.show_description_key).equals(key)) {
+                    showDescription = sharedPreferences.getBoolean(key, true);
+                    tabSettingsChanged = true;
+                }
+            };
+
     @State
     protected int serviceId = Constants.NO_SERVICE_ID;
     @State
@@ -240,14 +257,14 @@ public final class VideoDetailFragment
             playerUi.ifPresent(MainPlayerUi::toggleFullscreen);
         }
 
-        //noinspection SimplifyOptionalCallChains
         if (playAfterConnect
                 || (currentInfo != null
                 && isAutoplayEnabled()
-                && !playerUi.isPresent())) {
+                && playerUi.isEmpty())) {
             autoPlayEnabled = true; // forcefully start playing
             openVideoPlayerAutoFullscreen();
         }
+        updateOverlayPlayQueueButtonVisibility();
     }
 
     @Override
@@ -290,7 +307,7 @@ public final class VideoDetailFragment
         showDescription = prefs.getBoolean(getString(R.string.show_description_key), true);
         selectedTabTag = prefs.getString(
                 getString(R.string.stream_info_selected_tab_key), COMMENTS_TAB_TAG);
-        prefs.registerOnSharedPreferenceChangeListener(this);
+        prefs.registerOnSharedPreferenceChangeListener(preferenceChangeListener);
 
         setupBroadcastReceiver();
 
@@ -337,6 +354,8 @@ public final class VideoDetailFragment
 
         activity.sendBroadcast(new Intent(ACTION_VIDEO_FRAGMENT_RESUMED));
 
+        updateOverlayPlayQueueButtonVisibility();
+
         setupBrightness();
 
         if (tabSettingsChanged) {
@@ -375,7 +394,7 @@ public final class VideoDetailFragment
         }
 
         PreferenceManager.getDefaultSharedPreferences(activity)
-                .unregisterOnSharedPreferenceChangeListener(this);
+                .unregisterOnSharedPreferenceChangeListener(preferenceChangeListener);
         activity.unregisterReceiver(broadcastReceiver);
         activity.getContentResolver().unregisterContentObserver(settingsContentObserver);
 
@@ -421,127 +440,121 @@ public final class VideoDetailFragment
         }
     }
 
-    @Override
-    public void onSharedPreferenceChanged(final SharedPreferences sharedPreferences,
-                                          final String key) {
-        if (key.equals(getString(R.string.show_comments_key))) {
-            showComments = sharedPreferences.getBoolean(key, true);
-            tabSettingsChanged = true;
-        } else if (key.equals(getString(R.string.show_next_video_key))) {
-            showRelatedItems = sharedPreferences.getBoolean(key, true);
-            tabSettingsChanged = true;
-        } else if (key.equals(getString(R.string.show_description_key))) {
-            showDescription = sharedPreferences.getBoolean(key, true);
-            tabSettingsChanged = true;
-        }
-    }
-
     /*//////////////////////////////////////////////////////////////////////////
     // OnClick
     //////////////////////////////////////////////////////////////////////////*/
 
-    @Override
-    public void onClick(final View v) {
-        switch (v.getId()) {
-            case R.id.detail_controls_background:
-                openBackgroundPlayer(false);
-                break;
-            case R.id.detail_controls_popup:
-                openPopupPlayer(false);
-                break;
-            case R.id.detail_controls_playlist_append:
-                if (getFM() != null && currentInfo != null) {
-                    disposables.add(
-                            PlaylistDialog.createCorrespondingDialog(
-                                    getContext(),
-                                    List.of(new StreamEntity(currentInfo)),
-                                    dialog -> dialog.show(getFM(), TAG)
-                            )
-                    );
-                }
-                break;
-            case R.id.detail_controls_download:
-                if (PermissionHelper.checkStoragePermissions(activity,
-                        PermissionHelper.DOWNLOAD_DIALOG_REQUEST_CODE)) {
-                    this.openDownloadDialog();
-                }
-                break;
-            case R.id.detail_controls_share:
-                if (currentInfo != null) {
-                    ShareUtils.shareText(requireContext(), currentInfo.getName(),
-                            currentInfo.getUrl(), currentInfo.getThumbnailUrl());
-                }
-                break;
-            case R.id.detail_controls_open_in_browser:
-                if (currentInfo != null) {
-                    ShareUtils.openUrlInBrowser(requireContext(), currentInfo.getUrl());
-                }
-                break;
-            case R.id.detail_controls_play_with_kodi:
-                if (currentInfo != null) {
-                    try {
-                        NavigationHelper.playWithKore(
-                                requireContext(), Uri.parse(currentInfo.getUrl()));
-                    } catch (final Exception e) {
-                        if (DEBUG) {
-                            Log.i(TAG, "Failed to start kore", e);
-                        }
-                        KoreUtils.showInstallKoreDialog(requireContext());
-                    }
-                }
-                break;
-            case R.id.detail_uploader_root_layout:
-                if (isEmpty(currentInfo.getSubChannelUrl())) {
-                    if (!isEmpty(currentInfo.getUploaderUrl())) {
-                        openChannel(currentInfo.getUploaderUrl(), currentInfo.getUploaderName());
-                    }
-
-                    if (DEBUG) {
-                        Log.i(TAG, "Can't open sub-channel because we got no channel URL");
-                    }
-                } else {
-                    openChannel(currentInfo.getSubChannelUrl(),
-                            currentInfo.getSubChannelName());
-                }
-                break;
-            case R.id.detail_thumbnail_root_layout:
-                // make sure not to open any player if there is nothing currently loaded!
-                // FIXME removing this `if` causes the player service to start correctly, then stop,
-                //  then restart badly without calling `startForeground()`, causing a crash when
-                //  later closing the detail fragment
-                if (currentInfo != null) {
-                    autoPlayEnabled = true; // forcefully start playing
-                    // FIXME Workaround #7427
-                    if (isPlayerAvailable()) {
-                        player.setRecovery();
-                    }
-                    openVideoPlayerAutoFullscreen();
-                }
-                break;
-            case R.id.detail_title_root_layout:
-                toggleTitleAndSecondaryControls();
-                break;
-            case R.id.overlay_thumbnail:
-            case R.id.overlay_metadata_layout:
-            case R.id.overlay_buttons_layout:
-                bottomSheetBehavior.setState(BottomSheetBehavior.STATE_EXPANDED);
-                break;
-            case R.id.overlay_play_pause_button:
-                if (playerIsNotStopped()) {
-                    player.playPause();
-                    player.UIs().get(VideoPlayerUi.class).ifPresent(ui -> ui.hideControls(0, 0));
-                    showSystemUi();
-                } else {
-                    autoPlayEnabled = true; // forcefully start playing
-                    openVideoPlayer(false);
+    private void setOnClickListeners() {
+        binding.detailTitleRootLayout.setOnClickListener(v -> toggleTitleAndSecondaryControls());
+        binding.detailUploaderRootLayout.setOnClickListener(makeOnClickListener(info -> {
+            if (isEmpty(info.getSubChannelUrl())) {
+                if (!isEmpty(info.getUploaderUrl())) {
+                    openChannel(info.getUploaderUrl(), info.getUploaderName());
                 }
 
-                setOverlayPlayPauseImage(isPlayerAvailable() && player.isPlaying());
-                break;
-            case R.id.overlay_close_button:
-                bottomSheetBehavior.setState(BottomSheetBehavior.STATE_HIDDEN);
-                break;
+                if (DEBUG) {
+                    Log.i(TAG, "Can't open sub-channel because we got no channel URL");
+                }
+            } else {
+                openChannel(info.getSubChannelUrl(), info.getSubChannelName());
+            }
+        }));
+        binding.detailThumbnailRootLayout.setOnClickListener(v -> {
+            autoPlayEnabled = true; // forcefully start playing
+            // FIXME Workaround #7427
+            if (isPlayerAvailable()) {
+                player.setRecovery();
+            }
+            openVideoPlayerAutoFullscreen();
+        });
+
+        binding.detailControlsBackground.setOnClickListener(v -> openBackgroundPlayer(false));
+        binding.detailControlsPopup.setOnClickListener(v -> openPopupPlayer(false));
+        binding.detailControlsPlaylistAppend.setOnClickListener(makeOnClickListener(info ->
+                disposables.add(PlaylistDialog.createCorrespondingDialog(requireContext(),
+                        List.of(new StreamEntity(info)),
+                        dialog -> dialog.show(getParentFragmentManager(), TAG)))));
+        binding.detailControlsDownload.setOnClickListener(v -> {
+            if (PermissionHelper.checkStoragePermissions(activity,
+                    PermissionHelper.DOWNLOAD_DIALOG_REQUEST_CODE)) {
+                openDownloadDialog();
+            }
+        });
+        binding.detailControlsShare.setOnClickListener(makeOnClickListener(info ->
+                ShareUtils.shareText(requireContext(), info.getName(), info.getUrl(),
+                        info.getThumbnailUrl())));
+        binding.detailControlsOpenInBrowser.setOnClickListener(makeOnClickListener(info ->
+                ShareUtils.openUrlInBrowser(requireContext(), info.getUrl())));
+        binding.detailControlsPlayWithKodi.setOnClickListener(makeOnClickListener(info ->
+                KoreUtils.playWithKore(requireContext(), Uri.parse(info.getUrl()))));
+        if (DEBUG) {
+            binding.detailControlsCrashThePlayer.setOnClickListener(v ->
+                    VideoDetailPlayerCrasher.onCrashThePlayer(requireContext(), player));
         }
+
+        final View.OnClickListener overlayListener = v -> bottomSheetBehavior
+                .setState(BottomSheetBehavior.STATE_EXPANDED);
+        binding.overlayThumbnail.setOnClickListener(overlayListener);
+        binding.overlayMetadataLayout.setOnClickListener(overlayListener);
+        binding.overlayButtonsLayout.setOnClickListener(overlayListener);
+        binding.overlayCloseButton.setOnClickListener(v -> bottomSheetBehavior
+                .setState(BottomSheetBehavior.STATE_HIDDEN));
+        binding.overlayPlayQueueButton.setOnClickListener(v -> openPlayQueue(requireContext()));
+        binding.overlayPlayPauseButton.setOnClickListener(v -> {
+            if (playerIsNotStopped()) {
+                player.playPause();
+                player.UIs().get(VideoPlayerUi.class).ifPresent(ui -> ui.hideControls(0, 0));
+                showSystemUi();
+            } else {
+                autoPlayEnabled = true; // forcefully start playing
+                openVideoPlayer(false);
+            }
+
+            setOverlayPlayPauseImage(isPlayerAvailable() && player.isPlaying());
+        });
+    }
+
+    private View.OnClickListener makeOnClickListener(final Consumer<StreamInfo> consumer) {
+        return v -> {
+            if (!isLoading.get() && currentInfo != null) {
+                consumer.accept(currentInfo);
+            }
+        };
+    }
+
+    private void setOnLongClickListeners() {
+        binding.detailTitleRootLayout.setOnLongClickListener(makeOnLongClickListener(info ->
+                ShareUtils.copyToClipboard(requireContext(),
+                        binding.detailVideoTitleView.getText().toString())));
+        binding.detailUploaderRootLayout.setOnLongClickListener(makeOnLongClickListener(info -> {
+            if (isEmpty(info.getSubChannelUrl())) {
+                Log.w(TAG, "Can't open parent channel because we got no parent channel URL");
+            } else {
+                openChannel(info.getUploaderUrl(), info.getUploaderName());
+            }
+        }));
+
+        binding.detailControlsBackground.setOnLongClickListener(makeOnLongClickListener(info ->
+                openBackgroundPlayer(true)));
+        binding.detailControlsPopup.setOnLongClickListener(makeOnLongClickListener(info ->
+                openPopupPlayer(true)));
+        binding.detailControlsDownload.setOnLongClickListener(makeOnLongClickListener(info ->
+                NavigationHelper.openDownloads(activity)));
+
+        final View.OnLongClickListener overlayListener = makeOnLongClickListener(info ->
+                openChannel(info.getUploaderUrl(), info.getUploaderName()));
+        binding.overlayThumbnail.setOnLongClickListener(overlayListener);
+        binding.overlayMetadataLayout.setOnLongClickListener(overlayListener);
+    }
+
+    private View.OnLongClickListener makeOnLongClickListener(final Consumer<StreamInfo> consumer) {
+        return v -> {
+            if (isLoading.get() || currentInfo == null) {
+                return false;
+            }
+            consumer.accept(currentInfo);
+            return true;
+        };
     }
 
     private void openChannel(final String subChannelUrl, final String subChannelName) {
@@ -553,43 +566,6 @@ public final class VideoDetailFragment
         }
     }
 
-    @Override
-    public boolean onLongClick(final View v) {
-        if (isLoading.get() || currentInfo == null) {
-            return false;
-        }
-
-        switch (v.getId()) {
-            case R.id.detail_controls_background:
-                openBackgroundPlayer(true);
-                break;
-            case R.id.detail_controls_popup:
-                openPopupPlayer(true);
-                break;
-            case R.id.detail_controls_download:
-                NavigationHelper.openDownloads(activity);
-                break;
-            case R.id.overlay_thumbnail:
-            case R.id.overlay_metadata_layout:
-                openChannel(currentInfo.getUploaderUrl(), currentInfo.getUploaderName());
-                break;
-            case R.id.detail_uploader_root_layout:
-                if (isEmpty(currentInfo.getSubChannelUrl())) {
-                    Log.w(TAG,
-                            "Can't open parent channel because we got no parent channel URL");
-                } else {
-                    openChannel(currentInfo.getUploaderUrl(), currentInfo.getUploaderName());
-                }
-                break;
-            case R.id.detail_title_root_layout:
-                ShareUtils.copyToClipboard(requireContext(),
-                        binding.detailVideoTitleView.getText().toString());
-                break;
-        }
-
-        return true;
-    }
-
     private void toggleTitleAndSecondaryControls() {
         if (binding.detailSecondaryControlPanel.getVisibility() == View.GONE) {
             binding.detailVideoTitleView.setMaxLines(10);
@@ -610,11 +586,6 @@ public final class VideoDetailFragment
     // Init
     //////////////////////////////////////////////////////////////////////////*/
 
-    @Override
-    public void onViewCreated(@NonNull final View rootView, final Bundle savedInstanceState) {
-        super.onViewCreated(rootView, savedInstanceState);
-    }
-
     @Override // called from onViewCreated in {@link BaseFragment#onViewCreated}
     protected void initViews(final View rootView, final Bundle savedInstanceState) {
         super.initViews(rootView, savedInstanceState);
@@ -636,59 +607,29 @@ public final class VideoDetailFragment
                         ? View.VISIBLE
                         : View.GONE
         );
-
-        if (DeviceUtils.isTv(getContext())) {
-            // remove ripple effects from detail controls
-            final int transparent = ContextCompat.getColor(requireContext(),
-                    R.color.transparent_background_color);
-            binding.detailControlsPlaylistAppend.setBackgroundColor(transparent);
-            binding.detailControlsBackground.setBackgroundColor(transparent);
-            binding.detailControlsPopup.setBackgroundColor(transparent);
-            binding.detailControlsDownload.setBackgroundColor(transparent);
-            binding.detailControlsShare.setBackgroundColor(transparent);
-            binding.detailControlsOpenInBrowser.setBackgroundColor(transparent);
-            binding.detailControlsPlayWithKodi.setBackgroundColor(transparent);
-        }
+        accommodateForTvAndDesktopMode();
     }
 
     @Override
+    @SuppressLint("ClickableViewAccessibility")
     protected void initListeners() {
         super.initListeners();
 
-        binding.detailTitleRootLayout.setOnClickListener(this);
-        binding.detailTitleRootLayout.setOnLongClickListener(this);
-        binding.detailUploaderRootLayout.setOnClickListener(this);
-        binding.detailUploaderRootLayout.setOnLongClickListener(this);
-        binding.detailThumbnailRootLayout.setOnClickListener(this);
+        setOnClickListeners();
+        setOnLongClickListeners();
 
-        binding.detailControlsBackground.setOnClickListener(this);
-        binding.detailControlsBackground.setOnLongClickListener(this);
-        binding.detailControlsPopup.setOnClickListener(this);
-        binding.detailControlsPopup.setOnLongClickListener(this);
-        binding.detailControlsPlaylistAppend.setOnClickListener(this);
-        binding.detailControlsDownload.setOnClickListener(this);
-        binding.detailControlsDownload.setOnLongClickListener(this);
-        binding.detailControlsShare.setOnClickListener(this);
-        binding.detailControlsOpenInBrowser.setOnClickListener(this);
-        binding.detailControlsPlayWithKodi.setOnClickListener(this);
-        if (DEBUG) {
-            binding.detailControlsCrashThePlayer.setOnClickListener(
-                    v -> VideoDetailPlayerCrasher.onCrashThePlayer(
-                            this.getContext(),
-                            this.player)
-            );
-        }
+        final View.OnTouchListener controlsTouchListener = (view, motionEvent) -> {
+            if (motionEvent.getAction() == MotionEvent.ACTION_DOWN
+                && PreferenceManager.getDefaultSharedPreferences(activity)
+                    .getBoolean(getString(R.string.show_hold_to_append_key), true)) {
 
-        binding.overlayThumbnail.setOnClickListener(this);
-        binding.overlayThumbnail.setOnLongClickListener(this);
-        binding.overlayMetadataLayout.setOnClickListener(this);
-        binding.overlayMetadataLayout.setOnLongClickListener(this);
-        binding.overlayButtonsLayout.setOnClickListener(this);
-        binding.overlayCloseButton.setOnClickListener(this);
-        binding.overlayPlayPauseButton.setOnClickListener(this);
-
-        binding.detailControlsBackground.setOnTouchListener(getOnControlsTouchListener());
-        binding.detailControlsPopup.setOnTouchListener(getOnControlsTouchListener());
+                animate(binding.touchAppendDetail, true, 250, AnimationType.ALPHA, 0, () ->
+                        animate(binding.touchAppendDetail, false, 1500, AnimationType.ALPHA, 1000));
+            }
+            return false;
+        };
+        binding.detailControlsBackground.setOnTouchListener(controlsTouchListener);
+        binding.detailControlsPopup.setOnTouchListener(controlsTouchListener);
 
         binding.appBarLayout.addOnOffsetChangedListener((layout, verticalOffset) -> {
             // prevent useless updates to tab layout visibility if nothing changed
@@ -707,44 +648,6 @@ public final class VideoDetailFragment
         }
     }
 
-    private View.OnTouchListener getOnControlsTouchListener() {
-        return (view, motionEvent) -> {
-            if (!PreferenceManager.getDefaultSharedPreferences(activity)
-                    .getBoolean(getString(R.string.show_hold_to_append_key), true)) {
-                return false;
-            }
-
-            if (motionEvent.getAction() == MotionEvent.ACTION_DOWN) {
-                animate(binding.touchAppendDetail, true, 250, AnimationType.ALPHA,
-                        0, () ->
-                        animate(binding.touchAppendDetail, false, 1500,
-                                AnimationType.ALPHA, 1000));
-            }
-            return false;
-        };
-    }
-
-    private void initThumbnailViews(@NonNull final StreamInfo info) {
-        PicassoHelper.loadDetailsThumbnail(info.getThumbnailUrl()).tag(PICASSO_VIDEO_DETAILS_TAG)
-                .into(binding.detailThumbnailImageView, new Callback() {
-                    @Override
-                    public void onSuccess() {
-                        // nothing to do, the image was loaded correctly into the thumbnail
-                    }
-
-                    @Override
-                    public void onError(final Exception e) {
-                        showSnackBarError(new ErrorInfo(e, UserAction.LOAD_IMAGE,
-                                info.getThumbnailUrl(), info));
-                    }
-                });
-
-        PicassoHelper.loadAvatar(info.getSubChannelAvatarUrl()).tag(PICASSO_VIDEO_DETAILS_TAG)
-                .into(binding.detailSubChannelThumbnailView);
-        PicassoHelper.loadAvatar(info.getUploaderAvatarUrl()).tag(PICASSO_VIDEO_DETAILS_TAG)
-                .into(binding.detailUploaderThumbnailView);
-    }
-
     /*//////////////////////////////////////////////////////////////////////////
     // OwnStack
     //////////////////////////////////////////////////////////////////////////*/
@@ -933,7 +836,8 @@ public final class VideoDetailFragment
                             if (playQueue == null) {
                                 playQueue = new SinglePlayQueue(result);
                             }
-                            if (stack.isEmpty() || !stack.peek().getPlayQueue().equals(playQueue)) {
+                            if (stack.isEmpty() || !stack.peek().getPlayQueue()
+                                    .equalStreams(playQueue)) {
                                 stack.push(new StackItem(serviceId, url, title, playQueue));
                             }
                         }
@@ -1118,26 +1022,15 @@ public final class VideoDetailFragment
             player.setRecovery();
         }
 
-        if (!useExternalAudioPlayer) {
-            openNormalBackgroundPlayer(append);
+        if (useExternalAudioPlayer) {
+            showExternalAudioPlaybackDialog();
         } else {
-            final List<AudioStream> audioStreams = getUrlAndNonTorrentStreams(
-                    currentInfo.getAudioStreams());
-            final int index = ListHelper.getDefaultAudioFormat(activity, audioStreams);
-
-            if (index == -1) {
-                Toast.makeText(activity, R.string.no_audio_streams_available_for_external_players,
-                        Toast.LENGTH_SHORT).show();
-                return;
-            }
-
-            startOnExternalPlayer(activity, currentInfo, audioStreams.get(index));
+            openNormalBackgroundPlayer(append);
         }
     }
 
     private void openPopupPlayer(final boolean append) {
-        if (!PermissionHelper.isPopupEnabled(activity)) {
-            PermissionHelper.showPopupEnablementToast(activity);
+        if (!PermissionHelper.isPopupEnabledElseAsk(activity)) {
             return;
         }
 
@@ -1185,7 +1078,7 @@ public final class VideoDetailFragment
 
         if (PreferenceManager.getDefaultSharedPreferences(activity)
                 .getBoolean(this.getString(R.string.use_external_video_player_key), false)) {
-            showExternalPlaybackDialog();
+            showExternalVideoPlaybackDialog();
         } else {
             replaceQueueIfUserConfirms(this::openMainPlayer);
         }
@@ -1243,16 +1136,15 @@ public final class VideoDetailFragment
      * be reused in a few milliseconds and the flickering would be annoying.
      */
     private void hideMainPlayerOnLoadingNewStream() {
-        //noinspection SimplifyOptionalCallChains
-        if (!isPlayerServiceAvailable() || !getRoot().isPresent()
-                || !player.videoPlayerSelected()) {
+        final var root = getRoot();
+        if (!isPlayerServiceAvailable() || root.isEmpty() || !player.videoPlayerSelected()) {
             return;
         }
 
         removeVideoPlayerView();
         if (isAutoplayEnabled()) {
             playerService.stopForImmediateReusing();
-            getRoot().ifPresent(view -> view.setVisibility(View.GONE));
+            root.ifPresent(view -> view.setVisibility(View.GONE));
         } else {
             playerHolder.stopService();
         }
@@ -1526,8 +1418,8 @@ public final class VideoDetailFragment
 
         animate(binding.detailThumbnailPlayButton, false, 50);
         animate(binding.detailDurationView, false, 100);
-        animate(binding.detailPositionView, false, 100);
-        animate(binding.positionView, false, 50);
+        binding.detailPositionView.setVisibility(View.GONE);
+        binding.positionView.setVisibility(View.GONE);
 
         binding.detailVideoTitleView.setText(title);
         binding.detailVideoTitleView.setMaxLines(1);
@@ -1567,11 +1459,8 @@ public final class VideoDetailFragment
 
         if (!isEmpty(info.getSubChannelName())) {
             displayBothUploaderAndSubChannel(info);
-        } else if (!isEmpty(info.getUploaderName())) {
-            displayUploaderAsSubChannel(info);
         } else {
-            binding.detailUploaderTextView.setVisibility(View.GONE);
-            binding.detailUploaderThumbnailView.setVisibility(View.GONE);
+            displayUploaderAsSubChannel(info);
         }
 
         final Drawable buddyDrawable =
@@ -1644,8 +1533,9 @@ public final class VideoDetailFragment
         binding.detailToggleSecondaryControlsView.setVisibility(View.VISIBLE);
         binding.detailSecondaryControlPanel.setVisibility(View.GONE);
 
-        updateProgressInfo(info);
-        initThumbnailViews(info);
+        checkUpdateProgressInfo(info);
+        PicassoHelper.loadDetailsThumbnail(info.getThumbnailUrl()).tag(PICASSO_VIDEO_DETAILS_TAG)
+                .into(binding.detailThumbnailImageView);
         showMetaInfoInTextView(info.getMetaInfo(), binding.detailMetaInfoTextView,
                 binding.detailMetaInfoSeparator, disposables);
 
@@ -1671,8 +1561,9 @@ public final class VideoDetailFragment
 
         binding.detailControlsDownload.setVisibility(
                 StreamTypeUtil.isLiveStream(info.getStreamType()) ? View.GONE : View.VISIBLE);
-        binding.detailControlsBackground.setVisibility(info.getAudioStreams().isEmpty()
-                ? View.GONE : View.VISIBLE);
+        binding.detailControlsBackground.setVisibility(
+                info.getAudioStreams().isEmpty() && info.getVideoStreams().isEmpty()
+                        ? View.GONE : View.VISIBLE);
 
         final boolean noVideoStreams =
                 info.getVideoStreams().isEmpty() && info.getVideoOnlyStreams().isEmpty();
@@ -1685,7 +1576,19 @@ public final class VideoDetailFragment
         binding.detailSubChannelTextView.setText(info.getUploaderName());
         binding.detailSubChannelTextView.setVisibility(View.VISIBLE);
         binding.detailSubChannelTextView.setSelected(true);
-        binding.detailUploaderTextView.setVisibility(View.GONE);
+
+        if (info.getUploaderSubscriberCount() > -1) {
+            binding.detailUploaderTextView.setText(
+                    Localization.shortSubscriberCount(activity, info.getUploaderSubscriberCount()));
+            binding.detailUploaderTextView.setVisibility(View.VISIBLE);
+        } else {
+            binding.detailUploaderTextView.setVisibility(View.GONE);
+        }
+
+        PicassoHelper.loadAvatar(info.getUploaderAvatarUrl()).tag(PICASSO_VIDEO_DETAILS_TAG)
+                .into(binding.detailSubChannelThumbnailView);
+        binding.detailSubChannelThumbnailView.setVisibility(View.VISIBLE);
+        binding.detailUploaderThumbnailView.setVisibility(View.GONE);
     }
 
     private void displayBothUploaderAndSubChannel(final StreamInfo info) {
@@ -1693,16 +1596,33 @@ public final class VideoDetailFragment
         binding.detailSubChannelTextView.setVisibility(View.VISIBLE);
         binding.detailSubChannelTextView.setSelected(true);
 
-        binding.detailSubChannelThumbnailView.setVisibility(View.VISIBLE);
-
+        final StringBuilder subText = new StringBuilder();
         if (!isEmpty(info.getUploaderName())) {
-            binding.detailUploaderTextView.setText(
+            subText.append(
                     String.format(getString(R.string.video_detail_by), info.getUploaderName()));
+        }
+        if (info.getUploaderSubscriberCount() > -1) {
+            if (subText.length() > 0) {
+                subText.append(Localization.DOT_SEPARATOR);
+            }
+            subText.append(
+                    Localization.shortSubscriberCount(activity, info.getUploaderSubscriberCount()));
+        }
+
+        if (subText.length() > 0) {
+            binding.detailUploaderTextView.setText(subText);
             binding.detailUploaderTextView.setVisibility(View.VISIBLE);
             binding.detailUploaderTextView.setSelected(true);
         } else {
             binding.detailUploaderTextView.setVisibility(View.GONE);
         }
+
+        PicassoHelper.loadAvatar(info.getSubChannelAvatarUrl()).tag(PICASSO_VIDEO_DETAILS_TAG)
+                .into(binding.detailSubChannelThumbnailView);
+        binding.detailSubChannelThumbnailView.setVisibility(View.VISIBLE);
+        PicassoHelper.loadAvatar(info.getUploaderAvatarUrl()).tag(PICASSO_VIDEO_DETAILS_TAG)
+                .into(binding.detailUploaderThumbnailView);
+        binding.detailUploaderThumbnailView.setVisibility(View.VISIBLE);
     }
 
     public void openDownloadDialog() {
@@ -1723,67 +1643,43 @@ public final class VideoDetailFragment
     // Stream Results
     //////////////////////////////////////////////////////////////////////////*/
 
-    private void updateProgressInfo(@NonNull final StreamInfo info) {
+    private void checkUpdateProgressInfo(@NonNull final StreamInfo info) {
         if (positionSubscriber != null) {
             positionSubscriber.dispose();
         }
-        final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(activity);
-        final boolean playbackResumeEnabled = prefs
-                .getBoolean(activity.getString(R.string.enable_watch_history_key), true)
-                && prefs.getBoolean(activity.getString(R.string.enable_playback_resume_key), true);
-        final boolean showPlaybackPosition = prefs.getBoolean(
-                activity.getString(R.string.enable_playback_state_lists_key), true);
-        if (!playbackResumeEnabled) {
-            if (playQueue == null || playQueue.getStreams().isEmpty()
-                    || playQueue.getItem().getRecoveryPosition() == RECOVERY_UNSET
-                    || !showPlaybackPosition) {
-                binding.positionView.setVisibility(View.INVISIBLE);
-                binding.detailPositionView.setVisibility(View.GONE);
-                // TODO: Remove this check when separation of concerns is done.
-                //  (live streams weren't getting updated because they are mixed)
-                if (!StreamTypeUtil.isLiveStream(info.getStreamType())) {
-                    return;
-                }
-            } else {
-                // Show saved position from backStack if user allows it
-                showPlaybackProgress(playQueue.getItem().getRecoveryPosition(),
-                        playQueue.getItem().getDuration() * 1000);
-                animate(binding.positionView, true, 500);
-                animate(binding.detailPositionView, true, 500);
-            }
+        if (!getResumePlaybackEnabled(activity)) {
+            binding.positionView.setVisibility(View.GONE);
+            binding.detailPositionView.setVisibility(View.GONE);
             return;
         }
         final HistoryRecordManager recordManager = new HistoryRecordManager(requireContext());
-
-        // TODO: Separate concerns when updating database data.
-        //  (move the updating part to when the loading happens)
         positionSubscriber = recordManager.loadStreamState(info)
                 .subscribeOn(Schedulers.io())
                 .onErrorComplete()
                 .observeOn(AndroidSchedulers.mainThread())
                 .subscribe(state -> {
-                    showPlaybackProgress(state.getProgressMillis(), info.getDuration() * 1000);
-                    animate(binding.positionView, true, 500);
-                    animate(binding.detailPositionView, true, 500);
+                    updatePlaybackProgress(
+                            state.getProgressMillis(), info.getDuration() * 1000);
                 }, e -> {
-                    if (DEBUG) {
-                        e.printStackTrace();
-                    }
+                    // impossible since the onErrorComplete()
                 }, () -> {
                     binding.positionView.setVisibility(View.GONE);
                     binding.detailPositionView.setVisibility(View.GONE);
                 });
     }
 
-    private void showPlaybackProgress(final long progress, final long duration) {
+    private void updatePlaybackProgress(final long progress, final long duration) {
+        if (!getResumePlaybackEnabled(activity)) {
+            return;
+        }
         final int progressSeconds = (int) TimeUnit.MILLISECONDS.toSeconds(progress);
         final int durationSeconds = (int) TimeUnit.MILLISECONDS.toSeconds(duration);
-        // If the old and the new progress values have a big difference then use
-        // animation. Otherwise don't because it affects CPU
-        final boolean shouldAnimate = Math.abs(binding.positionView.getProgress()
-                - progressSeconds) > 2;
+        // If the old and the new progress values have a big difference then use animation.
+        // Otherwise don't because it affects CPU
+        final int progressDifference = Math.abs(binding.positionView.getProgress()
+                - progressSeconds);
         binding.positionView.setMax(durationSeconds);
-        if (shouldAnimate) {
+        if (progressDifference > 2) {
             binding.positionView.setProgressAnimated(progressSeconds);
         } else {
             binding.positionView.setProgress(progressSeconds);
@@ -1816,12 +1712,20 @@ public final class VideoDetailFragment
                     + title + "], playQueue = [" + playQueue + "]");
         }
 
+        // Register broadcast receiver to listen to playQueue changes
+        // and hide the overlayPlayQueueButton when the playQueue is empty / destroyed.
+        if (playQueue != null && playQueue.getBroadcastReceiver() != null) {
+            playQueue.getBroadcastReceiver().subscribe(
+                    event -> updateOverlayPlayQueueButtonVisibility()
+            );
+        }
+
         // This should be the only place where we push data to stack.
         // It will allow to have live instance of PlayQueue with actual information about
         // deleted/added items inside Channel/Playlist queue and makes possible to have
         // a history of played items
         @Nullable final StackItem stackPeek = stack.peek();
-        if (stackPeek != null && !stackPeek.getPlayQueue().equals(queue)) {
+        if (stackPeek != null && !stackPeek.getPlayQueue().equalStreams(queue)) {
             @Nullable final PlayQueueItem playQueueItem = queue.getItem();
             if (playQueueItem != null) {
                 stack.push(new StackItem(playQueueItem.getServiceId(), playQueueItem.getUrl(),
@@ -1870,7 +1774,7 @@ public final class VideoDetailFragment
         }
 
         if (player.getPlayQueue().getItem().getUrl().equals(url)) {
-            showPlaybackProgress(currentProgress, duration);
+            updatePlaybackProgress(currentProgress, duration);
         }
     }
 
@@ -1887,7 +1791,7 @@ public final class VideoDetailFragment
         // They are not equal when user watches something in popup while browsing in fragment and
         // then changes screen orientation. In that case the fragment will set itself as
         // a service listener and will receive initial call to onMetadataUpdate()
-        if (!queue.equals(playQueue)) {
+        if (!queue.equalStreams(playQueue)) {
             return;
         }
 
@@ -1922,15 +1826,15 @@ public final class VideoDetailFragment
                     currentInfo.getUploaderName(),
                     currentInfo.getThumbnailUrl());
         }
+        updateOverlayPlayQueueButtonVisibility();
     }
 
     @Override
     public void onFullscreenStateChanged(final boolean fullscreen) {
         setupBrightness();
-        //noinspection SimplifyOptionalCallChains
         if (!isPlayerAndPlayerServiceAvailable()
-                || !player.UIs().get(MainPlayerUi.class).isPresent()
-                || getRoot().map(View::getParent).orElse(null) == null) {
+                || player.UIs().get(MainPlayerUi.class).isEmpty()
+                || getRoot().map(View::getParent).isEmpty()) {
             return;
         }
 
@@ -2089,7 +1993,10 @@ public final class VideoDetailFragment
             restoreDefaultBrightness();
         } else {
             // Do not restore if user has disabled brightness gesture
-            if (!PlayerHelper.isBrightnessGestureEnabled(activity)) {
+            if (!PlayerHelper.getActionForRightGestureSide(activity)
+                    .equals(getString(R.string.brightness_control_key))
+                    && !PlayerHelper.getActionForLeftGestureSide(activity)
+                    .equals(getString(R.string.brightness_control_key))) {
                 return;
             }
             // Restore already saved brightness level
@@ -2102,6 +2009,30 @@ public final class VideoDetailFragment
         }
     }
 
+    /**
+     * Make changes to the UI to accommodate for better usability on bigger screens such as TVs
+     * or in Android's desktop mode (DeX etc).
+     */
+    private void accommodateForTvAndDesktopMode() {
+        if (DeviceUtils.isTv(getContext())) {
+            // remove ripple effects from detail controls
+            final int transparent = ContextCompat.getColor(requireContext(),
+                    R.color.transparent_background_color);
+            binding.detailControlsPlaylistAppend.setBackgroundColor(transparent);
+            binding.detailControlsBackground.setBackgroundColor(transparent);
+            binding.detailControlsPopup.setBackgroundColor(transparent);
+            binding.detailControlsDownload.setBackgroundColor(transparent);
+            binding.detailControlsShare.setBackgroundColor(transparent);
+            binding.detailControlsOpenInBrowser.setBackgroundColor(transparent);
+            binding.detailControlsPlayWithKodi.setBackgroundColor(transparent);
+        }
+        if (DeviceUtils.isDesktopMode(getContext())) {
+            // Remove the "hover" overlay (since it is visible on all mouse events and interferes
+            // with the video content being played)
+            binding.detailThumbnailRootLayout.setForeground(null);
+        }
+    }
+
     private void checkLandscape() {
         if ((!player.isPlaying() && player.getPlayQueue() != playQueue)
                 || player.getPlayQueue() == null) {
@@ -2129,7 +2060,7 @@ public final class VideoDetailFragment
         final Iterator<StackItem> iterator = stack.descendingIterator();
         while (iterator.hasNext()) {
             final StackItem next = iterator.next();
-            if (next.getPlayQueue().equals(queue)) {
+            if (next.getPlayQueue().equalStreams(queue)) {
                 item = next;
                 break;
             }
@@ -2144,7 +2075,7 @@ public final class VideoDetailFragment
         if (isClearingQueueConfirmationRequired(activity)
                 && playerIsNotStopped()
                 && activeQueue != null
-                && !activeQueue.equals(playQueue)) {
+                && !activeQueue.equalStreams(playQueue)) {
             showClearingQueueConfirmation(onAllow);
         } else {
             onAllow.run();
@@ -2158,10 +2089,11 @@ public final class VideoDetailFragment
                 .setPositiveButton(R.string.ok, (dialog, which) -> {
                     onAllow.run();
                     dialog.dismiss();
-                }).show();
+                })
+                .show();
     }
 
-    private void showExternalPlaybackDialog() {
+    private void showExternalVideoPlaybackDialog() {
         if (currentInfo == null) {
             return;
         }
@@ -2208,6 +2140,43 @@ public final class VideoDetailFragment
         builder.show();
     }
 
+    private void showExternalAudioPlaybackDialog() {
+        if (currentInfo == null) {
+            return;
+        }
+
+        final List<AudioStream> audioStreams = getUrlAndNonTorrentStreams(
+                currentInfo.getAudioStreams());
+        final List<AudioStream> audioTracks =
+                ListHelper.getFilteredAudioStreams(activity, audioStreams);
+
+        if (audioTracks.isEmpty()) {
+            Toast.makeText(activity, R.string.no_audio_streams_available_for_external_players,
+                    Toast.LENGTH_SHORT).show();
+        } else if (audioTracks.size() == 1) {
+            startOnExternalPlayer(activity, currentInfo, audioTracks.get(0));
+        } else {
+            final int selectedAudioStream =
+                    ListHelper.getDefaultAudioFormat(activity, audioTracks);
+            final CharSequence[] trackNames = audioTracks.stream()
+                    .map(audioStream -> Localization.audioTrackName(activity, audioStream))
+                    .toArray(CharSequence[]::new);
+
+            new AlertDialog.Builder(activity)
+                    .setTitle(R.string.select_audio_track_external_players)
+                    .setNeutralButton(R.string.open_in_browser, (dialog, i) ->
+                            ShareUtils.openUrlInBrowser(requireActivity(), url))
+                    .setSingleChoiceItems(trackNames, selectedAudioStream, null)
+                    .setNegativeButton(R.string.cancel, null)
+                    .setPositiveButton(R.string.ok, (dialog, i) -> {
+                        final int index = ((AlertDialog) dialog).getListView()
+                                .getCheckedItemPosition();
+                        startOnExternalPlayer(activity, currentInfo, audioTracks.get(index));
+                    })
+                    .show();
+        }
+    }
+
     /*
      * Remove unneeded information while waiting for a next task
      * */
@@ -2388,6 +2357,18 @@ public final class VideoDetailFragment
         });
     }
 
+    private void updateOverlayPlayQueueButtonVisibility() {
+        final boolean isPlayQueueEmpty =
+                player == null // no player => no play queue :)
+                        || player.getPlayQueue() == null
+                        || player.getPlayQueue().isEmpty();
+        if (binding != null) {
+            // binding is null when rotating the device...
+            binding.overlayPlayQueueButton.setVisibility(
+                    isPlayQueueEmpty ? View.GONE : View.VISIBLE);
+        }
+    }
+
     private void updateOverlayData(@Nullable final String overlayTitle,
                                    @Nullable final String uploader,
                                    @Nullable final String thumbnailUrl) {
@@ -2426,29 +2407,27 @@ public final class VideoDetailFragment
         binding.overlayMetadataLayout.setClickable(enable);
         binding.overlayMetadataLayout.setLongClickable(enable);
         binding.overlayButtonsLayout.setClickable(enable);
+        binding.overlayPlayQueueButton.setClickable(enable);
         binding.overlayPlayPauseButton.setClickable(enable);
         binding.overlayCloseButton.setClickable(enable);
     }
 
     // helpers to check the state of player and playerService
     boolean isPlayerAvailable() {
-        return (player != null);
+        return player != null;
     }
 
     boolean isPlayerServiceAvailable() {
-        return (playerService != null);
+        return playerService != null;
     }
 
     boolean isPlayerAndPlayerServiceAvailable() {
-        return (player != null && playerService != null);
+        return player != null && playerService != null;
     }
 
     public Optional<View> getRoot() {
-        if (player == null) {
-            return Optional.empty();
-        }
-
-        return player.UIs().get(VideoPlayerUi.class)
+        return Optional.ofNullable(player)
+                .flatMap(player1 -> player1.UIs().get(VideoPlayerUi.class))
                 .map(playerUi -> playerUi.getBinding().getRoot());
     }
 

app/src/main/java/org/schabi/newpipe/fragments/list/BaseListFragment.java

@@ -5,7 +5,6 @@ import static org.schabi.newpipe.ktx.ViewUtils.animateHideRecyclerViewAllowingSc
 
 import android.content.Context;
 import android.content.SharedPreferences;
-import android.content.res.Configuration;
 import android.content.res.Resources;
 import android.os.Bundle;
 import android.util.Log;
@@ -27,10 +26,12 @@ import org.schabi.newpipe.extractor.stream.StreamInfoItem;
 import org.schabi.newpipe.fragments.BaseStateFragment;
 import org.schabi.newpipe.fragments.OnScrollBelowItemsListener;
 import org.schabi.newpipe.info_list.InfoListAdapter;
+import org.schabi.newpipe.info_list.ItemViewMode;
 import org.schabi.newpipe.info_list.dialog.InfoItemDialog;
 import org.schabi.newpipe.util.NavigationHelper;
 import org.schabi.newpipe.util.OnClickGesture;
 import org.schabi.newpipe.util.StateSaver;
+import org.schabi.newpipe.util.ThemeHelper;
 import org.schabi.newpipe.views.SuperScrollLayoutManager;
 
 import java.util.List;
@@ -91,11 +92,7 @@ public abstract class BaseListFragment<I, N> extends BaseStateFragment<I>
 
         if (updateFlags != 0) {
             if ((updateFlags & LIST_MODE_UPDATE_FLAG) != 0) {
-                final boolean useGrid = isGridLayout();
-                itemsList.setLayoutManager(useGrid
-                        ? getGridLayoutManager() : getListLayoutManager());
-                infoListAdapter.setUseGridVariant(useGrid);
-                infoListAdapter.notifyDataSetChanged();
+                refreshItemViewMode();
             }
             updateFlags = 0;
         }
@@ -215,22 +212,29 @@ public abstract class BaseListFragment<I, N> extends BaseStateFragment<I>
         final Resources resources = activity.getResources();
         int width = resources.getDimensionPixelSize(R.dimen.video_item_grid_thumbnail_image_width);
         width += (24 * resources.getDisplayMetrics().density);
-        final int spanCount = (int) Math.floor(resources.getDisplayMetrics().widthPixels
-                / (double) width);
+        final int spanCount = Math.floorDiv(resources.getDisplayMetrics().widthPixels, width);
         final GridLayoutManager lm = new GridLayoutManager(activity, spanCount);
         lm.setSpanSizeLookup(infoListAdapter.getSpanSizeLookup(spanCount));
         return lm;
     }
 
+    /**
+     * Updates the item view mode based on user preference.
+     */
+    private void refreshItemViewMode() {
+        final ItemViewMode itemViewMode = getItemViewMode();
+        itemsList.setLayoutManager((itemViewMode == ItemViewMode.GRID)
+                ? getGridLayoutManager() : getListLayoutManager());
+        infoListAdapter.setItemViewMode(itemViewMode);
+        infoListAdapter.notifyDataSetChanged();
+    }
+
     @Override
     protected void initViews(final View rootView, final Bundle savedInstanceState) {
         super.initViews(rootView, savedInstanceState);
 
-        final boolean useGrid = isGridLayout();
         itemsList = rootView.findViewById(R.id.items_list);
-        itemsList.setLayoutManager(useGrid ? getGridLayoutManager() : getListLayoutManager());
-
-        infoListAdapter.setUseGridVariant(useGrid);
+        refreshItemViewMode();
 
         final Supplier<View> listHeaderSupplier = getListHeaderSupplier();
         if (listHeaderSupplier != null) {
@@ -470,21 +474,16 @@ public abstract class BaseListFragment<I, N> extends BaseStateFragment<I>
     @Override
     public void onSharedPreferenceChanged(final SharedPreferences sharedPreferences,
                                           final String key) {
-        if (key.equals(getString(R.string.list_view_mode_key))) {
+        if (getString(R.string.list_view_mode_key).equals(key)) {
             updateFlags |= LIST_MODE_UPDATE_FLAG;
         }
     }
 
-    protected boolean isGridLayout() {
-        final String listMode = PreferenceManager.getDefaultSharedPreferences(activity)
-                .getString(getString(R.string.list_view_mode_key),
-                        getString(R.string.list_view_mode_value));
-        if ("auto".equals(listMode)) {
-            final Configuration configuration = getResources().getConfiguration();
-            return configuration.orientation == Configuration.ORIENTATION_LANDSCAPE
-                    && configuration.isLayoutSizeAtLeast(Configuration.SCREENLAYOUT_SIZE_LARGE);
-        } else {
-            return "grid".equals(listMode);
-        }
+    /**
+     * Returns preferred item view mode.
+     * @return ItemViewMode
+     */
+    protected ItemViewMode getItemViewMode() {
+        return ThemeHelper.getItemViewMode(requireContext());
     }
 }

app/src/main/java/org/schabi/newpipe/fragments/list/channel/ChannelFragment.java

@@ -204,8 +204,7 @@ public class ChannelFragment extends BaseListInfoFragment<StreamInfoItem, Channe
                 break;
             case R.id.menu_item_rss:
                 if (currentInfo != null) {
-                    ShareUtils.openUrlInBrowser(
-                            requireContext(), currentInfo.getFeedUrl(), false);
+                    ShareUtils.openUrlInApp(requireContext(), currentInfo.getFeedUrl());
                 }
                 break;
             case R.id.menu_item_openInBrowser:

app/src/main/java/org/schabi/newpipe/fragments/list/comments/CommentsFragment.java

@@ -17,6 +17,7 @@ import org.schabi.newpipe.extractor.ListExtractor;
 import org.schabi.newpipe.extractor.comments.CommentsInfo;
 import org.schabi.newpipe.extractor.comments.CommentsInfoItem;
 import org.schabi.newpipe.fragments.list.BaseListInfoFragment;
+import org.schabi.newpipe.info_list.ItemViewMode;
 import org.schabi.newpipe.ktx.ViewUtils;
 import org.schabi.newpipe.util.ExtractorHelper;
 
@@ -106,7 +107,7 @@ public class CommentsFragment extends BaseListInfoFragment<CommentsInfoItem, Com
                                     @NonNull final MenuInflater inflater) { }
 
     @Override
-    protected boolean isGridLayout() {
-        return false;
+    protected ItemViewMode getItemViewMode() {
+        return ItemViewMode.LIST;
     }
 }

app/src/main/java/org/schabi/newpipe/fragments/list/playlist/PlaylistFragment.java

@@ -132,6 +132,8 @@ public class PlaylistFragment extends BaseListInfoFragment<StreamInfoItem, Playl
     protected void initViews(final View rootView, final Bundle savedInstanceState) {
         super.initViews(rootView, savedInstanceState);
 
+        // Is mini variant still relevant?
+        // Only the remote playlist screen uses it now
         infoListAdapter.setUseMiniVariant(true);
     }
 
@@ -230,24 +232,24 @@ public class PlaylistFragment extends BaseListInfoFragment<StreamInfoItem, Playl
                 ShareUtils.openUrlInBrowser(requireContext(), url);
                 break;
             case R.id.menu_item_share:
-                if (currentInfo != null) {
-                    ShareUtils.shareText(requireContext(), name, url,
-                            currentInfo.getThumbnailUrl());
-                }
+                ShareUtils.shareText(requireContext(), name, url,
+                        currentInfo == null ? null : currentInfo.getThumbnailUrl());
                 break;
             case R.id.menu_item_bookmark:
                 onBookmarkClicked();
                 break;
             case R.id.menu_item_append_playlist:
-                disposables.add(PlaylistDialog.createCorrespondingDialog(
-                        getContext(),
-                        getPlayQueue()
-                                .getStreams()
-                                .stream()
-                                .map(StreamEntity::new)
-                                .collect(Collectors.toList()),
-                        dialog -> dialog.show(getFM(), TAG)
-                ));
+                if (currentInfo != null) {
+                    disposables.add(PlaylistDialog.createCorrespondingDialog(
+                            getContext(),
+                            getPlayQueue()
+                                    .getStreams()
+                                    .stream()
+                                    .map(StreamEntity::new)
+                                    .collect(Collectors.toList()),
+                            dialog -> dialog.show(getFM(), TAG)
+                    ));
+                }
                 break;
             default:
                 return super.onOptionsItemSelected(item);

app/src/main/java/org/schabi/newpipe/fragments/list/search/SearchFragment.java

@@ -33,6 +33,7 @@ import androidx.annotation.Nullable;
 import androidx.appcompat.app.ActionBar;
 import androidx.appcompat.app.AlertDialog;
 import androidx.appcompat.widget.TooltipCompat;
+import androidx.collection.SparseArrayCompat;
 import androidx.core.text.HtmlCompat;
 import androidx.preference.PreferenceManager;
 import androidx.recyclerview.widget.ItemTouchHelper;
@@ -70,9 +71,7 @@ import org.schabi.newpipe.util.ServiceHelper;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.Queue;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
@@ -141,7 +140,7 @@ public class SearchFragment extends BaseListFragment<SearchInfo, ListExtractor.I
     @State
     boolean wasSearchFocused = false;
 
-    @Nullable private Map<Integer, String> menuItemToFilterName = null;
+    private final SparseArrayCompat<String> menuItemToFilterName = new SparseArrayCompat<>();
     private StreamingService service;
     private Page nextPage;
     private boolean showLocalSuggestions = true;
@@ -426,8 +425,6 @@ public class SearchFragment extends BaseListFragment<SearchInfo, ListExtractor.I
             supportActionBar.setDisplayHomeAsUpEnabled(true);
         }
 
-        menuItemToFilterName = new HashMap<>();
-
         int itemId = 0;
         boolean isFirstItem = true;
         final Context c = getContext();
@@ -468,11 +465,8 @@ public class SearchFragment extends BaseListFragment<SearchInfo, ListExtractor.I
 
     @Override
     public boolean onOptionsItemSelected(@NonNull final MenuItem item) {
-        if (menuItemToFilterName != null) {
-            final List<String> cf = new ArrayList<>(1);
-            cf.add(menuItemToFilterName.get(item.getItemId()));
-            changeContentFilter(item, cf);
-        }
+        final var filter = Collections.singletonList(menuItemToFilterName.get(item.getItemId()));
+        changeContentFilter(item, filter);
         return true;
     }
 

app/src/main/java/org/schabi/newpipe/fragments/list/videos/RelatedItemsFragment.java

@@ -19,6 +19,7 @@ import org.schabi.newpipe.extractor.InfoItem;
 import org.schabi.newpipe.extractor.ListExtractor;
 import org.schabi.newpipe.extractor.stream.StreamInfo;
 import org.schabi.newpipe.fragments.list.BaseListInfoFragment;
+import org.schabi.newpipe.info_list.ItemViewMode;
 import org.schabi.newpipe.ktx.ViewUtils;
 import org.schabi.newpipe.util.RelatedItemInfo;
 
@@ -158,16 +159,19 @@ public class RelatedItemsFragment extends BaseListInfoFragment<InfoItem, Related
 
     @Override
     public void onSharedPreferenceChanged(final SharedPreferences sharedPreferences,
-                                          final String s) {
-        if (headerBinding != null) {
-            headerBinding.autoplaySwitch.setChecked(
-                    sharedPreferences.getBoolean(
-                            getString(R.string.auto_queue_key), false));
+                                          final String key) {
+        if (headerBinding != null && getString(R.string.auto_queue_key).equals(key)) {
+            headerBinding.autoplaySwitch.setChecked(sharedPreferences.getBoolean(key, false));
         }
     }
 
     @Override
-    protected boolean isGridLayout() {
-        return false;
+    protected ItemViewMode getItemViewMode() {
+        ItemViewMode mode = super.getItemViewMode();
+        // Only list mode is supported. Either List or card will be used.
+        if (mode != ItemViewMode.LIST && mode != ItemViewMode.CARD) {
+            mode = ItemViewMode.LIST;
+        }
+        return mode;
     }
 }

app/src/main/java/org/schabi/newpipe/info_list/InfoListAdapter.java

@@ -17,15 +17,18 @@ import org.schabi.newpipe.extractor.channel.ChannelInfoItem;
 import org.schabi.newpipe.extractor.comments.CommentsInfoItem;
 import org.schabi.newpipe.extractor.playlist.PlaylistInfoItem;
 import org.schabi.newpipe.extractor.stream.StreamInfoItem;
+import org.schabi.newpipe.info_list.holder.ChannelCardInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.ChannelGridInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.ChannelInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.ChannelMiniInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.CommentsInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.CommentsMiniInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.InfoItemHolder;
+import org.schabi.newpipe.info_list.holder.PlaylistCardInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.PlaylistGridInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.PlaylistInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.PlaylistMiniInfoItemHolder;
+import org.schabi.newpipe.info_list.holder.StreamCardInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.StreamGridInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.StreamInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.StreamMiniInfoItemHolder;
@@ -67,12 +70,15 @@ public class InfoListAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
     private static final int MINI_STREAM_HOLDER_TYPE = 0x100;
     private static final int STREAM_HOLDER_TYPE = 0x101;
     private static final int GRID_STREAM_HOLDER_TYPE = 0x102;
+    private static final int CARD_STREAM_HOLDER_TYPE = 0x103;
     private static final int MINI_CHANNEL_HOLDER_TYPE = 0x200;
     private static final int CHANNEL_HOLDER_TYPE = 0x201;
     private static final int GRID_CHANNEL_HOLDER_TYPE = 0x202;
+    private static final int CARD_CHANNEL_HOLDER_TYPE = 0x203;
     private static final int MINI_PLAYLIST_HOLDER_TYPE = 0x300;
     private static final int PLAYLIST_HOLDER_TYPE = 0x301;
     private static final int GRID_PLAYLIST_HOLDER_TYPE = 0x302;
+    private static final int CARD_PLAYLIST_HOLDER_TYPE = 0x303;
     private static final int MINI_COMMENT_HOLDER_TYPE = 0x400;
     private static final int COMMENT_HOLDER_TYPE = 0x401;
 
@@ -82,9 +88,10 @@ public class InfoListAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
     private final HistoryRecordManager recordManager;
 
     private boolean useMiniVariant = false;
-    private boolean useGridVariant = false;
     private boolean showFooter = false;
 
+    private ItemViewMode itemMode = ItemViewMode.LIST;
+
     private Supplier<View> headerSupplier = null;
 
     public InfoListAdapter(final Context context) {
@@ -114,8 +121,8 @@ public class InfoListAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
         this.useMiniVariant = useMiniVariant;
     }
 
-    public void setUseGridVariant(final boolean useGridVariant) {
-        this.useGridVariant = useGridVariant;
+    public void setItemViewMode(final ItemViewMode itemViewMode) {
+        this.itemMode = itemViewMode;
     }
 
     public void addInfoItemList(@Nullable final List<? extends InfoItem> data) {
@@ -234,14 +241,35 @@ public class InfoListAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
         final InfoItem item = infoItemList.get(position);
         switch (item.getInfoType()) {
             case STREAM:
-                return useGridVariant ? GRID_STREAM_HOLDER_TYPE : useMiniVariant
-                        ? MINI_STREAM_HOLDER_TYPE : STREAM_HOLDER_TYPE;
+                if (itemMode == ItemViewMode.CARD) {
+                    return CARD_STREAM_HOLDER_TYPE;
+                } else if (itemMode == ItemViewMode.GRID) {
+                    return GRID_STREAM_HOLDER_TYPE;
+                } else if (useMiniVariant) {
+                    return MINI_STREAM_HOLDER_TYPE;
+                } else {
+                    return STREAM_HOLDER_TYPE;
+                }
             case CHANNEL:
-                return useGridVariant ? GRID_CHANNEL_HOLDER_TYPE : useMiniVariant
-                        ? MINI_CHANNEL_HOLDER_TYPE : CHANNEL_HOLDER_TYPE;
+                if (itemMode == ItemViewMode.CARD) {
+                    return CARD_CHANNEL_HOLDER_TYPE;
+                } else if (itemMode == ItemViewMode.GRID) {
+                    return GRID_CHANNEL_HOLDER_TYPE;
+                } else if (useMiniVariant) {
+                    return MINI_CHANNEL_HOLDER_TYPE;
+                } else {
+                    return CHANNEL_HOLDER_TYPE;
+                }
             case PLAYLIST:
-                return useGridVariant ? GRID_PLAYLIST_HOLDER_TYPE : useMiniVariant
-                        ? MINI_PLAYLIST_HOLDER_TYPE : PLAYLIST_HOLDER_TYPE;
+                if (itemMode == ItemViewMode.CARD) {
+                    return CARD_PLAYLIST_HOLDER_TYPE;
+                } else if (itemMode == ItemViewMode.GRID) {
+                    return GRID_PLAYLIST_HOLDER_TYPE;
+                } else if (useMiniVariant) {
+                    return MINI_PLAYLIST_HOLDER_TYPE;
+                } else {
+                    return PLAYLIST_HOLDER_TYPE;
+                }
             case COMMENT:
                 return useMiniVariant ? MINI_COMMENT_HOLDER_TYPE : COMMENT_HOLDER_TYPE;
             default:
@@ -274,10 +302,14 @@ public class InfoListAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
                 return new StreamInfoItemHolder(infoItemBuilder, parent);
             case GRID_STREAM_HOLDER_TYPE:
                 return new StreamGridInfoItemHolder(infoItemBuilder, parent);
+            case CARD_STREAM_HOLDER_TYPE:
+                return new StreamCardInfoItemHolder(infoItemBuilder, parent);
             case MINI_CHANNEL_HOLDER_TYPE:
                 return new ChannelMiniInfoItemHolder(infoItemBuilder, parent);
             case CHANNEL_HOLDER_TYPE:
                 return new ChannelInfoItemHolder(infoItemBuilder, parent);
+            case CARD_CHANNEL_HOLDER_TYPE:
+                return new ChannelCardInfoItemHolder(infoItemBuilder, parent);
             case GRID_CHANNEL_HOLDER_TYPE:
                 return new ChannelGridInfoItemHolder(infoItemBuilder, parent);
             case MINI_PLAYLIST_HOLDER_TYPE:
@@ -286,6 +318,8 @@ public class InfoListAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
                 return new PlaylistInfoItemHolder(infoItemBuilder, parent);
             case GRID_PLAYLIST_HOLDER_TYPE:
                 return new PlaylistGridInfoItemHolder(infoItemBuilder, parent);
+            case CARD_PLAYLIST_HOLDER_TYPE:
+                return new PlaylistCardInfoItemHolder(infoItemBuilder, parent);
             case MINI_COMMENT_HOLDER_TYPE:
                 return new CommentsMiniInfoItemHolder(infoItemBuilder, parent);
             case COMMENT_HOLDER_TYPE:

app/src/main/java/org/schabi/newpipe/info_list/ItemViewMode.java

@@ -0,0 +1,23 @@
+package org.schabi.newpipe.info_list;
+
+/**
+ * Item view mode for streams & playlist listing screens.
+ */
+public enum ItemViewMode {
+    /**
+     * Default mode.
+     */
+    AUTO,
+    /**
+     * Full width list item with thumb on the left and two line title & uploader in right.
+     */
+    LIST,
+    /**
+     * Grid mode places two cards per row.
+     */
+    GRID,
+    /**
+     * A full width card in phone - portrait.
+     */
+    CARD
+}

app/src/main/java/org/schabi/newpipe/info_list/StreamSegmentAdapter.kt

@@ -61,5 +61,6 @@ class StreamSegmentAdapter(
 
     interface StreamSegmentListener {
         fun onItemClick(item: StreamSegmentItem, seconds: Int)
+        fun onItemLongClick(item: StreamSegmentItem, seconds: Int)
     }
 }

app/src/main/java/org/schabi/newpipe/info_list/StreamSegmentItem.kt

@@ -41,6 +41,7 @@ class StreamSegmentItem(
         viewHolder.root.findViewById<TextView>(R.id.textViewStartSeconds).text =
             Localization.getDurationString(item.startTimeSeconds.toLong())
         viewHolder.root.setOnClickListener { onClick.onItemClick(this, item.startTimeSeconds) }
+        viewHolder.root.setOnLongClickListener { onClick.onItemLongClick(this, item.startTimeSeconds); true }
         viewHolder.root.isSelected = isSelected
     }
 

app/src/main/java/org/schabi/newpipe/info_list/dialog/InfoItemDialog.java

@@ -252,10 +252,11 @@ public final class InfoItemDialog {
          * @return the current {@link Builder} instance
          */
         public Builder addEnqueueEntriesIfNeeded() {
-            if (PlayerHolder.getInstance().isPlayQueueReady()) {
+            final PlayerHolder holder = PlayerHolder.getInstance();
+            if (holder.isPlayQueueReady()) {
                 addEntry(StreamDialogDefaultEntry.ENQUEUE);
 
-                if (PlayerHolder.getInstance().getQueueSize() > 1) {
+                if (holder.getQueuePosition() < holder.getQueueSize() - 1) {
                     addEntry(StreamDialogDefaultEntry.ENQUEUE_NEXT);
                 }
             }

app/src/main/java/org/schabi/newpipe/info_list/dialog/StreamDialogDefaultEntry.java

@@ -99,25 +99,26 @@ public enum StreamDialogDefaultEntry {
         )
     ),
 
-    PLAY_WITH_KODI(R.string.play_with_kodi_title, (fragment, item) -> {
-        final Uri videoUrl = Uri.parse(item.getUrl());
-        try {
-            NavigationHelper.playWithKore(fragment.requireContext(), videoUrl);
-        } catch (final Exception e) {
-            KoreUtils.showInstallKoreDialog(fragment.requireActivity());
-        }
-    }),
+    PLAY_WITH_KODI(R.string.play_with_kodi_title, (fragment, item) ->
+            KoreUtils.playWithKore(fragment.requireContext(), Uri.parse(item.getUrl()))),
 
     SHARE(R.string.share, (fragment, item) ->
             ShareUtils.shareText(fragment.requireContext(), item.getName(), item.getUrl(),
                     item.getThumbnailUrl())),
 
+    /**
+     * Opens a {@link DownloadDialog} after fetching some stream info.
+     * If the user quits the current fragment, it will not open a DownloadDialog.
+     */
     DOWNLOAD(R.string.download, (fragment, item) ->
             fetchStreamInfoAndSaveToDatabase(fragment.requireContext(), item.getServiceId(),
                     item.getUrl(), info -> {
-                        final DownloadDialog downloadDialog =
-                                new DownloadDialog(fragment.requireContext(), info);
-                        downloadDialog.show(fragment.getChildFragmentManager(), "downloadDialog");
+                        if (fragment.getContext() != null) {
+                            final DownloadDialog downloadDialog =
+                                    new DownloadDialog(fragment.requireContext(), info);
+                            downloadDialog.show(fragment.getChildFragmentManager(),
+                                    "downloadDialog");
+                        }
                     })
     ),
 

app/src/main/java/org/schabi/newpipe/info_list/holder/ChannelCardInfoItemHolder.java

@@ -0,0 +1,22 @@
+package org.schabi.newpipe.info_list.holder;
+
+import android.view.ViewGroup;
+
+import androidx.annotation.Nullable;
+
+import org.schabi.newpipe.R;
+import org.schabi.newpipe.info_list.InfoItemBuilder;
+
+public class ChannelCardInfoItemHolder extends ChannelMiniInfoItemHolder {
+    public ChannelCardInfoItemHolder(final InfoItemBuilder infoItemBuilder,
+                                     final ViewGroup parent) {
+        super(infoItemBuilder, R.layout.list_channel_card_item, parent);
+    }
+
+    @Override
+    protected int getDescriptionMaxLineCount(@Nullable final String content) {
+        // Based on `list_channel_card_item` left side content (thumbnail 100dp
+        // + additional details), Right side description can grow up to 8 lines.
+        return 8;
+    }
+}

app/src/main/java/org/schabi/newpipe/info_list/holder/ChannelInfoItemHolder.java

@@ -1,14 +1,9 @@
 package org.schabi.newpipe.info_list.holder;
 
 import android.view.ViewGroup;
-import android.widget.TextView;
 
 import org.schabi.newpipe.R;
-import org.schabi.newpipe.extractor.InfoItem;
-import org.schabi.newpipe.extractor.channel.ChannelInfoItem;
 import org.schabi.newpipe.info_list.InfoItemBuilder;
-import org.schabi.newpipe.local.history.HistoryRecordManager;
-import org.schabi.newpipe.util.Localization;
 
 /*
  * Created by Christian Schabesberger on 12.02.17.
@@ -31,40 +26,7 @@ import org.schabi.newpipe.util.Localization;
  */
 
 public class ChannelInfoItemHolder extends ChannelMiniInfoItemHolder {
-    private final TextView itemChannelDescriptionView;
-
     public ChannelInfoItemHolder(final InfoItemBuilder infoItemBuilder, final ViewGroup parent) {
         super(infoItemBuilder, R.layout.list_channel_item, parent);
-        itemChannelDescriptionView = itemView.findViewById(R.id.itemChannelDescriptionView);
-    }
-
-    @Override
-    public void updateFromItem(final InfoItem infoItem,
-                               final HistoryRecordManager historyRecordManager) {
-        super.updateFromItem(infoItem, historyRecordManager);
-
-        if (!(infoItem instanceof ChannelInfoItem)) {
-            return;
-        }
-        final ChannelInfoItem item = (ChannelInfoItem) infoItem;
-
-        itemChannelDescriptionView.setText(item.getDescription());
-    }
-
-    @Override
-    protected String getDetailLine(final ChannelInfoItem item) {
-        String details = super.getDetailLine(item);
-
-        if (item.getStreamCount() >= 0) {
-            final String formattedVideoAmount = Localization.localizeStreamCount(
-                    itemBuilder.getContext(), item.getStreamCount());
-
-            if (!details.isEmpty()) {
-                details += " • " + formattedVideoAmount;
-            } else {
-                details = formattedVideoAmount;
-            }
-        }
-        return details;
     }
 }

app/src/main/java/org/schabi/newpipe/info_list/holder/ChannelMiniInfoItemHolder.java

@@ -1,21 +1,26 @@
 package org.schabi.newpipe.info_list.holder;
 
+import android.view.View;
 import android.view.ViewGroup;
 import android.widget.ImageView;
 import android.widget.TextView;
 
+import androidx.annotation.Nullable;
+
 import org.schabi.newpipe.R;
 import org.schabi.newpipe.extractor.InfoItem;
 import org.schabi.newpipe.extractor.channel.ChannelInfoItem;
+import org.schabi.newpipe.extractor.utils.Utils;
 import org.schabi.newpipe.info_list.InfoItemBuilder;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
 import org.schabi.newpipe.util.PicassoHelper;
 import org.schabi.newpipe.util.Localization;
 
 public class ChannelMiniInfoItemHolder extends InfoItemHolder {
-    public final ImageView itemThumbnailView;
-    public final TextView itemTitleView;
+    private final ImageView itemThumbnailView;
+    private final TextView itemTitleView;
     private final TextView itemAdditionalDetailView;
+    private final TextView itemChannelDescriptionView;
 
     ChannelMiniInfoItemHolder(final InfoItemBuilder infoItemBuilder, final int layoutId,
                               final ViewGroup parent) {
@@ -24,6 +29,7 @@ public class ChannelMiniInfoItemHolder extends InfoItemHolder {
         itemThumbnailView = itemView.findViewById(R.id.itemThumbnailView);
         itemTitleView = itemView.findViewById(R.id.itemTitleView);
         itemAdditionalDetailView = itemView.findViewById(R.id.itemAdditionalDetails);
+        itemChannelDescriptionView = itemView.findViewById(R.id.itemChannelDescriptionView);
     }
 
     public ChannelMiniInfoItemHolder(final InfoItemBuilder infoItemBuilder,
@@ -40,7 +46,15 @@ public class ChannelMiniInfoItemHolder extends InfoItemHolder {
         final ChannelInfoItem item = (ChannelInfoItem) infoItem;
 
         itemTitleView.setText(item.getName());
-        itemAdditionalDetailView.setText(getDetailLine(item));
+        itemTitleView.setSelected(true);
+
+        final String detailLine = getDetailLine(item);
+        if (detailLine == null) {
+            itemAdditionalDetailView.setVisibility(View.GONE);
+        } else {
+            itemAdditionalDetailView.setVisibility(View.VISIBLE);
+            itemAdditionalDetailView.setText(getDetailLine(item));
+        }
 
         PicassoHelper.loadAvatar(item.getThumbnailUrl()).into(itemThumbnailView);
 
@@ -56,14 +70,48 @@ public class ChannelMiniInfoItemHolder extends InfoItemHolder {
             }
             return true;
         });
+
+        if (itemChannelDescriptionView != null) {
+            // itemChannelDescriptionView will be null in the mini variant
+            if (Utils.isBlank(item.getDescription())) {
+                itemChannelDescriptionView.setVisibility(View.GONE);
+            } else {
+                itemChannelDescriptionView.setVisibility(View.VISIBLE);
+                itemChannelDescriptionView.setText(item.getDescription());
+                // setMaxLines utilize the line space for description if the additional details
+                // (sub / video count) are not present.
+                // Case1: 2 lines of description + 1 line additional details
+                // Case2: 3 lines of description (additionalDetails is GONE)
+                itemChannelDescriptionView.setMaxLines(getDescriptionMaxLineCount(detailLine));
+            }
+        }
     }
 
-    protected String getDetailLine(final ChannelInfoItem item) {
-        String details = "";
-        if (item.getSubscriberCount() >= 0) {
-            details += Localization.shortSubscriberCount(itemBuilder.getContext(),
+    /**
+     * Returns max number of allowed lines for the description field.
+     * @param content additional detail content (video / sub count)
+     * @return max line count
+     */
+    protected int getDescriptionMaxLineCount(@Nullable final String content) {
+        return content == null ? 3 : 2;
+    }
+
+    @Nullable
+    private String getDetailLine(final ChannelInfoItem item) {
+        if (item.getStreamCount() >= 0 && item.getSubscriberCount() >= 0) {
+            return Localization.concatenateStrings(
+                    Localization.shortSubscriberCount(itemBuilder.getContext(),
+                            item.getSubscriberCount()),
+                    Localization.localizeStreamCount(itemBuilder.getContext(),
+                            item.getStreamCount()));
+        } else if (item.getStreamCount() >= 0) {
+            return Localization.localizeStreamCount(itemBuilder.getContext(),
+                    item.getStreamCount());
+        } else if (item.getSubscriberCount() >= 0) {
+            return Localization.shortSubscriberCount(itemBuilder.getContext(),
                     item.getSubscriberCount());
+        } else {
+            return null;
         }
-        return details;
     }
 }

app/src/main/java/org/schabi/newpipe/info_list/holder/CommentsMiniInfoItemHolder.java

@@ -1,9 +1,11 @@
 package org.schabi.newpipe.info_list.holder;
 
-import android.text.TextUtils;
+import static android.text.TextUtils.isEmpty;
+
+import android.graphics.Paint;
+import android.text.Layout;
 import android.text.method.LinkMovementMethod;
 import android.text.style.URLSpan;
-import android.text.util.Linkify;
 import android.util.Log;
 import android.view.View;
 import android.view.ViewGroup;
@@ -11,26 +13,36 @@ import android.widget.ImageView;
 import android.widget.RelativeLayout;
 import android.widget.TextView;
 
+import androidx.annotation.Nullable;
 import androidx.appcompat.app.AppCompatActivity;
+import androidx.core.text.HtmlCompat;
 
 import org.schabi.newpipe.R;
 import org.schabi.newpipe.error.ErrorUtil;
 import org.schabi.newpipe.extractor.InfoItem;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.ServiceList;
+import org.schabi.newpipe.extractor.StreamingService;
 import org.schabi.newpipe.extractor.comments.CommentsInfoItem;
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+import org.schabi.newpipe.extractor.stream.Description;
 import org.schabi.newpipe.info_list.InfoItemBuilder;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
-import org.schabi.newpipe.util.CommentTextOnTouchListener;
 import org.schabi.newpipe.util.DeviceUtils;
 import org.schabi.newpipe.util.Localization;
 import org.schabi.newpipe.util.NavigationHelper;
 import org.schabi.newpipe.util.PicassoHelper;
 import org.schabi.newpipe.util.external_communication.ShareUtils;
-import org.schabi.newpipe.util.external_communication.TimestampExtractor;
+import org.schabi.newpipe.util.text.CommentTextOnTouchListener;
+import org.schabi.newpipe.util.text.TextLinkifier;
 
-import java.util.regex.Matcher;
+import java.util.function.Consumer;
+
+import io.reactivex.rxjava3.disposables.CompositeDisposable;
 
 public class CommentsMiniInfoItemHolder extends InfoItemHolder {
     private static final String TAG = "CommentsMiniIIHolder";
+    private static final String ELLIPSIS = "…";
 
     private static final int COMMENT_DEFAULT_LINES = 2;
     private static final int COMMENT_EXPANDED_LINES = 1000;
@@ -38,35 +50,19 @@ public class CommentsMiniInfoItemHolder extends InfoItemHolder {
     private final int commentHorizontalPadding;
     private final int commentVerticalPadding;
 
+    private final Paint paintAtContentSize;
+    private final float ellipsisWidthPx;
+
     private final RelativeLayout itemRoot;
-    public final ImageView itemThumbnailView;
+    private final ImageView itemThumbnailView;
     private final TextView itemContentView;
     private final TextView itemLikesCountView;
     private final TextView itemPublishedTime;
 
-    private String commentText;
-    private String streamUrl;
-
-    private final Linkify.TransformFilter timestampLink = new Linkify.TransformFilter() {
-        @Override
-        public String transformUrl(final Matcher match, final String url) {
-            try {
-                final TimestampExtractor.TimestampMatchDTO timestampMatchDTO =
-                        TimestampExtractor.getTimestampFromMatcher(match, commentText);
-
-                if (timestampMatchDTO == null) {
-                    return url;
-                }
-
-                return streamUrl + url.replace(
-                        match.group(0),
-                        "#timestamp=" + timestampMatchDTO.seconds());
-            } catch (final Exception ex) {
-                Log.e(TAG, "Unable to process url='" + url + "' as timestampLink", ex);
-                return url;
-            }
-        }
-    };
+    private final CompositeDisposable disposables = new CompositeDisposable();
+    @Nullable private Description commentText;
+    @Nullable private StreamingService streamService;
+    @Nullable private String streamUrl;
 
     CommentsMiniInfoItemHolder(final InfoItemBuilder infoItemBuilder, final int layoutId,
                                final ViewGroup parent) {
@@ -82,6 +78,10 @@ public class CommentsMiniInfoItemHolder extends InfoItemHolder {
                 .getResources().getDimension(R.dimen.comments_horizontal_padding);
         commentVerticalPadding = (int) infoItemBuilder.getContext()
                 .getResources().getDimension(R.dimen.comments_vertical_padding);
+
+        paintAtContentSize = new Paint();
+        paintAtContentSize.setTextSize(itemContentView.getTextSize());
+        ellipsisWidthPx = paintAtContentSize.measureText(ELLIPSIS);
     }
 
     public CommentsMiniInfoItemHolder(final InfoItemBuilder infoItemBuilder,
@@ -111,18 +111,20 @@ public class CommentsMiniInfoItemHolder extends InfoItemHolder {
 
         itemThumbnailView.setOnClickListener(view -> openCommentAuthor(item));
 
-        streamUrl = item.getUrl();
-
-        itemContentView.setLines(COMMENT_DEFAULT_LINES);
-        commentText = item.getCommentText();
-        itemContentView.setText(commentText);
-        itemContentView.setOnTouchListener(CommentTextOnTouchListener.INSTANCE);
-
-        if (itemContentView.getLineCount() == 0) {
-            itemContentView.post(this::ellipsize);
-        } else {
-            ellipsize();
+        try {
+            streamService = NewPipe.getService(item.getServiceId());
+        } catch (final ExtractionException e) {
+            // should never happen
+            ErrorUtil.showUiErrorSnackbar(itemBuilder.getContext(), "Getting StreamingService", e);
+            Log.w(TAG, "Cannot obtain service from comment service id, defaulting to YouTube", e);
+            streamService = ServiceList.YouTube;
         }
+        streamUrl = item.getUrl();
+        commentText = item.getCommentText();
+        ellipsize();
+
+        //noinspection ClickableViewAccessibility
+        itemContentView.setOnTouchListener(CommentTextOnTouchListener.INSTANCE);
 
         if (item.getLikeCount() >= 0) {
             itemLikesCountView.setText(
@@ -152,14 +154,17 @@ public class CommentsMiniInfoItemHolder extends InfoItemHolder {
             if (DeviceUtils.isTv(itemBuilder.getContext())) {
                 openCommentAuthor(item);
             } else {
-                ShareUtils.copyToClipboard(itemBuilder.getContext(), commentText);
+                final CharSequence text = itemContentView.getText();
+                if (text != null) {
+                    ShareUtils.copyToClipboard(itemBuilder.getContext(), text.toString());
+                }
             }
             return true;
         });
     }
 
     private void openCommentAuthor(final CommentsInfoItem item) {
-        if (TextUtils.isEmpty(item.getUploaderUrl())) {
+        if (isEmpty(item.getUploaderUrl())) {
             return;
         }
         final AppCompatActivity activity = (AppCompatActivity) itemBuilder.getContext();
@@ -192,7 +197,7 @@ public class CommentsMiniInfoItemHolder extends InfoItemHolder {
         return urls != null && urls.length != 0;
     }
 
-    private void determineLinkFocus() {
+    private void determineMovementMethod() {
         if (shouldFocusLinks()) {
             allowLinkFocus();
         } else {
@@ -201,56 +206,74 @@ public class CommentsMiniInfoItemHolder extends InfoItemHolder {
     }
 
     private void ellipsize() {
-        boolean hasEllipsis = false;
+        itemContentView.setMaxLines(COMMENT_EXPANDED_LINES);
+        linkifyCommentContentView(v -> {
+            boolean hasEllipsis = false;
 
-        if (itemContentView.getLineCount() > COMMENT_DEFAULT_LINES) {
-            final int endOfLastLine = itemContentView
-                    .getLayout()
-                    .getLineEnd(COMMENT_DEFAULT_LINES - 1);
-            int end = itemContentView.getText().toString().lastIndexOf(' ', endOfLastLine - 2);
-            if (end == -1) {
-                end = Math.max(endOfLastLine - 2, 0);
+            final CharSequence charSeqText = itemContentView.getText();
+            if (charSeqText != null && itemContentView.getLineCount() > COMMENT_DEFAULT_LINES) {
+                // Note that converting to String removes spans (i.e. links), but that's something
+                // we actually want since when the text is ellipsized we want all clicks on the
+                // comment to expand the comment, not to open links.
+                final String text = charSeqText.toString();
+
+                final Layout layout = itemContentView.getLayout();
+                final float lineWidth = layout.getLineWidth(COMMENT_DEFAULT_LINES - 1);
+                final float layoutWidth = layout.getWidth();
+                final int lineStart = layout.getLineStart(COMMENT_DEFAULT_LINES - 1);
+                final int lineEnd = layout.getLineEnd(COMMENT_DEFAULT_LINES - 1);
+
+                // remove characters up until there is enough space for the ellipsis
+                // (also summing 2 more pixels, just to be sure to avoid float rounding errors)
+                int end = lineEnd;
+                float removedCharactersWidth = 0.0f;
+                while (lineWidth - removedCharactersWidth + ellipsisWidthPx + 2.0f > layoutWidth
+                        && end >= lineStart) {
+                    end -= 1;
+                    // recalculate each time to account for ligatures or other similar things
+                    removedCharactersWidth = paintAtContentSize.measureText(
+                            text.substring(end, lineEnd));
+                }
+
+                // remove trailing spaces and newlines
+                while (end > 0 && Character.isWhitespace(text.charAt(end - 1))) {
+                    end -= 1;
+                }
+
+                final String newVal = text.substring(0, end) + ELLIPSIS;
+                itemContentView.setText(newVal);
+                hasEllipsis = true;
             }
-            final String newVal = itemContentView.getText().subSequence(0, end) + " …";
-            itemContentView.setText(newVal);
-            hasEllipsis = true;
-        }
 
-        linkify();
-
-        if (hasEllipsis) {
-            denyLinkFocus();
-        } else {
-            determineLinkFocus();
-        }
+            itemContentView.setMaxLines(COMMENT_DEFAULT_LINES);
+            if (hasEllipsis) {
+                denyLinkFocus();
+            } else {
+                determineMovementMethod();
+            }
+        });
     }
 
     private void toggleEllipsize() {
-        if (itemContentView.getText().toString().equals(commentText)) {
-            if (itemContentView.getLineCount() > COMMENT_DEFAULT_LINES) {
-                ellipsize();
-            }
-        } else {
+        final CharSequence text = itemContentView.getText();
+        if (!isEmpty(text) && text.charAt(text.length() - 1) == ELLIPSIS.charAt(0)) {
             expand();
+        } else if (itemContentView.getLineCount() > COMMENT_DEFAULT_LINES) {
+            ellipsize();
         }
     }
 
     private void expand() {
         itemContentView.setMaxLines(COMMENT_EXPANDED_LINES);
-        itemContentView.setText(commentText);
-        linkify();
-        determineLinkFocus();
+        linkifyCommentContentView(v -> determineMovementMethod());
     }
 
-    private void linkify() {
-        Linkify.addLinks(
-                itemContentView,
-                Linkify.WEB_URLS);
-        Linkify.addLinks(
-                itemContentView,
-                TimestampExtractor.TIMESTAMPS_PATTERN,
-                null,
-                null,
-                timestampLink);
+    private void linkifyCommentContentView(@Nullable final Consumer<TextView> onCompletion) {
+        disposables.clear();
+        if (commentText != null) {
+            TextLinkifier.fromDescription(itemContentView, commentText,
+                    HtmlCompat.FROM_HTML_MODE_LEGACY, streamService, streamUrl, disposables,
+                    onCompletion);
+        }
     }
 }

app/src/main/java/org/schabi/newpipe/info_list/holder/PlaylistCardInfoItemHolder.java

@@ -0,0 +1,17 @@
+package org.schabi.newpipe.info_list.holder;
+
+import android.view.ViewGroup;
+
+import org.schabi.newpipe.R;
+import org.schabi.newpipe.info_list.InfoItemBuilder;
+
+/**
+ * Playlist card layout.
+ */
+public class PlaylistCardInfoItemHolder extends PlaylistMiniInfoItemHolder {
+
+    public PlaylistCardInfoItemHolder(final InfoItemBuilder infoItemBuilder,
+                                      final ViewGroup parent) {
+        super(infoItemBuilder, R.layout.list_playlist_card_item, parent);
+    }
+}

app/src/main/java/org/schabi/newpipe/info_list/holder/StreamCardInfoItemHolder.java

@@ -0,0 +1,16 @@
+package org.schabi.newpipe.info_list.holder;
+
+import android.view.ViewGroup;
+
+import org.schabi.newpipe.R;
+import org.schabi.newpipe.info_list.InfoItemBuilder;
+
+/**
+ * Card layout for stream.
+ */
+public class StreamCardInfoItemHolder extends StreamInfoItemHolder {
+
+    public StreamCardInfoItemHolder(final InfoItemBuilder infoItemBuilder, final ViewGroup parent) {
+        super(infoItemBuilder, R.layout.list_stream_card_item, parent);
+    }
+}

app/src/main/java/org/schabi/newpipe/info_list/holder/StreamMiniInfoItemHolder.java

@@ -14,6 +14,7 @@ import org.schabi.newpipe.extractor.stream.StreamInfoItem;
 import org.schabi.newpipe.info_list.InfoItemBuilder;
 import org.schabi.newpipe.ktx.ViewUtils;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
+import org.schabi.newpipe.util.DependentPreferenceHelper;
 import org.schabi.newpipe.util.Localization;
 import org.schabi.newpipe.util.PicassoHelper;
 import org.schabi.newpipe.util.StreamTypeUtil;
@@ -60,8 +61,12 @@ public class StreamMiniInfoItemHolder extends InfoItemHolder {
                     R.color.duration_background_color));
             itemDurationView.setVisibility(View.VISIBLE);
 
-            final StreamStateEntity state2 = historyRecordManager.loadStreamState(infoItem)
-                    .blockingGet()[0];
+            StreamStateEntity state2 = null;
+            if (DependentPreferenceHelper
+                    .getPositionsInListsEnabled(itemProgressView.getContext())) {
+                state2 = historyRecordManager.loadStreamState(infoItem)
+                        .blockingGet()[0];
+            }
             if (state2 != null) {
                 itemProgressView.setVisibility(View.VISIBLE);
                 itemProgressView.setMax((int) item.getDuration());
@@ -111,9 +116,12 @@ public class StreamMiniInfoItemHolder extends InfoItemHolder {
                             final HistoryRecordManager historyRecordManager) {
         final StreamInfoItem item = (StreamInfoItem) infoItem;
 
-        final StreamStateEntity state = historyRecordManager
-                .loadStreamState(infoItem)
-                .blockingGet()[0];
+        StreamStateEntity state = null;
+        if (DependentPreferenceHelper.getPositionsInListsEnabled(itemProgressView.getContext())) {
+            state = historyRecordManager
+                    .loadStreamState(infoItem)
+                    .blockingGet()[0];
+        }
         if (state != null && item.getDuration() > 0
                 && !StreamTypeUtil.isLiveStream(item.getStreamType())) {
             itemProgressView.setMax((int) item.getDuration());

app/src/main/java/org/schabi/newpipe/local/BaseLocalListFragment.java

@@ -22,10 +22,11 @@ import org.schabi.newpipe.R;
 import org.schabi.newpipe.databinding.PignateFooterBinding;
 import org.schabi.newpipe.fragments.BaseStateFragment;
 import org.schabi.newpipe.fragments.list.ListViewContract;
+import org.schabi.newpipe.info_list.ItemViewMode;
 
 import static org.schabi.newpipe.ktx.ViewUtils.animate;
 import static org.schabi.newpipe.ktx.ViewUtils.animateHideRecyclerViewAllowingScrolling;
-import static org.schabi.newpipe.util.ThemeHelper.shouldUseGridLayout;
+import static org.schabi.newpipe.util.ThemeHelper.getItemViewMode;
 
 /**
  * This fragment is design to be used with persistent data such as
@@ -77,16 +78,23 @@ public abstract class BaseLocalListFragment<I, N> extends BaseStateFragment<I>
         super.onResume();
         if (updateFlags != 0) {
             if ((updateFlags & LIST_MODE_UPDATE_FLAG) != 0) {
-                final boolean useGrid = shouldUseGridLayout(requireContext());
-                itemsList.setLayoutManager(
-                        useGrid ? getGridLayoutManager() : getListLayoutManager());
-                itemListAdapter.setUseGridVariant(useGrid);
-                itemListAdapter.notifyDataSetChanged();
+                refreshItemViewMode();
             }
             updateFlags = 0;
         }
     }
 
+    /**
+     * Updates the item view mode based on user preference.
+     */
+    private void refreshItemViewMode() {
+        final ItemViewMode itemViewMode = getItemViewMode(requireContext());
+        itemsList.setLayoutManager((itemViewMode == ItemViewMode.GRID)
+                ? getGridLayoutManager() : getListLayoutManager());
+        itemListAdapter.setItemViewMode(itemViewMode);
+        itemListAdapter.notifyDataSetChanged();
+    }
+
     /*//////////////////////////////////////////////////////////////////////////
     // Lifecycle - View
     //////////////////////////////////////////////////////////////////////////*/
@@ -104,8 +112,7 @@ public abstract class BaseLocalListFragment<I, N> extends BaseStateFragment<I>
         final Resources resources = activity.getResources();
         int width = resources.getDimensionPixelSize(R.dimen.video_item_grid_thumbnail_image_width);
         width += (24 * resources.getDisplayMetrics().density);
-        final int spanCount = (int) Math.floor(resources.getDisplayMetrics().widthPixels
-                / (double) width);
+        final int spanCount = Math.floorDiv(resources.getDisplayMetrics().widthPixels, width);
         final GridLayoutManager lm = new GridLayoutManager(activity, spanCount);
         lm.setSpanSizeLookup(itemListAdapter.getSpanSizeLookup(spanCount));
         return lm;
@@ -121,11 +128,9 @@ public abstract class BaseLocalListFragment<I, N> extends BaseStateFragment<I>
 
         itemListAdapter = new LocalItemListAdapter(activity);
 
-        final boolean useGrid = shouldUseGridLayout(requireContext());
         itemsList = rootView.findViewById(R.id.items_list);
-        itemsList.setLayoutManager(useGrid ? getGridLayoutManager() : getListLayoutManager());
+        refreshItemViewMode();
 
-        itemListAdapter.setUseGridVariant(useGrid);
         headerRootBinding = getListHeader();
         if (headerRootBinding != null) {
             itemListAdapter.setHeader(headerRootBinding.getRoot());
@@ -256,7 +261,7 @@ public abstract class BaseLocalListFragment<I, N> extends BaseStateFragment<I>
     @Override
     public void onSharedPreferenceChanged(final SharedPreferences sharedPreferences,
                                           final String key) {
-        if (key.equals(getString(R.string.list_view_mode_key))) {
+        if (getString(R.string.list_view_mode_key).equals(key)) {
             updateFlags |= LIST_MODE_UPDATE_FLAG;
         }
     }

app/src/main/java/org/schabi/newpipe/local/LocalItemListAdapter.java

@@ -12,14 +12,19 @@ import androidx.recyclerview.widget.RecyclerView;
 
 import org.schabi.newpipe.database.LocalItem;
 import org.schabi.newpipe.database.stream.model.StreamStateEntity;
+import org.schabi.newpipe.info_list.ItemViewMode;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
 import org.schabi.newpipe.local.holder.LocalItemHolder;
+import org.schabi.newpipe.local.holder.LocalPlaylistCardItemHolder;
 import org.schabi.newpipe.local.holder.LocalPlaylistGridItemHolder;
 import org.schabi.newpipe.local.holder.LocalPlaylistItemHolder;
+import org.schabi.newpipe.local.holder.LocalPlaylistStreamCardItemHolder;
 import org.schabi.newpipe.local.holder.LocalPlaylistStreamGridItemHolder;
 import org.schabi.newpipe.local.holder.LocalPlaylistStreamItemHolder;
+import org.schabi.newpipe.local.holder.LocalStatisticStreamCardItemHolder;
 import org.schabi.newpipe.local.holder.LocalStatisticStreamGridItemHolder;
 import org.schabi.newpipe.local.holder.LocalStatisticStreamItemHolder;
+import org.schabi.newpipe.local.holder.RemotePlaylistCardItemHolder;
 import org.schabi.newpipe.local.holder.RemotePlaylistGridItemHolder;
 import org.schabi.newpipe.local.holder.RemotePlaylistItemHolder;
 import org.schabi.newpipe.util.FallbackViewHolder;
@@ -61,11 +66,17 @@ public class LocalItemListAdapter extends RecyclerView.Adapter<RecyclerView.View
     private static final int STREAM_STATISTICS_HOLDER_TYPE = 0x1000;
     private static final int STREAM_PLAYLIST_HOLDER_TYPE = 0x1001;
     private static final int STREAM_STATISTICS_GRID_HOLDER_TYPE = 0x1002;
+    private static final int STREAM_STATISTICS_CARD_HOLDER_TYPE = 0x1003;
     private static final int STREAM_PLAYLIST_GRID_HOLDER_TYPE = 0x1004;
+    private static final int STREAM_PLAYLIST_CARD_HOLDER_TYPE = 0x1005;
+
     private static final int LOCAL_PLAYLIST_HOLDER_TYPE = 0x2000;
-    private static final int REMOTE_PLAYLIST_HOLDER_TYPE = 0x2001;
-    private static final int LOCAL_PLAYLIST_GRID_HOLDER_TYPE = 0x2002;
-    private static final int REMOTE_PLAYLIST_GRID_HOLDER_TYPE = 0x2004;
+    private static final int LOCAL_PLAYLIST_GRID_HOLDER_TYPE = 0x2001;
+    private static final int LOCAL_PLAYLIST_CARD_HOLDER_TYPE = 0x2002;
+
+    private static final int REMOTE_PLAYLIST_HOLDER_TYPE = 0x3000;
+    private static final int REMOTE_PLAYLIST_GRID_HOLDER_TYPE = 0x3001;
+    private static final int REMOTE_PLAYLIST_CARD_HOLDER_TYPE = 0x3002;
 
     private final LocalItemBuilder localItemBuilder;
     private final ArrayList<LocalItem> localItems;
@@ -73,9 +84,9 @@ public class LocalItemListAdapter extends RecyclerView.Adapter<RecyclerView.View
     private final DateTimeFormatter dateTimeFormatter;
 
     private boolean showFooter = false;
-    private boolean useGridVariant = false;
     private View header = null;
     private View footer = null;
+    private ItemViewMode itemViewMode = ItemViewMode.LIST;
 
     public LocalItemListAdapter(final Context context) {
         recordManager = new HistoryRecordManager(context);
@@ -165,8 +176,8 @@ public class LocalItemListAdapter extends RecyclerView.Adapter<RecyclerView.View
         notifyDataSetChanged();
     }
 
-    public void setUseGridVariant(final boolean useGridVariant) {
-        this.useGridVariant = useGridVariant;
+    public void setItemViewMode(final ItemViewMode itemViewMode) {
+        this.itemViewMode = itemViewMode;
     }
 
     public void setHeader(final View header) {
@@ -244,21 +255,39 @@ public class LocalItemListAdapter extends RecyclerView.Adapter<RecyclerView.View
             return FOOTER_TYPE;
         }
         final LocalItem item = localItems.get(position);
-
         switch (item.getLocalItemType()) {
             case PLAYLIST_LOCAL_ITEM:
-                return useGridVariant
-                        ? LOCAL_PLAYLIST_GRID_HOLDER_TYPE : LOCAL_PLAYLIST_HOLDER_TYPE;
+                if (itemViewMode == ItemViewMode.CARD) {
+                    return LOCAL_PLAYLIST_CARD_HOLDER_TYPE;
+                } else if (itemViewMode == ItemViewMode.GRID) {
+                    return LOCAL_PLAYLIST_GRID_HOLDER_TYPE;
+                } else {
+                    return LOCAL_PLAYLIST_HOLDER_TYPE;
+                }
             case PLAYLIST_REMOTE_ITEM:
-                return useGridVariant
-                        ? REMOTE_PLAYLIST_GRID_HOLDER_TYPE : REMOTE_PLAYLIST_HOLDER_TYPE;
-
+                if (itemViewMode == ItemViewMode.CARD) {
+                    return REMOTE_PLAYLIST_CARD_HOLDER_TYPE;
+                } else if (itemViewMode == ItemViewMode.GRID) {
+                    return REMOTE_PLAYLIST_GRID_HOLDER_TYPE;
+                } else {
+                    return REMOTE_PLAYLIST_HOLDER_TYPE;
+                }
             case PLAYLIST_STREAM_ITEM:
-                return useGridVariant
-                        ? STREAM_PLAYLIST_GRID_HOLDER_TYPE : STREAM_PLAYLIST_HOLDER_TYPE;
+                if (itemViewMode == ItemViewMode.CARD) {
+                    return STREAM_PLAYLIST_CARD_HOLDER_TYPE;
+                } else if (itemViewMode == ItemViewMode.GRID) {
+                    return STREAM_PLAYLIST_GRID_HOLDER_TYPE;
+                } else {
+                    return STREAM_PLAYLIST_HOLDER_TYPE;
+                }
             case STATISTIC_STREAM_ITEM:
-                return useGridVariant
-                        ? STREAM_STATISTICS_GRID_HOLDER_TYPE : STREAM_STATISTICS_HOLDER_TYPE;
+                if (itemViewMode == ItemViewMode.CARD) {
+                    return STREAM_STATISTICS_CARD_HOLDER_TYPE;
+                } else if (itemViewMode == ItemViewMode.GRID) {
+                    return STREAM_STATISTICS_GRID_HOLDER_TYPE;
+                } else {
+                    return STREAM_STATISTICS_HOLDER_TYPE;
+                }
             default:
                 Log.e(TAG, "No holder type has been considered for item: ["
                         + item.getLocalItemType() + "]");
@@ -283,18 +312,26 @@ public class LocalItemListAdapter extends RecyclerView.Adapter<RecyclerView.View
                 return new LocalPlaylistItemHolder(localItemBuilder, parent);
             case LOCAL_PLAYLIST_GRID_HOLDER_TYPE:
                 return new LocalPlaylistGridItemHolder(localItemBuilder, parent);
+            case LOCAL_PLAYLIST_CARD_HOLDER_TYPE:
+                return new LocalPlaylistCardItemHolder(localItemBuilder, parent);
             case REMOTE_PLAYLIST_HOLDER_TYPE:
                 return new RemotePlaylistItemHolder(localItemBuilder, parent);
             case REMOTE_PLAYLIST_GRID_HOLDER_TYPE:
                 return new RemotePlaylistGridItemHolder(localItemBuilder, parent);
+            case REMOTE_PLAYLIST_CARD_HOLDER_TYPE:
+                return new RemotePlaylistCardItemHolder(localItemBuilder, parent);
             case STREAM_PLAYLIST_HOLDER_TYPE:
                 return new LocalPlaylistStreamItemHolder(localItemBuilder, parent);
             case STREAM_PLAYLIST_GRID_HOLDER_TYPE:
                 return new LocalPlaylistStreamGridItemHolder(localItemBuilder, parent);
+            case STREAM_PLAYLIST_CARD_HOLDER_TYPE:
+                return new LocalPlaylistStreamCardItemHolder(localItemBuilder, parent);
             case STREAM_STATISTICS_HOLDER_TYPE:
                 return new LocalStatisticStreamItemHolder(localItemBuilder, parent);
             case STREAM_STATISTICS_GRID_HOLDER_TYPE:
                 return new LocalStatisticStreamGridItemHolder(localItemBuilder, parent);
+            case STREAM_STATISTICS_CARD_HOLDER_TYPE:
+                return new LocalStatisticStreamCardItemHolder(localItemBuilder, parent);
             default:
                 Log.e(TAG, "No view type has been considered for holder: [" + type + "]");
                 return new FallbackViewHolder(new View(parent.getContext()));

app/src/main/java/org/schabi/newpipe/local/bookmark/BookmarkFragment.java

@@ -1,5 +1,6 @@
 package org.schabi.newpipe.local.bookmark;
 
+import android.content.DialogInterface;
 import android.os.Bundle;
 import android.os.Parcelable;
 import android.text.InputType;
@@ -31,6 +32,7 @@ import org.schabi.newpipe.local.playlist.RemotePlaylistManager;
 import org.schabi.newpipe.util.NavigationHelper;
 import org.schabi.newpipe.util.OnClickGesture;
 
+import java.util.ArrayList;
 import java.util.List;
 
 import icepick.State;
@@ -256,25 +258,54 @@ public final class BookmarkFragment extends BaseLocalListFragment<List<PlaylistL
     }
 
     private void showLocalDialog(final PlaylistMetadataEntry selectedItem) {
+        final String rename = getString(R.string.rename);
+        final String delete = getString(R.string.delete);
+        final String unsetThumbnail = getString(R.string.unset_playlist_thumbnail);
+        final boolean isThumbnailPermanent = localPlaylistManager
+                .getIsPlaylistThumbnailPermanent(selectedItem.uid);
+
+        final ArrayList<String> items = new ArrayList<>();
+        items.add(rename);
+        items.add(delete);
+        if (isThumbnailPermanent) {
+            items.add(unsetThumbnail);
+        }
+
+        final DialogInterface.OnClickListener action = (d, index) -> {
+            if (items.get(index).equals(rename)) {
+                showRenameDialog(selectedItem);
+            } else if (items.get(index).equals(delete)) {
+                showDeleteDialog(selectedItem.name,
+                        localPlaylistManager.deletePlaylist(selectedItem.uid));
+            } else if (isThumbnailPermanent && items.get(index).equals(unsetThumbnail)) {
+                final long thumbnailStreamId = localPlaylistManager
+                        .getAutomaticPlaylistThumbnailStreamId(selectedItem.uid);
+                localPlaylistManager
+                        .changePlaylistThumbnail(selectedItem.uid, thumbnailStreamId, false)
+                        .observeOn(AndroidSchedulers.mainThread())
+                        .subscribe();
+            }
+        };
+
+        new AlertDialog.Builder(activity)
+                .setItems(items.toArray(new String[0]), action)
+                .show();
+    }
+
+    private void showRenameDialog(final PlaylistMetadataEntry selectedItem) {
         final DialogEditTextBinding dialogBinding =
                 DialogEditTextBinding.inflate(getLayoutInflater());
         dialogBinding.dialogEditText.setHint(R.string.name);
         dialogBinding.dialogEditText.setInputType(InputType.TYPE_CLASS_TEXT);
         dialogBinding.dialogEditText.setText(selectedItem.name);
 
-        final AlertDialog.Builder builder = new AlertDialog.Builder(activity);
-        builder.setView(dialogBinding.getRoot())
+        new AlertDialog.Builder(activity)
+                .setView(dialogBinding.getRoot())
                 .setPositiveButton(R.string.rename_playlist, (dialog, which) ->
                         changeLocalPlaylistName(
                                 selectedItem.uid,
                                 dialogBinding.dialogEditText.getText().toString()))
                 .setNegativeButton(R.string.cancel, null)
-                .setNeutralButton(R.string.delete, (dialog, which) -> {
-                    showDeleteDialog(selectedItem.name,
-                            localPlaylistManager.deletePlaylist(selectedItem.uid));
-                    dialog.dismiss();
-                })
-                .create()
                 .show();
     }
 

app/src/main/java/org/schabi/newpipe/local/dialog/PlaylistAppendDialog.java

@@ -4,6 +4,7 @@ import android.os.Bundle;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.widget.TextView;
 import android.widget.Toast;
 
 import androidx.annotation.NonNull;
@@ -13,7 +14,8 @@ import androidx.recyclerview.widget.RecyclerView;
 
 import org.schabi.newpipe.NewPipeDatabase;
 import org.schabi.newpipe.R;
-import org.schabi.newpipe.database.playlist.PlaylistMetadataEntry;
+import org.schabi.newpipe.database.playlist.model.PlaylistEntity;
+import org.schabi.newpipe.database.playlist.PlaylistDuplicatesEntry;
 import org.schabi.newpipe.database.stream.model.StreamEntity;
 import org.schabi.newpipe.local.LocalItemListAdapter;
 import org.schabi.newpipe.local.playlist.LocalPlaylistManager;
@@ -28,6 +30,7 @@ public final class PlaylistAppendDialog extends PlaylistDialog {
 
     private RecyclerView playlistRecyclerView;
     private LocalItemListAdapter playlistAdapter;
+    private TextView playlistDuplicateIndicator;
 
     private final CompositeDisposable playlistDisposables = new CompositeDisposable();
 
@@ -63,8 +66,9 @@ public final class PlaylistAppendDialog extends PlaylistDialog {
         playlistAdapter = new LocalItemListAdapter(getActivity());
         playlistAdapter.setSelectedListener(selectedItem -> {
             final List<StreamEntity> entities = getStreamEntities();
-            if (selectedItem instanceof PlaylistMetadataEntry && entities != null) {
-                onPlaylistSelected(playlistManager, (PlaylistMetadataEntry) selectedItem, entities);
+            if (selectedItem instanceof PlaylistDuplicatesEntry && entities != null) {
+                onPlaylistSelected(playlistManager,
+                        (PlaylistDuplicatesEntry) selectedItem, entities);
             }
         });
 
@@ -72,10 +76,13 @@ public final class PlaylistAppendDialog extends PlaylistDialog {
         playlistRecyclerView.setLayoutManager(new LinearLayoutManager(requireContext()));
         playlistRecyclerView.setAdapter(playlistAdapter);
 
+        playlistDuplicateIndicator = view.findViewById(R.id.playlist_duplicate);
+
         final View newPlaylistButton = view.findViewById(R.id.newPlaylist);
         newPlaylistButton.setOnClickListener(ignored -> openCreatePlaylistDialog());
 
-        playlistDisposables.add(playlistManager.getPlaylists()
+        playlistDisposables.add(playlistManager
+                .getPlaylistDuplicates(getStreamEntities().get(0).getUrl())
                 .observeOn(AndroidSchedulers.mainThread())
                 .subscribe(this::onPlaylistsReceived));
     }
@@ -117,31 +124,50 @@ public final class PlaylistAppendDialog extends PlaylistDialog {
         requireDialog().dismiss();
     }
 
-    private void onPlaylistsReceived(@NonNull final List<PlaylistMetadataEntry> playlists) {
-        if (playlistAdapter != null && playlistRecyclerView != null) {
+    private void onPlaylistsReceived(@NonNull final List<PlaylistDuplicatesEntry> playlists) {
+        if (playlistAdapter != null
+                && playlistRecyclerView != null
+                && playlistDuplicateIndicator != null) {
             playlistAdapter.clearStreamItemList();
             playlistAdapter.addItems(playlists);
             playlistRecyclerView.setVisibility(View.VISIBLE);
+            playlistDuplicateIndicator.setVisibility(
+                    anyPlaylistContainsDuplicates(playlists) ? View.VISIBLE : View.GONE);
         }
     }
 
-    private void onPlaylistSelected(@NonNull final LocalPlaylistManager manager,
-                                    @NonNull final PlaylistMetadataEntry playlist,
-                                    @NonNull final List<StreamEntity> streams) {
-        final Toast successToast = Toast.makeText(getContext(),
-                R.string.playlist_add_stream_success, Toast.LENGTH_SHORT);
+    private boolean anyPlaylistContainsDuplicates(final List<PlaylistDuplicatesEntry> playlists) {
+        return playlists.stream()
+                .anyMatch(playlist -> playlist.timesStreamIsContained > 0);
+    }
 
-        if (playlist.thumbnailUrl
-                .equals("drawable://" + R.drawable.placeholder_thumbnail_playlist)) {
-            playlistDisposables.add(manager
-                    .changePlaylistThumbnail(playlist.uid, streams.get(0).getThumbnailUrl())
-                    .observeOn(AndroidSchedulers.mainThread())
-                    .subscribe(ignored -> successToast.show()));
+    private void onPlaylistSelected(@NonNull final LocalPlaylistManager manager,
+                                    @NonNull final PlaylistDuplicatesEntry playlist,
+                                    @NonNull final List<StreamEntity> streams) {
+
+        final String toastText;
+        if (playlist.timesStreamIsContained > 0) {
+            toastText = getString(R.string.playlist_add_stream_success_duplicate,
+                    playlist.timesStreamIsContained);
+        } else {
+            toastText = getString(R.string.playlist_add_stream_success);
         }
 
+        final Toast successToast = Toast.makeText(getContext(), toastText, Toast.LENGTH_SHORT);
+
         playlistDisposables.add(manager.appendToPlaylist(playlist.uid, streams)
                 .observeOn(AndroidSchedulers.mainThread())
-                .subscribe(ignored -> successToast.show()));
+                .subscribe(ignored -> {
+                    successToast.show();
+
+                    if (playlist.thumbnailUrl.equals(PlaylistEntity.DEFAULT_THUMBNAIL)) {
+                        playlistDisposables.add(manager
+                                .changePlaylistThumbnail(playlist.uid, streams.get(0).getUid(),
+                                        false)
+                                .observeOn(AndroidSchedulers.mainThread())
+                                .subscribe(ignore -> successToast.show()));
+                    }
+                }));
 
         requireDialog().dismiss();
     }

app/src/main/java/org/schabi/newpipe/local/feed/FeedDatabaseManager.kt

@@ -43,11 +43,13 @@ class FeedDatabaseManager(context: Context) {
     fun getStreams(
         groupId: Long,
         includePlayedStreams: Boolean,
+        includePartiallyPlayedStreams: Boolean,
         includeFutureStreams: Boolean
     ): Maybe<List<StreamWithState>> {
         return feedTable.getStreams(
             groupId,
             includePlayedStreams,
+            includePartiallyPlayedStreams,
             if (includeFutureStreams) null else OffsetDateTime.now()
         )
     }

app/src/main/java/org/schabi/newpipe/local/feed/FeedFragment.kt

@@ -36,12 +36,10 @@ import android.view.MenuItem
 import android.view.View
 import android.view.ViewGroup
 import android.widget.Button
-import androidx.annotation.Nullable
 import androidx.appcompat.app.AlertDialog
-import androidx.appcompat.content.res.AppCompatResources
 import androidx.core.content.edit
+import androidx.core.math.MathUtils
 import androidx.core.os.bundleOf
-import androidx.core.view.MenuItemCompat
 import androidx.core.view.isVisible
 import androidx.lifecycle.ViewModelProvider
 import androidx.preference.PreferenceManager
@@ -68,6 +66,7 @@ import org.schabi.newpipe.extractor.exceptions.ContentNotAvailableException
 import org.schabi.newpipe.extractor.stream.StreamInfoItem
 import org.schabi.newpipe.extractor.utils.Utils.isNullOrEmpty
 import org.schabi.newpipe.fragments.BaseStateFragment
+import org.schabi.newpipe.info_list.ItemViewMode
 import org.schabi.newpipe.info_list.dialog.InfoItemDialog
 import org.schabi.newpipe.ktx.animate
 import org.schabi.newpipe.ktx.animateHideRecyclerViewAllowingScrolling
@@ -79,6 +78,7 @@ import org.schabi.newpipe.util.DeviceUtils
 import org.schabi.newpipe.util.Localization
 import org.schabi.newpipe.util.NavigationHelper
 import org.schabi.newpipe.util.ThemeHelper.getGridSpanCountStreams
+import org.schabi.newpipe.util.ThemeHelper.getItemViewMode
 import org.schabi.newpipe.util.ThemeHelper.resolveDrawable
 import org.schabi.newpipe.util.ThemeHelper.shouldUseGridLayout
 import java.time.OffsetDateTime
@@ -98,8 +98,6 @@ class FeedFragment : BaseStateFragment<FeedState>() {
     private var oldestSubscriptionUpdate: OffsetDateTime? = null
 
     private lateinit var groupAdapter: GroupieAdapter
-    @State @JvmField var showPlayedItems: Boolean = true
-    @State @JvmField var showFutureItems: Boolean = true
 
     private var onSettingsChangeListener: SharedPreferences.OnSharedPreferenceChangeListener? = null
     private var updateListViewModeOnResume = false
@@ -119,7 +117,7 @@ class FeedFragment : BaseStateFragment<FeedState>() {
         groupName = arguments?.getString(KEY_GROUP_NAME) ?: ""
 
         onSettingsChangeListener = SharedPreferences.OnSharedPreferenceChangeListener { _, key ->
-            if (key.equals(getString(R.string.list_view_mode_key))) {
+            if (getString(R.string.list_view_mode_key).equals(key)) {
                 updateListViewModeOnResume = true
             }
         }
@@ -138,8 +136,6 @@ class FeedFragment : BaseStateFragment<FeedState>() {
 
         val factory = FeedViewModel.getFactory(requireContext(), groupId)
         viewModel = ViewModelProvider(this, factory)[FeedViewModel::class.java]
-        showPlayedItems = viewModel.getShowPlayedItemsFromPreferences()
-        showFutureItems = viewModel.getShowFutureItemsFromPreferences()
         viewModel.stateLiveData.observe(viewLifecycleOwner) { it?.let(::handleResult) }
 
         groupAdapter = GroupieAdapter().apply {
@@ -214,8 +210,6 @@ class FeedFragment : BaseStateFragment<FeedState>() {
         activity.supportActionBar?.subtitle = groupName
 
         inflater.inflate(R.menu.menu_feed_fragment, menu)
-        updateTogglePlayedItemsButton(menu.findItem(R.id.menu_item_feed_toggle_played_items))
-        updateToggleFutureItemsButton(menu.findItem(R.id.menu_item_feed_toggle_future_items))
     }
 
     override fun onOptionsItemSelected(item: MenuItem): Boolean {
@@ -237,24 +231,42 @@ class FeedFragment : BaseStateFragment<FeedState>() {
                     }
                 }
                 .setPositiveButton(resources.getString(R.string.ok), null)
-                .create()
                 .show()
             return true
         } else if (item.itemId == R.id.menu_item_feed_toggle_played_items) {
-            showPlayedItems = !item.isChecked
-            updateTogglePlayedItemsButton(item)
-            viewModel.togglePlayedItems(showPlayedItems)
-            viewModel.saveShowPlayedItemsToPreferences(showPlayedItems)
-        } else if (item.itemId == R.id.menu_item_feed_toggle_future_items) {
-            showFutureItems = !item.isChecked
-            updateToggleFutureItemsButton(item)
-            viewModel.toggleFutureItems(showFutureItems)
-            viewModel.saveShowFutureItemsToPreferences(showFutureItems)
+            showStreamVisibilityDialog()
         }
 
         return super.onOptionsItemSelected(item)
     }
 
+    private fun showStreamVisibilityDialog() {
+        val dialogItems = arrayOf(
+            getString(R.string.feed_show_watched),
+            getString(R.string.feed_show_partially_watched),
+            getString(R.string.feed_show_upcoming)
+        )
+
+        val checkedDialogItems = booleanArrayOf(
+            viewModel.getShowPlayedItemsFromPreferences(),
+            viewModel.getShowPartiallyPlayedItemsFromPreferences(),
+            viewModel.getShowFutureItemsFromPreferences()
+        )
+
+        AlertDialog.Builder(context!!)
+            .setTitle(R.string.feed_hide_streams_title)
+            .setMultiChoiceItems(dialogItems, checkedDialogItems) { _, which, isChecked ->
+                checkedDialogItems[which] = isChecked
+            }
+            .setPositiveButton(R.string.ok) { _, _ ->
+                viewModel.setSaveShowPlayedItems(checkedDialogItems[0])
+                viewModel.setSaveShowPartiallyPlayedItems(checkedDialogItems[1])
+                viewModel.setSaveShowFutureItems(checkedDialogItems[2])
+            }
+            .setNegativeButton(R.string.cancel, null)
+            .show()
+    }
+
     override fun onDestroyOptionsMenu() {
         super.onDestroyOptionsMenu()
         activity?.supportActionBar?.subtitle = null
@@ -281,40 +293,6 @@ class FeedFragment : BaseStateFragment<FeedState>() {
         super.onDestroyView()
     }
 
-    private fun updateTogglePlayedItemsButton(menuItem: MenuItem) {
-        menuItem.isChecked = showPlayedItems
-        menuItem.icon = AppCompatResources.getDrawable(
-            requireContext(),
-            if (showPlayedItems) R.drawable.ic_visibility_on else R.drawable.ic_visibility_off
-        )
-        MenuItemCompat.setTooltipText(
-            menuItem,
-            getString(
-                if (showPlayedItems)
-                    R.string.feed_toggle_hide_played_items
-                else
-                    R.string.feed_toggle_show_played_items
-            )
-        )
-    }
-
-    private fun updateToggleFutureItemsButton(menuItem: MenuItem) {
-        menuItem.isChecked = showFutureItems
-        menuItem.icon = AppCompatResources.getDrawable(
-            requireContext(),
-            if (showFutureItems) R.drawable.ic_history_future else R.drawable.ic_history
-        )
-        MenuItemCompat.setTooltipText(
-            menuItem,
-            getString(
-                if (showFutureItems)
-                    R.string.feed_toggle_hide_future_items
-                else
-                    R.string.feed_toggle_show_future_items
-            )
-        )
-    }
-
     // //////////////////////////////////////////////////////////////////////////
     // Handling
     // //////////////////////////////////////////////////////////////////////////
@@ -415,11 +393,10 @@ class FeedFragment : BaseStateFragment<FeedState>() {
 
     @SuppressLint("StringFormatMatches")
     private fun handleLoadedState(loadedState: FeedState.LoadedState) {
-
-        val itemVersion = if (shouldUseGridLayout(context)) {
-            StreamItem.ItemVersion.GRID
-        } else {
-            StreamItem.ItemVersion.NORMAL
+        val itemVersion = when (getItemViewMode(requireContext())) {
+            ItemViewMode.GRID -> StreamItem.ItemVersion.GRID
+            ItemViewMode.CARD -> StreamItem.ItemVersion.CARD
+            else -> StreamItem.ItemVersion.NORMAL
         }
         loadedState.items.forEach { it.itemVersion = itemVersion }
 
@@ -498,7 +475,7 @@ class FeedFragment : BaseStateFragment<FeedState>() {
 
     private fun handleFeedNotAvailable(
         subscriptionEntity: SubscriptionEntity,
-        @Nullable cause: Throwable?,
+        cause: Throwable?,
         nextItemsErrors: List<Throwable>
     ) {
         val sharedPreferences = PreferenceManager.getDefaultSharedPreferences(requireContext())
@@ -508,15 +485,13 @@ class FeedFragment : BaseStateFragment<FeedState>() {
 
         val builder = AlertDialog.Builder(requireContext())
             .setTitle(R.string.feed_load_error)
-            .setPositiveButton(
-                R.string.unsubscribe
-            ) { _, _ ->
-                SubscriptionManager(requireContext()).deleteSubscription(
-                    subscriptionEntity.serviceId, subscriptionEntity.url
-                ).subscribe()
+            .setPositiveButton(R.string.unsubscribe) { _, _ ->
+                SubscriptionManager(requireContext())
+                    .deleteSubscription(subscriptionEntity.serviceId, subscriptionEntity.url)
+                    .subscribe()
                 handleItemsErrors(nextItemsErrors)
             }
-            .setNegativeButton(R.string.cancel) { _, _ -> }
+            .setNegativeButton(R.string.cancel, null)
 
         var message = getString(R.string.feed_load_error_account_info, subscriptionEntity.name)
         if (cause is AccountTerminatedException) {
@@ -533,7 +508,8 @@ class FeedFragment : BaseStateFragment<FeedState>() {
                 message += "\n" + cause.message
             }
         }
-        builder.setMessage(message).create().show()
+        builder.setMessage(message)
+            .show()
     }
 
     private fun updateRelativeTimeViews() {
@@ -603,7 +579,7 @@ class FeedFragment : BaseStateFragment<FeedState>() {
         // state until the user scrolls them out of the visible area which causes a update/bind-call
         groupAdapter.notifyItemRangeChanged(
             0,
-            minOf(groupAdapter.itemCount, maxOf(highlightCount, lastNewItemsCount))
+            MathUtils.clamp(highlightCount, lastNewItemsCount, groupAdapter.itemCount)
         )
 
         if (highlightCount > 0) {

app/src/main/java/org/schabi/newpipe/local/feed/FeedViewModel.kt

@@ -11,7 +11,7 @@ import androidx.lifecycle.viewmodel.viewModelFactory
 import androidx.preference.PreferenceManager
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
 import io.reactivex.rxjava3.core.Flowable
-import io.reactivex.rxjava3.functions.Function5
+import io.reactivex.rxjava3.functions.Function6
 import io.reactivex.rxjava3.processors.BehaviorProcessor
 import io.reactivex.rxjava3.schedulers.Schedulers
 import org.schabi.newpipe.App
@@ -31,18 +31,24 @@ import java.util.concurrent.TimeUnit
 class FeedViewModel(
     private val application: Application,
     groupId: Long = FeedGroupEntity.GROUP_ALL_ID,
-    initialShowPlayedItems: Boolean = true,
-    initialShowFutureItems: Boolean = true
+    initialShowPlayedItems: Boolean,
+    initialShowPartiallyPlayedItems: Boolean,
+    initialShowFutureItems: Boolean
 ) : ViewModel() {
     private val feedDatabaseManager = FeedDatabaseManager(application)
 
-    private val toggleShowPlayedItems = BehaviorProcessor.create<Boolean>()
-    private val toggleShowPlayedItemsFlowable = toggleShowPlayedItems
+    private val showPlayedItems = BehaviorProcessor.create<Boolean>()
+    private val showPlayedItemsFlowable = showPlayedItems
         .startWithItem(initialShowPlayedItems)
         .distinctUntilChanged()
 
-    private val toggleShowFutureItems = BehaviorProcessor.create<Boolean>()
-    private val toggleShowFutureItemsFlowable = toggleShowFutureItems
+    private val showPartiallyPlayedItems = BehaviorProcessor.create<Boolean>()
+    private val showPartiallyPlayedItemsFlowable = showPartiallyPlayedItems
+        .startWithItem(initialShowPartiallyPlayedItems)
+        .distinctUntilChanged()
+
+    private val showFutureItems = BehaviorProcessor.create<Boolean>()
+    private val showFutureItemsFlowable = showFutureItems
         .startWithItem(initialShowFutureItems)
         .distinctUntilChanged()
 
@@ -52,23 +58,24 @@ class FeedViewModel(
     private var combineDisposable = Flowable
         .combineLatest(
             FeedEventManager.events(),
-            toggleShowPlayedItemsFlowable,
-            toggleShowFutureItemsFlowable,
+            showPlayedItemsFlowable,
+            showPartiallyPlayedItemsFlowable,
+            showFutureItemsFlowable,
             feedDatabaseManager.notLoadedCount(groupId),
             feedDatabaseManager.oldestSubscriptionUpdate(groupId),
 
-            Function5 { t1: FeedEventManager.Event, t2: Boolean, t3: Boolean,
-                t4: Long, t5: List<OffsetDateTime> ->
-                return@Function5 CombineResultEventHolder(t1, t2, t3, t4, t5.firstOrNull())
+            Function6 { t1: FeedEventManager.Event, t2: Boolean, t3: Boolean, t4: Boolean,
+                t5: Long, t6: List<OffsetDateTime> ->
+                return@Function6 CombineResultEventHolder(t1, t2, t3, t4, t5, t6.firstOrNull())
             }
         )
         .throttleLatest(DEFAULT_THROTTLE_TIMEOUT, TimeUnit.MILLISECONDS)
         .subscribeOn(Schedulers.io())
         .observeOn(Schedulers.io())
-        .map { (event, showPlayedItems, showFutureItems, notLoadedCount, oldestUpdate) ->
+        .map { (event, showPlayedItems, showPartiallyPlayedItems, showFutureItems, notLoadedCount, oldestUpdate) ->
             val streamItems = if (event is SuccessResultEvent || event is IdleEvent)
                 feedDatabaseManager
-                    .getStreams(groupId, showPlayedItems, showFutureItems)
+                    .getStreams(groupId, showPlayedItems, showPartiallyPlayedItems, showFutureItems)
                     .blockingGet(arrayListOf())
             else
                 arrayListOf()
@@ -100,8 +107,9 @@ class FeedViewModel(
         val t1: FeedEventManager.Event,
         val t2: Boolean,
         val t3: Boolean,
-        val t4: Long,
-        val t5: OffsetDateTime?
+        val t4: Boolean,
+        val t5: Long,
+        val t6: OffsetDateTime?
     )
 
     private data class CombineResultDataHolder(
@@ -111,37 +119,49 @@ class FeedViewModel(
         val t4: OffsetDateTime?
     )
 
-    fun togglePlayedItems(showPlayedItems: Boolean) {
-        toggleShowPlayedItems.onNext(showPlayedItems)
-    }
-
-    fun saveShowPlayedItemsToPreferences(showPlayedItems: Boolean) =
+    fun setSaveShowPlayedItems(showPlayedItems: Boolean) {
+        this.showPlayedItems.onNext(showPlayedItems)
         PreferenceManager.getDefaultSharedPreferences(application).edit {
-            this.putBoolean(application.getString(R.string.feed_show_played_items_key), showPlayedItems)
+            this.putBoolean(application.getString(R.string.feed_show_watched_items_key), showPlayedItems)
             this.apply()
         }
+    }
 
     fun getShowPlayedItemsFromPreferences() = getShowPlayedItemsFromPreferences(application)
 
-    fun toggleFutureItems(showFutureItems: Boolean) {
-        toggleShowFutureItems.onNext(showFutureItems)
+    fun setSaveShowPartiallyPlayedItems(showPartiallyPlayedItems: Boolean) {
+        this.showPartiallyPlayedItems.onNext(showPartiallyPlayedItems)
+        PreferenceManager.getDefaultSharedPreferences(application).edit {
+            this.putBoolean(application.getString(R.string.feed_show_partially_watched_items_key), showPartiallyPlayedItems)
+            this.apply()
+        }
     }
 
-    fun saveShowFutureItemsToPreferences(showFutureItems: Boolean) =
+    fun getShowPartiallyPlayedItemsFromPreferences() = getShowPartiallyPlayedItemsFromPreferences(application)
+
+    fun setSaveShowFutureItems(showFutureItems: Boolean) {
+        this.showFutureItems.onNext(showFutureItems)
         PreferenceManager.getDefaultSharedPreferences(application).edit {
             this.putBoolean(application.getString(R.string.feed_show_future_items_key), showFutureItems)
             this.apply()
         }
+    }
 
     fun getShowFutureItemsFromPreferences() = getShowFutureItemsFromPreferences(application)
 
     companion object {
         private fun getShowPlayedItemsFromPreferences(context: Context) =
             PreferenceManager.getDefaultSharedPreferences(context)
-                .getBoolean(context.getString(R.string.feed_show_played_items_key), true)
+                .getBoolean(context.getString(R.string.feed_show_watched_items_key), true)
+
+        private fun getShowPartiallyPlayedItemsFromPreferences(context: Context) =
+            PreferenceManager.getDefaultSharedPreferences(context)
+                .getBoolean(context.getString(R.string.feed_show_partially_watched_items_key), true)
+
         private fun getShowFutureItemsFromPreferences(context: Context) =
             PreferenceManager.getDefaultSharedPreferences(context)
                 .getBoolean(context.getString(R.string.feed_show_future_items_key), true)
+
         fun getFactory(context: Context, groupId: Long) = viewModelFactory {
             initializer {
                 FeedViewModel(
@@ -149,6 +169,7 @@ class FeedViewModel(
                     groupId,
                     // Read initial value from preferences
                     getShowPlayedItemsFromPreferences(context.applicationContext),
+                    getShowPartiallyPlayedItemsFromPreferences(context.applicationContext),
                     getShowFutureItemsFromPreferences(context.applicationContext)
                 )
             }

app/src/main/java/org/schabi/newpipe/local/feed/item/StreamItem.kt

@@ -42,12 +42,13 @@ data class StreamItem(
 
     override fun getId(): Long = stream.uid
 
-    enum class ItemVersion { NORMAL, MINI, GRID }
+    enum class ItemVersion { NORMAL, MINI, GRID, CARD }
 
     override fun getLayout(): Int = when (itemVersion) {
         ItemVersion.NORMAL -> R.layout.list_stream_item
         ItemVersion.MINI -> R.layout.list_stream_mini_item
         ItemVersion.GRID -> R.layout.list_stream_grid_item
+        ItemVersion.CARD -> R.layout.list_stream_card_item
     }
 
     override fun initializeViewBinding(view: View) = ListStreamItemBinding.bind(view)

app/src/main/java/org/schabi/newpipe/local/feed/notifications/NotificationHelper.kt

@@ -1,7 +1,6 @@
 package org.schabi.newpipe.local.feed.notifications
 
 import android.app.NotificationManager
-import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
 import android.graphics.Bitmap
@@ -11,6 +10,7 @@ import android.os.Build
 import android.provider.Settings
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
+import androidx.core.app.PendingIntentCompat
 import androidx.core.content.ContextCompat
 import androidx.preference.PreferenceManager
 import com.squareup.picasso.Picasso
@@ -70,16 +70,14 @@ class NotificationHelper(val context: Context) {
 
         // open the channel page when clicking on the notification
         builder.setContentIntent(
-            PendingIntent.getActivity(
+            PendingIntentCompat.getActivity(
                 context,
                 data.pseudoId,
                 NavigationHelper
                     .getChannelIntent(context, data.listInfo.serviceId, data.listInfo.url)
                     .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK),
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
-                    PendingIntent.FLAG_IMMUTABLE
-                else
-                    0
+                0,
+                false
             )
         )
 

app/src/main/java/org/schabi/newpipe/local/feed/service/FeedLoadService.kt

@@ -19,7 +19,6 @@
 
 package org.schabi.newpipe.local.feed.service
 
-import android.app.PendingIntent
 import android.app.Service
 import android.content.BroadcastReceiver
 import android.content.Context
@@ -30,6 +29,7 @@ import android.os.IBinder
 import android.util.Log
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
+import androidx.core.app.PendingIntentCompat
 import androidx.core.app.ServiceCompat
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
 import io.reactivex.rxjava3.core.Flowable
@@ -152,12 +152,8 @@ class FeedLoadService : Service() {
     private lateinit var notificationBuilder: NotificationCompat.Builder
 
     private fun createNotification(): NotificationCompat.Builder {
-        val cancelActionIntent = PendingIntent.getBroadcast(
-            this,
-            NOTIFICATION_ID,
-            Intent(ACTION_CANCEL),
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) PendingIntent.FLAG_IMMUTABLE else 0
-        )
+        val cancelActionIntent = PendingIntentCompat
+            .getBroadcast(this, NOTIFICATION_ID, Intent(ACTION_CANCEL), 0, false)
 
         return NotificationCompat.Builder(this, getString(R.string.notification_channel_id))
             .setOngoing(true)

app/src/main/java/org/schabi/newpipe/local/history/HistoryRecordManager.java

@@ -87,7 +87,7 @@ public class HistoryRecordManager {
      * Marks a stream item as watched such that it is hidden from the feed if watched videos are
      * hidden. Adds a history entry and updates the stream progress to 100%.
      *
-     * @see FeedViewModel#togglePlayedItems
+     * @see FeedViewModel#setSaveShowPlayedItems
      * @param info the item to mark as watched
      * @return a Maybe containing the ID of the item if successful
      */

app/src/main/java/org/schabi/newpipe/local/holder/LocalPlaylistCardItemHolder.java

@@ -0,0 +1,17 @@
+package org.schabi.newpipe.local.holder;
+
+import android.view.ViewGroup;
+
+import org.schabi.newpipe.R;
+import org.schabi.newpipe.local.LocalItemBuilder;
+
+/**
+ * Playlist card layout.
+ */
+public class LocalPlaylistCardItemHolder extends LocalPlaylistItemHolder {
+
+    public LocalPlaylistCardItemHolder(final LocalItemBuilder infoItemBuilder,
+                                       final ViewGroup parent) {
+        super(infoItemBuilder, R.layout.list_playlist_card_item, parent);
+    }
+}

app/src/main/java/org/schabi/newpipe/local/holder/LocalPlaylistItemHolder.java

@@ -4,6 +4,7 @@ import android.view.View;
 import android.view.ViewGroup;
 
 import org.schabi.newpipe.database.LocalItem;
+import org.schabi.newpipe.database.playlist.PlaylistDuplicatesEntry;
 import org.schabi.newpipe.database.playlist.PlaylistMetadataEntry;
 import org.schabi.newpipe.local.LocalItemBuilder;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
@@ -13,6 +14,9 @@ import org.schabi.newpipe.util.Localization;
 import java.time.format.DateTimeFormatter;
 
 public class LocalPlaylistItemHolder extends PlaylistItemHolder {
+
+    private static final float GRAYED_OUT_ALPHA = 0.6f;
+
     public LocalPlaylistItemHolder(final LocalItemBuilder infoItemBuilder, final ViewGroup parent) {
         super(infoItemBuilder, parent);
     }
@@ -38,6 +42,13 @@ public class LocalPlaylistItemHolder extends PlaylistItemHolder {
 
         PicassoHelper.loadPlaylistThumbnail(item.thumbnailUrl).into(itemThumbnailView);
 
+        if (item instanceof PlaylistDuplicatesEntry
+                && ((PlaylistDuplicatesEntry) item).timesStreamIsContained > 0) {
+            itemView.setAlpha(GRAYED_OUT_ALPHA);
+        } else {
+            itemView.setAlpha(1.0f);
+        }
+
         super.updateFromItem(localItem, historyRecordManager, dateTimeFormatter);
     }
 }

app/src/main/java/org/schabi/newpipe/local/holder/LocalPlaylistStreamCardItemHolder.java

@@ -0,0 +1,17 @@
+package org.schabi.newpipe.local.holder;
+
+import android.view.ViewGroup;
+
+import org.schabi.newpipe.R;
+import org.schabi.newpipe.local.LocalItemBuilder;
+
+/**
+ * Local playlist stream UI. This also includes a handle to rearrange the videos.
+ */
+public class LocalPlaylistStreamCardItemHolder extends LocalPlaylistStreamItemHolder {
+
+    public LocalPlaylistStreamCardItemHolder(final LocalItemBuilder infoItemBuilder,
+                                             final ViewGroup parent) {
+        super(infoItemBuilder, R.layout.list_stream_playlist_card_item, parent);
+    }
+}

app/src/main/java/org/schabi/newpipe/local/holder/LocalPlaylistStreamItemHolder.java

@@ -14,6 +14,7 @@ import org.schabi.newpipe.database.playlist.PlaylistStreamEntry;
 import org.schabi.newpipe.ktx.ViewUtils;
 import org.schabi.newpipe.local.LocalItemBuilder;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
+import org.schabi.newpipe.util.DependentPreferenceHelper;
 import org.schabi.newpipe.util.Localization;
 import org.schabi.newpipe.util.PicassoHelper;
 import org.schabi.newpipe.util.ServiceHelper;
@@ -68,7 +69,8 @@ public class LocalPlaylistStreamItemHolder extends LocalItemHolder {
                     R.color.duration_background_color));
             itemDurationView.setVisibility(View.VISIBLE);
 
-            if (item.getProgressMillis() > 0) {
+            if (DependentPreferenceHelper.getPositionsInListsEnabled(itemProgressView.getContext())
+                    && item.getProgressMillis() > 0) {
                 itemProgressView.setVisibility(View.VISIBLE);
                 itemProgressView.setMax((int) item.getStreamEntity().getDuration());
                 itemProgressView.setProgress((int) TimeUnit.MILLISECONDS
@@ -109,7 +111,8 @@ public class LocalPlaylistStreamItemHolder extends LocalItemHolder {
         }
         final PlaylistStreamEntry item = (PlaylistStreamEntry) localItem;
 
-        if (item.getProgressMillis() > 0 && item.getStreamEntity().getDuration() > 0) {
+        if (DependentPreferenceHelper.getPositionsInListsEnabled(itemProgressView.getContext())
+                && item.getProgressMillis() > 0 && item.getStreamEntity().getDuration() > 0) {
             itemProgressView.setMax((int) item.getStreamEntity().getDuration());
             if (itemProgressView.getVisibility() == View.VISIBLE) {
                 itemProgressView.setProgressAnimated((int) TimeUnit.MILLISECONDS

app/src/main/java/org/schabi/newpipe/local/holder/LocalStatisticStreamCardItemHolder.java

@@ -0,0 +1,13 @@
+package org.schabi.newpipe.local.holder;
+
+import android.view.ViewGroup;
+
+import org.schabi.newpipe.R;
+import org.schabi.newpipe.local.LocalItemBuilder;
+
+public class LocalStatisticStreamCardItemHolder extends LocalStatisticStreamItemHolder {
+    public LocalStatisticStreamCardItemHolder(final LocalItemBuilder infoItemBuilder,
+                                              final ViewGroup parent) {
+        super(infoItemBuilder, R.layout.list_stream_card_item, parent);
+    }
+}

app/src/main/java/org/schabi/newpipe/local/holder/LocalStatisticStreamItemHolder.java

@@ -14,6 +14,7 @@ import org.schabi.newpipe.database.stream.StreamStatisticsEntry;
 import org.schabi.newpipe.ktx.ViewUtils;
 import org.schabi.newpipe.local.LocalItemBuilder;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
+import org.schabi.newpipe.util.DependentPreferenceHelper;
 import org.schabi.newpipe.util.Localization;
 import org.schabi.newpipe.util.PicassoHelper;
 import org.schabi.newpipe.util.ServiceHelper;
@@ -97,7 +98,8 @@ public class LocalStatisticStreamItemHolder extends LocalItemHolder {
                     R.color.duration_background_color));
             itemDurationView.setVisibility(View.VISIBLE);
 
-            if (item.getProgressMillis() > 0) {
+            if (DependentPreferenceHelper.getPositionsInListsEnabled(itemProgressView.getContext())
+                    && item.getProgressMillis() > 0) {
                 itemProgressView.setVisibility(View.VISIBLE);
                 itemProgressView.setMax((int) item.getStreamEntity().getDuration());
                 itemProgressView.setProgress((int) TimeUnit.MILLISECONDS
@@ -141,7 +143,8 @@ public class LocalStatisticStreamItemHolder extends LocalItemHolder {
         }
         final StreamStatisticsEntry item = (StreamStatisticsEntry) localItem;
 
-        if (item.getProgressMillis() > 0 && item.getStreamEntity().getDuration() > 0) {
+        if (DependentPreferenceHelper.getPositionsInListsEnabled(itemProgressView.getContext())
+                && item.getProgressMillis() > 0 && item.getStreamEntity().getDuration() > 0) {
             itemProgressView.setMax((int) item.getStreamEntity().getDuration());
             if (itemProgressView.getVisibility() == View.VISIBLE) {
                 itemProgressView.setProgressAnimated((int) TimeUnit.MILLISECONDS

app/src/main/java/org/schabi/newpipe/local/holder/RemotePlaylistCardItemHolder.java

@@ -0,0 +1,17 @@
+package org.schabi.newpipe.local.holder;
+
+import android.view.ViewGroup;
+
+import org.schabi.newpipe.R;
+import org.schabi.newpipe.local.LocalItemBuilder;
+
+/**
+ * Playlist card UI for list item.
+ */
+public class RemotePlaylistCardItemHolder extends RemotePlaylistItemHolder {
+
+    public RemotePlaylistCardItemHolder(final LocalItemBuilder infoItemBuilder,
+                                        final ViewGroup parent) {
+        super(infoItemBuilder, R.layout.list_playlist_card_item, parent);
+    }
+}

app/src/main/java/org/schabi/newpipe/local/playlist/LocalPlaylistFragment.java

@@ -5,12 +5,12 @@ import static org.schabi.newpipe.ktx.ViewUtils.animate;
 import static org.schabi.newpipe.util.ThemeHelper.shouldUseGridLayout;
 
 import android.content.Context;
-import android.content.DialogInterface;
 import android.os.Bundle;
 import android.os.Parcelable;
 import android.text.InputType;
 import android.text.TextUtils;
 import android.util.Log;
+import android.util.Pair;
 import android.view.LayoutInflater;
 import android.view.Menu;
 import android.view.MenuInflater;
@@ -22,6 +22,7 @@ import android.widget.Toast;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.appcompat.app.AlertDialog;
+import androidx.preference.PreferenceManager;
 import androidx.recyclerview.widget.ItemTouchHelper;
 import androidx.recyclerview.widget.RecyclerView;
 import androidx.viewbinding.ViewBinding;
@@ -33,8 +34,8 @@ import org.schabi.newpipe.R;
 import org.schabi.newpipe.database.LocalItem;
 import org.schabi.newpipe.database.history.model.StreamHistoryEntry;
 import org.schabi.newpipe.database.playlist.PlaylistStreamEntry;
+import org.schabi.newpipe.database.playlist.model.PlaylistEntity;
 import org.schabi.newpipe.database.stream.model.StreamEntity;
-import org.schabi.newpipe.database.stream.model.StreamStateEntity;
 import org.schabi.newpipe.databinding.DialogEditTextBinding;
 import org.schabi.newpipe.databinding.LocalPlaylistHeaderBinding;
 import org.schabi.newpipe.databinding.PlaylistControlBinding;
@@ -55,7 +56,6 @@ import org.schabi.newpipe.util.external_communication.ShareUtils;
 
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.Iterator;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -63,7 +63,6 @@ import java.util.stream.Collectors;
 
 import icepick.State;
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
-import io.reactivex.rxjava3.core.Flowable;
 import io.reactivex.rxjava3.core.Single;
 import io.reactivex.rxjava3.disposables.CompositeDisposable;
 import io.reactivex.rxjava3.disposables.Disposable;
@@ -96,8 +95,8 @@ public class LocalPlaylistFragment extends BaseLocalListFragment<List<PlaylistSt
     private AtomicBoolean isLoadingComplete;
     /* Has the playlist been modified (e.g. items reordered or deleted) */
     private AtomicBoolean isModified;
-    /* Is the playlist currently being processed to remove watched videos */
-    private boolean isRemovingWatched = false;
+    /* Flag to prevent simultaneous rewrites of the playlist */
+    private boolean isRewritingPlaylist = false;
 
     public static LocalPlaylistFragment getInstance(final long playlistId, final String name) {
         final LocalPlaylistFragment instance = new LocalPlaylistFragment();
@@ -309,7 +308,7 @@ public class LocalPlaylistFragment extends BaseLocalListFragment<List<PlaylistSt
     ///////////////////////////////////////////////////////////////////////////
 
     private Subscriber<List<PlaylistStreamEntry>> getPlaylistObserver() {
-        return new Subscriber<List<PlaylistStreamEntry>>() {
+        return new Subscriber<>() {
             @Override
             public void onSubscribe(final Subscription s) {
                 showLoading();
@@ -354,20 +353,23 @@ public class LocalPlaylistFragment extends BaseLocalListFragment<List<PlaylistSt
         } else if (item.getItemId() == R.id.menu_item_rename_playlist) {
             createRenameDialog();
         } else if (item.getItemId() == R.id.menu_item_remove_watched) {
-            if (!isRemovingWatched) {
+            if (!isRewritingPlaylist) {
                 new AlertDialog.Builder(requireContext())
                         .setMessage(R.string.remove_watched_popup_warning)
                         .setTitle(R.string.remove_watched_popup_title)
-                        .setPositiveButton(R.string.ok,
-                                (DialogInterface d, int id) -> removeWatchedStreams(false))
+                        .setPositiveButton(R.string.ok, (d, id) ->
+                                removeWatchedStreams(false))
                         .setNeutralButton(
                                 R.string.remove_watched_popup_yes_and_partially_watched_videos,
-                                (DialogInterface d, int id) -> removeWatchedStreams(true))
+                                (d, id) -> removeWatchedStreams(true))
                         .setNegativeButton(R.string.cancel,
-                                (DialogInterface d, int id) -> d.cancel())
-                        .create()
+                                (d, id) -> d.cancel())
                         .show();
             }
+        } else if (item.getItemId() == R.id.menu_item_remove_duplicates) {
+            if (!isRewritingPlaylist) {
+                openRemoveDuplicatesDialog();
+            }
         } else {
             return super.onOptionsItemSelected(item);
         }
@@ -389,83 +391,76 @@ public class LocalPlaylistFragment extends BaseLocalListFragment<List<PlaylistSt
     }
 
     public void removeWatchedStreams(final boolean removePartiallyWatched) {
-        if (isRemovingWatched) {
+        if (isRewritingPlaylist) {
             return;
         }
-        isRemovingWatched = true;
+        isRewritingPlaylist = true;
         showLoading();
 
-        disposables.add(playlistManager.getPlaylistStreams(playlistId)
-                .subscribeOn(Schedulers.io())
-                .map((List<PlaylistStreamEntry> playlist) -> {
-                    // Playlist data
-                    final Iterator<PlaylistStreamEntry> playlistIter = playlist.iterator();
-
-                    // History data
-                    final HistoryRecordManager recordManager =
-                            new HistoryRecordManager(getContext());
-                    final Iterator<StreamHistoryEntry> historyIter = recordManager
-                            .getStreamHistorySortedById().blockingFirst().iterator();
-
+        final var recordManager = new HistoryRecordManager(getContext());
+        final var historyIdsMaybe = recordManager.getStreamHistorySortedById()
+                .firstElement()
+                // already sorted by ^ getStreamHistorySortedById(), binary search can be used
+                .map(historyList -> historyList.stream().map(StreamHistoryEntry::getStreamId)
+                        .collect(Collectors.toList()));
+        final var streamsMaybe = playlistManager.getPlaylistStreams(playlistId)
+                .firstElement()
+                .zipWith(historyIdsMaybe, (playlist, historyStreamIds) -> {
                     // Remove Watched, Functionality data
-                    final List<PlaylistStreamEntry> notWatchedItems = new ArrayList<>();
+                    final List<PlaylistStreamEntry> itemsToKeep = new ArrayList<>();
+                    final boolean isThumbnailPermanent = playlistManager
+                            .getIsPlaylistThumbnailPermanent(playlistId);
                     boolean thumbnailVideoRemoved = false;
 
-                    // already sorted by ^ getStreamHistorySortedById(), binary search can be used
-                    final ArrayList<Long> historyStreamIds = new ArrayList<>();
-                    while (historyIter.hasNext()) {
-                        historyStreamIds.add(historyIter.next().getStreamId());
-                    }
-
                     if (removePartiallyWatched) {
-                        while (playlistIter.hasNext()) {
-                            final PlaylistStreamEntry playlistItem = playlistIter.next();
+                        for (final var playlistItem : playlist) {
                             final int indexInHistory = Collections.binarySearch(historyStreamIds,
                                     playlistItem.getStreamId());
 
                             if (indexInHistory < 0) {
-                                notWatchedItems.add(playlistItem);
-                            } else if (!thumbnailVideoRemoved
-                                    && playlistManager.getPlaylistThumbnail(playlistId)
-                                    .equals(playlistItem.getStreamEntity().getThumbnailUrl())) {
+                                itemsToKeep.add(playlistItem);
+                            } else if (!isThumbnailPermanent && !thumbnailVideoRemoved
+                                    && playlistManager.getPlaylistThumbnailStreamId(playlistId)
+                                    == playlistItem.getStreamEntity().getUid()) {
                                 thumbnailVideoRemoved = true;
                             }
                         }
                     } else {
-                        final Iterator<StreamStateEntity> streamStatesIter = recordManager
-                                .loadLocalStreamStateBatch(playlist).blockingGet().iterator();
+                        final var streamStates = recordManager
+                                .loadLocalStreamStateBatch(playlist).blockingGet();
+
+                        for (int i = 0; i < playlist.size(); i++) {
+                            final var playlistItem = playlist.get(i);
+                            final var streamStateEntity = streamStates.get(i);
 
-                        while (playlistIter.hasNext()) {
-                            final PlaylistStreamEntry playlistItem = playlistIter.next();
                             final int indexInHistory = Collections.binarySearch(historyStreamIds,
                                     playlistItem.getStreamId());
-                            final StreamStateEntity streamStateEntity = streamStatesIter.next();
                             final long duration = playlistItem.toStreamInfoItem().getDuration();
 
                             if (indexInHistory < 0 || (streamStateEntity != null
                                     && !streamStateEntity.isFinished(duration))) {
-                                notWatchedItems.add(playlistItem);
-                            } else if (!thumbnailVideoRemoved
-                                    && playlistManager.getPlaylistThumbnail(playlistId)
-                                    .equals(playlistItem.getStreamEntity().getThumbnailUrl())) {
+                                itemsToKeep.add(playlistItem);
+                            } else if (!isThumbnailPermanent && !thumbnailVideoRemoved
+                                    && playlistManager.getPlaylistThumbnailStreamId(playlistId)
+                                    == playlistItem.getStreamEntity().getUid()) {
                                 thumbnailVideoRemoved = true;
                             }
                         }
                     }
 
-                    return Flowable.just(notWatchedItems, thumbnailVideoRemoved);
-                })
+                    return new Pair<>(itemsToKeep, thumbnailVideoRemoved);
+                });
+
+        disposables.add(streamsMaybe.subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
                 .subscribe(flow -> {
-                    final List<PlaylistStreamEntry> notWatchedItems =
-                            (List<PlaylistStreamEntry>) flow.blockingFirst();
-                    final boolean thumbnailVideoRemoved = (Boolean) flow.blockingLast();
+                    final List<PlaylistStreamEntry> itemsToKeep = flow.first;
+                    final boolean thumbnailVideoRemoved = flow.second;
 
                     itemListAdapter.clearStreamItemList();
-                    itemListAdapter.addItems(notWatchedItems);
+                    itemListAdapter.addItems(itemsToKeep);
                     saveChanges();
 
-
                     if (thumbnailVideoRemoved) {
                         updateThumbnailUrl();
                     }
@@ -477,7 +472,7 @@ public class LocalPlaylistFragment extends BaseLocalListFragment<List<PlaylistSt
                     }
 
                     hideLoading();
-                    isRemovingWatched = false;
+                    isRewritingPlaylist = false;
                 }, throwable -> showError(new ErrorInfo(throwable, UserAction.REQUESTED_BOOKMARK,
                         "Removing watched videos, partially watched=" + removePartiallyWatched))));
     }
@@ -503,13 +498,18 @@ public class LocalPlaylistFragment extends BaseLocalListFragment<List<PlaylistSt
         }
         setVideoCount(itemListAdapter.getItemsList().size());
 
-        playlistControlBinding.playlistCtrlPlayAllButton.setOnClickListener(view ->
-                NavigationHelper.playOnMainPlayer(activity, getPlayQueue()));
-        playlistControlBinding.playlistCtrlPlayPopupButton.setOnClickListener(view ->
-                NavigationHelper.playOnPopupPlayer(activity, getPlayQueue(), false));
-        playlistControlBinding.playlistCtrlPlayBgButton.setOnClickListener(view ->
-                NavigationHelper.playOnBackgroundPlayer(activity, getPlayQueue(), false));
-
+        playlistControlBinding.playlistCtrlPlayAllButton.setOnClickListener(view -> {
+            NavigationHelper.playOnMainPlayer(activity, getPlayQueue());
+            showHoldToAppendTipIfNeeded();
+        });
+        playlistControlBinding.playlistCtrlPlayPopupButton.setOnClickListener(view -> {
+            NavigationHelper.playOnPopupPlayer(activity, getPlayQueue(), false);
+            showHoldToAppendTipIfNeeded();
+        });
+        playlistControlBinding.playlistCtrlPlayBgButton.setOnClickListener(view -> {
+            NavigationHelper.playOnBackgroundPlayer(activity, getPlayQueue(), false);
+            showHoldToAppendTipIfNeeded();
+        });
         playlistControlBinding.playlistCtrlPlayPopupButton.setOnLongClickListener(view -> {
             NavigationHelper.enqueueOnPlayer(activity, getPlayQueue(), PlayerType.POPUP);
             return true;
@@ -523,6 +523,13 @@ public class LocalPlaylistFragment extends BaseLocalListFragment<List<PlaylistSt
         hideLoading();
     }
 
+    private void showHoldToAppendTipIfNeeded() {
+        if (PreferenceManager.getDefaultSharedPreferences(activity)
+                .getBoolean(getString(R.string.show_hold_to_append_key), true)) {
+            Toast.makeText(activity, R.string.hold_to_append, Toast.LENGTH_SHORT).show();
+        }
+    }
+
     ///////////////////////////////////////////////////////////////////////////
     // Fragment Error Handling
     ///////////////////////////////////////////////////////////////////////////
@@ -551,15 +558,14 @@ public class LocalPlaylistFragment extends BaseLocalListFragment<List<PlaylistSt
         dialogBinding.dialogEditText.setSelection(dialogBinding.dialogEditText.getText().length());
         dialogBinding.dialogEditText.setText(name);
 
-        final AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(getContext())
+        new AlertDialog.Builder(getContext())
                 .setTitle(R.string.rename_playlist)
                 .setView(dialogBinding.getRoot())
                 .setCancelable(true)
                 .setNegativeButton(R.string.cancel, null)
                 .setPositiveButton(R.string.rename, (dialogInterface, i) ->
-                        changePlaylistName(dialogBinding.dialogEditText.getText().toString()));
-
-        dialogBuilder.show();
+                        changePlaylistName(dialogBinding.dialogEditText.getText().toString()))
+                .show();
     }
 
     private void changePlaylistName(final String title) {
@@ -583,8 +589,9 @@ public class LocalPlaylistFragment extends BaseLocalListFragment<List<PlaylistSt
         disposables.add(disposable);
     }
 
-    private void changeThumbnailUrl(final String thumbnailUrl) {
-        if (playlistManager == null) {
+    private void changeThumbnailStreamId(final long thumbnailStreamId, final boolean isPermanent) {
+        if (playlistManager == null || (!isPermanent && playlistManager
+                .getIsPlaylistThumbnailPermanent(playlistId))) {
             return;
         }
 
@@ -594,11 +601,11 @@ public class LocalPlaylistFragment extends BaseLocalListFragment<List<PlaylistSt
 
         if (DEBUG) {
             Log.d(TAG, "Updating playlist id=[" + playlistId + "] "
-                    + "with new thumbnail url=[" + thumbnailUrl + "]");
+                    + "with new thumbnail stream id=[" + thumbnailStreamId + "]");
         }
 
         final Disposable disposable = playlistManager
-                .changePlaylistThumbnail(playlistId, thumbnailUrl)
+                .changePlaylistThumbnail(playlistId, thumbnailStreamId, isPermanent)
                 .observeOn(AndroidSchedulers.mainThread())
                 .subscribe(ignore -> successToast.show(), throwable ->
                         showError(new ErrorInfo(throwable, UserAction.REQUESTED_BOOKMARK,
@@ -607,16 +614,55 @@ public class LocalPlaylistFragment extends BaseLocalListFragment<List<PlaylistSt
     }
 
     private void updateThumbnailUrl() {
-        final String newThumbnailUrl;
-
-        if (!itemListAdapter.getItemsList().isEmpty()) {
-            newThumbnailUrl = ((PlaylistStreamEntry) itemListAdapter.getItemsList().get(0))
-                    .getStreamEntity().getThumbnailUrl();
-        } else {
-            newThumbnailUrl = "drawable://" + R.drawable.placeholder_thumbnail_playlist;
+        if (playlistManager.getIsPlaylistThumbnailPermanent(playlistId)) {
+            return;
         }
 
-        changeThumbnailUrl(newThumbnailUrl);
+        final long thumbnailStreamId;
+
+        if (!itemListAdapter.getItemsList().isEmpty()) {
+            thumbnailStreamId = ((PlaylistStreamEntry) itemListAdapter.getItemsList().get(0))
+                    .getStreamEntity().getUid();
+        } else {
+            thumbnailStreamId = PlaylistEntity.DEFAULT_THUMBNAIL_ID;
+        }
+
+        changeThumbnailStreamId(thumbnailStreamId, false);
+    }
+
+    private void openRemoveDuplicatesDialog() {
+        new AlertDialog.Builder(this.getActivity())
+                .setTitle(R.string.remove_duplicates_title)
+                .setMessage(R.string.remove_duplicates_message)
+                .setPositiveButton(R.string.ok, (dialog, i) ->
+                        removeDuplicatesInPlaylist())
+                .setNeutralButton(R.string.cancel, null)
+                .show();
+    }
+
+    private void removeDuplicatesInPlaylist() {
+        if (isRewritingPlaylist) {
+            return;
+        }
+        isRewritingPlaylist = true;
+        showLoading();
+
+        final var streamsMaybe = playlistManager
+                .getDistinctPlaylistStreams(playlistId).firstElement();
+
+
+        disposables.add(streamsMaybe.subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe(itemsToKeep -> {
+                    itemListAdapter.clearStreamItemList();
+                    itemListAdapter.addItems(itemsToKeep);
+                    setVideoCount(itemListAdapter.getItemsList().size());
+                    saveChanges();
+
+                    hideLoading();
+                    isRewritingPlaylist = false;
+                }, throwable -> showError(new ErrorInfo(throwable, UserAction.REQUESTED_BOOKMARK,
+                        "Removing duplicated streams"))));
     }
 
     private void deleteItem(final PlaylistStreamEntry item) {
@@ -625,8 +671,7 @@ public class LocalPlaylistFragment extends BaseLocalListFragment<List<PlaylistSt
         }
 
         itemListAdapter.removeItem(item);
-        if (playlistManager.getPlaylistThumbnail(playlistId)
-                .equals(item.getStreamEntity().getThumbnailUrl())) {
+        if (playlistManager.getPlaylistThumbnailStreamId(playlistId) == item.getStreamId()) {
             updateThumbnailUrl();
         }
 
@@ -784,7 +829,8 @@ public class LocalPlaylistFragment extends BaseLocalListFragment<List<PlaylistSt
                     .setAction(
                             StreamDialogDefaultEntry.SET_AS_PLAYLIST_THUMBNAIL,
                             (f, i) ->
-                                    changeThumbnailUrl(item.getStreamEntity().getThumbnailUrl()))
+                                    changeThumbnailStreamId(item.getStreamEntity().getUid(),
+                                            true))
                     .setAction(
                             StreamDialogDefaultEntry.DELETE,
                             (f, i) -> deleteItem(item))

app/src/main/java/org/schabi/newpipe/local/playlist/LocalPlaylistManager.java

@@ -3,6 +3,7 @@ package org.schabi.newpipe.local.playlist;
 import androidx.annotation.Nullable;
 
 import org.schabi.newpipe.database.AppDatabase;
+import org.schabi.newpipe.database.playlist.PlaylistDuplicatesEntry;
 import org.schabi.newpipe.database.playlist.PlaylistMetadataEntry;
 import org.schabi.newpipe.database.playlist.PlaylistStreamEntry;
 import org.schabi.newpipe.database.playlist.dao.PlaylistDAO;
@@ -22,6 +23,8 @@ import io.reactivex.rxjava3.core.Single;
 import io.reactivex.rxjava3.schedulers.Schedulers;
 
 public class LocalPlaylistManager {
+    private static final long THUMBNAIL_ID_LEAVE_UNCHANGED = -2;
+
     private final AppDatabase database;
     private final StreamDAO streamTable;
     private final PlaylistDAO playlistTable;
@@ -39,30 +42,34 @@ public class LocalPlaylistManager {
         if (streams.isEmpty()) {
             return Maybe.empty();
         }
-        final StreamEntity defaultStream = streams.get(0);
-        final PlaylistEntity newPlaylist =
-                new PlaylistEntity(name, defaultStream.getThumbnailUrl());
 
-        return Maybe.fromCallable(() -> database.runInTransaction(() ->
-                upsertStreams(playlistTable.insert(newPlaylist), streams, 0))
-        ).subscribeOn(Schedulers.io());
+        return Maybe.fromCallable(() -> database.runInTransaction(() -> {
+                    final List<Long> streamIds = streamTable.upsertAll(streams);
+                    final PlaylistEntity newPlaylist = new PlaylistEntity(name, false,
+                            streamIds.get(0));
+
+                    return insertJoinEntities(playlistTable.insert(newPlaylist),
+                            streamIds, 0);
+                }
+        )).subscribeOn(Schedulers.io());
     }
 
     public Maybe<List<Long>> appendToPlaylist(final long playlistId,
                                               final List<StreamEntity> streams) {
         return playlistStreamTable.getMaximumIndexOf(playlistId)
                 .firstElement()
-                .map(maxJoinIndex -> database.runInTransaction(() ->
-                        upsertStreams(playlistId, streams, maxJoinIndex + 1))
-                ).subscribeOn(Schedulers.io());
+                .map(maxJoinIndex -> database.runInTransaction(() -> {
+                            final List<Long> streamIds = streamTable.upsertAll(streams);
+                            return insertJoinEntities(playlistId, streamIds, maxJoinIndex + 1);
+                        }
+                )).subscribeOn(Schedulers.io());
     }
 
-    private List<Long> upsertStreams(final long playlistId,
-                                     final List<StreamEntity> streams,
-                                     final int indexOffset) {
+    private List<Long> insertJoinEntities(final long playlistId, final List<Long> streamIds,
+                                          final int indexOffset) {
+
+        final List<PlaylistStreamEntity> joinEntities = new ArrayList<>(streamIds.size());
 
-        final List<PlaylistStreamEntity> joinEntities = new ArrayList<>(streams.size());
-        final List<Long> streamIds = streamTable.upsertAll(streams);
         for (int index = 0; index < streamIds.size(); index++) {
             joinEntities.add(new PlaylistStreamEntity(playlistId, streamIds.get(index),
                     index + indexOffset));
@@ -86,6 +93,23 @@ public class LocalPlaylistManager {
         return playlistStreamTable.getPlaylistMetadata().subscribeOn(Schedulers.io());
     }
 
+    public Flowable<List<PlaylistStreamEntry>> getDistinctPlaylistStreams(final long playlistId) {
+        return playlistStreamTable
+                .getStreamsWithoutDuplicates(playlistId).subscribeOn(Schedulers.io());
+    }
+
+    /**
+     * Get playlists with attached information about how many times the provided stream is already
+     * contained in each playlist.
+     *
+     * @param streamUrl the stream url for which to check for duplicates
+     * @return a list of {@link PlaylistDuplicatesEntry}
+     */
+    public Flowable<List<PlaylistDuplicatesEntry>> getPlaylistDuplicates(final String streamUrl) {
+        return playlistStreamTable.getPlaylistDuplicatesMetadata(streamUrl)
+                .subscribeOn(Schedulers.io());
+    }
+
     public Flowable<List<PlaylistStreamEntry>> getPlaylistStreams(final long playlistId) {
         return playlistStreamTable.getOrderedStreamsOf(playlistId).subscribeOn(Schedulers.io());
     }
@@ -96,21 +120,37 @@ public class LocalPlaylistManager {
     }
 
     public Maybe<Integer> renamePlaylist(final long playlistId, final String name) {
-        return modifyPlaylist(playlistId, name, null);
+        return modifyPlaylist(playlistId, name, THUMBNAIL_ID_LEAVE_UNCHANGED, false);
     }
 
     public Maybe<Integer> changePlaylistThumbnail(final long playlistId,
-                                                  final String thumbnailUrl) {
-        return modifyPlaylist(playlistId, null, thumbnailUrl);
+                                                  final long thumbnailStreamId,
+                                                  final boolean isPermanent) {
+        return modifyPlaylist(playlistId, null, thumbnailStreamId, isPermanent);
     }
 
-    public String getPlaylistThumbnail(final long playlistId) {
-        return playlistTable.getPlaylist(playlistId).blockingFirst().get(0).getThumbnailUrl();
+    public long getPlaylistThumbnailStreamId(final long playlistId) {
+        return playlistTable.getPlaylist(playlistId).blockingFirst().get(0).getThumbnailStreamId();
+    }
+
+    public boolean getIsPlaylistThumbnailPermanent(final long playlistId) {
+        return playlistTable.getPlaylist(playlistId).blockingFirst().get(0)
+                .getIsThumbnailPermanent();
+    }
+
+    public long getAutomaticPlaylistThumbnailStreamId(final long playlistId) {
+        final long streamId = playlistStreamTable.getAutomaticThumbnailStreamId(playlistId)
+                .blockingFirst();
+        if (streamId < 0) {
+            return PlaylistEntity.DEFAULT_THUMBNAIL_ID;
+        }
+        return streamId;
     }
 
     private Maybe<Integer> modifyPlaylist(final long playlistId,
                                           @Nullable final String name,
-                                          @Nullable final String thumbnailUrl) {
+                                          final long thumbnailStreamId,
+                                          final boolean isPermanent) {
         return playlistTable.getPlaylist(playlistId)
                 .firstElement()
                 .filter(playlistEntities -> !playlistEntities.isEmpty())
@@ -119,8 +159,9 @@ public class LocalPlaylistManager {
                     if (name != null) {
                         playlist.setName(name);
                     }
-                    if (thumbnailUrl != null) {
-                        playlist.setThumbnailUrl(thumbnailUrl);
+                    if (thumbnailStreamId != THUMBNAIL_ID_LEAVE_UNCHANGED) {
+                        playlist.setThumbnailStreamId(thumbnailStreamId);
+                        playlist.setIsThumbnailPermanent(isPermanent);
                     }
                     return playlistTable.update(playlist);
                 }).subscribeOn(Schedulers.io());

app/src/main/java/org/schabi/newpipe/local/subscription/FeedGroupIcon.kt

@@ -51,7 +51,8 @@ enum class FeedGroupIcon(
     WORLD(34, R.drawable.ic_public),
     STAR(35, R.drawable.ic_stars),
     SUN(36, R.drawable.ic_wb_sunny),
-    RSS(37, R.drawable.ic_rss_feed);
+    RSS(37, R.drawable.ic_rss_feed),
+    WHATS_NEW(38, R.drawable.ic_subscriptions);
 
     @DrawableRes
     fun getDrawableRes(): Int {

app/src/main/java/org/schabi/newpipe/local/subscription/SubscriptionFragment.kt

@@ -22,13 +22,12 @@ import androidx.lifecycle.ViewModelProvider
 import androidx.recyclerview.widget.GridLayoutManager
 import com.xwray.groupie.Group
 import com.xwray.groupie.GroupAdapter
-import com.xwray.groupie.Item
 import com.xwray.groupie.Section
 import com.xwray.groupie.viewbinding.GroupieViewHolder
 import icepick.State
 import io.reactivex.rxjava3.disposables.CompositeDisposable
 import org.schabi.newpipe.R
-import org.schabi.newpipe.database.feed.model.FeedGroupEntity
+import org.schabi.newpipe.database.feed.model.FeedGroupEntity.Companion.GROUP_ALL_ID
 import org.schabi.newpipe.databinding.DialogTitleBinding
 import org.schabi.newpipe.databinding.FeedItemCarouselBinding
 import org.schabi.newpipe.databinding.FragmentSubscriptionBinding
@@ -42,12 +41,14 @@ import org.schabi.newpipe.local.subscription.SubscriptionViewModel.SubscriptionS
 import org.schabi.newpipe.local.subscription.dialog.FeedGroupDialog
 import org.schabi.newpipe.local.subscription.dialog.FeedGroupReorderDialog
 import org.schabi.newpipe.local.subscription.item.ChannelItem
-import org.schabi.newpipe.local.subscription.item.EmptyPlaceholderItem
-import org.schabi.newpipe.local.subscription.item.FeedGroupAddItem
+import org.schabi.newpipe.local.subscription.item.FeedGroupAddNewGridItem
+import org.schabi.newpipe.local.subscription.item.FeedGroupAddNewItem
+import org.schabi.newpipe.local.subscription.item.FeedGroupCardGridItem
 import org.schabi.newpipe.local.subscription.item.FeedGroupCardItem
 import org.schabi.newpipe.local.subscription.item.FeedGroupCarouselItem
-import org.schabi.newpipe.local.subscription.item.HeaderWithMenuItem
-import org.schabi.newpipe.local.subscription.item.HeaderWithMenuItem.Companion.PAYLOAD_UPDATE_VISIBILITY_MENU_ITEM
+import org.schabi.newpipe.local.subscription.item.GroupsHeader
+import org.schabi.newpipe.local.subscription.item.Header
+import org.schabi.newpipe.local.subscription.item.ImportSubscriptionsHintPlaceholderItem
 import org.schabi.newpipe.local.subscription.services.SubscriptionsExportService
 import org.schabi.newpipe.local.subscription.services.SubscriptionsImportService
 import org.schabi.newpipe.local.subscription.services.SubscriptionsImportService.KEY_MODE
@@ -59,7 +60,6 @@ import org.schabi.newpipe.util.NavigationHelper
 import org.schabi.newpipe.util.OnClickGesture
 import org.schabi.newpipe.util.ServiceHelper
 import org.schabi.newpipe.util.ThemeHelper.getGridSpanCountChannels
-import org.schabi.newpipe.util.ThemeHelper.shouldUseGridLayout
 import org.schabi.newpipe.util.external_communication.ShareUtils
 import java.text.SimpleDateFormat
 import java.util.Date
@@ -74,9 +74,9 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
     private val disposables: CompositeDisposable = CompositeDisposable()
 
     private val groupAdapter = GroupAdapter<GroupieViewHolder<FeedItemCarouselBinding>>()
-    private val feedGroupsSection = Section()
-    private var feedGroupsCarousel: FeedGroupCarouselItem? = null
-    private lateinit var feedGroupsSortMenuItem: HeaderWithMenuItem
+    private lateinit var carouselAdapter: GroupAdapter<GroupieViewHolder<FeedItemCarouselBinding>>
+    private lateinit var feedGroupsCarousel: FeedGroupCarouselItem
+    private lateinit var feedGroupsSortMenuItem: GroupsHeader
     private val subscriptionsSection = Section()
 
     private val requestExportLauncher =
@@ -90,7 +90,7 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
 
     @State
     @JvmField
-    var feedGroupsListState: Parcelable? = null
+    var feedGroupsCarouselState: Parcelable? = null
 
     init {
         setHasOptionsMenu(true)
@@ -100,11 +100,6 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
     // Fragment LifeCycle
     // /////////////////////////////////////////////////////////////////////////
 
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setupInitialLayout()
-    }
-
     override fun onAttach(context: Context) {
         super.onAttach(context)
         subscriptionManager = SubscriptionManager(requireContext())
@@ -117,7 +112,7 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
     override fun onPause() {
         super.onPause()
         itemsListState = binding.itemsList.layoutManager?.onSaveInstanceState()
-        feedGroupsListState = feedGroupsCarousel?.onSaveInstanceState()
+        feedGroupsCarouselState = feedGroupsCarousel.onSaveInstanceState()
     }
 
     override fun onDestroy() {
@@ -184,7 +179,7 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
         menuItem: MenuItem,
         onClick: Runnable
     ): MenuItem {
-        menuItem.setOnMenuItemClickListener { _ ->
+        menuItem.setOnMenuItemClickListener {
             onClick.run()
             true
         }
@@ -245,64 +240,90 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
     // Fragment Views
     // ////////////////////////////////////////////////////////////////////////
 
+    override fun initViews(rootView: View, savedInstanceState: Bundle?) {
+        super.initViews(rootView, savedInstanceState)
+        _binding = FragmentSubscriptionBinding.bind(rootView)
+
+        groupAdapter.spanCount = if (SubscriptionViewModel.shouldUseGridForSubscription(requireContext())) getGridSpanCountChannels(context) else 1
+        binding.itemsList.layoutManager = GridLayoutManager(requireContext(), groupAdapter.spanCount).apply {
+            spanSizeLookup = groupAdapter.spanSizeLookup
+        }
+        binding.itemsList.adapter = groupAdapter
+        binding.itemsList.itemAnimator = null
+
+        viewModel = ViewModelProvider(this)[SubscriptionViewModel::class.java]
+        viewModel.stateLiveData.observe(viewLifecycleOwner) { it?.let(this::handleResult) }
+        viewModel.feedGroupsLiveData.observe(viewLifecycleOwner) {
+            it?.let { (groups, listViewMode) ->
+                handleFeedGroups(groups, listViewMode)
+            }
+        }
+
+        setupInitialLayout()
+    }
+
     private fun setupInitialLayout() {
         Section().apply {
-            val carouselAdapter = GroupAdapter<GroupieViewHolder<FeedItemCarouselBinding>>()
-
-            carouselAdapter.add(FeedGroupCardItem(-1, getString(R.string.all), FeedGroupIcon.RSS))
-            carouselAdapter.add(feedGroupsSection)
-            carouselAdapter.add(FeedGroupAddItem())
+            carouselAdapter = GroupAdapter<GroupieViewHolder<FeedItemCarouselBinding>>()
 
             carouselAdapter.setOnItemClickListener { item, _ ->
-                listenerFeedGroups.selected(item)
+                when (item) {
+                    is FeedGroupCardItem ->
+                        NavigationHelper.openFeedFragment(fm, item.groupId, item.name)
+                    is FeedGroupCardGridItem ->
+                        NavigationHelper.openFeedFragment(fm, item.groupId, item.name)
+                    is FeedGroupAddNewItem ->
+                        FeedGroupDialog.newInstance().show(fm, null)
+                    is FeedGroupAddNewGridItem ->
+                        FeedGroupDialog.newInstance().show(fm, null)
+                }
             }
             carouselAdapter.setOnItemLongClickListener { item, _ ->
-                if (item is FeedGroupCardItem) {
-                    if (item.groupId == FeedGroupEntity.GROUP_ALL_ID) {
-                        return@setOnItemLongClickListener false
-                    }
+                if ((item is FeedGroupCardItem && item.groupId == GROUP_ALL_ID) ||
+                    (item is FeedGroupCardGridItem && item.groupId == GROUP_ALL_ID)
+                ) {
+                    return@setOnItemLongClickListener false
+                }
+
+                when (item) {
+                    is FeedGroupCardItem ->
+                        FeedGroupDialog.newInstance(item.groupId).show(fm, null)
+                    is FeedGroupCardGridItem ->
+                        FeedGroupDialog.newInstance(item.groupId).show(fm, null)
                 }
-                listenerFeedGroups.held(item)
                 return@setOnItemLongClickListener true
             }
 
-            feedGroupsCarousel = FeedGroupCarouselItem(requireContext(), carouselAdapter)
-            feedGroupsSortMenuItem = HeaderWithMenuItem(
-                getString(R.string.feed_groups_header_title),
-                R.drawable.ic_sort,
-                menuItemOnClickListener = ::openReorderDialog
+            feedGroupsCarousel = FeedGroupCarouselItem(
+                carouselAdapter = carouselAdapter,
+                listViewMode = viewModel.getListViewMode()
             )
-            add(Section(feedGroupsSortMenuItem, listOf(feedGroupsCarousel)))
 
+            feedGroupsSortMenuItem = GroupsHeader(
+                title = getString(R.string.feed_groups_header_title),
+                onSortClicked = ::openReorderDialog,
+                onToggleListViewModeClicked = ::toggleListViewMode,
+                listViewMode = viewModel.getListViewMode(),
+            )
+
+            add(Section(feedGroupsSortMenuItem, listOf(feedGroupsCarousel)))
+            groupAdapter.clear()
             groupAdapter.add(this)
         }
 
-        subscriptionsSection.setPlaceholder(EmptyPlaceholderItem())
+        subscriptionsSection.setPlaceholder(ImportSubscriptionsHintPlaceholderItem())
         subscriptionsSection.setHideWhenEmpty(true)
 
         groupAdapter.add(
             Section(
-                HeaderWithMenuItem(
-                    getString(R.string.tab_subscriptions)
-                ),
+                Header(getString(R.string.tab_subscriptions)),
                 listOf(subscriptionsSection)
             )
         )
     }
 
-    override fun initViews(rootView: View, savedInstanceState: Bundle?) {
-        super.initViews(rootView, savedInstanceState)
-        _binding = FragmentSubscriptionBinding.bind(rootView)
-
-        groupAdapter.spanCount = if (shouldUseGridLayout(context)) getGridSpanCountChannels(context) else 1
-        binding.itemsList.layoutManager = GridLayoutManager(requireContext(), groupAdapter.spanCount).apply {
-            spanSizeLookup = groupAdapter.spanSizeLookup
-        }
-        binding.itemsList.adapter = groupAdapter
-
-        viewModel = ViewModelProvider(this).get(SubscriptionViewModel::class.java)
-        viewModel.stateLiveData.observe(viewLifecycleOwner) { it?.let(this::handleResult) }
-        viewModel.feedGroupsLiveData.observe(viewLifecycleOwner) { it?.let(this::handleFeedGroups) }
+    private fun toggleListViewMode() {
+        viewModel.setListViewMode(!viewModel.getListViewMode())
     }
 
     private fun showLongTapDialog(selectedItem: ChannelInfoItem) {
@@ -331,7 +352,6 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
         AlertDialog.Builder(requireContext())
             .setCustomTitle(dialogTitleBinding.root)
             .setItems(commands, actions)
-            .create()
             .show()
     }
 
@@ -346,21 +366,6 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
     override fun doInitialLoadLogic() = Unit
     override fun startLoading(forceLoad: Boolean) = Unit
 
-    private val listenerFeedGroups = object : OnClickGesture<Item<*>> {
-        override fun selected(selectedItem: Item<*>?) {
-            when (selectedItem) {
-                is FeedGroupCardItem -> NavigationHelper.openFeedFragment(fm, selectedItem.groupId, selectedItem.name)
-                is FeedGroupAddItem -> FeedGroupDialog.newInstance().show(fm, null)
-            }
-        }
-
-        override fun held(selectedItem: Item<*>?) {
-            when (selectedItem) {
-                is FeedGroupCardItem -> FeedGroupDialog.newInstance(selectedItem.groupId).show(fm, null)
-            }
-        }
-    }
-
     private val listenerChannelItem = object : OnClickGesture<ChannelInfoItem> {
         override fun selected(selectedItem: ChannelInfoItem) = NavigationHelper.openChannelFragment(
             fm,
@@ -373,15 +378,15 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
     override fun handleResult(result: SubscriptionState) {
         super.handleResult(result)
 
-        val shouldUseGridLayout = shouldUseGridLayout(context)
         when (result) {
             is SubscriptionState.LoadedState -> {
                 result.subscriptions.forEach {
                     if (it is ChannelItem) {
                         it.gesturesListener = listenerChannelItem
-                        it.itemVersion = when {
-                            shouldUseGridLayout -> ChannelItem.ItemVersion.GRID
-                            else -> ChannelItem.ItemVersion.MINI
+                        it.itemVersion = if (SubscriptionViewModel.shouldUseGridForSubscription(requireContext())) {
+                            ChannelItem.ItemVersion.GRID
+                        } else {
+                            ChannelItem.ItemVersion.MINI
                         }
                     }
                 }
@@ -402,16 +407,38 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
         }
     }
 
-    private fun handleFeedGroups(groups: List<Group>) {
-        feedGroupsSection.update(groups)
-
-        if (feedGroupsListState != null) {
-            feedGroupsCarousel?.onRestoreInstanceState(feedGroupsListState)
-            feedGroupsListState = null
+    private fun handleFeedGroups(groups: List<Group>, listViewMode: Boolean) {
+        if (feedGroupsCarouselState != null) {
+            feedGroupsCarousel.onRestoreInstanceState(feedGroupsCarouselState)
+            feedGroupsCarouselState = null
         }
 
-        feedGroupsSortMenuItem.showMenuItem = groups.size > 1
-        binding.itemsList.post { feedGroupsSortMenuItem.notifyChanged(PAYLOAD_UPDATE_VISIBILITY_MENU_ITEM) }
+        binding.itemsList.post {
+            if (context == null) {
+                // since this part was posted to the next UI cycle, the fragment might have been
+                // removed in the meantime
+                return@post
+            }
+
+            feedGroupsCarousel.listViewMode = listViewMode
+            feedGroupsSortMenuItem.showSortButton = groups.size > 1
+            feedGroupsSortMenuItem.listViewMode = listViewMode
+            feedGroupsCarousel.notifyChanged(FeedGroupCarouselItem.PAYLOAD_UPDATE_LIST_VIEW_MODE)
+            feedGroupsSortMenuItem.notifyChanged(GroupsHeader.PAYLOAD_UPDATE_ICONS)
+
+            // update items here to prevent flickering
+            carouselAdapter.apply {
+                clear()
+                if (listViewMode) {
+                    add(FeedGroupAddNewItem())
+                    add(FeedGroupCardItem(GROUP_ALL_ID, getString(R.string.all), FeedGroupIcon.WHATS_NEW))
+                } else {
+                    add(FeedGroupAddNewGridItem())
+                    add(FeedGroupCardGridItem(GROUP_ALL_ID, getString(R.string.all), FeedGroupIcon.WHATS_NEW))
+                }
+                addAll(groups)
+            }
+        }
     }
 
     // /////////////////////////////////////////////////////////////////////////

app/src/main/java/org/schabi/newpipe/local/subscription/SubscriptionViewModel.kt

@@ -1,29 +1,51 @@
 package org.schabi.newpipe.local.subscription
 
 import android.app.Application
+import android.content.Context
 import androidx.lifecycle.AndroidViewModel
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
 import com.xwray.groupie.Group
+import io.reactivex.rxjava3.core.Flowable
+import io.reactivex.rxjava3.processors.BehaviorProcessor
 import io.reactivex.rxjava3.schedulers.Schedulers
+import org.schabi.newpipe.info_list.ItemViewMode
 import org.schabi.newpipe.local.feed.FeedDatabaseManager
 import org.schabi.newpipe.local.subscription.item.ChannelItem
+import org.schabi.newpipe.local.subscription.item.FeedGroupCardGridItem
 import org.schabi.newpipe.local.subscription.item.FeedGroupCardItem
 import org.schabi.newpipe.util.DEFAULT_THROTTLE_TIMEOUT
+import org.schabi.newpipe.util.ThemeHelper.getItemViewMode
 import java.util.concurrent.TimeUnit
 
 class SubscriptionViewModel(application: Application) : AndroidViewModel(application) {
     private var feedDatabaseManager: FeedDatabaseManager = FeedDatabaseManager(application)
     private var subscriptionManager = SubscriptionManager(application)
 
-    private val mutableStateLiveData = MutableLiveData<SubscriptionState>()
-    private val mutableFeedGroupsLiveData = MutableLiveData<List<Group>>()
-    val stateLiveData: LiveData<SubscriptionState> = mutableStateLiveData
-    val feedGroupsLiveData: LiveData<List<Group>> = mutableFeedGroupsLiveData
+    // true -> list view, false -> grid view
+    private val listViewMode = BehaviorProcessor.createDefault(
+        !shouldUseGridForSubscription(application)
+    )
+    private val listViewModeFlowable = listViewMode.distinctUntilChanged()
 
-    private var feedGroupItemsDisposable = feedDatabaseManager.groups()
+    private val mutableStateLiveData = MutableLiveData<SubscriptionState>()
+    private val mutableFeedGroupsLiveData = MutableLiveData<Pair<List<Group>, Boolean>>()
+    val stateLiveData: LiveData<SubscriptionState> = mutableStateLiveData
+    val feedGroupsLiveData: LiveData<Pair<List<Group>, Boolean>> = mutableFeedGroupsLiveData
+
+    private var feedGroupItemsDisposable = Flowable
+        .combineLatest(
+            feedDatabaseManager.groups(),
+            listViewModeFlowable,
+            ::Pair
+        )
         .throttleLatest(DEFAULT_THROTTLE_TIMEOUT, TimeUnit.MILLISECONDS)
-        .map { it.map(::FeedGroupCardItem) }
+        .map { (feedGroups, listViewMode) ->
+            Pair(
+                feedGroups.map(if (listViewMode) ::FeedGroupCardItem else ::FeedGroupCardGridItem),
+                listViewMode
+            )
+        }
         .subscribeOn(Schedulers.io())
         .subscribe(
             { mutableFeedGroupsLiveData.postValue(it) },
@@ -45,8 +67,38 @@ class SubscriptionViewModel(application: Application) : AndroidViewModel(applica
         feedGroupItemsDisposable.dispose()
     }
 
+    fun setListViewMode(newListViewMode: Boolean) {
+        listViewMode.onNext(newListViewMode)
+    }
+
+    fun getListViewMode(): Boolean {
+        return listViewMode.value ?: true
+    }
+
     sealed class SubscriptionState {
         data class LoadedState(val subscriptions: List<Group>) : SubscriptionState()
         data class ErrorState(val error: Throwable? = null) : SubscriptionState()
     }
+
+    companion object {
+
+        /**
+         * Returns whether to use GridLayout mode for Subscription Fragment.
+         *
+         * ### Current mapping:
+         *
+         *  | ItemViewMode | ItemVersion | Span count |
+         *  |---|---|---|
+         *  | AUTO | MINI | 1 |
+         *  | LIST | MINI | 1 |
+         *  | CARD | GRID | > 1 (ThemeHelper defined) |
+         *  | GRID | GRID | > 1 (ThemeHelper defined) |
+         *
+         *  @see [SubscriptionViewModel.shouldUseGridForSubscription] to modify Layout Manager
+         */
+        fun shouldUseGridForSubscription(context: Context): Boolean {
+            val itemViewMode = getItemViewMode(context)
+            return itemViewMode == ItemViewMode.GRID || itemViewMode == ItemViewMode.CARD
+        }
+    }
 }

app/src/main/java/org/schabi/newpipe/local/subscription/decoration/FeedGroupCarouselDecoration.kt

@@ -1,35 +0,0 @@
-package org.schabi.newpipe.local.subscription.decoration
-
-import android.content.Context
-import android.graphics.Rect
-import android.view.View
-import androidx.recyclerview.widget.RecyclerView
-import org.schabi.newpipe.R
-
-class FeedGroupCarouselDecoration(context: Context) : RecyclerView.ItemDecoration() {
-
-    private val marginStartEnd: Int
-    private val marginTopBottom: Int
-    private val marginBetweenItems: Int
-
-    init {
-        with(context.resources) {
-            marginStartEnd = getDimensionPixelOffset(R.dimen.feed_group_carousel_start_end_margin)
-            marginTopBottom = getDimensionPixelOffset(R.dimen.feed_group_carousel_top_bottom_margin)
-            marginBetweenItems = getDimensionPixelOffset(R.dimen.feed_group_carousel_between_items_margin)
-        }
-    }
-
-    override fun getItemOffsets(outRect: Rect, child: View, parent: RecyclerView, state: RecyclerView.State) {
-        val childAdapterPosition = parent.getChildAdapterPosition(child)
-        val childAdapterCount = parent.adapter?.itemCount ?: 0
-
-        outRect.set(marginBetweenItems, marginTopBottom, 0, marginTopBottom)
-
-        if (childAdapterPosition == 0) {
-            outRect.left = marginStartEnd
-        } else if (childAdapterPosition == childAdapterCount - 1) {
-            outRect.right = marginStartEnd
-        }
-    }
-}

app/src/main/java/org/schabi/newpipe/local/subscription/dialog/FeedGroupDialog.kt

@@ -35,7 +35,7 @@ import org.schabi.newpipe.local.subscription.dialog.FeedGroupDialog.ScreenState.
 import org.schabi.newpipe.local.subscription.dialog.FeedGroupDialog.ScreenState.SubscriptionsPickerScreen
 import org.schabi.newpipe.local.subscription.dialog.FeedGroupDialogViewModel.DialogEvent.ProcessingEvent
 import org.schabi.newpipe.local.subscription.dialog.FeedGroupDialogViewModel.DialogEvent.SuccessEvent
-import org.schabi.newpipe.local.subscription.item.EmptyPlaceholderItem
+import org.schabi.newpipe.local.subscription.item.ImportSubscriptionsHintPlaceholderItem
 import org.schabi.newpipe.local.subscription.item.PickerIconItem
 import org.schabi.newpipe.local.subscription.item.PickerSubscriptionItem
 import org.schabi.newpipe.util.DeviceUtils
@@ -124,11 +124,13 @@ class FeedGroupDialog : DialogFragment(), BackPressable {
 
         viewModel = ViewModelProvider(
             this,
-            FeedGroupDialogViewModel.Factory(
+            FeedGroupDialogViewModel.getFactory(
                 requireContext(),
-                groupId, subscriptionsCurrentSearchQuery, subscriptionsShowOnlyUngrouped
+                groupId,
+                subscriptionsCurrentSearchQuery,
+                subscriptionsShowOnlyUngrouped
             )
-        ).get(FeedGroupDialogViewModel::class.java)
+        )[FeedGroupDialogViewModel::class.java]
 
         viewModel.groupLiveData.observe(viewLifecycleOwner, Observer(::handleGroup))
         viewModel.subscriptionsLiveData.observe(viewLifecycleOwner) {
@@ -336,7 +338,7 @@ class FeedGroupDialog : DialogFragment(), BackPressable {
 
         if (subscriptions.isEmpty()) {
             subscriptionEmptyFooter.clear()
-            subscriptionEmptyFooter.add(EmptyPlaceholderItem())
+            subscriptionEmptyFooter.add(ImportSubscriptionsHintPlaceholderItem())
         } else {
             subscriptionEmptyFooter.clear()
         }

app/src/main/java/org/schabi/newpipe/local/subscription/dialog/FeedGroupDialogViewModel.kt

@@ -4,7 +4,8 @@ import android.content.Context
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.ViewModel
-import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.viewmodel.initializer
+import androidx.lifecycle.viewmodel.viewModelFactory
 import io.reactivex.rxjava3.core.Completable
 import io.reactivex.rxjava3.core.Flowable
 import io.reactivex.rxjava3.disposables.Disposable
@@ -115,18 +116,18 @@ class FeedGroupDialogViewModel(
 
     data class Filter(val query: String, val showOnlyUngrouped: Boolean)
 
-    class Factory(
-        private val context: Context,
-        private val groupId: Long = FeedGroupEntity.GROUP_ALL_ID,
-        private val initialQuery: String = "",
-        private val initialShowOnlyUngrouped: Boolean = false
-    ) : ViewModelProvider.Factory {
-        @Suppress("UNCHECKED_CAST")
-        override fun <T : ViewModel> create(modelClass: Class<T>): T {
-            return FeedGroupDialogViewModel(
-                context.applicationContext,
-                groupId, initialQuery, initialShowOnlyUngrouped
-            ) as T
+    companion object {
+        fun getFactory(
+            context: Context,
+            groupId: Long,
+            initialQuery: String,
+            initialShowOnlyUngrouped: Boolean
+        ) = viewModelFactory {
+            initializer {
+                FeedGroupDialogViewModel(
+                    context.applicationContext, groupId, initialQuery, initialShowOnlyUngrouped
+                )
+            }
         }
     }
 }

app/src/main/java/org/schabi/newpipe/local/subscription/item/FeedGroupAddNewGridItem.kt

@@ -0,0 +1,14 @@
+package org.schabi.newpipe.local.subscription.item
+
+import android.view.View
+import com.xwray.groupie.viewbinding.BindableItem
+import org.schabi.newpipe.R
+import org.schabi.newpipe.databinding.FeedGroupAddNewGridItemBinding
+
+class FeedGroupAddNewGridItem : BindableItem<FeedGroupAddNewGridItemBinding>() {
+    override fun getLayout(): Int = R.layout.feed_group_add_new_grid_item
+    override fun initializeViewBinding(view: View) = FeedGroupAddNewGridItemBinding.bind(view)
+    override fun bind(viewBinding: FeedGroupAddNewGridItemBinding, position: Int) {
+        // this is a static item, nothing to do here
+    }
+}

app/src/main/java/org/schabi/newpipe/local/subscription/item/FeedGroupAddNewItem.kt

@@ -5,8 +5,10 @@ import com.xwray.groupie.viewbinding.BindableItem
 import org.schabi.newpipe.R
 import org.schabi.newpipe.databinding.FeedGroupAddNewItemBinding
 
-class FeedGroupAddItem : BindableItem<FeedGroupAddNewItemBinding>() {
+class FeedGroupAddNewItem : BindableItem<FeedGroupAddNewItemBinding>() {
     override fun getLayout(): Int = R.layout.feed_group_add_new_item
-    override fun bind(viewBinding: FeedGroupAddNewItemBinding, position: Int) {}
     override fun initializeViewBinding(view: View) = FeedGroupAddNewItemBinding.bind(view)
+    override fun bind(viewBinding: FeedGroupAddNewItemBinding, position: Int) {
+        // this is a static item, nothing to do here
+    }
 }

app/src/main/java/org/schabi/newpipe/local/subscription/item/FeedGroupCardGridItem.kt

@@ -0,0 +1,32 @@
+package org.schabi.newpipe.local.subscription.item
+
+import android.view.View
+import com.xwray.groupie.viewbinding.BindableItem
+import org.schabi.newpipe.R
+import org.schabi.newpipe.database.feed.model.FeedGroupEntity
+import org.schabi.newpipe.databinding.FeedGroupCardGridItemBinding
+import org.schabi.newpipe.local.subscription.FeedGroupIcon
+
+data class FeedGroupCardGridItem(
+    val groupId: Long = FeedGroupEntity.GROUP_ALL_ID,
+    val name: String,
+    val icon: FeedGroupIcon,
+) : BindableItem<FeedGroupCardGridItemBinding>() {
+    constructor (feedGroupEntity: FeedGroupEntity) : this(feedGroupEntity.uid, feedGroupEntity.name, feedGroupEntity.icon)
+
+    override fun getId(): Long {
+        return when (groupId) {
+            FeedGroupEntity.GROUP_ALL_ID -> super.getId()
+            else -> groupId
+        }
+    }
+
+    override fun getLayout(): Int = R.layout.feed_group_card_grid_item
+
+    override fun bind(viewBinding: FeedGroupCardGridItemBinding, position: Int) {
+        viewBinding.title.text = name
+        viewBinding.icon.setImageResource(icon.getDrawableRes())
+    }
+
+    override fun initializeViewBinding(view: View) = FeedGroupCardGridItemBinding.bind(view)
+}

app/src/main/java/org/schabi/newpipe/local/subscription/item/FeedGroupCarouselItem.kt

@@ -1,60 +1,82 @@
 package org.schabi.newpipe.local.subscription.item
 
-import android.content.Context
 import android.os.Parcelable
 import android.view.View
+import androidx.recyclerview.widget.GridLayoutManager
 import androidx.recyclerview.widget.LinearLayoutManager
-import androidx.recyclerview.widget.RecyclerView
 import com.xwray.groupie.GroupAdapter
 import com.xwray.groupie.viewbinding.BindableItem
 import com.xwray.groupie.viewbinding.GroupieViewHolder
 import org.schabi.newpipe.R
 import org.schabi.newpipe.databinding.FeedItemCarouselBinding
-import org.schabi.newpipe.local.subscription.decoration.FeedGroupCarouselDecoration
+import org.schabi.newpipe.util.DeviceUtils
+import org.schabi.newpipe.util.ThemeHelper.getGridSpanCount
 
 class FeedGroupCarouselItem(
-    context: Context,
-    private val carouselAdapter: GroupAdapter<GroupieViewHolder<FeedItemCarouselBinding>>
+    private val carouselAdapter: GroupAdapter<GroupieViewHolder<FeedItemCarouselBinding>>,
+    var listViewMode: Boolean
 ) : BindableItem<FeedItemCarouselBinding>() {
-    private val feedGroupCarouselDecoration = FeedGroupCarouselDecoration(context)
+    companion object {
+        const val PAYLOAD_UPDATE_LIST_VIEW_MODE = 2
+    }
 
-    private var linearLayoutManager: LinearLayoutManager? = null
+    private var carouselLayoutManager: LinearLayoutManager? = null
     private var listState: Parcelable? = null
 
     override fun getLayout() = R.layout.feed_item_carousel
 
     fun onSaveInstanceState(): Parcelable? {
-        listState = linearLayoutManager?.onSaveInstanceState()
+        listState = carouselLayoutManager?.onSaveInstanceState()
         return listState
     }
 
     fun onRestoreInstanceState(state: Parcelable?) {
-        linearLayoutManager?.onRestoreInstanceState(state)
+        carouselLayoutManager?.onRestoreInstanceState(state)
         listState = state
     }
 
     override fun initializeViewBinding(view: View): FeedItemCarouselBinding {
-        val viewHolder = FeedItemCarouselBinding.bind(view)
+        val viewBinding = FeedItemCarouselBinding.bind(view)
+        updateViewMode(viewBinding)
+        return viewBinding
+    }
 
-        linearLayoutManager = LinearLayoutManager(view.context, RecyclerView.HORIZONTAL, false)
-
-        viewHolder.recyclerView.apply {
-            layoutManager = linearLayoutManager
-            adapter = carouselAdapter
-            addItemDecoration(feedGroupCarouselDecoration)
+    override fun bind(
+        viewBinding: FeedItemCarouselBinding,
+        position: Int,
+        payloads: MutableList<Any>
+    ) {
+        if (payloads.contains(PAYLOAD_UPDATE_LIST_VIEW_MODE)) {
+            updateViewMode(viewBinding)
+            return
         }
 
-        return viewHolder
+        super.bind(viewBinding, position, payloads)
     }
 
     override fun bind(viewBinding: FeedItemCarouselBinding, position: Int) {
         viewBinding.recyclerView.apply { adapter = carouselAdapter }
-        linearLayoutManager?.onRestoreInstanceState(listState)
+        carouselLayoutManager?.onRestoreInstanceState(listState)
     }
 
     override fun unbind(viewHolder: GroupieViewHolder<FeedItemCarouselBinding>) {
         super.unbind(viewHolder)
+        listState = carouselLayoutManager?.onSaveInstanceState()
+    }
 
-        listState = linearLayoutManager?.onSaveInstanceState()
+    private fun updateViewMode(viewBinding: FeedItemCarouselBinding) {
+        viewBinding.recyclerView.apply { adapter = carouselAdapter }
+
+        val context = viewBinding.root.context
+        carouselLayoutManager = if (listViewMode) {
+            LinearLayoutManager(context)
+        } else {
+            GridLayoutManager(context, getGridSpanCount(context, DeviceUtils.dpToPx(112, context)))
+        }
+
+        viewBinding.recyclerView.apply {
+            layoutManager = carouselLayoutManager
+            adapter = carouselAdapter
+        }
     }
 }

app/src/main/java/org/schabi/newpipe/local/subscription/item/GroupsHeader.kt

@@ -0,0 +1,50 @@
+package org.schabi.newpipe.local.subscription.item
+
+import android.view.View
+import androidx.core.view.isVisible
+import com.xwray.groupie.viewbinding.BindableItem
+import org.schabi.newpipe.R
+import org.schabi.newpipe.databinding.SubscriptionGroupsHeaderBinding
+
+class GroupsHeader(
+    private val title: String,
+    private val onSortClicked: () -> Unit,
+    private val onToggleListViewModeClicked: () -> Unit,
+    var showSortButton: Boolean = true,
+    var listViewMode: Boolean = true
+) : BindableItem<SubscriptionGroupsHeaderBinding>() {
+    companion object {
+        const val PAYLOAD_UPDATE_ICONS = 1
+    }
+
+    override fun getLayout(): Int = R.layout.subscription_groups_header
+
+    override fun bind(
+        viewBinding: SubscriptionGroupsHeaderBinding,
+        position: Int,
+        payloads: MutableList<Any>
+    ) {
+        if (payloads.contains(PAYLOAD_UPDATE_ICONS)) {
+            updateIcons(viewBinding)
+            return
+        }
+
+        super.bind(viewBinding, position, payloads)
+    }
+
+    override fun bind(viewBinding: SubscriptionGroupsHeaderBinding, position: Int) {
+        viewBinding.headerTitle.text = title
+        viewBinding.headerSort.setOnClickListener { onSortClicked() }
+        viewBinding.headerToggleViewMode.setOnClickListener { onToggleListViewModeClicked() }
+        updateIcons(viewBinding)
+    }
+
+    override fun initializeViewBinding(view: View) = SubscriptionGroupsHeaderBinding.bind(view)
+
+    private fun updateIcons(viewBinding: SubscriptionGroupsHeaderBinding) {
+        viewBinding.headerToggleViewMode.setImageResource(
+            if (listViewMode) R.drawable.ic_apps else R.drawable.ic_list
+        )
+        viewBinding.headerSort.isVisible = showSortButton
+    }
+}

app/src/main/java/org/schabi/newpipe/local/subscription/item/Header.kt

@@ -0,0 +1,17 @@
+package org.schabi.newpipe.local.subscription.item
+
+import android.view.View
+import com.xwray.groupie.viewbinding.BindableItem
+import org.schabi.newpipe.R
+import org.schabi.newpipe.databinding.SubscriptionHeaderBinding
+
+class Header(private val title: String) : BindableItem<SubscriptionHeaderBinding>() {
+
+    override fun getLayout(): Int = R.layout.subscription_header
+
+    override fun bind(viewBinding: SubscriptionHeaderBinding, position: Int) {
+        viewBinding.root.text = title
+    }
+
+    override fun initializeViewBinding(view: View) = SubscriptionHeaderBinding.bind(view)
+}

app/src/main/java/org/schabi/newpipe/local/subscription/item/HeaderWithMenuItem.kt

@@ -1,50 +0,0 @@
-package org.schabi.newpipe.local.subscription.item
-
-import android.view.View
-import android.view.View.OnClickListener
-import androidx.annotation.DrawableRes
-import androidx.core.view.isVisible
-import com.xwray.groupie.viewbinding.BindableItem
-import org.schabi.newpipe.R
-import org.schabi.newpipe.databinding.HeaderWithMenuItemBinding
-
-class HeaderWithMenuItem(
-    val title: String,
-    @DrawableRes val itemIcon: Int = 0,
-    var showMenuItem: Boolean = true,
-    private val onClickListener: (() -> Unit)? = null,
-    private val menuItemOnClickListener: (() -> Unit)? = null
-) : BindableItem<HeaderWithMenuItemBinding>() {
-    companion object {
-        const val PAYLOAD_UPDATE_VISIBILITY_MENU_ITEM = 1
-    }
-
-    override fun getLayout(): Int = R.layout.header_with_menu_item
-
-    override fun bind(viewBinding: HeaderWithMenuItemBinding, position: Int, payloads: MutableList<Any>) {
-        if (payloads.contains(PAYLOAD_UPDATE_VISIBILITY_MENU_ITEM)) {
-            updateMenuItemVisibility(viewBinding)
-            return
-        }
-
-        super.bind(viewBinding, position, payloads)
-    }
-
-    override fun bind(viewBinding: HeaderWithMenuItemBinding, position: Int) {
-        viewBinding.headerTitle.text = title
-        viewBinding.headerMenuItem.setImageResource(itemIcon)
-
-        val listener = onClickListener?.let { OnClickListener { onClickListener.invoke() } }
-        viewBinding.root.setOnClickListener(listener)
-
-        val menuItemListener = menuItemOnClickListener?.let { OnClickListener { menuItemOnClickListener.invoke() } }
-        viewBinding.headerMenuItem.setOnClickListener(menuItemListener)
-        updateMenuItemVisibility(viewBinding)
-    }
-
-    override fun initializeViewBinding(view: View) = HeaderWithMenuItemBinding.bind(view)
-
-    private fun updateMenuItemVisibility(viewBinding: HeaderWithMenuItemBinding) {
-        viewBinding.headerMenuItem.isVisible = showMenuItem
-    }
-}

app/src/main/java/org/schabi/newpipe/local/subscription/item/ImportSubscriptionsHintPlaceholderItem.kt

@@ -5,8 +5,11 @@ import com.xwray.groupie.viewbinding.BindableItem
 import org.schabi.newpipe.R
 import org.schabi.newpipe.databinding.ListEmptyViewBinding
 
-class EmptyPlaceholderItem : BindableItem<ListEmptyViewBinding>() {
-    override fun getLayout(): Int = R.layout.list_empty_view
+/**
+ * When there are no subscriptions, show a hint to the user about how to import subscriptions
+ */
+class ImportSubscriptionsHintPlaceholderItem : BindableItem<ListEmptyViewBinding>() {
+    override fun getLayout(): Int = R.layout.list_empty_view_subscriptions
     override fun bind(viewBinding: ListEmptyViewBinding, position: Int) {}
     override fun getSpanSize(spanCount: Int, position: Int): Int = spanCount
     override fun initializeViewBinding(view: View) = ListEmptyViewBinding.bind(view)

app/src/main/java/org/schabi/newpipe/player/PlayQueueActivity.java

@@ -13,6 +13,7 @@ import android.provider.Settings;
 import android.util.Log;
 import android.view.Menu;
 import android.view.MenuItem;
+import android.view.SubMenu;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.SeekBar;
@@ -27,11 +28,13 @@ import com.google.android.exoplayer2.PlaybackParameters;
 
 import org.schabi.newpipe.R;
 import org.schabi.newpipe.databinding.ActivityPlayerQueueControlBinding;
+import org.schabi.newpipe.extractor.stream.AudioStream;
 import org.schabi.newpipe.extractor.stream.StreamInfo;
 import org.schabi.newpipe.fragments.OnScrollBelowItemsListener;
 import org.schabi.newpipe.local.dialog.PlaylistDialog;
 import org.schabi.newpipe.player.event.PlayerEventListener;
 import org.schabi.newpipe.player.helper.PlaybackParameterDialog;
+import org.schabi.newpipe.player.mediaitem.MediaItemTag;
 import org.schabi.newpipe.player.playqueue.PlayQueue;
 import org.schabi.newpipe.player.playqueue.PlayQueueAdapter;
 import org.schabi.newpipe.player.playqueue.PlayQueueItem;
@@ -44,6 +47,9 @@ import org.schabi.newpipe.util.PermissionHelper;
 import org.schabi.newpipe.util.ServiceHelper;
 import org.schabi.newpipe.util.ThemeHelper;
 
+import java.util.List;
+import java.util.Optional;
+
 public final class PlayQueueActivity extends AppCompatActivity
         implements PlayerEventListener, SeekBar.OnSeekBarChangeListener,
         View.OnClickListener, PlaybackParameterDialog.Callback {
@@ -52,6 +58,8 @@ public final class PlayQueueActivity extends AppCompatActivity
 
     private static final int SMOOTH_SCROLL_MAXIMUM_DISTANCE = 80;
 
+    private static final int MENU_ID_AUDIO_TRACK = 71;
+
     private Player player;
 
     private boolean serviceBound;
@@ -97,6 +105,7 @@ public final class PlayQueueActivity extends AppCompatActivity
         this.menu = m;
         getMenuInflater().inflate(R.menu.menu_play_queue, m);
         getMenuInflater().inflate(R.menu.menu_play_queue_bg, m);
+        buildAudioTrackMenu();
         onMaybeMuteChanged();
         // to avoid null reference
         if (player != null) {
@@ -143,11 +152,9 @@ public final class PlayQueueActivity extends AppCompatActivity
                 NavigationHelper.playOnMainPlayer(this, player.getPlayQueue(), true);
                 return true;
             case R.id.action_switch_popup:
-                if (PermissionHelper.isPopupEnabled(this)) {
+                if (PermissionHelper.isPopupEnabledElseAsk(this)) {
                     this.player.setRecovery();
                     NavigationHelper.playOnPopupPlayer(this, player.getPlayQueue(), true);
-                } else {
-                    PermissionHelper.showPopupEnablementToast(this);
                 }
                 return true;
             case R.id.action_switch_background:
@@ -155,6 +162,12 @@ public final class PlayQueueActivity extends AppCompatActivity
                 NavigationHelper.playOnBackgroundPlayer(this, player.getPlayQueue(), true);
                 return true;
         }
+
+        if (item.getGroupId() == MENU_ID_AUDIO_TRACK) {
+            onAudioTrackClick(item.getItemId());
+            return true;
+        }
+
         return super.onOptionsItemSelected(item);
     }
 
@@ -212,7 +225,6 @@ public final class PlayQueueActivity extends AppCompatActivity
 
                 if (player == null || player.getPlayQueue() == null || player.exoPlayerIsNull()) {
                     unbind();
-                    finish();
                 } else {
                     onQueueUpdate(player.getPlayQueue());
                     buildComponents();
@@ -594,4 +606,69 @@ public final class PlayQueueActivity extends AppCompatActivity
             item.setIcon(player.isMuted() ? R.drawable.ic_volume_off : R.drawable.ic_volume_up);
         }
     }
+
+    @Override
+    public void onAudioTrackUpdate() {
+        buildAudioTrackMenu();
+    }
+
+    private void buildAudioTrackMenu() {
+        if (menu == null) {
+            return;
+        }
+
+        final MenuItem audioTrackSelector = menu.findItem(R.id.action_audio_track);
+        final List<AudioStream> availableStreams =
+                Optional.ofNullable(player.getCurrentMetadata())
+                        .flatMap(MediaItemTag::getMaybeAudioTrack)
+                        .map(MediaItemTag.AudioTrack::getAudioStreams)
+                        .orElse(null);
+        final Optional<AudioStream> selectedAudioStream = player.getSelectedAudioStream();
+
+        if (availableStreams == null || availableStreams.size() < 2
+                || selectedAudioStream.isEmpty()) {
+            audioTrackSelector.setVisible(false);
+        } else {
+            final SubMenu audioTrackMenu = audioTrackSelector.getSubMenu();
+            audioTrackMenu.clear();
+
+            for (int i = 0; i < availableStreams.size(); i++) {
+                final AudioStream audioStream = availableStreams.get(i);
+                audioTrackMenu.add(MENU_ID_AUDIO_TRACK, i, Menu.NONE,
+                        Localization.audioTrackName(this, audioStream));
+            }
+
+            final AudioStream s = selectedAudioStream.get();
+            final String trackName = Localization.audioTrackName(this, s);
+            audioTrackSelector.setTitle(
+                    getString(R.string.play_queue_audio_track, trackName));
+
+            final String shortName = s.getAudioLocale() != null
+                    ? s.getAudioLocale().getLanguage() : trackName;
+            audioTrackSelector.setTitleCondensed(
+                    shortName.substring(0, Math.min(shortName.length(), 2)));
+            audioTrackSelector.setVisible(true);
+        }
+    }
+
+    /**
+     * Called when an item from the audio track selector is selected.
+     *
+     * @param itemId index of the selected item
+     */
+    private void onAudioTrackClick(final int itemId) {
+        if (player.getCurrentMetadata() == null) {
+            return;
+        }
+        player.getCurrentMetadata().getMaybeAudioTrack().ifPresent(audioTrack -> {
+            final List<AudioStream> availableStreams = audioTrack.getAudioStreams();
+            final int selectedStreamIndex = audioTrack.getSelectedAudioStreamIndex();
+            if (selectedStreamIndex == itemId || availableStreams.size() <= itemId) {
+                return;
+            }
+
+            final String newAudioTrack = availableStreams.get(itemId).getAudioTrackId();
+            player.setAudioTrack(newAudioTrack);
+        });
+    }
 }

app/src/main/java/org/schabi/newpipe/player/Player.java

@@ -29,7 +29,6 @@ import static com.google.android.exoplayer2.Player.REPEAT_MODE_ONE;
 import static com.google.android.exoplayer2.Player.RepeatMode;
 import static org.schabi.newpipe.extractor.ServiceList.YouTube;
 import static org.schabi.newpipe.extractor.utils.Utils.isNullOrEmpty;
-import static org.schabi.newpipe.player.helper.PlayerHelper.isPlaybackResumeEnabled;
 import static org.schabi.newpipe.player.helper.PlayerHelper.nextRepeatMode;
 import static org.schabi.newpipe.player.helper.PlayerHelper.retrievePlaybackParametersFromPrefs;
 import static org.schabi.newpipe.player.helper.PlayerHelper.retrieveSeekDurationFromPreferences;
@@ -70,7 +69,6 @@ import com.google.android.exoplayer2.ExoPlayer;
 import com.google.android.exoplayer2.PlaybackException;
 import com.google.android.exoplayer2.PlaybackParameters;
 import com.google.android.exoplayer2.Player.PositionInfo;
-import com.google.android.exoplayer2.RenderersFactory;
 import com.google.android.exoplayer2.Timeline;
 import com.google.android.exoplayer2.Tracks;
 import com.google.android.exoplayer2.source.MediaSource;
@@ -78,7 +76,6 @@ import com.google.android.exoplayer2.text.CueGroup;
 import com.google.android.exoplayer2.trackselection.DefaultTrackSelector;
 import com.google.android.exoplayer2.trackselection.MappingTrackSelector;
 import com.google.android.exoplayer2.upstream.DefaultBandwidthMeter;
-import com.google.android.exoplayer2.util.Util;
 import com.google.android.exoplayer2.video.VideoSize;
 import com.squareup.picasso.Picasso;
 import com.squareup.picasso.Target;
@@ -89,6 +86,7 @@ import org.schabi.newpipe.databinding.PlayerBinding;
 import org.schabi.newpipe.error.ErrorInfo;
 import org.schabi.newpipe.error.ErrorUtil;
 import org.schabi.newpipe.error.UserAction;
+import org.schabi.newpipe.extractor.stream.AudioStream;
 import org.schabi.newpipe.extractor.stream.StreamInfo;
 import org.schabi.newpipe.extractor.stream.StreamType;
 import org.schabi.newpipe.extractor.stream.VideoStream;
@@ -97,6 +95,7 @@ import org.schabi.newpipe.local.history.HistoryRecordManager;
 import org.schabi.newpipe.player.event.PlayerEventListener;
 import org.schabi.newpipe.player.event.PlayerServiceEventListener;
 import org.schabi.newpipe.player.helper.AudioReactor;
+import org.schabi.newpipe.player.helper.CustomRenderersFactory;
 import org.schabi.newpipe.player.helper.LoadController;
 import org.schabi.newpipe.player.helper.PlayerDataSource;
 import org.schabi.newpipe.player.helper.PlayerHelper;
@@ -115,7 +114,7 @@ import org.schabi.newpipe.player.ui.PlayerUi;
 import org.schabi.newpipe.player.ui.PlayerUiList;
 import org.schabi.newpipe.player.ui.PopupPlayerUi;
 import org.schabi.newpipe.player.ui.VideoPlayerUi;
-import org.schabi.newpipe.util.DeviceUtils;
+import org.schabi.newpipe.util.DependentPreferenceHelper;
 import org.schabi.newpipe.util.ListHelper;
 import org.schabi.newpipe.util.NavigationHelper;
 import org.schabi.newpipe.util.PicassoHelper;
@@ -181,13 +180,18 @@ public final class Player implements PlaybackListener, Listener {
     //////////////////////////////////////////////////////////////////////////*/
 
     // play queue might be null e.g. while player is starting
-    @Nullable private PlayQueue playQueue;
+    @Nullable
+    private PlayQueue playQueue;
 
-    @Nullable private MediaSourceManager playQueueManager;
+    @Nullable
+    private MediaSourceManager playQueueManager;
 
-    @Nullable private PlayQueueItem currentItem;
-    @Nullable private MediaItemTag currentMetadata;
-    @Nullable private Bitmap currentThumbnail;
+    @Nullable
+    private PlayQueueItem currentItem;
+    @Nullable
+    private MediaItemTag currentMetadata;
+    @Nullable
+    private Bitmap currentThumbnail;
 
     /*//////////////////////////////////////////////////////////////////////////
     // Player
@@ -196,12 +200,17 @@ public final class Player implements PlaybackListener, Listener {
     private ExoPlayer simpleExoPlayer;
     private AudioReactor audioReactor;
 
-    @NonNull private final DefaultTrackSelector trackSelector;
-    @NonNull private final LoadController loadController;
-    @NonNull private final RenderersFactory renderFactory;
+    @NonNull
+    private final DefaultTrackSelector trackSelector;
+    @NonNull
+    private final LoadController loadController;
+    @NonNull
+    private final DefaultRenderersFactory renderFactory;
 
-    @NonNull private final VideoPlaybackResolver videoResolver;
-    @NonNull private final AudioPlaybackResolver audioResolver;
+    @NonNull
+    private final VideoPlaybackResolver videoResolver;
+    @NonNull
+    private final AudioPlaybackResolver audioResolver;
 
     private final PlayerService service; //TODO try to remove and replace everything with context
 
@@ -216,7 +225,6 @@ public final class Player implements PlaybackListener, Listener {
     // minimized to background but will resume automatically to the original player type
     private boolean isAudioOnly = false;
     private boolean isPrepared = false;
-    private boolean wasPlaying = false;
 
     /*//////////////////////////////////////////////////////////////////////////
     // UIs, listeners and disposables
@@ -227,24 +235,32 @@ public final class Player implements PlaybackListener, Listener {
 
     private BroadcastReceiver broadcastReceiver;
     private IntentFilter intentFilter;
-    @Nullable private PlayerServiceEventListener fragmentListener = null;
-    @Nullable private PlayerEventListener activityListener = null;
+    @Nullable
+    private PlayerServiceEventListener fragmentListener = null;
+    @Nullable
+    private PlayerEventListener activityListener = null;
 
-    @NonNull private final SerialDisposable progressUpdateDisposable = new SerialDisposable();
-    @NonNull private final CompositeDisposable databaseUpdateDisposable = new CompositeDisposable();
+    @NonNull
+    private final SerialDisposable progressUpdateDisposable = new SerialDisposable();
+    @NonNull
+    private final CompositeDisposable databaseUpdateDisposable = new CompositeDisposable();
 
     // This is the only listener we need for thumbnail loading, since there is always at most only
     // one thumbnail being loaded at a time. This field is also here to maintain a strong reference,
     // which would otherwise be garbage collected since Picasso holds weak references to targets.
-    @NonNull private final Target currentThumbnailTarget;
+    @NonNull
+    private final Target currentThumbnailTarget;
 
     /*//////////////////////////////////////////////////////////////////////////
     // Utils
     //////////////////////////////////////////////////////////////////////////*/
 
-    @NonNull private final Context context;
-    @NonNull private final SharedPreferences prefs;
-    @NonNull private final HistoryRecordManager recordManager;
+    @NonNull
+    private final Context context;
+    @NonNull
+    private final SharedPreferences prefs;
+    @NonNull
+    private final HistoryRecordManager recordManager;
 
 
     /*//////////////////////////////////////////////////////////////////////////
@@ -264,7 +280,16 @@ public final class Player implements PlaybackListener, Listener {
         final PlayerDataSource dataSource = new PlayerDataSource(context,
                 new DefaultBandwidthMeter.Builder(context).build());
         loadController = new LoadController();
-        renderFactory = new DefaultRenderersFactory(context);
+
+        renderFactory = prefs.getBoolean(
+                context.getString(
+                        R.string.always_use_exoplayer_set_output_surface_workaround_key), false)
+                ? new CustomRenderersFactory(context) : new DefaultRenderersFactory(context);
+
+        renderFactory.setEnableDecoderFallback(
+                prefs.getBoolean(
+                        context.getString(
+                                R.string.use_exoplayer_decoder_fallback_key), false));
 
         videoResolver = new VideoPlaybackResolver(context, dataSource, getQualityResolver());
         audioResolver = new AudioPlaybackResolver(context, dataSource);
@@ -327,7 +352,7 @@ public final class Player implements PlaybackListener, Listener {
         isAudioOnly = audioPlayerSelected();
 
         if (intent.hasExtra(PLAYBACK_QUALITY)) {
-            setPlaybackQuality(intent.getStringExtra(PLAYBACK_QUALITY));
+            videoResolver.setPlaybackQuality(intent.getStringExtra(PLAYBACK_QUALITY));
         }
 
         // Resolve enqueue intents
@@ -335,7 +360,7 @@ public final class Player implements PlaybackListener, Listener {
             playQueue.append(newQueue.getStreams());
             return;
 
-        // Resolve enqueue next intents
+            // Resolve enqueue next intents
         } else if (intent.getBooleanExtra(ENQUEUE_NEXT, false) && playQueue != null) {
             final int currentIndex = playQueue.getIndex();
             playQueue.append(newQueue.getStreams());
@@ -349,7 +374,7 @@ public final class Player implements PlaybackListener, Listener {
         final boolean playbackSkipSilence = getPrefs().getBoolean(getContext().getString(
                 R.string.playback_skip_silence_key), getPlaybackSkipSilence());
 
-        final boolean samePlayQueue = playQueue != null && playQueue.equals(newQueue);
+        final boolean samePlayQueue = playQueue != null && playQueue.equalStreamsAndIndex(newQueue);
         final int repeatMode = intent.getIntExtra(REPEAT_MODE, getRepeatMode());
         final boolean playWhenReady = intent.getBooleanExtra(PLAY_WHEN_READY, true);
         final boolean isMuted = intent.getBooleanExtra(IS_MUTED, isMuted());
@@ -392,7 +417,7 @@ public final class Player implements PlaybackListener, Listener {
             simpleExoPlayer.setPlayWhenReady(playWhenReady);
 
         } else if (intent.getBooleanExtra(RESUME_PLAYBACK, false)
-                && isPlaybackResumeEnabled(this)
+                && DependentPreferenceHelper.getResumePlaybackEnabled(context)
                 && !samePlayQueue
                 && !newQueue.isEmpty()
                 && newQueue.getItem() != null
@@ -521,16 +546,11 @@ public final class Player implements PlaybackListener, Listener {
         // Setup UIs
         UIs.call(PlayerUi::initPlayer);
 
-        // enable media tunneling
-        if (DEBUG && PreferenceManager.getDefaultSharedPreferences(context)
+        // Disable media tunneling if requested by the user from ExoPlayer settings
+        if (!PreferenceManager.getDefaultSharedPreferences(context)
                 .getBoolean(context.getString(R.string.disable_media_tunneling_key), false)) {
-            Log.d(TAG, "[" + Util.DEVICE_DEBUG_INFO + "] "
-                    + "media tunneling disabled in debug preferences");
-        } else if (DeviceUtils.shouldSupportMediaTunneling()) {
             trackSelector.setParameters(trackSelector.buildUponParameters()
                     .setTunnelingEnabled(true));
-        } else if (DEBUG) {
-            Log.d(TAG, "[" + Util.DEVICE_DEBUG_INFO + "] does not support media tunneling");
         }
     }
     //endregion
@@ -912,23 +932,15 @@ public final class Player implements PlaybackListener, Listener {
 
     private Disposable getProgressUpdateDisposable() {
         return Observable.interval(PROGRESS_LOOP_INTERVAL_MILLIS, MILLISECONDS,
-                AndroidSchedulers.mainThread())
+                        AndroidSchedulers.mainThread())
                 .observeOn(AndroidSchedulers.mainThread())
                 .subscribe(ignored -> triggerProgressUpdate(),
                         error -> Log.e(TAG, "Progress update failure: ", error));
     }
 
-    public void saveWasPlaying() {
-        this.wasPlaying = getPlayWhenReady();
-    }
-
-    public boolean wasPlaying() {
-        return wasPlaying;
-    }
     //endregion
 
 
-
     /*//////////////////////////////////////////////////////////////////////////
     // Playback states
     //////////////////////////////////////////////////////////////////////////*/
@@ -1250,6 +1262,9 @@ public final class Player implements PlaybackListener, Listener {
             }
             final StreamInfo previousInfo = Optional.ofNullable(currentMetadata)
                     .flatMap(MediaItemTag::getMaybeStreamInfo).orElse(null);
+            final MediaItemTag.AudioTrack previousAudioTrack =
+                    Optional.ofNullable(currentMetadata)
+                            .flatMap(MediaItemTag::getMaybeAudioTrack).orElse(null);
             currentMetadata = tag;
 
             if (!currentMetadata.getErrors().isEmpty()) {
@@ -1270,6 +1285,12 @@ public final class Player implements PlaybackListener, Listener {
                 if (previousInfo == null || !previousInfo.getUrl().equals(info.getUrl())) {
                     // only update with the new stream info if it has actually changed
                     updateMetadataWith(info);
+                } else if (previousAudioTrack == null
+                        || tag.getMaybeAudioTrack()
+                        .map(t -> t.getSelectedAudioStreamIndex()
+                                != previousAudioTrack.getSelectedAudioStreamIndex())
+                        .orElse(false)) {
+                    notifyAudioTrackUpdateToListeners();
                 }
             });
         });
@@ -1357,6 +1378,7 @@ public final class Player implements PlaybackListener, Listener {
     // Errors
     //////////////////////////////////////////////////////////////////////////*/
     //region Errors
+
     /**
      * Process exceptions produced by {@link com.google.android.exoplayer2.ExoPlayer ExoPlayer}.
      * <p>There are multiple types of errors:</p>
@@ -1383,8 +1405,9 @@ public final class Player implements PlaybackListener, Listener {
      * For any error above that is <b>not</b> explicitly <b>catchable</b>, the player will
      * create a notification so users are aware.
      * </ul>
+     *
      * @see com.google.android.exoplayer2.Player.Listener#onPlayerError(PlaybackException)
-     * */
+     */
     // Any error code not explicitly covered here are either unrelated to NewPipe use case
     // (e.g. DRM) or not recoverable (e.g. Decoder error). In both cases, the player should
     // shutdown.
@@ -1703,26 +1726,25 @@ public final class Player implements PlaybackListener, Listener {
     }
 
     private void saveStreamProgressState(final long progressMillis) {
-        //noinspection SimplifyOptionalCallChains
-        if (!getCurrentStreamInfo().isPresent()
-                || !prefs.getBoolean(context.getString(R.string.enable_watch_history_key), true)) {
-            return;
-        }
-        if (DEBUG) {
-            Log.d(TAG, "saveStreamProgressState() called with: progressMillis=" + progressMillis
-                    + ", currentMetadata=[" + getCurrentStreamInfo().get().getName() + "]");
-        }
+        getCurrentStreamInfo().ifPresent(info -> {
+            if (!prefs.getBoolean(context.getString(R.string.enable_watch_history_key), true)) {
+                return;
+            }
+            if (DEBUG) {
+                Log.d(TAG, "saveStreamProgressState() called with: progressMillis=" + progressMillis
+                        + ", currentMetadata=[" + info.getName() + "]");
+            }
 
-        databaseUpdateDisposable
-                .add(recordManager.saveStreamState(getCurrentStreamInfo().get(), progressMillis)
-                .observeOn(AndroidSchedulers.mainThread())
-                .doOnError(e -> {
-                    if (DEBUG) {
-                        e.printStackTrace();
-                    }
-                })
-                .onErrorComplete()
-                .subscribe());
+            databaseUpdateDisposable.add(recordManager.saveStreamState(info, progressMillis)
+                    .observeOn(AndroidSchedulers.mainThread())
+                    .doOnError(e -> {
+                        if (DEBUG) {
+                            e.printStackTrace();
+                        }
+                    })
+                    .onErrorComplete()
+                    .subscribe());
+        });
     }
 
     public void saveStreamProgressState() {
@@ -1767,6 +1789,7 @@ public final class Player implements PlaybackListener, Listener {
         registerStreamViewed();
 
         notifyMetadataUpdateToListeners();
+        notifyAudioTrackUpdateToListeners();
         UIs.call(playerUi -> playerUi.onMetadataChanged(info));
     }
 
@@ -1884,23 +1907,22 @@ public final class Player implements PlaybackListener, Listener {
         loadController.disablePreloadingOfCurrentTrack();
     }
 
-    @Nullable
-    public VideoStream getSelectedVideoStream() {
-        @Nullable final MediaItemTag.Quality quality = Optional.ofNullable(currentMetadata)
+    public Optional<VideoStream> getSelectedVideoStream() {
+        return Optional.ofNullable(currentMetadata)
                 .flatMap(MediaItemTag::getMaybeQuality)
-                .orElse(null);
-        if (quality == null) {
-            return null;
-        }
+                .filter(quality -> {
+                    final int selectedStreamIndex = quality.getSelectedVideoStreamIndex();
+                    return selectedStreamIndex >= 0
+                            && selectedStreamIndex < quality.getSortedVideoStreams().size();
+                })
+                .map(quality -> quality.getSortedVideoStreams()
+                        .get(quality.getSelectedVideoStreamIndex()));
+    }
 
-        final List<VideoStream> availableStreams = quality.getSortedVideoStreams();
-        final int selectedStreamIndex = quality.getSelectedVideoStreamIndex();
-
-        if (selectedStreamIndex >= 0 && availableStreams.size() > selectedStreamIndex) {
-            return availableStreams.get(selectedStreamIndex);
-        } else {
-            return null;
-        }
+    public Optional<AudioStream> getSelectedAudioStream() {
+        return Optional.ofNullable(currentMetadata)
+                .flatMap(MediaItemTag::getMaybeAudioTrack)
+                .map(MediaItemTag.AudioTrack::getSelectedAudioStream);
     }
     //endregion
 
@@ -2033,6 +2055,15 @@ public final class Player implements PlaybackListener, Listener {
         }
     }
 
+    private void notifyAudioTrackUpdateToListeners() {
+        if (fragmentListener != null) {
+            fragmentListener.onAudioTrackUpdate();
+        }
+        if (activityListener != null) {
+            activityListener.onAudioTrackUpdate();
+        }
+    }
+
     public void useVideoSource(final boolean videoEnabled) {
         if (playQueue == null || isAudioOnly == !videoEnabled || audioPlayerSelected()) {
             return;
@@ -2044,40 +2075,36 @@ public final class Player implements PlaybackListener, Listener {
         // in livestreams) so we will be not able to execute the block below.
         // Reload the play queue manager in this case, which is the behavior when we don't know the
         // index of the video renderer or playQueueManagerReloadingNeeded returns true.
-        final Optional<StreamInfo> optCurrentStreamInfo = getCurrentStreamInfo();
-        if (!optCurrentStreamInfo.isPresent()) {
-            reloadPlayQueueManager();
-            setRecovery();
-            return;
-        }
+        getCurrentStreamInfo().ifPresentOrElse(info -> {
+            // In the case we don't know the source type, fallback to the one with video with audio
+            // or audio-only source.
+            final SourceType sourceType = videoResolver.getStreamSourceType()
+                    .orElse(SourceType.VIDEO_WITH_AUDIO_OR_AUDIO_ONLY);
 
-        final StreamInfo info = optCurrentStreamInfo.get();
+            if (playQueueManagerReloadingNeeded(sourceType, info, getVideoRendererIndex())) {
+                reloadPlayQueueManager();
+            } else {
+                if (StreamTypeUtil.isAudio(info.getStreamType())) {
+                    // Nothing to do more than setting the recovery position
+                    setRecovery();
+                    return;
+                }
 
-        // In the case we don't know the source type, fallback to the one with video with audio or
-        // audio-only source.
-        final SourceType sourceType = videoResolver.getStreamSourceType().orElse(
-                SourceType.VIDEO_WITH_AUDIO_OR_AUDIO_ONLY);
+                final var parametersBuilder = trackSelector.buildUponParameters();
 
-        if (playQueueManagerReloadingNeeded(sourceType, info, getVideoRendererIndex())) {
-            reloadPlayQueueManager();
-        } else {
-            if (StreamTypeUtil.isAudio(info.getStreamType())) {
-                // Nothing to do more than setting the recovery position
-                setRecovery();
-                return;
+                // Enable/disable the video track and the ability to select subtitles
+                parametersBuilder.setTrackTypeDisabled(C.TRACK_TYPE_TEXT, !videoEnabled);
+                parametersBuilder.setTrackTypeDisabled(C.TRACK_TYPE_VIDEO, !videoEnabled);
+
+                trackSelector.setParameters(parametersBuilder);
             }
 
-            final DefaultTrackSelector.Parameters.Builder parametersBuilder =
-                    trackSelector.buildUponParameters();
-
-            // Enable/disable the video track and the ability to select subtitles
-            parametersBuilder.setTrackTypeDisabled(C.TRACK_TYPE_TEXT, !videoEnabled);
-            parametersBuilder.setTrackTypeDisabled(C.TRACK_TYPE_VIDEO, !videoEnabled);
-
-            trackSelector.setParameters(parametersBuilder);
-        }
-
-        setRecovery();
+            setRecovery();
+        }, () -> {
+            // This is executed when the current stream info is not available.
+            reloadPlayQueueManager();
+            setRecovery();
+        });
     }
 
     /**
@@ -2133,7 +2160,7 @@ public final class Player implements PlaybackListener, Listener {
         // because the stream source will be probably the same as the current played
         if (sourceType == SourceType.VIDEO_WITH_SEPARATED_AUDIO
                 || (sourceType == SourceType.VIDEO_WITH_AUDIO_OR_AUDIO_ONLY
-                    && isNullOrEmpty(streamInfo.getAudioStreams()))) {
+                && isNullOrEmpty(streamInfo.getAudioStreams()))) {
             // It's not needed to reload the play queue manager only if the content's stream type
             // is a video stream, a live stream or an ended live stream
             return !StreamTypeUtil.isVideo(streamType);
@@ -2195,7 +2222,18 @@ public final class Player implements PlaybackListener, Listener {
     }
 
     public void setPlaybackQuality(@Nullable final String quality) {
+        saveStreamProgressState();
+        setRecovery();
         videoResolver.setPlaybackQuality(quality);
+        reloadPlayQueueManager();
+    }
+
+    public void setAudioTrack(@Nullable final String audioTrackId) {
+        saveStreamProgressState();
+        setRecovery();
+        videoResolver.setAudioTrack(audioTrackId);
+        audioResolver.setAudioTrack(audioTrackId);
+        reloadPlayQueueManager();
     }
 
 
@@ -2273,7 +2311,7 @@ public final class Player implements PlaybackListener, Listener {
 
     /**
      * Get the video renderer index of the current playing stream.
-     *
+     * <p>
      * This method returns the video renderer index of the current
      * {@link MappingTrackSelector.MappedTrackInfo} or {@link #RENDERER_UNAVAILABLE} if the current
      * {@link MappingTrackSelector.MappedTrackInfo} is null or if there is no video renderer index.

app/src/main/java/org/schabi/newpipe/player/PlayerService.java

@@ -86,8 +86,6 @@ public final class PlayerService extends Service {
         }
 
         if (!player.exoPlayerIsNull()) {
-            player.saveWasPlaying();
-
             // Releases wifi & cpu, disables keepScreenOn, etc.
             // We can't just pause the player here because it will make transition
             // from one stream to a new stream not smooth

app/src/main/java/org/schabi/newpipe/player/event/PlayerEventListener.java

@@ -11,5 +11,6 @@ public interface PlayerEventListener {
                           PlaybackParameters parameters);
     void onProgressUpdate(int currentProgress, int duration, int bufferPercent);
     void onMetadataUpdate(StreamInfo info, PlayQueue queue);
+    default void onAudioTrackUpdate() { }
     void onServiceStopped();
 }

app/src/main/java/org/schabi/newpipe/player/gesture/BasePlayerGestureListener.kt

@@ -6,6 +6,7 @@ import android.util.Log
 import android.view.GestureDetector
 import android.view.MotionEvent
 import android.view.View
+import androidx.core.os.postDelayed
 import org.schabi.newpipe.databinding.PlayerBinding
 import org.schabi.newpipe.player.Player
 import org.schabi.newpipe.player.ui.VideoPlayerUi
@@ -132,13 +133,6 @@ abstract class BasePlayerGestureListener(
 
     private var doubleTapDelay = DOUBLE_TAP_DELAY
     private val doubleTapHandler: Handler = Handler(Looper.getMainLooper())
-    private val doubleTapRunnable = Runnable {
-        if (DEBUG)
-            Log.d(TAG, "doubleTapRunnable called")
-
-        isDoubleTapping = false
-        doubleTapControls?.onDoubleTapFinished()
-    }
 
     private fun startMultiDoubleTap(e: MotionEvent) {
         if (!isDoubleTapping) {
@@ -155,8 +149,15 @@ abstract class BasePlayerGestureListener(
             Log.d(TAG, "keepInDoubleTapMode called")
 
         isDoubleTapping = true
-        doubleTapHandler.removeCallbacks(doubleTapRunnable)
-        doubleTapHandler.postDelayed(doubleTapRunnable, doubleTapDelay)
+        doubleTapHandler.removeCallbacksAndMessages(DOUBLE_TAP)
+        doubleTapHandler.postDelayed(DOUBLE_TAP_DELAY, DOUBLE_TAP) {
+            if (DEBUG) {
+                Log.d(TAG, "doubleTapRunnable called")
+            }
+
+            isDoubleTapping = false
+            doubleTapControls?.onDoubleTapFinished()
+        }
     }
 
     fun endMultiDoubleTap() {
@@ -164,7 +165,7 @@ abstract class BasePlayerGestureListener(
             Log.d(TAG, "endMultiDoubleTap called")
 
         isDoubleTapping = false
-        doubleTapHandler.removeCallbacks(doubleTapRunnable)
+        doubleTapHandler.removeCallbacksAndMessages(DOUBLE_TAP)
         doubleTapControls?.onDoubleTapFinished()
     }
 
@@ -181,6 +182,7 @@ abstract class BasePlayerGestureListener(
         private const val TAG = "BasePlayerGestListener"
         private val DEBUG = Player.DEBUG
 
+        private const val DOUBLE_TAP = "doubleTap"
         private const val DOUBLE_TAP_DELAY = 550L
     }
 }

app/src/main/java/org/schabi/newpipe/player/gesture/MainPlayerGestureListener.kt

@@ -7,6 +7,7 @@ import android.view.View.OnTouchListener
 import android.widget.ProgressBar
 import androidx.appcompat.app.AppCompatActivity
 import androidx.appcompat.content.res.AppCompatResources
+import androidx.core.math.MathUtils
 import androidx.core.view.isVisible
 import org.schabi.newpipe.MainActivity
 import org.schabi.newpipe.R
@@ -18,8 +19,6 @@ import org.schabi.newpipe.player.helper.PlayerHelper
 import org.schabi.newpipe.player.ui.MainPlayerUi
 import org.schabi.newpipe.util.ThemeHelper.getAndroidDimenPx
 import kotlin.math.abs
-import kotlin.math.max
-import kotlin.math.min
 
 /**
  * GestureListener for the player
@@ -114,7 +113,7 @@ class MainPlayerGestureListener(
 
         // Update progress bar
         val oldBrightness = layoutParams.screenBrightness
-        bar.progress = (bar.max * max(0f, min(1f, oldBrightness))).toInt()
+        bar.progress = (bar.max * MathUtils.clamp(oldBrightness, 0f, 1f)).toInt()
         bar.incrementProgressBy(distanceY.toInt())
 
         // Update brightness
@@ -194,18 +193,20 @@ class MainPlayerGestureListener(
         isMoving = true
 
         // -- Brightness and Volume control --
-        val isBrightnessGestureEnabled = PlayerHelper.isBrightnessGestureEnabled(player.context)
-        val isVolumeGestureEnabled = PlayerHelper.isVolumeGestureEnabled(player.context)
-        if (isBrightnessGestureEnabled && isVolumeGestureEnabled) {
-            if (getDisplayHalfPortion(initialEvent) === DisplayPortion.LEFT_HALF) {
-                onScrollBrightness(distanceY)
-            } else /* DisplayPortion.RIGHT_HALF */ {
-                onScrollVolume(distanceY)
+        if (getDisplayHalfPortion(initialEvent) == DisplayPortion.RIGHT_HALF) {
+            when (PlayerHelper.getActionForRightGestureSide(player.context)) {
+                player.context.getString(R.string.volume_control_key) ->
+                    onScrollVolume(distanceY)
+                player.context.getString(R.string.brightness_control_key) ->
+                    onScrollBrightness(distanceY)
+            }
+        } else {
+            when (PlayerHelper.getActionForLeftGestureSide(player.context)) {
+                player.context.getString(R.string.volume_control_key) ->
+                    onScrollVolume(distanceY)
+                player.context.getString(R.string.brightness_control_key) ->
+                    onScrollBrightness(distanceY)
             }
-        } else if (isBrightnessGestureEnabled) {
-            onScrollBrightness(distanceY)
-        } else if (isVolumeGestureEnabled) {
-            onScrollVolume(distanceY)
         }
 
         return true

app/src/main/java/org/schabi/newpipe/player/gesture/PopupPlayerGestureListener.kt

@@ -160,15 +160,15 @@ class PopupPlayerGestureListener(
         }
     }
 
-    override fun onLongPress(e: MotionEvent?) {
+    override fun onLongPress(e: MotionEvent) {
         playerUi.updateScreenSize()
         playerUi.checkPopupPositionBounds()
         playerUi.changePopupSize(playerUi.screenWidth)
     }
 
     override fun onFling(
-        e1: MotionEvent?,
-        e2: MotionEvent?,
+        e1: MotionEvent,
+        e2: MotionEvent,
         velocityX: Float,
         velocityY: Float
     ): Boolean {

app/src/main/java/org/schabi/newpipe/player/helper/CustomMediaCodecVideoRenderer.java

@@ -0,0 +1,54 @@
+package org.schabi.newpipe.player.helper;
+
+import android.content.Context;
+import android.os.Handler;
+
+import androidx.annotation.Nullable;
+
+import com.google.android.exoplayer2.mediacodec.MediaCodecAdapter;
+import com.google.android.exoplayer2.mediacodec.MediaCodecSelector;
+import com.google.android.exoplayer2.video.MediaCodecVideoRenderer;
+import com.google.android.exoplayer2.video.VideoRendererEventListener;
+
+/**
+ * A {@link MediaCodecVideoRenderer} which always enable the output surface workaround that
+ * ExoPlayer enables on several devices which are known to implement
+ * {@link android.media.MediaCodec#setOutputSurface(android.view.Surface)
+ * MediaCodec.setOutputSurface(Surface)} incorrectly.
+ *
+ * <p>
+ * See {@link MediaCodecVideoRenderer#codecNeedsSetOutputSurfaceWorkaround(String)} for more
+ * details.
+ * </p>
+ *
+ * <p>
+ * This custom {@link MediaCodecVideoRenderer} may be useful in the case a device is affected by
+ * this issue but is not present in ExoPlayer's list.
+ * </p>
+ *
+ * <p>
+ * This class has only effect on devices with Android 6 and higher, as the {@code setOutputSurface}
+ * method is only implemented in these Android versions and the method used as a workaround is
+ * always applied on older Android versions (releasing and re-instantiating video codec instances).
+ * </p>
+ */
+public final class CustomMediaCodecVideoRenderer extends MediaCodecVideoRenderer {
+
+    @SuppressWarnings({"checkstyle:ParameterNumber", "squid:S107"})
+    public CustomMediaCodecVideoRenderer(final Context context,
+                                         final MediaCodecAdapter.Factory codecAdapterFactory,
+                                         final MediaCodecSelector mediaCodecSelector,
+                                         final long allowedJoiningTimeMs,
+                                         final boolean enableDecoderFallback,
+                                         @Nullable final Handler eventHandler,
+                                         @Nullable final VideoRendererEventListener eventListener,
+                                         final int maxDroppedFramesToNotify) {
+        super(context, codecAdapterFactory, mediaCodecSelector, allowedJoiningTimeMs,
+                enableDecoderFallback, eventHandler, eventListener, maxDroppedFramesToNotify);
+    }
+
+    @Override
+    protected boolean codecNeedsSetOutputSurfaceWorkaround(final String name) {
+        return true;
+    }
+}

app/src/main/java/org/schabi/newpipe/player/helper/CustomRenderersFactory.java

@@ -0,0 +1,43 @@
+package org.schabi.newpipe.player.helper;
+
+import android.content.Context;
+import android.os.Handler;
+
+import com.google.android.exoplayer2.DefaultRenderersFactory;
+import com.google.android.exoplayer2.Renderer;
+import com.google.android.exoplayer2.mediacodec.MediaCodecSelector;
+import com.google.android.exoplayer2.video.VideoRendererEventListener;
+
+import java.util.ArrayList;
+
+/**
+ * A {@link DefaultRenderersFactory} which only uses {@link CustomMediaCodecVideoRenderer} as an
+ * implementation of video codec renders.
+ *
+ * <p>
+ * As no ExoPlayer extension is currently used, the reflection code used by ExoPlayer to try to
+ * load video extension libraries is not needed in our case and has been removed. This should be
+ * changed in the case an extension is shipped with the app, such as the AV1 one.
+ * </p>
+ */
+public final class CustomRenderersFactory extends DefaultRenderersFactory {
+
+    public CustomRenderersFactory(final Context context) {
+        super(context);
+    }
+
+    @SuppressWarnings("checkstyle:ParameterNumber")
+    @Override
+    protected void buildVideoRenderers(final Context context,
+                                       @ExtensionRendererMode final int extensionRendererMode,
+                                       final MediaCodecSelector mediaCodecSelector,
+                                       final boolean enableDecoderFallback,
+                                       final Handler eventHandler,
+                                       final VideoRendererEventListener eventListener,
+                                       final long allowedVideoJoiningTimeMs,
+                                       final ArrayList<Renderer> out) {
+        out.add(new CustomMediaCodecVideoRenderer(context, getCodecAdapterFactory(),
+                mediaCodecSelector, allowedVideoJoiningTimeMs, enableDecoderFallback, eventHandler,
+                eventListener, MAX_DROPPED_VIDEO_FRAME_COUNT_TO_NOTIFY));
+    }
+}