Merge pull request #7063 from TeamNewPipe/release/0.21.10

Release 0.21.10

.github/CONTRIBUTING.md

@@ -39,6 +39,10 @@ You'll see *exactly* what is sent, be able to add **your comments**, and then se
 * Create PRs that cover only **one specific issue/solution/bug**. Do not create PRs that are huge monoliths and could have been split into multiple independent contributions.
 * NewPipe uses [NewPipeExtractor](https://github.com/TeamNewPipe/NewPipeExtractor) to fetch data from services. If you need to change something there, you must test your changes in NewPipe. Telling NewPipe to use your extractor version can be accomplished by editing the `app/build.gradle` file: the comments under the "NewPipe libraries" section of `dependencies` will help you out.
 
+### Kotlin in NewPipe
+* NewPipe will remain mostly Java for time being
+* Contributions containing a simple conversion from Java to Kotlin should be avoided. Conversions to Kotlin should only be done if Kotlin actually brings improvements like bug fixes or better performance which are not, or only with much more effort, implementable in Java. The core team sees Java as an easier to learn and generally well adopted programming language.
+
 ### Creating a Pull Request (PR)
 
 * Make changes on a **separate branch** with a meaningful name, not on the _master_ branch or the _dev_ branch. This is commonly known as *feature branch workflow*. You may then send your changes as a pull request (PR) on GitHub.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -57,7 +57,7 @@ Oh no, a bug! It happens. Thanks for reporting an issue with NewPipe. To make it
 
 
 
-<!-- Please fill this out when you do not provide a log generate by NewPipe -->
+<!-- Please fill this section if you did not provide a log generated by NewPipe -->
 
 ### Device info
 

.github/workflows/ci.yml

@@ -1,14 +1,25 @@
 name: CI
 
 on:
+  workflow_dispatch:
   pull_request:
     branches:
       - dev
       - master
+    paths-ignore:
+      - 'README*.md'
+      - 'fastlane/**'
+      - 'assets/**'
+      - '.github/**/*.md'
   push:
     branches:
       - dev
       - master
+    paths-ignore:
+      - 'README*.md'
+      - 'fastlane/**'
+      - 'assets/**'
+      - '.github/**/*.md'
 
 jobs:
   build-and-test-jvm:
@@ -26,17 +37,11 @@ jobs:
         uses: actions/setup-java@v2
         with:
           java-version: 8
-          distribution: "adopt"
-
-      - name: Cache Gradle dependencies
-        uses: actions/cache@v2
-        with:
-          path: ~/.gradle/caches
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
-          restore-keys: ${{ runner.os }}-gradle
-
+          distribution: "temurin"
+          cache: 'gradle'
+          
       - name: Build debug APK and run jvm tests
-        run: ./gradlew assembleDebug lintDebug testDebugUnitTest --stacktrace
+        run: ./gradlew assembleDebug lintDebug testDebugUnitTest --stacktrace -DskipFormatKtlint
 
       - name: Upload APK
         uses: actions/upload-artifact@v2
@@ -44,35 +49,30 @@ jobs:
           name: app
           path: app/build/outputs/apk/debug/*.apk
 
-# Disabled until emulator works again. see https://github.com/TeamNewPipe/NewPipe/pull/6560
-#  test-android:
-     # macos has hardware acceleration. See android-emulator-runner action
-#    runs-on: macos-latest
-#    strategy:
-#      matrix:
-          # api-level 19 is min sdk, but throws errors related to desugaring
-#        api-level: [21, 29]
-#    steps:
-#      - uses: actions/checkout@v2
-#
-#      - name: set up JDK 8
-#        uses: actions/setup-java@v2
-#        with:
-#          java-version: 8
-#          distribution: "adopt"
-#
-#      - name: Cache Gradle dependencies
-#        uses: actions/cache@v2
-#        with:
-#          path: ~/.gradle/caches
-#          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
-#          restore-keys: ${{ runner.os }}-gradle
-#
-#      - name: Run android tests
-#        uses: reactivecircus/android-emulator-runner@v2
-#        with:
-#          api-level: ${{ matrix.api-level }}
-#          script: ./gradlew connectedCheck
+  test-android:
+    # macos has hardware acceleration. See android-emulator-runner action
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        # api-level 19 is min sdk, but throws errors related to desugaring 
+        api-level: [ 21, 29 ]
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: set up JDK 8
+        uses: actions/setup-java@v2
+        with:
+          java-version: 8
+          distribution: "temurin"
+          cache: 'gradle'
+
+      - name: Run android tests
+        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
+          script: ./gradlew connectedCheck
 
 #   sonar:
 #     runs-on: ubuntu-latest
@@ -85,7 +85,8 @@ jobs:
 #         uses: actions/setup-java@v2
 #         with:
 #           java-version: 11 # Sonar requires JDK 11
-#           distribution: "adopt"
+#           distribution: "temurin"
+#           cache: 'gradle'
 
 #       - name: Cache SonarCloud packages
 #         uses: actions/cache@v2
@@ -94,13 +95,6 @@ jobs:
 #           key: ${{ runner.os }}-sonar
 #           restore-keys: ${{ runner.os }}-sonar
 
-#       - name: Cache Gradle packages
-#         uses: actions/cache@v2
-#         with:
-#           path: ~/.gradle/caches
-#           key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
-#           restore-keys: ${{ runner.os }}-gradle
-
 #       - name: Build and analyze
 #         env:
 #           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}  # Needed to get PR information, if any

.github/workflows/no-response.yml

@@ -0,0 +1,20 @@
+name: No Response
+
+# Both `issue_comment` and `scheduled` event types are required for this Action
+# to work properly.
+on:
+  issue_comment:
+    types: [created]
+  schedule:
+    # Run daily at midnight.
+    - cron: '0 0 * * *'
+
+jobs:
+  noResponse:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: lee-dohm/no-response@v0.5.0
+        with:
+          token: ${{ github.token }}
+          daysUntilClose: 14
+          responseRequiredLabel: waiting-for-author

app/build.gradle

@@ -4,21 +4,21 @@ plugins {
 
 apply plugin: 'com.android.application'
 apply plugin: 'kotlin-android'
-apply plugin: 'kotlin-android-extensions'
+apply plugin: 'kotlin-parcelize'
 apply plugin: 'kotlin-kapt'
 apply plugin: 'checkstyle'
 
 android {
-    compileSdkVersion 29
-    buildToolsVersion '29.0.3'
+    compileSdkVersion 30
+    buildToolsVersion '30.0.3'
 
     defaultConfig {
         applicationId "org.schabi.newpipe"
         resValue "string", "app_name", "NewPipe"
         minSdkVersion 19
         targetSdkVersion 29
-        versionCode 972
-        versionName "0.21.6"
+        versionCode 976
+        versionName "0.21.10"
 
         multiDexEnabled true
 
@@ -84,11 +84,6 @@ android {
         jvmTarget = JavaVersion.VERSION_1_8
     }
 
-    // Required and used only by groupie
-    androidExtensions {
-        experimental = true
-    }
-
     sourceSets {
         androidTest.assets.srcDirs += files("$projectDir/schemas".toString())
     }
@@ -101,17 +96,17 @@ android {
 ext {
     checkstyleVersion = '8.38'
 
-    androidxLifecycleVersion = '2.2.0'
+    androidxLifecycleVersion = '2.3.1'
     androidxRoomVersion = '2.3.0'
 
     icepickVersion = '3.2.0'
     exoPlayerVersion = '2.12.3'
-    googleAutoServiceVersion = '1.0-rc7'
+    googleAutoServiceVersion = '1.0'
     groupieVersion = '2.8.1'
-    markwonVersion = '4.6.0'
+    markwonVersion = '4.6.2'
 
     leakCanaryVersion = '2.5'
-    stethoVersion = '1.5.1'
+    stethoVersion = '1.6.0'
     mockitoVersion = '3.6.0'
 }
 
@@ -121,7 +116,7 @@ configurations {
 }
 
 checkstyle {
-    configDir rootProject.file(".")
+    getConfigDirectory().set(rootProject.file("."))
     ignoreFailures false
     showViolations true
     toolVersion = checkstyleVersion
@@ -140,8 +135,8 @@ task runCheckstyle(type: Checkstyle) {
     showViolations true
 
     reports {
-        xml.enabled true
-        html.enabled true
+        xml.getRequired().set(true)
+        html.getRequired().set(true)
     }
 }
 
@@ -151,7 +146,7 @@ def inputFiles = project.fileTree(dir: "src", include: "**/*.kt")
 task runKtlint(type: JavaExec) {
     inputs.files(inputFiles)
     outputs.dir(outputDir)
-    main = "com.pinterest.ktlint.Main"
+    getMainClass().set("com.pinterest.ktlint.Main")
     classpath = configurations.ktlint
     args "src/**/*.kt"
 }
@@ -159,13 +154,16 @@ task runKtlint(type: JavaExec) {
 task formatKtlint(type: JavaExec) {
     inputs.files(inputFiles)
     outputs.dir(outputDir)
-    main = "com.pinterest.ktlint.Main"
+    getMainClass().set("com.pinterest.ktlint.Main")
     classpath = configurations.ktlint
     args "-F", "src/**/*.kt"
 }
 
 afterEvaluate {
-    preDebugBuild.dependsOn formatKtlint, runCheckstyle, runKtlint
+    if (!System.properties.containsKey('skipFormatKtlint')) {
+        preDebugBuild.dependsOn formatKtlint
+    }
+    preDebugBuild.dependsOn runCheckstyle, runKtlint
 }
 
 sonarqube {
@@ -186,7 +184,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:v0.21.6'
+    implementation 'com.github.TeamNewPipe:NewPipeExtractor:v0.21.10'
 
 /** Checkstyle **/
     checkstyle "com.puppycrawl.tools:checkstyle:${checkstyleVersion}"
@@ -196,16 +194,16 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:${kotlin_version}"
 
 /** AndroidX **/
-    implementation 'androidx.appcompat:appcompat:1.2.0'
+    implementation 'androidx.appcompat:appcompat:1.3.1'
     implementation 'androidx.cardview:cardview:1.0.0'
     implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
-    implementation 'androidx.core:core-ktx:1.3.2'
+    implementation 'androidx.core:core-ktx:1.6.0'
     implementation 'androidx.documentfile:documentfile:1.0.1'
-    implementation 'androidx.fragment:fragment-ktx:1.3.4'
+    implementation 'androidx.fragment:fragment-ktx:1.3.6'
     implementation "androidx.lifecycle:lifecycle-livedata:${androidxLifecycleVersion}"
     implementation "androidx.lifecycle:lifecycle-viewmodel:${androidxLifecycleVersion}"
     implementation 'androidx.localbroadcastmanager:localbroadcastmanager:1.0.0'
-    implementation 'androidx.media:media:1.2.1'
+    implementation 'androidx.media:media:1.3.1'
     implementation 'androidx.multidex:multidex:2.0.1'
     implementation 'androidx.preference:preference:1.1.1'
     implementation 'androidx.recyclerview:recyclerview:1.1.0'
@@ -237,13 +235,14 @@ dependencies {
     kapt "com.google.auto.service:auto-service:${googleAutoServiceVersion}"
 
     // Manager for complex RecyclerView layouts
-    implementation "com.xwray:groupie:${groupieVersion}"
-    implementation "com.xwray:groupie-viewbinding:${groupieVersion}"
+    implementation "com.github.lisawray.groupie:groupie:${groupieVersion}"
+    implementation "com.github.lisawray.groupie:groupie-viewbinding:${groupieVersion}"
 
     // Circular ImageView
     implementation "de.hdodenhof:circleimageview:3.1.0"
     // Image loading
-    implementation "com.nostra13.universalimageloader:universal-image-loader:1.9.5"
+    //noinspection GradleDependency --> 2.8 is the last version, not 2.71828!
+    implementation "com.squareup.picasso:picasso:2.8"
 
     // Markdown library for Android
     implementation "io.noties.markwon:core:${markwonVersion}"
@@ -255,6 +254,9 @@ dependencies {
     // Crash reporting
     implementation "ch.acra:acra-core:5.7.0"
 
+    // Properly restarting
+    implementation 'com.jakewharton:process-phoenix:2.1.2'
+
     // Reactive extensions for Java VM
     implementation "io.reactivex.rxjava3:rxjava:3.0.7"
     implementation "io.reactivex.rxjava3:rxandroid:3.0.0"

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

@@ -0,0 +1,713 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 4,
+    "identityHash": "d8070091972a7011bce18aed62f80b90",
+    "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)",
+        "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
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "uid"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_subscriptions_service_id_url",
+            "unique": true,
+            "columnNames": [
+              "service_id",
+              "url"
+            ],
+            "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}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `creation_date` INTEGER, `service_id` INTEGER NOT NULL, `search` TEXT)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "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
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_search_history_search",
+            "unique": false,
+            "columnNames": [
+              "search"
+            ],
+            "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"
+            ],
+            "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"
+            ],
+            "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)",
+        "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
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "uid"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_playlists_name",
+            "unique": false,
+            "columnNames": [
+              "name"
+            ],
+            "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"
+            ],
+            "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"
+            ],
+            "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"
+            ],
+            "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"
+            ],
+            "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"
+            ],
+            "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"
+            ],
+            "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"
+            ],
+            "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, 'd8070091972a7011bce18aed62f80b90')"
+    ]
+  }
+}

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

@@ -1,134 +0,0 @@
-package org.schabi.newpipe.database
-
-import android.content.ContentValues
-import android.database.sqlite.SQLiteDatabase
-import androidx.room.Room
-import androidx.room.testing.MigrationTestHelper
-import androidx.sqlite.db.framework.FrameworkSQLiteOpenHelperFactory
-import androidx.test.core.app.ApplicationProvider
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.platform.app.InstrumentationRegistry
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
-import org.junit.Rule
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.schabi.newpipe.extractor.stream.StreamType
-
-@RunWith(AndroidJUnit4::class)
-class AppDatabaseTest {
-    companion object {
-        private const val DEFAULT_SERVICE_ID = 0
-        private const val DEFAULT_URL = "https://www.youtube.com/watch?v=cDphUib5iG4"
-        private const val DEFAULT_TITLE = "Test Title"
-        private val DEFAULT_TYPE = StreamType.VIDEO_STREAM
-        private const val DEFAULT_DURATION = 480L
-        private const val DEFAULT_UPLOADER_NAME = "Uploader Test"
-        private const val DEFAULT_THUMBNAIL = "https://example.com/example.jpg"
-
-        private const val DEFAULT_SECOND_SERVICE_ID = 0
-        private const val DEFAULT_SECOND_URL = "https://www.youtube.com/watch?v=ncQU6iBn5Fc"
-    }
-
-    @get:Rule
-    val testHelper = MigrationTestHelper(
-        InstrumentationRegistry.getInstrumentation(),
-        AppDatabase::class.java.canonicalName, FrameworkSQLiteOpenHelperFactory()
-    )
-
-    @Test
-    fun migrateDatabaseFrom2to3() {
-        val databaseInV2 = testHelper.createDatabase(AppDatabase.DATABASE_NAME, Migrations.DB_VER_2)
-
-        databaseInV2.run {
-            insert(
-                "streams", SQLiteDatabase.CONFLICT_FAIL,
-                ContentValues().apply {
-                    // put("uid", null)
-                    put("service_id", DEFAULT_SERVICE_ID)
-                    put("url", DEFAULT_URL)
-                    put("title", DEFAULT_TITLE)
-                    put("stream_type", DEFAULT_TYPE.name)
-                    put("duration", DEFAULT_DURATION)
-                    put("uploader", DEFAULT_UPLOADER_NAME)
-                    put("thumbnail_url", DEFAULT_THUMBNAIL)
-                }
-            )
-            insert(
-                "streams", SQLiteDatabase.CONFLICT_FAIL,
-                ContentValues().apply {
-                    // put("uid", null)
-                    put("service_id", DEFAULT_SECOND_SERVICE_ID)
-                    put("url", DEFAULT_SECOND_URL)
-                    // put("title", null)
-                    // put("stream_type", null)
-                    // put("duration", null)
-                    // put("uploader", null)
-                    // put("thumbnail_url", null)
-                }
-            )
-            insert(
-                "streams", SQLiteDatabase.CONFLICT_FAIL,
-                ContentValues().apply {
-                    // put("uid", null)
-                    put("service_id", DEFAULT_SERVICE_ID)
-                    // put("url", null)
-                    // put("title", null)
-                    // put("stream_type", null)
-                    // put("duration", null)
-                    // put("uploader", null)
-                    // put("thumbnail_url", null)
-                }
-            )
-            close()
-        }
-
-        testHelper.runMigrationsAndValidate(
-            AppDatabase.DATABASE_NAME, Migrations.DB_VER_3,
-            true, Migrations.MIGRATION_2_3
-        )
-
-        val migratedDatabaseV3 = getMigratedDatabase()
-        val listFromDB = migratedDatabaseV3.streamDAO().all.blockingFirst()
-
-        // Only expect 2, the one with the null url will be ignored
-        assertEquals(2, listFromDB.size)
-
-        val streamFromMigratedDatabase = listFromDB[0]
-        assertEquals(DEFAULT_SERVICE_ID, streamFromMigratedDatabase.serviceId)
-        assertEquals(DEFAULT_URL, streamFromMigratedDatabase.url)
-        assertEquals(DEFAULT_TITLE, streamFromMigratedDatabase.title)
-        assertEquals(DEFAULT_TYPE, streamFromMigratedDatabase.streamType)
-        assertEquals(DEFAULT_DURATION, streamFromMigratedDatabase.duration)
-        assertEquals(DEFAULT_UPLOADER_NAME, streamFromMigratedDatabase.uploader)
-        assertEquals(DEFAULT_THUMBNAIL, streamFromMigratedDatabase.thumbnailUrl)
-        assertNull(streamFromMigratedDatabase.viewCount)
-        assertNull(streamFromMigratedDatabase.textualUploadDate)
-        assertNull(streamFromMigratedDatabase.uploadDate)
-        assertNull(streamFromMigratedDatabase.isUploadDateApproximation)
-
-        val secondStreamFromMigratedDatabase = listFromDB[1]
-        assertEquals(DEFAULT_SECOND_SERVICE_ID, secondStreamFromMigratedDatabase.serviceId)
-        assertEquals(DEFAULT_SECOND_URL, secondStreamFromMigratedDatabase.url)
-        assertEquals("", secondStreamFromMigratedDatabase.title)
-        // Should fallback to VIDEO_STREAM
-        assertEquals(StreamType.VIDEO_STREAM, secondStreamFromMigratedDatabase.streamType)
-        assertEquals(0, secondStreamFromMigratedDatabase.duration)
-        assertEquals("", secondStreamFromMigratedDatabase.uploader)
-        assertEquals("", secondStreamFromMigratedDatabase.thumbnailUrl)
-        assertNull(secondStreamFromMigratedDatabase.viewCount)
-        assertNull(secondStreamFromMigratedDatabase.textualUploadDate)
-        assertNull(secondStreamFromMigratedDatabase.uploadDate)
-        assertNull(secondStreamFromMigratedDatabase.isUploadDateApproximation)
-    }
-
-    private fun getMigratedDatabase(): AppDatabase {
-        val database: AppDatabase = Room.databaseBuilder(
-            ApplicationProvider.getApplicationContext(),
-            AppDatabase::class.java, AppDatabase.DATABASE_NAME
-        )
-            .build()
-        testHelper.closeWhenFinished(database)
-        return database
-    }
-}

app/src/androidTest/java/org/schabi/newpipe/local/playlist/LocalPlaylistManagerTest.kt

@@ -0,0 +1,88 @@
+package org.schabi.newpipe.local.playlist
+
+import androidx.room.Room
+import androidx.test.core.app.ApplicationProvider
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.schabi.newpipe.database.AppDatabase
+import org.schabi.newpipe.database.stream.model.StreamEntity
+import org.schabi.newpipe.extractor.stream.StreamType
+import org.schabi.newpipe.testUtil.TrampolineSchedulerRule
+import java.util.concurrent.TimeUnit
+
+class LocalPlaylistManagerTest {
+
+    private lateinit var manager: LocalPlaylistManager
+    private lateinit var database: AppDatabase
+
+    @get:Rule
+    val trampolineScheduler = TrampolineSchedulerRule()
+
+    @get:Rule
+    val timeout = Timeout(10, TimeUnit.SECONDS)
+
+    @Before
+    fun setup() {
+        database = Room.inMemoryDatabaseBuilder(
+            ApplicationProvider.getApplicationContext(),
+            AppDatabase::class.java
+        )
+            .allowMainThreadQueries()
+            .build()
+
+        manager = LocalPlaylistManager(database)
+    }
+
+    @After
+    fun cleanUp() {
+        database.close()
+    }
+
+    @Test
+    fun createPlaylist() {
+        val stream = StreamEntity(
+            serviceId = 1, url = "https://newpipe.net/", title = "title",
+            streamType = StreamType.VIDEO_STREAM, duration = 1, uploader = "uploader",
+            uploaderUrl = "https://newpipe.net/"
+        )
+
+        val result = manager.createPlaylist("name", listOf(stream))
+
+        // This should not behave like this.
+        // Currently list of all stream ids is returned instead of playlist id
+        result.test().await().assertValue(listOf(1L))
+    }
+
+    @Test
+    fun createPlaylist_emptyPlaylistMustReturnEmpty() {
+        val result = manager.createPlaylist("name", emptyList())
+
+        // This should not behave like this.
+        // It should throw an error because currently the result is null
+        result.test().await().assertComplete()
+        manager.playlists.test().awaitCount(1).assertValue(emptyList())
+    }
+
+    @Test()
+    fun createPlaylist_nonExistentStreamsAreUpserted() {
+        val stream = StreamEntity(
+            serviceId = 1, url = "https://newpipe.net/", title = "title",
+            streamType = StreamType.VIDEO_STREAM, duration = 1, uploader = "uploader",
+            uploaderUrl = "https://newpipe.net/"
+        )
+        database.streamDAO().insert(stream)
+        val upserted = StreamEntity(
+            serviceId = 1, url = "https://newpipe.net/2", title = "title2",
+            streamType = StreamType.VIDEO_STREAM, duration = 1, uploader = "uploader",
+            uploaderUrl = "https://newpipe.net/"
+        )
+
+        val result = manager.createPlaylist("name", listOf(stream, upserted))
+
+        result.test().await().assertComplete()
+        database.streamDAO().all.test().awaitCount(1).assertValue(listOf(stream, upserted))
+    }
+}

app/src/androidTest/java/org/schabi/newpipe/testUtil/TrampolineSchedulerRule.kt

@@ -0,0 +1,37 @@
+package org.schabi.newpipe.testUtil
+
+import io.reactivex.rxjava3.android.plugins.RxAndroidPlugins
+import io.reactivex.rxjava3.plugins.RxJavaPlugins
+import io.reactivex.rxjava3.schedulers.Schedulers
+import org.junit.rules.TestRule
+import org.junit.runner.Description
+import org.junit.runners.model.Statement
+
+/**
+ * Always run on [Schedulers.trampoline].
+ * This executes the task in the current thread in FIFO manner.
+ * This ensures that tasks are run quickly inside the tests
+ * and not scheduled away to another thread for later execution
+ */
+class TrampolineSchedulerRule : TestRule {
+
+    private val scheduler = Schedulers.trampoline()
+
+    override fun apply(base: Statement, description: Description): Statement =
+        object : Statement() {
+            override fun evaluate() {
+                try {
+                    RxJavaPlugins.setComputationSchedulerHandler { scheduler }
+                    RxJavaPlugins.setIoSchedulerHandler { scheduler }
+                    RxJavaPlugins.setNewThreadSchedulerHandler { scheduler }
+                    RxJavaPlugins.setSingleSchedulerHandler { scheduler }
+                    RxAndroidPlugins.setInitMainThreadSchedulerHandler { scheduler }
+
+                    base.evaluate()
+                } finally {
+                    RxJavaPlugins.reset()
+                    RxAndroidPlugins.reset()
+                }
+            }
+        }
+}

app/src/debug/java/org/schabi/newpipe/settings/DebugSettingsFragment.java

@@ -5,6 +5,7 @@ import android.os.Bundle;
 import androidx.preference.Preference;
 
 import org.schabi.newpipe.R;
+import org.schabi.newpipe.util.PicassoHelper;
 
 import leakcanary.LeakCanary;
 
@@ -15,10 +16,13 @@ public class DebugSettingsFragment extends BasePreferenceFragment {
 
         final Preference showMemoryLeaksPreference
                 = findPreference(getString(R.string.show_memory_leaks_key));
+        final Preference showImageIndicatorsPreference
+                = findPreference(getString(R.string.show_image_indicators_key));
         final Preference crashTheAppPreference
                 = findPreference(getString(R.string.crash_the_app_key));
 
         assert showMemoryLeaksPreference != null;
+        assert showImageIndicatorsPreference != null;
         assert crashTheAppPreference != null;
 
         showMemoryLeaksPreference.setOnPreferenceClickListener(preference -> {
@@ -26,6 +30,11 @@ public class DebugSettingsFragment extends BasePreferenceFragment {
             return true;
         });
 
+        showImageIndicatorsPreference.setOnPreferenceChangeListener((preference, newValue) -> {
+            PicassoHelper.setIndicatorsEnabled((Boolean) newValue);
+            return true;
+        });
+
         crashTheAppPreference.setOnPreferenceClickListener(preference -> {
             throw new RuntimeException();
         });

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

@@ -1,20 +1,17 @@
 package org.schabi.newpipe;
 
-import android.app.NotificationChannel;
-import android.app.NotificationManager;
 import android.content.Context;
 import android.content.SharedPreferences;
-import android.os.Build;
 import android.util.Log;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import androidx.core.app.NotificationChannelCompat;
+import androidx.core.app.NotificationManagerCompat;
 import androidx.multidex.MultiDexApplication;
 import androidx.preference.PreferenceManager;
 
-import com.nostra13.universalimageloader.cache.memory.impl.LRULimitedMemoryCache;
-import com.nostra13.universalimageloader.core.ImageLoader;
-import com.nostra13.universalimageloader.core.ImageLoaderConfiguration;
+import com.jakewharton.processphoenix.ProcessPhoenix;
 
 import org.acra.ACRA;
 import org.acra.config.ACRAConfigurationException;
@@ -29,6 +26,7 @@ import org.schabi.newpipe.extractor.downloader.Downloader;
 import org.schabi.newpipe.ktx.ExceptionUtils;
 import org.schabi.newpipe.settings.NewPipeSettings;
 import org.schabi.newpipe.util.Localization;
+import org.schabi.newpipe.util.PicassoHelper;
 import org.schabi.newpipe.util.ServiceHelper;
 import org.schabi.newpipe.util.StateSaver;
 
@@ -66,9 +64,9 @@ import io.reactivex.rxjava3.plugins.RxJavaPlugins;
  */
 
 public class App extends MultiDexApplication {
-    protected static final String TAG = App.class.toString();
-    private static App app;
     public static final String PACKAGE_NAME = BuildConfig.APPLICATION_ID;
+    private static final String TAG = App.class.toString();
+    private static App app;
 
     @Nullable
     private Disposable disposable = null;
@@ -90,6 +88,12 @@ public class App extends MultiDexApplication {
 
         app = this;
 
+        if (ProcessPhoenix.isPhoenixProcess(this)) {
+            Log.i(TAG, "This is a phoenix process! "
+                    + "Aborting initialization of App[onCreate]");
+            return;
+        }
+
         // Initialize settings first because others inits can use its values
         NewPipeSettings.initSettings(this);
 
@@ -104,7 +108,12 @@ public class App extends MultiDexApplication {
         ServiceHelper.initServices(this);
 
         // Initialize image loader
-        ImageLoader.getInstance().init(getImageLoaderConfigurations(10, 50));
+        final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
+        PicassoHelper.init(this);
+        PicassoHelper.setShouldLoadImages(
+                prefs.getBoolean(getString(R.string.download_thumbnail_key), true));
+        PicassoHelper.setIndicatorsEnabled(MainActivity.DEBUG
+                && prefs.getBoolean(getString(R.string.show_image_indicators_key), false));
 
         configureRxJavaErrorHandler();
 
@@ -118,6 +127,7 @@ public class App extends MultiDexApplication {
             disposable.dispose();
         }
         super.onTerminate();
+        PicassoHelper.terminate();
     }
 
     protected Downloader getDownloader() {
@@ -202,15 +212,6 @@ public class App extends MultiDexApplication {
         });
     }
 
-    private ImageLoaderConfiguration getImageLoaderConfigurations(final int memoryCacheSizeMb,
-                                                                  final int diskCacheSizeMb) {
-        return new ImageLoaderConfiguration.Builder(this)
-                .memoryCache(new LRULimitedMemoryCache(memoryCacheSizeMb * 1024 * 1024))
-                .diskCacheSize(diskCacheSizeMb * 1024 * 1024)
-                .imageDownloader(new ImageDownloader(getApplicationContext()))
-                .build();
-    }
-
     /**
      * Called in {@link #attachBaseContext(Context)} after calling the {@code super} method.
      * Should be overridden if MultiDex is enabled, since it has to be initialized before ACRA.
@@ -233,38 +234,31 @@ public class App extends MultiDexApplication {
     }
 
     private void initNotificationChannels() {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
-            return;
-        }
+        // Keep the importance below DEFAULT to avoid making noise on every notification update for
+        // the main and update channels
+        final NotificationChannelCompat mainChannel = new NotificationChannelCompat
+                .Builder(getString(R.string.notification_channel_id),
+                NotificationManagerCompat.IMPORTANCE_LOW)
+                .setName(getString(R.string.notification_channel_name))
+                .setDescription(getString(R.string.notification_channel_description))
+                .build();
 
-        String id = getString(R.string.notification_channel_id);
-        String name = getString(R.string.notification_channel_name);
-        String description = getString(R.string.notification_channel_description);
+        final NotificationChannelCompat appUpdateChannel = new NotificationChannelCompat
+                .Builder(getString(R.string.app_update_notification_channel_id),
+                NotificationManagerCompat.IMPORTANCE_LOW)
+                .setName(getString(R.string.app_update_notification_channel_name))
+                .setDescription(getString(R.string.app_update_notification_channel_description))
+                .build();
 
-        // Keep this below DEFAULT to avoid making noise on every notification update for the main
-        // and update channels
-        int importance = NotificationManager.IMPORTANCE_LOW;
+        final NotificationChannelCompat hashChannel = new NotificationChannelCompat
+                .Builder(getString(R.string.hash_channel_id),
+                NotificationManagerCompat.IMPORTANCE_HIGH)
+                .setName(getString(R.string.hash_channel_name))
+                .setDescription(getString(R.string.hash_channel_description))
+                .build();
 
-        final NotificationChannel mainChannel = new NotificationChannel(id, name, importance);
-        mainChannel.setDescription(description);
-
-        id = getString(R.string.app_update_notification_channel_id);
-        name = getString(R.string.app_update_notification_channel_name);
-        description = getString(R.string.app_update_notification_channel_description);
-
-        final NotificationChannel appUpdateChannel = new NotificationChannel(id, name, importance);
-        appUpdateChannel.setDescription(description);
-
-        id = getString(R.string.hash_channel_id);
-        name = getString(R.string.hash_channel_name);
-        description = getString(R.string.hash_channel_description);
-        importance = NotificationManager.IMPORTANCE_HIGH;
-
-        final NotificationChannel hashChannel = new NotificationChannel(id, name, importance);
-        hashChannel.setDescription(description);
-
-        final NotificationManager notificationManager = getSystemService(NotificationManager.class);
-        notificationManager.createNotificationChannels(Arrays.asList(mainChannel,
+        final NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
+        notificationManager.createNotificationChannelsCompat(Arrays.asList(mainChannel,
                 appUpdateChannel, hashChannel));
     }
 

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

@@ -10,16 +10,13 @@ import androidx.appcompat.app.AppCompatActivity;
 import androidx.fragment.app.Fragment;
 import androidx.fragment.app.FragmentManager;
 
-import com.nostra13.universalimageloader.core.ImageLoader;
-
 import icepick.Icepick;
 import icepick.State;
 import leakcanary.AppWatcher;
 
 public abstract class BaseFragment extends Fragment {
-    public static final ImageLoader IMAGE_LOADER = ImageLoader.getInstance();
     protected final String TAG = getClass().getSimpleName() + "@" + Integer.toHexString(hashCode());
-    protected final boolean DEBUG = MainActivity.DEBUG;
+    protected static final boolean DEBUG = MainActivity.DEBUG;
     protected AppCompatActivity activity;
     //These values are used for controlling fragments when they are part of the frontpage
     @State

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

@@ -4,7 +4,6 @@ import android.app.Application;
 import android.app.PendingIntent;
 import android.content.Intent;
 import android.content.SharedPreferences;
-import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 import android.content.pm.Signature;
 import android.net.ConnectivityManager;
@@ -16,6 +15,7 @@ import androidx.annotation.Nullable;
 import androidx.core.app.NotificationCompat;
 import androidx.core.app.NotificationManagerCompat;
 import androidx.core.content.ContextCompat;
+import androidx.core.content.pm.PackageInfoCompat;
 import androidx.preference.PreferenceManager;
 
 import com.grack.nanojson.JsonObject;
@@ -34,6 +34,7 @@ import java.security.cert.CertificateEncodingException;
 import java.security.cert.CertificateException;
 import java.security.cert.CertificateFactory;
 import java.security.cert.X509Certificate;
+import java.util.List;
 
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
 import io.reactivex.rxjava3.core.Maybe;
@@ -58,20 +59,22 @@ public final class CheckForNewAppVersion {
      */
     @NonNull
     private static String getCertificateSHA1Fingerprint(@NonNull final Application application) {
-        final PackageInfo packageInfo;
+        final List<Signature> signatures;
         try {
-            packageInfo = application.getPackageManager().getPackageInfo(
-                    application.getPackageName(), PackageManager.GET_SIGNATURES);
+            signatures = PackageInfoCompat.getSignatures(application.getPackageManager(),
+                    application.getPackageName());
         } catch (final PackageManager.NameNotFoundException e) {
             ErrorActivity.reportError(application, new ErrorInfo(e,
                     UserAction.CHECK_FOR_NEW_APP_VERSION, "Could not find package info"));
             return "";
         }
+        if (signatures.isEmpty()) {
+            return "";
+        }
 
         final X509Certificate c;
         try {
-            final Signature[] signatures = packageInfo.signatures;
-            final byte[] cert = signatures[0].toByteArray();
+            final byte[] cert = signatures.get(0).toByteArray();
             final InputStream input = new ByteArrayInputStream(cert);
             final CertificateFactory cf = CertificateFactory.getInstance("X509");
             c = (X509Certificate) cf.generateCertificate(input);

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

@@ -17,7 +17,6 @@ import org.schabi.newpipe.util.InfoCache;
 import org.schabi.newpipe.util.TLSSocketFactoryCompat;
 
 import java.io.IOException;
-import java.io.InputStream;
 import java.security.KeyManagementException;
 import java.security.KeyStore;
 import java.security.KeyStoreException;
@@ -194,36 +193,6 @@ public final class DownloaderImpl extends Downloader {
         }
     }
 
-    public InputStream stream(final String siteUrl) throws IOException {
-        try {
-            final okhttp3.Request.Builder requestBuilder = new okhttp3.Request.Builder()
-                    .method("GET", null).url(siteUrl)
-                    .addHeader("User-Agent", USER_AGENT);
-
-            final String cookies = getCookies(siteUrl);
-            if (!cookies.isEmpty()) {
-                requestBuilder.addHeader("Cookie", cookies);
-            }
-
-            final okhttp3.Request request = requestBuilder.build();
-            final okhttp3.Response response = client.newCall(request).execute();
-            final ResponseBody body = response.body();
-
-            if (response.code() == 429) {
-                throw new ReCaptchaException("reCaptcha Challenge requested", siteUrl);
-            }
-
-            if (body == null) {
-                response.close();
-                return null;
-            }
-
-            return body.byteStream();
-        } catch (final ReCaptchaException e) {
-            throw new IOException(e.getMessage(), e.getCause());
-        }
-    }
-
     @Override
     public Response execute(@NonNull final Request request)
             throws IOException, ReCaptchaException {

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

@@ -1,48 +0,0 @@
-package org.schabi.newpipe;
-
-import android.annotation.SuppressLint;
-import android.content.Context;
-import android.content.SharedPreferences;
-import android.content.res.Resources;
-
-import androidx.preference.PreferenceManager;
-
-import com.nostra13.universalimageloader.core.download.BaseImageDownloader;
-
-import org.schabi.newpipe.extractor.NewPipe;
-
-import java.io.IOException;
-import java.io.InputStream;
-
-public class ImageDownloader extends BaseImageDownloader {
-    private final Resources resources;
-    private final SharedPreferences preferences;
-    private final String downloadThumbnailKey;
-
-    public ImageDownloader(final Context context) {
-        super(context);
-        this.resources = context.getResources();
-        this.preferences = PreferenceManager.getDefaultSharedPreferences(context);
-        this.downloadThumbnailKey = context.getString(R.string.download_thumbnail_key);
-    }
-
-    private boolean isDownloadingThumbnail() {
-        return preferences.getBoolean(downloadThumbnailKey, true);
-    }
-
-    @SuppressLint("ResourceType")
-    @Override
-    public InputStream getStream(final String imageUri, final Object extra) throws IOException {
-        if (isDownloadingThumbnail()) {
-            return super.getStream(imageUri, extra);
-        } else {
-            return resources.openRawResource(R.drawable.dummy_thumbnail_dark);
-        }
-    }
-
-    protected InputStream getStreamFromNetwork(final String imageUri, final Object extra)
-            throws IOException {
-        final DownloaderImpl downloader = (DownloaderImpl) NewPipe.getDownloader();
-        return downloader.stream(imageUri);
-    }
-}

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

@@ -402,7 +402,7 @@ public class MainActivity extends AppCompatActivity {
                 new Handler(Looper.getMainLooper()).postDelayed(() -> {
                     getSupportFragmentManager().popBackStack(null,
                             FragmentManager.POP_BACK_STACK_INCLUSIVE);
-                    recreate();
+                    ActivityCompat.recreate(MainActivity.this);
                 }, 300);
             }
 
@@ -823,7 +823,7 @@ public class MainActivity extends AppCompatActivity {
             return;
         }
 
-        if (PlayerHolder.isPlayerOpen()) {
+        if (PlayerHolder.getInstance().isPlayerOpen()) {
             // if the player is already open, no need for a broadcast receiver
             openMiniPlayerIfMissing();
         } else {

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

@@ -11,6 +11,7 @@ import org.schabi.newpipe.database.AppDatabase;
 import static org.schabi.newpipe.database.AppDatabase.DATABASE_NAME;
 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;
 
 public final class NewPipeDatabase {
     private static volatile AppDatabase databaseInstance;
@@ -22,7 +23,7 @@ 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)
+                .addMigrations(MIGRATION_1_2, MIGRATION_2_3, MIGRATION_3_4)
                 .build();
     }
 

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

@@ -0,0 +1,70 @@
+package org.schabi.newpipe;
+
+import static org.schabi.newpipe.util.external_communication.ShareUtils.shareText;
+
+import android.content.Context;
+import android.view.ContextThemeWrapper;
+import android.view.View;
+import android.widget.PopupMenu;
+
+import androidx.fragment.app.FragmentManager;
+
+import org.schabi.newpipe.local.dialog.PlaylistAppendDialog;
+import org.schabi.newpipe.local.dialog.PlaylistCreationDialog;
+import org.schabi.newpipe.player.playqueue.PlayQueue;
+import org.schabi.newpipe.player.playqueue.PlayQueueItem;
+import org.schabi.newpipe.util.NavigationHelper;
+
+import java.util.Collections;
+
+public final class QueueItemMenuUtil {
+    public static void openPopupMenu(final PlayQueue playQueue,
+                                     final PlayQueueItem item,
+                                     final View view,
+                                     final boolean hideDetails,
+                                     final FragmentManager fragmentManager,
+                                     final Context context) {
+        final ContextThemeWrapper themeWrapper =
+                new ContextThemeWrapper(context, R.style.DarkPopupMenu);
+
+        final PopupMenu popupMenu = new PopupMenu(themeWrapper, view);
+        popupMenu.inflate(R.menu.menu_play_queue_item);
+
+        if (hideDetails) {
+            popupMenu.getMenu().findItem(R.id.menu_item_details).setVisible(false);
+        }
+
+        popupMenu.setOnMenuItemClickListener(menuItem -> {
+            switch (menuItem.getItemId()) {
+                case R.id.menu_item_remove:
+                    final int index = playQueue.indexOf(item);
+                    playQueue.remove(index);
+                    return true;
+                case R.id.menu_item_details:
+                    // playQueue is null since we don't want any queue change
+                    NavigationHelper.openVideoDetail(context, item.getServiceId(),
+                            item.getUrl(), item.getTitle(), null,
+                            false);
+                    return true;
+                case R.id.menu_item_append_playlist:
+                    final PlaylistAppendDialog d = PlaylistAppendDialog.fromPlayQueueItems(
+                            Collections.singletonList(item)
+                    );
+                    PlaylistAppendDialog.onPlaylistFound(context,
+                            () -> d.show(fragmentManager, "QueueItemMenuUtil@append_playlist"),
+                            () -> PlaylistCreationDialog.newInstance(d)
+                                    .show(fragmentManager, "QueueItemMenuUtil@append_playlist"));
+                    return true;
+                case R.id.menu_item_share:
+                    shareText(context, item.getTitle(), item.getUrl(),
+                            item.getThumbnailUrl());
+                    return true;
+            }
+            return false;
+        });
+
+        popupMenu.show();
+    }
+
+    private QueueItemMenuUtil() { }
+}

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

@@ -453,7 +453,7 @@ public class RouterActivity extends AppCompatActivity {
                 returnList.add(showInfo);
                 returnList.add(videoPlayer);
             } else {
-                final MainPlayer.PlayerType playerType = PlayerHolder.getType();
+                final MainPlayer.PlayerType playerType = PlayerHolder.getInstance().getType();
                 if (capabilities.contains(VIDEO)
                         && PlayerHelper.isAutoplayAllowedByUser(context)
                         && playerType == null || playerType == MainPlayer.PlayerType.VIDEO) {
@@ -589,9 +589,9 @@ public class RouterActivity extends AppCompatActivity {
                     downloadDialog.setVideoStreams(sortedVideoStreams);
                     downloadDialog.setAudioStreams(result.getAudioStreams());
                     downloadDialog.setSelectedVideoStream(selectedVideoStreamIndex);
+                    downloadDialog.setOnDismissListener(dialog -> finish());
                     downloadDialog.show(fm, "downloadDialog");
                     fm.executePendingTransactions();
-                    downloadDialog.requireDialog().setOnDismissListener(dialog -> finish());
                 }, throwable ->
                         showUnsupportedUrlDialog(currentUrl)));
     }

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

@@ -162,10 +162,18 @@ class AboutActivity : AppCompatActivity() {
                 "OkHttp", "2019", "Square, Inc.",
                 "https://square.github.io/okhttp/", StandardLicenses.APACHE2
             ),
+            SoftwareComponent(
+                "Picasso", "2013", "Square, Inc.",
+                "https://square.github.io/picasso/", StandardLicenses.APACHE2
+            ),
             SoftwareComponent(
                 "PrettyTime", "2012 - 2020", "Lincoln Baxter, III",
                 "https://github.com/ocpsoft/prettytime", StandardLicenses.APACHE2
             ),
+            SoftwareComponent(
+                "ProcessPhoenix", "2015", "Jake Wharton",
+                "https://github.com/JakeWharton/ProcessPhoenix", StandardLicenses.APACHE2
+            ),
             SoftwareComponent(
                 "RxAndroid", "2015", "The RxAndroid authors",
                 "https://github.com/ReactiveX/RxAndroid", StandardLicenses.APACHE2
@@ -177,11 +185,6 @@ class AboutActivity : AppCompatActivity() {
             SoftwareComponent(
                 "RxJava", "2016 - 2020", "RxJava Contributors",
                 "https://github.com/ReactiveX/RxJava", StandardLicenses.APACHE2
-            ),
-            SoftwareComponent(
-                "Universal Image Loader", "2011 - 2015", "Sergey Tarasevich",
-                "https://github.com/nostra13/Android-Universal-Image-Loader",
-                StandardLicenses.APACHE2
             )
         )
         private const val POS_ABOUT = 0

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

@@ -1,7 +1,7 @@
 package org.schabi.newpipe.about
 
 import android.os.Parcelable
-import kotlinx.android.parcel.Parcelize
+import kotlinx.parcelize.Parcelize
 import java.io.Serializable
 
 /**

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

@@ -11,8 +11,6 @@ import org.schabi.newpipe.R
 import org.schabi.newpipe.about.LicenseFragmentHelper.showLicense
 import org.schabi.newpipe.databinding.FragmentLicensesBinding
 import org.schabi.newpipe.databinding.ItemSoftwareComponentBinding
-import java.util.Arrays
-import java.util.Objects
 
 /**
  * Fragment containing the software licenses.
@@ -24,16 +22,10 @@ class LicenseFragment : Fragment() {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        softwareComponents =
-            arguments?.getParcelableArray(ARG_COMPONENTS) as Array<SoftwareComponent>
-        if (savedInstanceState != null) {
-            val license = savedInstanceState.getSerializable(LICENSE_KEY)
-            if (license != null) {
-                activeLicense = license as License?
-            }
-        }
+        softwareComponents = arguments?.getParcelableArray(ARG_COMPONENTS) as Array<SoftwareComponent>
+        activeLicense = savedInstanceState?.getSerializable(LICENSE_KEY) as? License
         // Sort components by name
-        Arrays.sort(softwareComponents, Comparator.comparing(SoftwareComponent::name))
+        softwareComponents.sortBy { it.name }
     }
 
     override fun onDestroy() {
@@ -74,19 +66,13 @@ class LicenseFragment : Fragment() {
             binding.licensesSoftwareComponents.addView(root)
             registerForContextMenu(root)
         }
-        if (activeLicense != null) {
-            compositeDisposable.add(
-                showLicense(activity, activeLicense!!)
-            )
-        }
+        activeLicense?.let { compositeDisposable.add(showLicense(activity, it)) }
         return binding.root
     }
 
     override fun onSaveInstanceState(savedInstanceState: Bundle) {
         super.onSaveInstanceState(savedInstanceState)
-        if (activeLicense != null) {
-            savedInstanceState.putSerializable(LICENSE_KEY, activeLicense)
-        }
+        activeLicense?.let { savedInstanceState.putSerializable(LICENSE_KEY, it) }
     }
 
     companion object {
@@ -94,8 +80,7 @@ class LicenseFragment : Fragment() {
         private const val LICENSE_KEY = "ACTIVE_LICENSE"
         fun newInstance(softwareComponents: Array<SoftwareComponent>): LicenseFragment {
             val fragment = LicenseFragment()
-            fragment.arguments =
-                bundleOf(ARG_COMPONENTS to Objects.requireNonNull(softwareComponents))
+            fragment.arguments = bundleOf(ARG_COMPONENTS to softwareComponents)
             return fragment
         }
     }

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

@@ -108,7 +108,7 @@ object LicenseFragmentHelper {
                     alert.setView(webView)
                     Localization.assureCorrectAppLanguage(context)
                     alert.setNegativeButton(
-                        context.getString(R.string.finish)
+                        context.getString(R.string.ok)
                     ) { dialog, _ -> dialog.dismiss() }
                     alert.show()
                 }

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

@@ -1,7 +1,7 @@
 package org.schabi.newpipe.about
 
 import android.os.Parcelable
-import kotlinx.android.parcel.Parcelize
+import kotlinx.parcelize.Parcelize
 
 @Parcelize
 class SoftwareComponent

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

@@ -27,7 +27,7 @@ import org.schabi.newpipe.database.stream.model.StreamStateEntity;
 import org.schabi.newpipe.database.subscription.SubscriptionDAO;
 import org.schabi.newpipe.database.subscription.SubscriptionEntity;
 
-import static org.schabi.newpipe.database.Migrations.DB_VER_3;
+import static org.schabi.newpipe.database.Migrations.DB_VER_4;
 
 @TypeConverters({Converters.class})
 @Database(
@@ -38,7 +38,7 @@ import static org.schabi.newpipe.database.Migrations.DB_VER_3;
                 FeedEntity.class, FeedGroupEntity.class, FeedGroupSubscriptionEntity.class,
                 FeedLastUpdatedEntity.class
         },
-        version = DB_VER_3
+        version = DB_VER_4
 )
 public abstract class AppDatabase extends RoomDatabase {
     public static final String DATABASE_NAME = "newpipe.db";

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

@@ -9,9 +9,19 @@ import androidx.sqlite.db.SupportSQLiteDatabase;
 import org.schabi.newpipe.MainActivity;
 
 public final class Migrations {
+
+    /////////////////////////////////////////////////////////////////////////////
+    //  Test new migrations manually by importing a database from daily usage  //
+    //  and checking if the migration works (Use the Database Inspector        //
+    //  https://developer.android.com/studio/inspect/database).                //
+    //  If you add a migration point it out in the pull request, so that       //
+    //  others remember to test it themselves.                                 //
+    /////////////////////////////////////////////////////////////////////////////
+
     public static final int DB_VER_1 = 1;
     public static final int DB_VER_2 = 2;
     public static final int DB_VER_3 = 3;
+    public static final int DB_VER_4 = 4;
 
     private static final String TAG = Migrations.class.getName();
     public static final boolean DEBUG = MainActivity.DEBUG;
@@ -160,5 +170,14 @@ public final class Migrations {
         }
     };
 
+    public static final Migration MIGRATION_3_4 = new Migration(DB_VER_3, DB_VER_4) {
+        @Override
+        public void migrate(@NonNull final SupportSQLiteDatabase database) {
+            database.execSQL(
+                    "ALTER TABLE streams ADD COLUMN uploader_url TEXT"
+            );
+        }
+    };
+
     private Migrations() { }
 }

app/src/main/java/org/schabi/newpipe/database/playlist/PlaylistStreamEntry.kt

@@ -27,6 +27,7 @@ data class PlaylistStreamEntry(
         val item = StreamInfoItem(streamEntity.serviceId, streamEntity.url, streamEntity.title, streamEntity.streamType)
         item.duration = streamEntity.duration
         item.uploaderName = streamEntity.uploader
+        item.uploaderUrl = streamEntity.uploaderUrl
         item.thumbnailUrl = streamEntity.thumbnailUrl
 
         return item

app/src/main/java/org/schabi/newpipe/database/stream/StreamStatisticsEntry.kt

@@ -29,6 +29,7 @@ class StreamStatisticsEntry(
         val item = StreamInfoItem(streamEntity.serviceId, streamEntity.url, streamEntity.title, streamEntity.streamType)
         item.duration = streamEntity.duration
         item.uploaderName = streamEntity.uploader
+        item.uploaderUrl = streamEntity.uploaderUrl
         item.thumbnailUrl = streamEntity.thumbnailUrl
 
         return item

app/src/main/java/org/schabi/newpipe/database/stream/dao/StreamDAO.kt

@@ -6,6 +6,7 @@ import androidx.room.Insert
 import androidx.room.OnConflictStrategy
 import androidx.room.Query
 import androidx.room.Transaction
+import io.reactivex.rxjava3.core.Completable
 import io.reactivex.rxjava3.core.Flowable
 import org.schabi.newpipe.database.BasicDAO
 import org.schabi.newpipe.database.stream.model.StreamEntity
@@ -29,6 +30,9 @@ abstract class StreamDAO : BasicDAO<StreamEntity> {
     @Query("SELECT * FROM streams WHERE url = :url AND service_id = :serviceId")
     abstract fun getStream(serviceId: Long, url: String): Flowable<List<StreamEntity>>
 
+    @Query("UPDATE streams SET uploader_url = :uploaderUrl WHERE url = :url AND service_id = :serviceId")
+    abstract fun setUploaderUrl(serviceId: Long, url: String, uploaderUrl: String): Completable
+
     @Insert(onConflict = OnConflictStrategy.IGNORE)
     internal abstract fun silentInsertInternal(stream: StreamEntity): Long
 

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

@@ -45,6 +45,9 @@ data class StreamEntity(
     @ColumnInfo(name = STREAM_UPLOADER)
     var uploader: String,
 
+    @ColumnInfo(name = STREAM_UPLOADER_URL)
+    var uploaderUrl: String? = null,
+
     @ColumnInfo(name = STREAM_THUMBNAIL_URL)
     var thumbnailUrl: String? = null,
 
@@ -64,7 +67,7 @@ data class StreamEntity(
     constructor(item: StreamInfoItem) : this(
         serviceId = item.serviceId, url = item.url, title = item.name,
         streamType = item.streamType, duration = item.duration, uploader = item.uploaderName,
-        thumbnailUrl = item.thumbnailUrl, viewCount = item.viewCount,
+        uploaderUrl = item.uploaderUrl, thumbnailUrl = item.thumbnailUrl, viewCount = item.viewCount,
         textualUploadDate = item.textualUploadDate, uploadDate = item.uploadDate?.offsetDateTime(),
         isUploadDateApproximation = item.uploadDate?.isApproximation
     )
@@ -73,7 +76,7 @@ data class StreamEntity(
     constructor(info: StreamInfo) : this(
         serviceId = info.serviceId, url = info.url, title = info.name,
         streamType = info.streamType, duration = info.duration, uploader = info.uploaderName,
-        thumbnailUrl = info.thumbnailUrl, viewCount = info.viewCount,
+        uploaderUrl = info.uploaderUrl, thumbnailUrl = info.thumbnailUrl, viewCount = info.viewCount,
         textualUploadDate = info.textualUploadDate, uploadDate = info.uploadDate?.offsetDateTime(),
         isUploadDateApproximation = info.uploadDate?.isApproximation
     )
@@ -82,13 +85,14 @@ data class StreamEntity(
     constructor(item: PlayQueueItem) : this(
         serviceId = item.serviceId, url = item.url, title = item.title,
         streamType = item.streamType, duration = item.duration, uploader = item.uploader,
-        thumbnailUrl = item.thumbnailUrl
+        uploaderUrl = item.uploaderUrl, thumbnailUrl = item.thumbnailUrl
     )
 
     fun toStreamInfoItem(): StreamInfoItem {
         val item = StreamInfoItem(serviceId, url, title, streamType)
         item.duration = duration
         item.uploaderName = uploader
+        item.uploaderUrl = uploaderUrl
         item.thumbnailUrl = thumbnailUrl
 
         if (viewCount != null) item.viewCount = viewCount as Long
@@ -109,6 +113,7 @@ data class StreamEntity(
         const val STREAM_TYPE = "stream_type"
         const val STREAM_DURATION = "duration"
         const val STREAM_UPLOADER = "uploader"
+        const val STREAM_UPLOADER_URL = "uploader_url"
         const val STREAM_THUMBNAIL_URL = "thumbnail_url"
 
         const val STREAM_VIEWS = "view_count"

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

@@ -3,6 +3,8 @@ package org.schabi.newpipe.download;
 import android.app.Activity;
 import android.content.ComponentName;
 import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnDismissListener;
 import android.content.Intent;
 import android.content.ServiceConnection;
 import android.content.SharedPreferences;
@@ -20,6 +22,9 @@ import android.widget.RadioGroup;
 import android.widget.SeekBar;
 import android.widget.Toast;
 
+import androidx.activity.result.ActivityResult;
+import androidx.activity.result.ActivityResultLauncher;
+import androidx.activity.result.contract.ActivityResultContracts.StartActivityForResult;
 import androidx.annotation.IdRes;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -35,7 +40,6 @@ import com.nononsenseapps.filepicker.Utils;
 
 import org.schabi.newpipe.MainActivity;
 import org.schabi.newpipe.R;
-import org.schabi.newpipe.RouterActivity;
 import org.schabi.newpipe.databinding.DownloadDialogBinding;
 import org.schabi.newpipe.error.ErrorActivity;
 import org.schabi.newpipe.error.ErrorInfo;
@@ -82,9 +86,6 @@ public class DownloadDialog extends DialogFragment
         implements RadioGroup.OnCheckedChangeListener, AdapterView.OnItemSelectedListener {
     private static final String TAG = "DialogFragment";
     private static final boolean DEBUG = MainActivity.DEBUG;
-    private static final int REQUEST_DOWNLOAD_SAVE_AS = 0x1230;
-    private static final int REQUEST_DOWNLOAD_PICK_VIDEO_FOLDER = 0x789E;
-    private static final int REQUEST_DOWNLOAD_PICK_AUDIO_FOLDER = 0x789F;
 
     @State
     StreamInfo currentInfo;
@@ -101,6 +102,9 @@ public class DownloadDialog extends DialogFragment
     @State
     int selectedSubtitleIndex = 0;
 
+    @Nullable
+    private OnDismissListener onDismissListener = null;
+
     private StoredDirectoryHelper mainStorageAudio = null;
     private StoredDirectoryHelper mainStorageVideo = null;
     private DownloadManager downloadManager = null;
@@ -122,6 +126,21 @@ public class DownloadDialog extends DialogFragment
     private String filenameTmp;
     private String mimeTmp;
 
+    private final ActivityResultLauncher<Intent> requestDownloadSaveAsLauncher =
+            registerForActivityResult(
+                    new StartActivityForResult(), this::requestDownloadSaveAsResult);
+    private final ActivityResultLauncher<Intent> requestDownloadPickAudioFolderLauncher =
+            registerForActivityResult(
+                    new StartActivityForResult(), this::requestDownloadPickAudioFolderResult);
+    private final ActivityResultLauncher<Intent> requestDownloadPickVideoFolderLauncher =
+            registerForActivityResult(
+                    new StartActivityForResult(), this::requestDownloadPickVideoFolderResult);
+
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Instance creation
+    //////////////////////////////////////////////////////////////////////////*/
+
     public static DownloadDialog newInstance(final StreamInfo info) {
         final DownloadDialog dialog = new DownloadDialog();
         dialog.setInfo(info);
@@ -143,6 +162,11 @@ public class DownloadDialog extends DialogFragment
         return instance;
     }
 
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Setters
+    //////////////////////////////////////////////////////////////////////////*/
+
     private void setInfo(final StreamInfo info) {
         this.currentInfo = info;
     }
@@ -184,6 +208,14 @@ public class DownloadDialog extends DialogFragment
         this.selectedSubtitleIndex = ssi;
     }
 
+    public void setOnDismissListener(@Nullable final OnDismissListener onDismissListener) {
+        this.onDismissListener = onDismissListener;
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Android lifecycle
+    //////////////////////////////////////////////////////////////////////////*/
+
     @Override
     public void onCreate(@Nullable final Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
@@ -194,7 +226,7 @@ public class DownloadDialog extends DialogFragment
 
         if (!PermissionHelper.checkStoragePermissions(getActivity(),
                 PermissionHelper.DOWNLOAD_DIALOG_REQUEST_CODE)) {
-            getDialog().dismiss();
+            dismiss();
             return;
         }
 
@@ -253,10 +285,6 @@ public class DownloadDialog extends DialogFragment
         }, Context.BIND_AUTO_CREATE);
     }
 
-    /*//////////////////////////////////////////////////////////////////////////
-    // Inits
-    //////////////////////////////////////////////////////////////////////////*/
-
     @Override
     public View onCreateView(@NonNull final LayoutInflater inflater, final ViewGroup container,
                              final Bundle savedInstanceState) {
@@ -312,6 +340,60 @@ public class DownloadDialog extends DialogFragment
         fetchStreamsSize();
     }
 
+    private void initToolbar(final Toolbar toolbar) {
+        if (DEBUG) {
+            Log.d(TAG, "initToolbar() called with: toolbar = [" + toolbar + "]");
+        }
+
+        toolbar.setTitle(R.string.download_dialog_title);
+        toolbar.setNavigationIcon(R.drawable.ic_arrow_back);
+        toolbar.inflateMenu(R.menu.dialog_url);
+        toolbar.setNavigationOnClickListener(v -> dismiss());
+        toolbar.setNavigationContentDescription(R.string.cancel);
+
+        okButton = toolbar.findViewById(R.id.okay);
+        okButton.setEnabled(false); // disable until the download service connection is done
+
+        toolbar.setOnMenuItemClickListener(item -> {
+            if (item.getItemId() == R.id.okay) {
+                prepareSelectedDownload();
+                return true;
+            }
+            return false;
+        });
+    }
+
+    @Override
+    public void onDismiss(@NonNull final DialogInterface dialog) {
+        super.onDismiss(dialog);
+        if (onDismissListener != null) {
+            onDismissListener.onDismiss(dialog);
+        }
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        disposables.clear();
+    }
+
+    @Override
+    public void onDestroyView() {
+        dialogBinding = null;
+        super.onDestroyView();
+    }
+
+    @Override
+    public void onSaveInstanceState(@NonNull final Bundle outState) {
+        super.onSaveInstanceState(outState);
+        Icepick.saveInstanceState(this, outState);
+    }
+
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Video, audio and subtitle spinners
+    //////////////////////////////////////////////////////////////////////////*/
+
     private void fetchStreamsSize() {
         disposables.clear();
         disposables.add(StreamSizeWrapper.fetchSizeForWrapper(wrappedVideoStreams)
@@ -346,126 +428,6 @@ public class DownloadDialog extends DialogFragment
                                 currentInfo.getServiceId()))));
     }
 
-    @Override
-    public void onDestroy() {
-        super.onDestroy();
-        disposables.clear();
-    }
-
-    @Override
-    public void onDestroyView() {
-        dialogBinding = null;
-        super.onDestroyView();
-    }
-
-    /*//////////////////////////////////////////////////////////////////////////
-    // Radio group Video&Audio options - Listener
-    //////////////////////////////////////////////////////////////////////////*/
-
-    @Override
-    public void onSaveInstanceState(@NonNull final Bundle outState) {
-        super.onSaveInstanceState(outState);
-        Icepick.saveInstanceState(this, outState);
-    }
-
-    /*//////////////////////////////////////////////////////////////////////////
-    // Streams Spinner Listener
-    //////////////////////////////////////////////////////////////////////////*/
-
-    @Override
-    public void onActivityResult(final int requestCode, final int resultCode, final Intent data) {
-        super.onActivityResult(requestCode, resultCode, data);
-
-        if (resultCode != Activity.RESULT_OK) {
-            return;
-        }
-
-        if (data.getData() == null) {
-            showFailedDialog(R.string.general_error);
-            return;
-        }
-
-        if (requestCode == REQUEST_DOWNLOAD_SAVE_AS) {
-            if (FilePickerActivityHelper.isOwnFileUri(context, data.getData())) {
-                final File file = Utils.getFileForUri(data.getData());
-                checkSelectedDownload(null, Uri.fromFile(file), file.getName(),
-                        StoredFileHelper.DEFAULT_MIME);
-                return;
-            }
-
-            final DocumentFile docFile = DocumentFile.fromSingleUri(context, data.getData());
-            if (docFile == null) {
-                showFailedDialog(R.string.general_error);
-                return;
-            }
-
-            // check if the selected file was previously used
-            checkSelectedDownload(null, data.getData(), docFile.getName(),
-                    docFile.getType());
-        } else if (requestCode == REQUEST_DOWNLOAD_PICK_AUDIO_FOLDER
-                || requestCode == REQUEST_DOWNLOAD_PICK_VIDEO_FOLDER) {
-            Uri uri = data.getData();
-            if (FilePickerActivityHelper.isOwnFileUri(context, uri)) {
-                uri = Uri.fromFile(Utils.getFileForUri(uri));
-            } else {
-                context.grantUriPermission(context.getPackageName(), uri,
-                        StoredDirectoryHelper.PERMISSION_FLAGS);
-            }
-
-            final String key;
-            final String tag;
-            if (requestCode == REQUEST_DOWNLOAD_PICK_AUDIO_FOLDER) {
-                key = getString(R.string.download_path_audio_key);
-                tag = DownloadManager.TAG_AUDIO;
-            } else {
-                key = getString(R.string.download_path_video_key);
-                tag = DownloadManager.TAG_VIDEO;
-            }
-
-            PreferenceManager.getDefaultSharedPreferences(context).edit()
-                    .putString(key, uri.toString()).apply();
-
-            try {
-                final StoredDirectoryHelper mainStorage
-                        = new StoredDirectoryHelper(context, uri, tag);
-                checkSelectedDownload(mainStorage, mainStorage.findFile(filenameTmp),
-                        filenameTmp, mimeTmp);
-            } catch (final IOException e) {
-                showFailedDialog(R.string.general_error);
-            }
-        }
-    }
-
-    private void initToolbar(final Toolbar toolbar) {
-        if (DEBUG) {
-            Log.d(TAG, "initToolbar() called with: toolbar = [" + toolbar + "]");
-        }
-
-        toolbar.setTitle(R.string.download_dialog_title);
-        toolbar.setNavigationIcon(R.drawable.ic_arrow_back);
-        toolbar.inflateMenu(R.menu.dialog_url);
-        toolbar.setNavigationOnClickListener(v -> requireDialog().dismiss());
-        toolbar.setNavigationContentDescription(R.string.cancel);
-
-        okButton = toolbar.findViewById(R.id.okay);
-        okButton.setEnabled(false); // disable until the download service connection is done
-
-        toolbar.setOnMenuItemClickListener(item -> {
-            if (item.getItemId() == R.id.okay) {
-                prepareSelectedDownload();
-                if (getActivity() instanceof RouterActivity) {
-                    getActivity().finish();
-                }
-                return true;
-            }
-            return false;
-        });
-    }
-
-    /*//////////////////////////////////////////////////////////////////////////
-    // Utils
-    //////////////////////////////////////////////////////////////////////////*/
-
     private void setupAudioSpinner() {
         if (getContext() == null) {
             return;
@@ -496,6 +458,88 @@ public class DownloadDialog extends DialogFragment
         setRadioButtonsState(true);
     }
 
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Activity results
+    //////////////////////////////////////////////////////////////////////////*/
+
+    private void requestDownloadPickAudioFolderResult(final ActivityResult result) {
+        requestDownloadPickFolderResult(
+                result, getString(R.string.download_path_audio_key), DownloadManager.TAG_AUDIO);
+    }
+
+    private void requestDownloadPickVideoFolderResult(final ActivityResult result) {
+        requestDownloadPickFolderResult(
+                result, getString(R.string.download_path_video_key), DownloadManager.TAG_VIDEO);
+    }
+
+    private void requestDownloadSaveAsResult(final ActivityResult result) {
+        if (result.getResultCode() != Activity.RESULT_OK) {
+            return;
+        }
+
+        if (result.getData() == null || result.getData().getData() == null) {
+            showFailedDialog(R.string.general_error);
+            return;
+        }
+
+        if (FilePickerActivityHelper.isOwnFileUri(context, result.getData().getData())) {
+            final File file = Utils.getFileForUri(result.getData().getData());
+            checkSelectedDownload(null, Uri.fromFile(file), file.getName(),
+                    StoredFileHelper.DEFAULT_MIME);
+            return;
+        }
+
+        final DocumentFile docFile
+                = DocumentFile.fromSingleUri(context, result.getData().getData());
+        if (docFile == null) {
+            showFailedDialog(R.string.general_error);
+            return;
+        }
+
+        // check if the selected file was previously used
+        checkSelectedDownload(null, result.getData().getData(), docFile.getName(),
+                docFile.getType());
+    }
+
+    private void requestDownloadPickFolderResult(final ActivityResult result,
+                                                 final String key,
+                                                 final String tag) {
+        if (result.getResultCode() != Activity.RESULT_OK) {
+            return;
+        }
+
+        if (result.getData() == null || result.getData().getData() == null) {
+            showFailedDialog(R.string.general_error);
+            return;
+        }
+
+        Uri uri = result.getData().getData();
+        if (FilePickerActivityHelper.isOwnFileUri(context, uri)) {
+            uri = Uri.fromFile(Utils.getFileForUri(uri));
+        } else {
+            context.grantUriPermission(context.getPackageName(), uri,
+                    StoredDirectoryHelper.PERMISSION_FLAGS);
+        }
+
+        PreferenceManager.getDefaultSharedPreferences(context).edit()
+                .putString(key, uri.toString()).apply();
+
+        try {
+            final StoredDirectoryHelper mainStorage
+                    = new StoredDirectoryHelper(context, uri, tag);
+            checkSelectedDownload(mainStorage, mainStorage.findFile(filenameTmp),
+                    filenameTmp, mimeTmp);
+        } catch (final IOException e) {
+            showFailedDialog(R.string.general_error);
+        }
+    }
+
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Listeners
+    //////////////////////////////////////////////////////////////////////////*/
+
     @Override
     public void onCheckedChanged(final RadioGroup group, @IdRes final int checkedId) {
         if (DEBUG) {
@@ -545,6 +589,11 @@ public class DownloadDialog extends DialogFragment
     public void onNothingSelected(final AdapterView<?> parent) {
     }
 
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Download
+    //////////////////////////////////////////////////////////////////////////*/
+
     protected void setupDownloadOptions() {
         setRadioButtonsState(false);
 
@@ -557,7 +606,7 @@ public class DownloadDialog extends DialogFragment
         dialogBinding.subtitleButton.setVisibility(isSubtitleStreamsAvailable
                 ? View.VISIBLE : View.GONE);
 
-        prefs = PreferenceManager.getDefaultSharedPreferences(getContext());
+        prefs = PreferenceManager.getDefaultSharedPreferences(requireContext());
         final String defaultMedia = prefs.getString(getString(R.string.last_used_download_type),
                     getString(R.string.last_download_type_video_key));
 
@@ -585,7 +634,7 @@ public class DownloadDialog extends DialogFragment
         } else {
             Toast.makeText(getContext(), R.string.no_streams_available_download,
                     Toast.LENGTH_SHORT).show();
-            getDialog().dismiss();
+            dismiss();
         }
     }
 
@@ -632,11 +681,15 @@ public class DownloadDialog extends DialogFragment
         new AlertDialog.Builder(context)
                 .setTitle(R.string.general_error)
                 .setMessage(msg)
-                .setNegativeButton(getString(R.string.finish), null)
+                .setNegativeButton(getString(R.string.ok), null)
                 .create()
                 .show();
     }
 
+    private void launchDirectoryPicker(final ActivityResultLauncher<Intent> launcher) {
+        launcher.launch(StoredDirectoryHelper.getPicker(context));
+    }
+
     private void prepareSelectedDownload() {
         final StoredDirectoryHelper mainStorage;
         final MediaFormat format;
@@ -691,11 +744,9 @@ public class DownloadDialog extends DialogFragment
                     Toast.LENGTH_LONG).show();
 
             if (dialogBinding.videoAudioGroup.getCheckedRadioButtonId() == R.id.audio_button) {
-                startActivityForResult(StoredDirectoryHelper.getPicker(context),
-                        REQUEST_DOWNLOAD_PICK_AUDIO_FOLDER);
+                launchDirectoryPicker(requestDownloadPickAudioFolderLauncher);
             } else {
-                startActivityForResult(StoredDirectoryHelper.getPicker(context),
-                        REQUEST_DOWNLOAD_PICK_VIDEO_FOLDER);
+                launchDirectoryPicker(requestDownloadPickVideoFolderLauncher);
             }
 
             return;
@@ -715,8 +766,8 @@ public class DownloadDialog extends DialogFragment
                 initialPath = Uri.parse(initialSavePath.getAbsolutePath());
             }
 
-            startActivityForResult(StoredFileHelper.getNewPicker(context,
-                    filenameTmp, mimeTmp, initialPath), REQUEST_DOWNLOAD_SAVE_AS);
+            requestDownloadSaveAsLauncher.launch(StoredFileHelper.getNewPicker(context,
+                    filenameTmp, mimeTmp, initialPath));
 
             return;
         }
@@ -813,7 +864,7 @@ public class DownloadDialog extends DialogFragment
         final AlertDialog.Builder askDialog = new AlertDialog.Builder(context)
                 .setTitle(R.string.download_dialog_title)
                 .setMessage(msgBody)
-                .setNegativeButton(android.R.string.cancel, null);
+                .setNegativeButton(R.string.cancel, null);
         final StoredFileHelper finalStorage = storage;
 
 

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

@@ -2,7 +2,7 @@ package org.schabi.newpipe.error
 
 import android.os.Parcelable
 import androidx.annotation.StringRes
-import kotlinx.android.parcel.Parcelize
+import kotlinx.parcelize.Parcelize
 import org.schabi.newpipe.R
 import org.schabi.newpipe.extractor.Info
 import org.schabi.newpipe.extractor.NewPipe

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

@@ -6,6 +6,8 @@ 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
 import com.jakewharton.rxbinding4.view.clicks
@@ -37,22 +39,39 @@ class ErrorPanelHelper(
     onRetry: Runnable
 ) {
     private val context: Context = rootView.context!!
+
     private val errorPanelRoot: View = rootView.findViewById(R.id.error_panel)
-    private val errorTextView: TextView = errorPanelRoot.findViewById(R.id.error_message_view)
-    private val errorServiceInfoTextView: TextView = errorPanelRoot.findViewById(R.id.error_message_service_info_view)
-    private val errorServiceExplenationTextView: TextView = errorPanelRoot.findViewById(R.id.error_message_service_explenation_view)
-    private val errorButtonAction: Button = errorPanelRoot.findViewById(R.id.error_button_action)
-    private val errorButtonRetry: Button = errorPanelRoot.findViewById(R.id.error_button_retry)
+
+    // the only element that is visible by default
+    private val errorTextView: TextView =
+        errorPanelRoot.findViewById(R.id.error_message_view)
+    private val errorServiceInfoTextView: TextView =
+        errorPanelRoot.findViewById(R.id.error_message_service_info_view)
+    private val errorServiceExplanationTextView: TextView =
+        errorPanelRoot.findViewById(R.id.error_message_service_explanation_view)
+    private val errorActionButton: Button =
+        errorPanelRoot.findViewById(R.id.error_action_button)
+    private val errorRetryButton: Button =
+        errorPanelRoot.findViewById(R.id.error_retry_button)
 
     private var errorDisposable: Disposable? = null
 
     init {
-        errorDisposable = errorButtonRetry.clicks()
+        errorDisposable = errorRetryButton.clicks()
             .debounce(300, TimeUnit.MILLISECONDS)
             .observeOn(AndroidSchedulers.mainThread())
             .subscribe { onRetry.run() }
     }
 
+    private fun ensureDefaultVisibility() {
+        errorTextView.isVisible = true
+
+        errorServiceInfoTextView.isVisible = false
+        errorServiceExplanationTextView.isVisible = false
+        errorActionButton.isVisible = false
+        errorRetryButton.isVisible = false
+    }
+
     fun showError(errorInfo: ErrorInfo) {
 
         if (errorInfo.throwable != null && errorInfo.throwable!!.isInterruptedCaused) {
@@ -62,10 +81,14 @@ class ErrorPanelHelper(
             return
         }
 
-        errorButtonAction.isVisible = true
+        ensureDefaultVisibility()
+
         if (errorInfo.throwable is ReCaptchaException) {
-            errorButtonAction.setText(R.string.recaptcha_solve)
-            errorButtonAction.setOnClickListener {
+            errorTextView.setText(R.string.recaptcha_request_toast)
+
+            showAndSetErrorButtonAction(
+                R.string.recaptcha_solve
+            ) {
                 // Starting ReCaptcha Challenge Activity
                 val intent = Intent(context, ReCaptchaActivity::class.java)
                 intent.putExtra(
@@ -73,78 +96,70 @@ class ErrorPanelHelper(
                     (errorInfo.throwable as ReCaptchaException).url
                 )
                 fragment.startActivityForResult(intent, ReCaptchaActivity.RECAPTCHA_REQUEST)
-                errorButtonAction.setOnClickListener(null)
+                errorActionButton.setOnClickListener(null)
             }
-            errorTextView.setText(R.string.recaptcha_request_toast)
-            // additional info is only provided by AccountTerminatedException
-            errorServiceInfoTextView.isVisible = false
-            errorServiceExplenationTextView.isVisible = false
-            errorButtonRetry.isVisible = true
+
+            errorRetryButton.isVisible = true
         } else if (errorInfo.throwable is AccountTerminatedException) {
-            errorButtonRetry.isVisible = false
-            errorButtonAction.isVisible = false
             errorTextView.setText(R.string.account_terminated)
+
             if (!isNullOrEmpty((errorInfo.throwable as AccountTerminatedException).message)) {
-                errorServiceInfoTextView.setText(
-                    context.resources.getString(
-                        R.string.service_provides_reason,
-                        NewPipe.getNameOfService(ServiceHelper.getSelectedServiceId(context))
-                    )
-                )
-                errorServiceExplenationTextView.setText(
-                    (errorInfo.throwable as AccountTerminatedException).message
+                errorServiceInfoTextView.text = context.resources.getString(
+                    R.string.service_provides_reason,
+                    NewPipe.getNameOfService(ServiceHelper.getSelectedServiceId(context))
                 )
                 errorServiceInfoTextView.isVisible = true
-                errorServiceExplenationTextView.isVisible = true
-            } else {
-                errorServiceInfoTextView.isVisible = false
-                errorServiceExplenationTextView.isVisible = false
+
+                errorServiceExplanationTextView.text =
+                    (errorInfo.throwable as AccountTerminatedException).message
+                errorServiceExplanationTextView.isVisible = true
             }
         } else {
-            errorButtonAction.setText(R.string.error_snackbar_action)
-            errorButtonAction.setOnClickListener {
+            showAndSetErrorButtonAction(
+                R.string.error_snackbar_action
+            ) {
                 ErrorActivity.reportError(context, errorInfo)
             }
 
-            // additional info is only provided by AccountTerminatedException
-            errorServiceInfoTextView.isVisible = false
-            errorServiceExplenationTextView.isVisible = false
+            errorTextView.setText(getExceptionDescription(errorInfo.throwable))
 
-            // hide retry button by default, then show only if not unavailable/unsupported content
-            errorButtonRetry.isVisible = false
-            errorTextView.setText(
-                when (errorInfo.throwable) {
-                    is AgeRestrictedContentException -> R.string.restricted_video_no_stream
-                    is GeographicRestrictionException -> R.string.georestricted_content
-                    is PaidContentException -> R.string.paid_content
-                    is PrivateContentException -> R.string.private_content
-                    is SoundCloudGoPlusContentException -> R.string.soundcloud_go_plus_content
-                    is YoutubeMusicPremiumContentException -> R.string.youtube_music_premium_content
-                    is ContentNotAvailableException -> R.string.content_not_available
-                    is ContentNotSupportedException -> R.string.content_not_supported
-                    else -> {
-                        // show retry button only for content which is not unavailable or unsupported
-                        errorButtonRetry.isVisible = true
-                        if (errorInfo.throwable != null && errorInfo.throwable!!.isNetworkRelated) {
-                            R.string.network_error
-                        } else {
-                            R.string.error_snackbar_message
-                        }
-                    }
-                }
-            )
+            if (errorInfo.throwable !is ContentNotAvailableException &&
+                errorInfo.throwable !is ContentNotSupportedException
+            ) {
+                // show retry button only for content which is not unavailable or unsupported
+                errorRetryButton.isVisible = true
+            }
         }
-        errorPanelRoot.animate(true, 300)
+
+        setRootVisible()
+    }
+
+    /**
+     * Shows the errorButtonAction, sets a text into it and sets the click listener.
+     */
+    private fun showAndSetErrorButtonAction(
+        @StringRes resid: Int,
+        @Nullable listener: View.OnClickListener
+    ) {
+        errorActionButton.isVisible = true
+        errorActionButton.setText(resid)
+        errorActionButton.setOnClickListener(listener)
     }
 
     fun showTextError(errorString: String) {
-        errorButtonAction.isVisible = false
-        errorButtonRetry.isVisible = false
+        ensureDefaultVisibility()
+
         errorTextView.text = errorString
+
+        setRootVisible()
+    }
+
+    private fun setRootVisible() {
+        errorPanelRoot.animate(true, 300)
     }
 
     fun hide() {
-        errorButtonAction.setOnClickListener(null)
+        errorActionButton.setOnClickListener(null)
         errorPanelRoot.animate(false, 150)
     }
 
@@ -153,13 +168,35 @@ class ErrorPanelHelper(
     }
 
     fun dispose() {
-        errorButtonAction.setOnClickListener(null)
-        errorButtonRetry.setOnClickListener(null)
+        errorActionButton.setOnClickListener(null)
+        errorRetryButton.setOnClickListener(null)
         errorDisposable?.dispose()
     }
 
     companion object {
         val TAG: String = ErrorPanelHelper::class.simpleName!!
         val DEBUG: Boolean = MainActivity.DEBUG
+
+        @StringRes
+        public fun getExceptionDescription(throwable: Throwable?): Int {
+            return when (throwable) {
+                is AgeRestrictedContentException -> R.string.restricted_video_no_stream
+                is GeographicRestrictionException -> R.string.georestricted_content
+                is PaidContentException -> R.string.paid_content
+                is PrivateContentException -> R.string.private_content
+                is SoundCloudGoPlusContentException -> R.string.soundcloud_go_plus_content
+                is YoutubeMusicPremiumContentException -> R.string.youtube_music_premium_content
+                is ContentNotAvailableException -> R.string.content_not_available
+                is ContentNotSupportedException -> R.string.content_not_supported
+                else -> {
+                    // show retry button only for content which is not unavailable or unsupported
+                    if (throwable != null && throwable.isNetworkRelated) {
+                        R.string.network_error
+                    } else {
+                        R.string.error_snackbar_message
+                    }
+                }
+            }
+        }
     }
 }

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

@@ -1,5 +1,6 @@
 package org.schabi.newpipe.error;
 
+import android.annotation.SuppressLint;
 import android.content.Intent;
 import android.content.SharedPreferences;
 import android.os.Build;
@@ -66,6 +67,7 @@ public class ReCaptchaActivity extends AppCompatActivity {
     private ActivityRecaptchaBinding recaptchaBinding;
     private String foundCookies = "";
 
+    @SuppressLint("SetJavaScriptEnabled")
     @Override
     protected void onCreate(final Bundle savedInstanceState) {
         ThemeHelper.setTheme(this);
@@ -162,6 +164,9 @@ public class ReCaptchaActivity extends AppCompatActivity {
             setResult(RESULT_OK);
         }
 
+        // Navigate to blank page (unloads youtube to prevent background playback)
+        recaptchaBinding.reCaptchaWebView.loadUrl("about:blank");
+
         final Intent intent = new Intent(this, org.schabi.newpipe.MainActivity.class);
         intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
         NavUtils.navigateUpTo(this, intent);

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

@@ -151,8 +151,6 @@ public class DescriptionFragment extends BaseFragment {
         addMetadataItem(inflater, layout, false,
                 R.string.metadata_category, streamInfo.getCategory());
 
-        addTagsMetadataItem(inflater, layout);
-
         addMetadataItem(inflater, layout, false,
                 R.string.metadata_licence, streamInfo.getLicence());
 
@@ -174,6 +172,8 @@ public class DescriptionFragment extends BaseFragment {
                 R.string.metadata_host, streamInfo.getHost());
         addMetadataItem(inflater, layout, true,
                 R.string.metadata_thumbnail_url, streamInfo.getThumbnailUrl());
+
+        addTagsMetadataItem(inflater, layout);
     }
 
     private void addMetadataItem(final LayoutInflater inflater,

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

@@ -48,9 +48,7 @@ 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.nostra13.universalimageloader.core.assist.FailReason;
-import com.nostra13.universalimageloader.core.listener.ImageLoadingListener;
-import com.nostra13.universalimageloader.core.listener.SimpleImageLoadingListener;
+import com.squareup.picasso.Callback;
 
 import org.schabi.newpipe.App;
 import org.schabi.newpipe.R;
@@ -90,14 +88,14 @@ import org.schabi.newpipe.player.playqueue.SinglePlayQueue;
 import org.schabi.newpipe.util.Constants;
 import org.schabi.newpipe.util.DeviceUtils;
 import org.schabi.newpipe.util.ExtractorHelper;
-import org.schabi.newpipe.util.ImageDisplayConstants;
-import org.schabi.newpipe.util.external_communication.KoreUtils;
 import org.schabi.newpipe.util.ListHelper;
 import org.schabi.newpipe.util.Localization;
 import org.schabi.newpipe.util.NavigationHelper;
 import org.schabi.newpipe.util.PermissionHelper;
-import org.schabi.newpipe.util.external_communication.ShareUtils;
+import org.schabi.newpipe.util.PicassoHelper;
 import org.schabi.newpipe.util.ThemeHelper;
+import org.schabi.newpipe.util.external_communication.KoreUtils;
+import org.schabi.newpipe.util.external_communication.ShareUtils;
 
 import java.util.ArrayList;
 import java.util.Iterator;
@@ -151,6 +149,8 @@ public final class VideoDetailFragment
     private static final String DESCRIPTION_TAB_TAG = "DESCRIPTION TAB";
     private static final String EMPTY_TAB_TAG = "EMPTY TAB";
 
+    private static final String PICASSO_VIDEO_DETAILS_TAG = "PICASSO_VIDEO_DETAILS_TAG";
+
     // tabs
     private boolean showComments;
     private boolean showRelatedItems;
@@ -201,6 +201,7 @@ public final class VideoDetailFragment
     @Nullable
     private MainPlayer playerService;
     private Player player;
+    private final PlayerHolder playerHolder = PlayerHolder.getInstance();
 
     /*//////////////////////////////////////////////////////////////////////////
     // Service management
@@ -219,7 +220,7 @@ public final class VideoDetailFragment
             return;
         }
 
-        if (isLandscape()) {
+        if (DeviceUtils.isLandscape(requireContext())) {
             // If the video is playing but orientation changed
             // let's make the video in fullscreen again
             checkLandscape();
@@ -240,7 +241,7 @@ public final class VideoDetailFragment
                 && isAutoplayEnabled()
                 && player.getParentActivity() == null)) {
             autoPlayEnabled = true; // forcefully start playing
-            openVideoPlayer();
+            openVideoPlayerAutoFullscreen();
         }
     }
 
@@ -304,7 +305,8 @@ public final class VideoDetailFragment
     @Override
     public View onCreateView(@NonNull final LayoutInflater inflater, final ViewGroup container,
                              final Bundle savedInstanceState) {
-        return inflater.inflate(R.layout.fragment_video_detail, container, false);
+        binding = FragmentVideoDetailBinding.inflate(inflater, container, false);
+        return binding.getRoot();
     }
 
     @Override
@@ -355,14 +357,13 @@ public final class VideoDetailFragment
     @Override
     public void onDestroy() {
         super.onDestroy();
-        binding = null;
 
         // Stop the service when user leaves the app with double back press
         // if video player is selected. Otherwise unbind
-        if (activity.isFinishing() && player != null && player.videoPlayerSelected()) {
-            PlayerHolder.stopService(App.getApp());
+        if (activity.isFinishing() && isPlayerAvailable() && player.videoPlayerSelected()) {
+            playerHolder.stopService();
         } else {
-            PlayerHolder.removeListener();
+            playerHolder.setListener(null);
         }
 
         PreferenceManager.getDefaultSharedPreferences(activity)
@@ -388,6 +389,12 @@ public final class VideoDetailFragment
         }
     }
 
+    @Override
+    public void onDestroyView() {
+        super.onDestroyView();
+        binding = null;
+    }
+
     @Override
     public void onActivityResult(final int requestCode, final int resultCode, final Intent data) {
         super.onActivityResult(requestCode, resultCode, data);
@@ -416,7 +423,7 @@ public final class VideoDetailFragment
             showRelatedItems = sharedPreferences.getBoolean(key, true);
             tabSettingsChanged = true;
         } else if (key.equals(getString(R.string.show_description_key))) {
-            showComments = sharedPreferences.getBoolean(key, true);
+            showDescription = sharedPreferences.getBoolean(key, true);
             tabSettingsChanged = true;
         }
     }
@@ -492,7 +499,7 @@ public final class VideoDetailFragment
                 break;
             case R.id.detail_thumbnail_root_layout:
                 autoPlayEnabled = true; // forcefully start playing
-                openVideoPlayer();
+                openVideoPlayerAutoFullscreen();
                 break;
             case R.id.detail_title_root_layout:
                 toggleTitleAndSecondaryControls();
@@ -509,10 +516,10 @@ public final class VideoDetailFragment
                     showSystemUi();
                 } else {
                     autoPlayEnabled = true; // forcefully start playing
-                    openVideoPlayer();
+                    openVideoPlayer(false);
                 }
 
-                setOverlayPlayPauseImage(player != null && player.isPlaying());
+                setOverlayPlayPauseImage(isPlayerAvailable() && player.isPlaying());
                 break;
             case R.id.overlay_close_button:
                 bottomSheetBehavior.setState(BottomSheetBehavior.STATE_HIDDEN);
@@ -586,10 +593,9 @@ public final class VideoDetailFragment
     // Init
     //////////////////////////////////////////////////////////////////////////*/
 
-    @Override
+    @Override // called from onViewCreated in {@link BaseFragment#onViewCreated}
     protected void initViews(final View rootView, final Bundle savedInstanceState) {
         super.initViews(rootView, savedInstanceState);
-        binding = FragmentVideoDetailBinding.bind(rootView);
 
         pageAdapter = new TabAdapter(getChildFragmentManager());
         binding.viewPager.setAdapter(pageAdapter);
@@ -655,10 +661,10 @@ public final class VideoDetailFragment
         });
 
         setupBottomPlayer();
-        if (!PlayerHolder.bound) {
+        if (!playerHolder.bound) {
             setHeightThumbnail();
         } else {
-            PlayerHolder.startService(App.getApp(), false, this);
+            playerHolder.startService(false, this);
         }
     }
 
@@ -680,33 +686,24 @@ public final class VideoDetailFragment
     }
 
     private void initThumbnailViews(@NonNull final StreamInfo info) {
-        binding.detailThumbnailImageView.setImageResource(R.drawable.dummy_thumbnail_dark);
+        PicassoHelper.loadThumbnail(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
+                    }
 
-        if (!isEmpty(info.getThumbnailUrl())) {
-            final ImageLoadingListener onFailListener = new SimpleImageLoadingListener() {
-                @Override
-                public void onLoadingFailed(final String imageUri, final View view,
-                                            final FailReason failReason) {
-                    showSnackBarError(new ErrorInfo(failReason.getCause(), UserAction.LOAD_IMAGE,
-                            imageUri, info));
-                }
-            };
+                    @Override
+                    public void onError(final Exception e) {
+                        showSnackBarError(new ErrorInfo(e, UserAction.LOAD_IMAGE,
+                                info.getThumbnailUrl(), info));
+                    }
+                });
 
-            IMAGE_LOADER.displayImage(info.getThumbnailUrl(), binding.detailThumbnailImageView,
-                    ImageDisplayConstants.DISPLAY_THUMBNAIL_OPTIONS, onFailListener);
-        }
-
-        if (!isEmpty(info.getSubChannelAvatarUrl())) {
-            IMAGE_LOADER.displayImage(info.getSubChannelAvatarUrl(),
-                    binding.detailSubChannelThumbnailView,
-                    ImageDisplayConstants.DISPLAY_AVATAR_OPTIONS);
-        }
-
-        if (!isEmpty(info.getUploaderAvatarUrl())) {
-            IMAGE_LOADER.displayImage(info.getUploaderAvatarUrl(),
-                    binding.detailUploaderThumbnailView,
-                    ImageDisplayConstants.DISPLAY_AVATAR_OPTIONS);
-        }
+        PicassoHelper.loadAvatar(info.getSubChannelAvatarUrl()).tag(PICASSO_VIDEO_DETAILS_TAG)
+                .into(binding.detailSubChannelThumbnailView);
+        PicassoHelper.loadAvatar(info.getUploaderAvatarUrl()).tag(PICASSO_VIDEO_DETAILS_TAG)
+                .into(binding.detailUploaderThumbnailView);
     }
 
     /*//////////////////////////////////////////////////////////////////////////
@@ -721,7 +718,7 @@ public final class VideoDetailFragment
 
     @Override
     public boolean onKeyDown(final int keyCode) {
-        return player != null && player.onKeyDown(keyCode);
+        return isPlayerAvailable() && player.onKeyDown(keyCode);
     }
 
     @Override
@@ -731,7 +728,7 @@ public final class VideoDetailFragment
         }
 
         // If we are in fullscreen mode just exit from it via first back press
-        if (player != null && player.isFullscreen()) {
+        if (isPlayerAvailable() && player.isFullscreen()) {
             if (!DeviceUtils.isTablet(activity)) {
                 player.pause();
             }
@@ -741,31 +738,30 @@ public final class VideoDetailFragment
         }
 
         // If we have something in history of played items we replay it here
-        if (player != null
+        if (isPlayerAvailable()
                 && player.getPlayQueue() != null
                 && player.videoPlayerSelected()
                 && player.getPlayQueue().previous()) {
-            return true;
+            return true; // no code here, as previous() was used in the if
         }
+
         // That means that we are on the start of the stack,
-        // return false to let the MainActivity handle the onBack
         if (stack.size() <= 1) {
             restoreDefaultOrientation();
-
-            return false;
+            return false; // let MainActivity handle the onBack (e.g. to minimize the mini player)
         }
+
         // Remove top
         stack.pop();
         // Get stack item from the new top
-        assert stack.peek() != null;
-        setupFromHistoryItem(stack.peek());
+        setupFromHistoryItem(Objects.requireNonNull(stack.peek()));
 
         return true;
     }
 
     private void setupFromHistoryItem(final StackItem item) {
         setAutoPlay(false);
-        hideMainPlayer();
+        hideMainPlayerOnLoadingNewStream();
 
         setInitialData(item.getServiceId(), item.getUrl(),
                 item.getTitle() == null ? "" : item.getTitle(), item.getPlayQueue());
@@ -778,7 +774,7 @@ public final class VideoDetailFragment
 
         final PlayQueueItem playQueueItem = item.getPlayQueue().getItem();
         // Update title, url, uploader from the last item in the stack (it's current now)
-        final boolean isPlayerStopped = player == null || player.isStopped();
+        final boolean isPlayerStopped = !isPlayerAvailable() || player.isStopped();
         if (playQueueItem != null && isPlayerStopped) {
             updateOverlayData(playQueueItem.getTitle(),
                     playQueueItem.getUploader(), playQueueItem.getThumbnailUrl());
@@ -806,8 +802,8 @@ public final class VideoDetailFragment
                                    @Nullable final String newUrl,
                                    @NonNull final String newTitle,
                                    @Nullable final PlayQueue newQueue) {
-        if (player != null && newQueue != null && playQueue != null
-                && !Objects.equals(newQueue.getItem(), playQueue.getItem())) {
+        if (isPlayerAvailable() && newQueue != null && playQueue != null
+                && playQueue.getItem() != null && !playQueue.getItem().getUrl().equals(newUrl)) {
             // Preloading can be disabled since playback is surely being replaced.
             player.disablePreloadingOfCurrentTrack();
         }
@@ -885,7 +881,7 @@ public final class VideoDetailFragment
                 .observeOn(AndroidSchedulers.mainThread())
                 .subscribe(result -> {
                     isLoading.set(false);
-                    hideMainPlayer();
+                    hideMainPlayerOnLoadingNewStream();
                     if (result.getAgeLimit() != NO_AGE_LIMIT && !prefs.getBoolean(
                             getString(R.string.show_age_restricted_content), false)) {
                         hideAgeRestrictedContent();
@@ -900,8 +896,9 @@ public final class VideoDetailFragment
                                 stack.push(new StackItem(serviceId, url, title, playQueue));
                             }
                         }
+
                         if (isAutoplayEnabled()) {
-                            openVideoPlayer();
+                            openVideoPlayerAutoFullscreen();
                         }
                     }
                 }, throwable -> showError(new ErrorInfo(throwable, UserAction.REQUESTED_STREAM,
@@ -982,7 +979,7 @@ public final class VideoDetailFragment
                         .replace(R.id.relatedItemsLayout, RelatedItemsFragment.getInstance(info))
                         .commitAllowingStateLoss();
                 binding.relatedItemsLayout.setVisibility(
-                        player != null && player.isFullscreen() ? View.GONE : View.VISIBLE);
+                        isPlayerAvailable() && player.isFullscreen() ? View.GONE : View.VISIBLE);
             }
         }
 
@@ -1059,6 +1056,14 @@ public final class VideoDetailFragment
     // Play Utils
     //////////////////////////////////////////////////////////////////////////*/
 
+    private void toggleFullscreenIfInFullscreenMode() {
+        // If a user watched video inside fullscreen mode and than chose another player
+        // return to non-fullscreen mode
+        if (isPlayerAvailable() && player.isFullscreen()) {
+            player.toggleFullscreen();
+        }
+    }
+
     private void openBackgroundPlayer(final boolean append) {
         final AudioStream audioStream = currentInfo.getAudioStreams()
                 .get(ListHelper.getDefaultAudioFormat(activity, currentInfo.getAudioStreams()));
@@ -1067,11 +1072,7 @@ public final class VideoDetailFragment
                 .getDefaultSharedPreferences(activity)
                 .getBoolean(activity.getString(R.string.use_external_audio_player_key), false);
 
-        //  If a user watched video inside fullscreen mode and than chose another player
-        //  return to non-fullscreen mode
-        if (player != null && player.isFullscreen()) {
-            player.toggleFullscreen();
-        }
+        toggleFullscreenIfInFullscreenMode();
 
         if (!useExternalAudioPlayer) {
             openNormalBackgroundPlayer(append);
@@ -1087,15 +1088,11 @@ public final class VideoDetailFragment
         }
 
         // See UI changes while remote playQueue changes
-        if (player == null) {
-            PlayerHolder.startService(App.getApp(), false, this);
+        if (!isPlayerAvailable()) {
+            playerHolder.startService(false, this);
         }
 
-        //  If a user watched video inside fullscreen mode and than chose another player
-        //  return to non-fullscreen mode
-        if (player != null && player.isFullscreen()) {
-            player.toggleFullscreen();
-        }
+        toggleFullscreenIfInFullscreenMode();
 
         final PlayQueue queue = setupPlayQueueForIntent(append);
         if (append) {
@@ -1106,7 +1103,29 @@ public final class VideoDetailFragment
         }
     }
 
-    public void openVideoPlayer() {
+    /**
+     * Opens the video player, in fullscreen if needed. In order to open fullscreen, the activity
+     * is toggled to landscape orientation (which will then cause fullscreen mode).
+     *
+     * @param directlyFullscreenIfApplicable whether to open fullscreen if we are not already
+     *                                       in landscape and screen orientation is locked
+     */
+    public void openVideoPlayer(final boolean directlyFullscreenIfApplicable) {
+        if (directlyFullscreenIfApplicable
+                && !DeviceUtils.isLandscape(requireContext())
+                && PlayerHelper.globalScreenOrientationLocked(requireContext())) {
+            // Make sure the bottom sheet turns out expanded. When this code kicks in the bottom
+            // sheet could not have fully expanded yet, and thus be in the STATE_SETTLING state.
+            // When the activity is rotated, and its state is saved and then restored, the bottom
+            // sheet would forget what it was doing, since even if STATE_SETTLING is restored, it
+            // doesn't tell which state it was settling to, and thus the bottom sheet settles to
+            // STATE_COLLAPSED. This can be solved by manually setting the state that will be
+            // restored (i.e. bottomSheetState) to STATE_EXPANDED.
+            bottomSheetState = BottomSheetBehavior.STATE_EXPANDED;
+            // toggle landscape in order to open directly in fullscreen
+            onScreenRotationButtonClicked();
+        }
+
         if (PreferenceManager.getDefaultSharedPreferences(activity)
                 .getBoolean(this.getString(R.string.use_external_video_player_key), false)) {
             showExternalPlaybackDialog();
@@ -1115,10 +1134,22 @@ public final class VideoDetailFragment
         }
     }
 
+    /**
+     * If the option to start directly fullscreen is enabled, calls
+     * {@link #openVideoPlayer(boolean)} with {@code directlyFullscreenIfApplicable = true}, so that
+     * if the user is not already in landscape and he has screen orientation locked the activity
+     * rotates and fullscreen starts. Otherwise, if the option to start directly fullscreen is
+     * disabled, calls {@link #openVideoPlayer(boolean)} with {@code directlyFullscreenIfApplicable
+     * = false}, hence preventing it from going directly fullscreen.
+     */
+    public void openVideoPlayerAutoFullscreen() {
+        openVideoPlayer(PlayerHelper.isStartMainPlayerFullscreenEnabled(requireContext()));
+    }
+
     private void openNormalBackgroundPlayer(final boolean append) {
         // See UI changes while remote playQueue changes
-        if (player == null) {
-            PlayerHolder.startService(App.getApp(), false, this);
+        if (!isPlayerAvailable()) {
+            playerHolder.startService(false, this);
         }
 
         final PlayQueue queue = setupPlayQueueForIntent(append);
@@ -1131,8 +1162,8 @@ public final class VideoDetailFragment
     }
 
     private void openMainPlayer() {
-        if (playerService == null) {
-            PlayerHolder.startService(App.getApp(), autoPlayEnabled, this);
+        if (!isPlayerServiceAvailable()) {
+            playerHolder.startService(autoPlayEnabled, this);
             return;
         }
         if (currentInfo == null) {
@@ -1148,21 +1179,32 @@ public final class VideoDetailFragment
         }
         addVideoPlayerView();
 
-        final Intent playerIntent = NavigationHelper
-                .getPlayerIntent(requireContext(), MainPlayer.class, queue, true, autoPlayEnabled);
-        activity.startService(playerIntent);
+        final Intent playerIntent = NavigationHelper.getPlayerIntent(requireContext(),
+                MainPlayer.class, queue, true, autoPlayEnabled);
+        ContextCompat.startForegroundService(activity, playerIntent);
     }
 
-    private void hideMainPlayer() {
-        if (playerService == null
+    /**
+     * When the video detail fragment is already showing details for a video and the user opens a
+     * new one, the video detail fragment changes all of its old data to the new stream, so if there
+     * is a video player currently open it should be hidden. This method does exactly that. If
+     * autoplay is enabled, the underlying player is not stopped completely, since it is going to
+     * be reused in a few milliseconds and the flickering would be annoying.
+     */
+    private void hideMainPlayerOnLoadingNewStream() {
+        if (!isPlayerServiceAvailable()
                 || playerService.getView() == null
                 || !player.videoPlayerSelected()) {
             return;
         }
 
         removeVideoPlayerView();
-        playerService.stop(isAutoplayEnabled());
-        playerService.getView().setVisibility(View.GONE);
+        if (isAutoplayEnabled()) {
+            playerService.stopForImmediateReusing();
+            playerService.getView().setVisibility(View.GONE);
+        } else {
+            playerHolder.stopService();
+        }
     }
 
     private PlayQueue setupPlayQueueForIntent(final boolean append) {
@@ -1211,13 +1253,13 @@ public final class VideoDetailFragment
     private boolean isAutoplayEnabled() {
         return autoPlayEnabled
                 && !isExternalPlayerEnabled()
-                && (player == null || player.videoPlayerSelected())
+                && (!isPlayerAvailable() || player.videoPlayerSelected())
                 && bottomSheetState != BottomSheetBehavior.STATE_HIDDEN
                 && PlayerHelper.isAutoplayAllowedByUser(requireContext());
     }
 
     private void addVideoPlayerView() {
-        if (player == null || getView() == null) {
+        if (!isPlayerAvailable() || getView() == null) {
             return;
         }
 
@@ -1255,7 +1297,7 @@ public final class VideoDetailFragment
                     final DisplayMetrics metrics = getResources().getDisplayMetrics();
 
                     if (getView() != null) {
-                        final int height = (isInMultiWindow()
+                        final int height = (DeviceUtils.isInMultiWindow(activity)
                                 ? requireView()
                                 : activity.getWindow().getDecorView()).getHeight();
                         setHeightThumbnail(height, metrics);
@@ -1277,8 +1319,8 @@ public final class VideoDetailFragment
         final boolean isPortrait = metrics.heightPixels > metrics.widthPixels;
         requireView().getViewTreeObserver().removeOnPreDrawListener(preDrawListener);
 
-        if (player != null && player.isFullscreen()) {
-            final int height = (isInMultiWindow()
+        if (isPlayerAvailable() && player.isFullscreen()) {
+            final int height = (DeviceUtils.isInMultiWindow(activity)
                     ? requireView()
                     : activity.getWindow().getDecorView()).getHeight();
             // Height is zero when the view is not yet displayed like after orientation change
@@ -1300,7 +1342,7 @@ public final class VideoDetailFragment
                 new FrameLayout.LayoutParams(
                         RelativeLayout.LayoutParams.MATCH_PARENT, newHeight));
         binding.detailThumbnailImageView.setMinimumHeight(newHeight);
-        if (player != null) {
+        if (isPlayerAvailable()) {
             final int maxHeight = (int) (metrics.heightPixels * MAX_PLAYER_HEIGHT);
             player.getSurfaceView()
                     .setHeights(newHeight, player.isFullscreen() ? newHeight : maxHeight);
@@ -1368,9 +1410,9 @@ public final class VideoDetailFragment
                             bottomSheetBehavior.setState(BottomSheetBehavior.STATE_COLLAPSED);
                         }
                         // Rebound to the service if it was closed via notification or mini player
-                        if (!PlayerHolder.bound) {
-                            PlayerHolder.startService(
-                                    App.getApp(), false, VideoDetailFragment.this);
+                        if (!playerHolder.bound) {
+                            playerHolder.startService(
+                                    false, VideoDetailFragment.this);
                         }
                         break;
                 }
@@ -1389,18 +1431,15 @@ public final class VideoDetailFragment
     //////////////////////////////////////////////////////////////////////////*/
 
     private void restoreDefaultOrientation() {
-        if (player == null || !player.videoPlayerSelected() || activity == null) {
-            return;
+        if (isPlayerAvailable() && player.videoPlayerSelected()) {
+            toggleFullscreenIfInFullscreenMode();
         }
 
-        if (player != null && player.isFullscreen()) {
-            player.toggleFullscreen();
-        }
         // This will show systemUI and pause the player.
         // User can tap on Play button and video will be in fullscreen mode again
         // Note for tablet: trying to avoid orientation changes since it's not easy
         // to physically rotate the tablet every time
-        if (!DeviceUtils.isTablet(activity)) {
+        if (activity != null && !DeviceUtils.isTablet(activity)) {
             activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
         }
     }
@@ -1435,14 +1474,13 @@ public final class VideoDetailFragment
         if (binding.relatedItemsLayout != null) {
             if (showRelatedItems) {
                 binding.relatedItemsLayout.setVisibility(
-                        player != null && player.isFullscreen() ? View.GONE : View.INVISIBLE);
+                        isPlayerAvailable() && player.isFullscreen() ? View.GONE : View.INVISIBLE);
             } else {
                 binding.relatedItemsLayout.setVisibility(View.GONE);
             }
         }
 
-        IMAGE_LOADER.cancelDisplayTask(binding.detailThumbnailImageView);
-        IMAGE_LOADER.cancelDisplayTask(binding.detailSubChannelThumbnailView);
+        PicassoHelper.cancelTag(PICASSO_VIDEO_DETAILS_TAG);
         binding.detailThumbnailImageView.setImageBitmap(null);
         binding.detailSubChannelThumbnailView.setImageBitmap(null);
     }
@@ -1549,7 +1587,7 @@ public final class VideoDetailFragment
         showMetaInfoInTextView(info.getMetaInfo(), binding.detailMetaInfoTextView,
                 binding.detailMetaInfoSeparator, disposables);
 
-        if (player == null || player.isStopped()) {
+        if (!isPlayerAvailable() || player.isStopped()) {
             updateOverlayData(info.getName(), info.getUploaderName(), info.getThumbnailUrl());
         }
 
@@ -1812,10 +1850,8 @@ public final class VideoDetailFragment
         if (error.type == ExoPlaybackException.TYPE_SOURCE
                 || error.type == ExoPlaybackException.TYPE_UNEXPECTED) {
             // Properly exit from fullscreen
-            if (playerService != null && player.isFullscreen()) {
-                player.toggleFullscreen();
-            }
-            hideMainPlayer();
+            toggleFullscreenIfInFullscreenMode();
+            hideMainPlayerOnLoadingNewStream();
         }
     }
 
@@ -1832,7 +1868,9 @@ public final class VideoDetailFragment
     @Override
     public void onFullscreenStateChanged(final boolean fullscreen) {
         setupBrightness();
-        if (playerService.getView() == null || player.getParentActivity() == null) {
+        if (!isPlayerAndPlayerServiceAvailable()
+                || playerService.getView() == null
+                || player.getParentActivity() == null) {
             return;
         }
 
@@ -1869,13 +1907,14 @@ public final class VideoDetailFragment
         // from landscape to portrait every time.
         // Just turn on fullscreen mode in landscape orientation
         // or portrait & unlocked global orientation
+        final boolean isLandscape = DeviceUtils.isLandscape(requireContext());
         if (DeviceUtils.isTablet(activity)
-                && (!globalScreenOrientationLocked(activity) || isLandscape())) {
+                && (!globalScreenOrientationLocked(activity) || isLandscape)) {
             player.toggleFullscreen();
             return;
         }
 
-        final int newOrientation = isLandscape()
+        final int newOrientation = isLandscape
                 ? ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
                 : ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE;
 
@@ -1947,15 +1986,17 @@ public final class VideoDetailFragment
                 | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                 | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                 | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
+
         // In multiWindow mode status bar is not transparent for devices with cutout
         // if I include this flag. So without it is better in this case
-        if (!isInMultiWindow()) {
+        final boolean isInMultiWindow = DeviceUtils.isInMultiWindow(activity);
+        if (!isInMultiWindow) {
             visibility |= View.SYSTEM_UI_FLAG_FULLSCREEN;
         }
         activity.getWindow().getDecorView().setSystemUiVisibility(visibility);
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP
-                && (isInMultiWindow() || (player != null && player.isFullscreen()))) {
+                && (isInMultiWindow || (isPlayerAvailable() && player.isFullscreen()))) {
             activity.getWindow().setStatusBarColor(Color.TRANSPARENT);
             activity.getWindow().setNavigationBarColor(Color.TRANSPARENT);
         }
@@ -1964,7 +2005,7 @@ public final class VideoDetailFragment
 
     // Listener implementation
     public void hideSystemUiIfNeeded() {
-        if (player != null
+        if (isPlayerAvailable()
                 && player.isFullscreen()
                 && bottomSheetBehavior.getState() == BottomSheetBehavior.STATE_EXPANDED) {
             hideSystemUi();
@@ -1972,7 +2013,7 @@ public final class VideoDetailFragment
     }
 
     private boolean playerIsNotStopped() {
-        return player != null && !player.isStopped();
+        return isPlayerAvailable() && !player.isStopped();
     }
 
     private void restoreDefaultBrightness() {
@@ -1993,7 +2034,7 @@ public final class VideoDetailFragment
         }
 
         final WindowManager.LayoutParams lp = activity.getWindow().getAttributes();
-        if (player == null
+        if (!isPlayerAvailable()
                 || !player.videoPlayerSelected()
                 || !player.isFullscreen()
                 || bottomSheetState != BottomSheetBehavior.STATE_EXPANDED) {
@@ -2027,15 +2068,6 @@ public final class VideoDetailFragment
         }
     }
 
-    private boolean isLandscape() {
-        return getResources().getDisplayMetrics().heightPixels < getResources()
-                .getDisplayMetrics().widthPixels;
-    }
-
-    private boolean isInMultiWindow() {
-        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && activity.isInMultiWindowMode();
-    }
-
     /*
      * Means that the player fragment was swiped away via BottomSheetLayout
      * and is empty but ready for any new actions. See cleanUp()
@@ -2059,7 +2091,7 @@ public final class VideoDetailFragment
     }
 
     private void replaceQueueIfUserConfirms(final Runnable onAllow) {
-        @Nullable final PlayQueue activeQueue = player == null ? null : player.getPlayQueue();
+        @Nullable final PlayQueue activeQueue = isPlayerAvailable() ? player.getPlayQueue() : null;
 
         // Player will have STATE_IDLE when a user pressed back button
         if (isClearingQueueConfirmationRequired(activity)
@@ -2075,8 +2107,8 @@ public final class VideoDetailFragment
     private void showClearingQueueConfirmation(final Runnable onAllow) {
         new AlertDialog.Builder(activity)
                 .setTitle(R.string.clear_queue_confirmation_description)
-                .setNegativeButton(android.R.string.cancel, null)
-                .setPositiveButton(android.R.string.yes, (dialog, which) -> {
+                .setNegativeButton(R.string.cancel, null)
+                .setPositiveButton(R.string.ok, (dialog, which) -> {
                     onAllow.run();
                     dialog.dismiss();
                 }).show();
@@ -2091,7 +2123,7 @@ public final class VideoDetailFragment
             resolutions[i] = sortedVideoStreams.get(i).getResolution();
         }
         final AlertDialog.Builder builder = new AlertDialog.Builder(activity)
-                .setNegativeButton(android.R.string.cancel, null)
+                .setNegativeButton(R.string.cancel, null)
                 .setNeutralButton(R.string.open_in_browser, (dialog, i) ->
                         ShareUtils.openUrlInBrowser(requireActivity(), url)
                 );
@@ -2115,7 +2147,7 @@ public final class VideoDetailFragment
         if (currentWorker != null) {
             currentWorker.dispose();
         }
-        PlayerHolder.stopService(App.getApp());
+        playerHolder.stopService();
         setInitialData(0, null, "", null);
         currentInfo = null;
         updateOverlayData(null, null, null);
@@ -2218,8 +2250,8 @@ public final class VideoDetailFragment
                         setOverlayElementsClickable(false);
                         hideSystemUiIfNeeded();
                         // Conditions when the player should be expanded to fullscreen
-                        if (isLandscape()
-                                && player != null
+                        if (DeviceUtils.isLandscape(requireContext())
+                                && isPlayerAvailable()
                                 && player.isPlaying()
                                 && !player.isFullscreen()
                                 && !DeviceUtils.isTablet(activity)
@@ -2236,17 +2268,17 @@ public final class VideoDetailFragment
 
                         // Re-enable clicks
                         setOverlayElementsClickable(true);
-                        if (player != null) {
+                        if (isPlayerAvailable()) {
                             player.closeItemsList();
                         }
                         setOverlayLook(binding.appBarLayout, behavior, 0);
                         break;
                     case BottomSheetBehavior.STATE_DRAGGING:
                     case BottomSheetBehavior.STATE_SETTLING:
-                        if (player != null && player.isFullscreen()) {
+                        if (isPlayerAvailable() && player.isFullscreen()) {
                             showSystemUi();
                         }
-                        if (player != null && player.isControlsVisible()) {
+                        if (isPlayerAvailable() && player.isControlsVisible()) {
                             player.hideControls(0, 0);
                         }
                         break;
@@ -2273,10 +2305,8 @@ public final class VideoDetailFragment
         binding.overlayTitleTextView.setText(isEmpty(overlayTitle) ? "" : overlayTitle);
         binding.overlayChannelTextView.setText(isEmpty(uploader) ? "" : uploader);
         binding.overlayThumbnail.setImageResource(R.drawable.dummy_thumbnail_dark);
-        if (!isEmpty(thumbnailUrl)) {
-            IMAGE_LOADER.displayImage(thumbnailUrl, binding.overlayThumbnail,
-                    ImageDisplayConstants.DISPLAY_THUMBNAIL_OPTIONS, null);
-        }
+        PicassoHelper.loadThumbnail(thumbnailUrl).tag(PICASSO_VIDEO_DETAILS_TAG)
+                .into(binding.overlayThumbnail);
     }
 
     private void setOverlayPlayPauseImage(final boolean playerIsPlaying) {
@@ -2310,4 +2340,17 @@ public final class VideoDetailFragment
         binding.overlayPlayPauseButton.setClickable(enable);
         binding.overlayCloseButton.setClickable(enable);
     }
+
+    // helpers to check the state of player and playerService
+    boolean isPlayerAvailable() {
+        return (player != null);
+    }
+
+    boolean isPlayerServiceAvailable() {
+        return (playerService != null);
+    }
+
+    boolean isPlayerAndPlayerServiceAvailable() {
+        return (player != null && playerService != null);
+    }
 }

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

@@ -353,7 +353,7 @@ public abstract class BaseListFragment<I, N> extends BaseStateFragment<I>
 
         final List<StreamDialogEntry> entries = new ArrayList<>();
 
-        if (PlayerHolder.getType() != null) {
+        if (PlayerHolder.getInstance().getType() != null) {
             entries.add(StreamDialogEntry.enqueue);
         }
         if (item.getStreamType() == StreamType.AUDIO_STREAM) {

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

@@ -40,10 +40,10 @@ import org.schabi.newpipe.local.subscription.SubscriptionManager;
 import org.schabi.newpipe.player.playqueue.ChannelPlayQueue;
 import org.schabi.newpipe.player.playqueue.PlayQueue;
 import org.schabi.newpipe.util.ExtractorHelper;
-import org.schabi.newpipe.util.ImageDisplayConstants;
 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.PicassoHelper;
 import org.schabi.newpipe.util.ThemeHelper;
 
 import java.util.ArrayList;
@@ -66,7 +66,10 @@ import static org.schabi.newpipe.ktx.ViewUtils.animateBackgroundColor;
 
 public class ChannelFragment extends BaseListInfoFragment<ChannelInfo>
         implements View.OnClickListener {
+
     private static final int BUTTON_DEBOUNCE_INTERVAL = 100;
+    private static final String PICASSO_CHANNEL_TAG = "PICASSO_CHANNEL_TAG";
+
     private final CompositeDisposable disposables = new CompositeDisposable();
     private Disposable subscribeButtonMonitor;
 
@@ -421,10 +424,7 @@ public class ChannelFragment extends BaseListInfoFragment<ChannelInfo>
     @Override
     public void showLoading() {
         super.showLoading();
-
-        IMAGE_LOADER.cancelDisplayTask(headerBinding.channelBannerImage);
-        IMAGE_LOADER.cancelDisplayTask(headerBinding.channelAvatarView);
-        IMAGE_LOADER.cancelDisplayTask(headerBinding.subChannelAvatarView);
+        PicassoHelper.cancelTag(PICASSO_CHANNEL_TAG);
         animate(headerBinding.channelSubscribeButton, false, 100);
     }
 
@@ -433,13 +433,12 @@ public class ChannelFragment extends BaseListInfoFragment<ChannelInfo>
         super.handleResult(result);
 
         headerBinding.getRoot().setVisibility(View.VISIBLE);
-        IMAGE_LOADER.displayImage(result.getBannerUrl(), headerBinding.channelBannerImage,
-                ImageDisplayConstants.DISPLAY_BANNER_OPTIONS);
-        IMAGE_LOADER.displayImage(result.getAvatarUrl(), headerBinding.channelAvatarView,
-                ImageDisplayConstants.DISPLAY_AVATAR_OPTIONS);
-        IMAGE_LOADER.displayImage(result.getParentChannelAvatarUrl(),
-                headerBinding.subChannelAvatarView,
-                ImageDisplayConstants.DISPLAY_AVATAR_OPTIONS);
+        PicassoHelper.loadBanner(result.getBannerUrl()).tag(PICASSO_CHANNEL_TAG)
+                .into(headerBinding.channelBannerImage);
+        PicassoHelper.loadAvatar(result.getAvatarUrl()).tag(PICASSO_CHANNEL_TAG)
+                .into(headerBinding.channelAvatarView);
+        PicassoHelper.loadAvatar(result.getParentChannelAvatarUrl()).tag(PICASSO_CHANNEL_TAG)
+                .into(headerBinding.subChannelAvatarView);
 
         headerBinding.channelSubscriberView.setVisibility(View.VISIBLE);
         if (result.getSubscriberCount() >= 0) {

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

@@ -6,6 +6,7 @@ import android.view.Menu;
 import android.view.MenuInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.widget.TextView;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -24,6 +25,8 @@ import io.reactivex.rxjava3.disposables.CompositeDisposable;
 public class CommentsFragment extends BaseListInfoFragment<CommentsInfo> {
     private final CompositeDisposable disposables = new CompositeDisposable();
 
+    private TextView emptyStateDesc;
+
     public static CommentsFragment getInstance(final int serviceId, final String url,
                                                final String name) {
         final CommentsFragment instance = new CommentsFragment();
@@ -35,6 +38,13 @@ public class CommentsFragment extends BaseListInfoFragment<CommentsInfo> {
         super(UserAction.REQUESTED_COMMENTS);
     }
 
+    @Override
+    protected void initViews(final View rootView, final Bundle savedInstanceState) {
+        super.initViews(rootView, savedInstanceState);
+
+        emptyStateDesc = rootView.findViewById(R.id.empty_state_desc);
+    }
+
     /*//////////////////////////////////////////////////////////////////////////
     // LifeCycle
     //////////////////////////////////////////////////////////////////////////*/
@@ -73,6 +83,12 @@ public class CommentsFragment extends BaseListInfoFragment<CommentsInfo> {
     @Override
     public void handleResult(@NonNull final CommentsInfo result) {
         super.handleResult(result);
+
+        emptyStateDesc.setText(
+                result.isCommentsDisabled()
+                        ? R.string.comments_are_disabled
+                        : R.string.no_comments);
+
         ViewUtils.slideUp(requireView(), 120, 150, 0.06f);
         disposables.clear();
     }

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

@@ -41,7 +41,7 @@ import org.schabi.newpipe.player.helper.PlayerHolder;
 import org.schabi.newpipe.player.playqueue.PlayQueue;
 import org.schabi.newpipe.player.playqueue.PlaylistPlayQueue;
 import org.schabi.newpipe.util.ExtractorHelper;
-import org.schabi.newpipe.util.ImageDisplayConstants;
+import org.schabi.newpipe.util.PicassoHelper;
 import org.schabi.newpipe.util.external_communication.KoreUtils;
 import org.schabi.newpipe.util.Localization;
 import org.schabi.newpipe.util.NavigationHelper;
@@ -64,12 +64,16 @@ import static org.schabi.newpipe.ktx.ViewUtils.animate;
 import static org.schabi.newpipe.ktx.ViewUtils.animateHideRecyclerViewAllowingScrolling;
 
 public class PlaylistFragment extends BaseListInfoFragment<PlaylistInfo> {
+
+    private static final String PICASSO_PLAYLIST_TAG = "PICASSO_PLAYLIST_TAG";
+
     private CompositeDisposable disposables;
     private Subscription bookmarkReactor;
     private AtomicBoolean isBookmarkButtonReady;
 
     private RemotePlaylistManager remotePlaylistManager;
     private PlaylistRemoteEntity playlistEntity;
+
     /*//////////////////////////////////////////////////////////////////////////
     // Views
     //////////////////////////////////////////////////////////////////////////*/
@@ -144,7 +148,7 @@ public class PlaylistFragment extends BaseListInfoFragment<PlaylistInfo> {
 
         final ArrayList<StreamDialogEntry> entries = new ArrayList<>();
 
-        if (PlayerHolder.getType() != null) {
+        if (PlayerHolder.getInstance().getType() != null) {
             entries.add(StreamDialogEntry.enqueue);
         }
         if (item.getStreamType() == StreamType.AUDIO_STREAM) {
@@ -274,7 +278,7 @@ public class PlaylistFragment extends BaseListInfoFragment<PlaylistInfo> {
         animate(headerBinding.getRoot(), false, 200);
         animateHideRecyclerViewAllowingScrolling(itemsList);
 
-        IMAGE_LOADER.cancelDisplayTask(headerBinding.uploaderAvatarView);
+        PicassoHelper.cancelTag(PICASSO_PLAYLIST_TAG);
         animate(headerBinding.uploaderLayout, false, 200);
     }
 
@@ -317,8 +321,8 @@ public class PlaylistFragment extends BaseListInfoFragment<PlaylistInfo> {
                     R.drawable.ic_radio)
             );
         } else {
-            IMAGE_LOADER.displayImage(avatarUrl, headerBinding.uploaderAvatarView,
-                    ImageDisplayConstants.DISPLAY_AVATAR_OPTIONS);
+            PicassoHelper.loadAvatar(avatarUrl).tag(PICASSO_PLAYLIST_TAG)
+                    .into(headerBinding.uploaderAvatarView);
         }
 
         headerBinding.playlistStreamCount.setText(Localization

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

@@ -57,6 +57,7 @@ import org.schabi.newpipe.fragments.list.BaseListFragment;
 import org.schabi.newpipe.ktx.AnimationType;
 import org.schabi.newpipe.ktx.ExceptionUtils;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
+import org.schabi.newpipe.settings.NewPipeSettings;
 import org.schabi.newpipe.util.Constants;
 import org.schabi.newpipe.util.DeviceUtils;
 import org.schabi.newpipe.util.ExtractorHelper;
@@ -65,16 +66,19 @@ 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.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Queue;
+import java.util.Set;
 import java.util.concurrent.TimeUnit;
 
 import icepick.State;
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
-import io.reactivex.rxjava3.core.Flowable;
 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.schedulers.Schedulers;
@@ -143,7 +147,8 @@ public class SearchFragment extends BaseListFragment<SearchInfo, ListExtractor.I
     @Nullable private Map<Integer, String> menuItemToFilterName = null;
     private StreamingService service;
     private Page nextPage;
-    private boolean isSuggestionsEnabled = true;
+    private boolean showLocalSuggestions = true;
+    private boolean showRemoteSuggestions = true;
 
     private Disposable searchDisposable;
     private Disposable suggestionDisposable;
@@ -194,26 +199,14 @@ public class SearchFragment extends BaseListFragment<SearchInfo, ListExtractor.I
     public void onAttach(@NonNull final Context context) {
         super.onAttach(context);
 
+        final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(activity);
+        showLocalSuggestions = NewPipeSettings.showLocalSearchSuggestions(activity, prefs);
+        showRemoteSuggestions = NewPipeSettings.showRemoteSearchSuggestions(activity, prefs);
+
         suggestionListAdapter = new SuggestionListAdapter(activity);
-        final SharedPreferences preferences
-                = PreferenceManager.getDefaultSharedPreferences(activity);
-        final boolean isSearchHistoryEnabled = preferences
-                .getBoolean(getString(R.string.enable_search_history_key), true);
-        suggestionListAdapter.setShowSuggestionHistory(isSearchHistoryEnabled);
-
         historyRecordManager = new HistoryRecordManager(context);
     }
 
-    @Override
-    public void onCreate(final Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-
-        final SharedPreferences preferences
-                = PreferenceManager.getDefaultSharedPreferences(activity);
-        isSuggestionsEnabled = preferences
-                .getBoolean(getString(R.string.show_search_suggestions_key), true);
-    }
-
     @Override
     public View onCreateView(final LayoutInflater inflater, @Nullable final ViewGroup container,
                              @Nullable final Bundle savedInstanceState) {
@@ -222,6 +215,7 @@ public class SearchFragment extends BaseListFragment<SearchInfo, ListExtractor.I
 
     @Override
     public void onViewCreated(@NonNull final View rootView, final Bundle savedInstanceState) {
+        searchBinding = FragmentSearchBinding.bind(rootView);
         super.onViewCreated(rootView, savedInstanceState);
         showSearchOnStart();
         initSearchListeners();
@@ -348,7 +342,6 @@ public class SearchFragment extends BaseListFragment<SearchInfo, ListExtractor.I
     @Override
     protected void initViews(final View rootView, final Bundle savedInstanceState) {
         super.initViews(rootView, savedInstanceState);
-        searchBinding = FragmentSearchBinding.bind(rootView);
 
         searchBinding.suggestionsList.setAdapter(suggestionListAdapter);
         new ItemTouchHelper(new ItemTouchHelper.Callback() {
@@ -554,7 +547,7 @@ public class SearchFragment extends BaseListFragment<SearchInfo, ListExtractor.I
             if (DEBUG) {
                 Log.d(TAG, "onClick() called with: v = [" + v + "]");
             }
-            if (isSuggestionsEnabled && !isErrorPanelVisible()) {
+            if ((showLocalSuggestions || showRemoteSuggestions) && !isErrorPanelVisible()) {
                 showSuggestionsPanel();
             }
             if (DeviceUtils.isTv(getContext())) {
@@ -567,7 +560,8 @@ public class SearchFragment extends BaseListFragment<SearchInfo, ListExtractor.I
                 Log.d(TAG, "onFocusChange() called with: "
                         + "v = [" + v + "], hasFocus = [" + hasFocus + "]");
             }
-            if (isSuggestionsEnabled && hasFocus && !isErrorPanelVisible()) {
+            if ((showLocalSuggestions || showRemoteSuggestions)
+                    && hasFocus && !isErrorPanelVisible()) {
                 showSuggestionsPanel();
             }
         });
@@ -743,6 +737,34 @@ public class SearchFragment extends BaseListFragment<SearchInfo, ListExtractor.I
         return false;
     }
 
+
+    private Observable<List<SuggestionItem>> getLocalSuggestionsObservable(
+            final String query, final int similarQueryLimit) {
+        return historyRecordManager
+                .getRelatedSearches(query, similarQueryLimit, 25)
+                .toObservable()
+                .map(searchHistoryEntries -> {
+                    final Set<SuggestionItem> result = new HashSet<>(); // remove duplicates
+                    for (final SearchHistoryEntry entry : searchHistoryEntries) {
+                        result.add(new SuggestionItem(true, entry.getSearch()));
+                    }
+                    return new ArrayList<>(result);
+                });
+    }
+
+    private Observable<List<SuggestionItem>> getRemoteSuggestionsObservable(final String query) {
+        return ExtractorHelper
+                .suggestionsFor(serviceId, query)
+                .toObservable()
+                .map(strings -> {
+                    final List<SuggestionItem> result = new ArrayList<>();
+                    for (final String entry : strings) {
+                        result.add(new SuggestionItem(false, entry));
+                    }
+                    return result;
+                });
+    }
+
     private void initSuggestionObserver() {
         if (DEBUG) {
             Log.d(TAG, "initSuggestionObserver() called");
@@ -753,73 +775,53 @@ public class SearchFragment extends BaseListFragment<SearchInfo, ListExtractor.I
 
         suggestionDisposable = suggestionPublisher
                 .debounce(SUGGESTIONS_DEBOUNCE, TimeUnit.MILLISECONDS)
-                .startWithItem(searchString != null
-                        ? searchString
-                        : "")
-                .filter(ss -> isSuggestionsEnabled)
+                .startWithItem(searchString == null ? "" : searchString)
                 .switchMap(query -> {
-                    final Flowable<List<SearchHistoryEntry>> flowable = historyRecordManager
-                            .getRelatedSearches(query, 3, 25);
-                    final Observable<List<SuggestionItem>> local = flowable.toObservable()
-                            .map(searchHistoryEntries -> {
-                                final List<SuggestionItem> result = new ArrayList<>();
-                                for (final SearchHistoryEntry entry : searchHistoryEntries) {
-                                    result.add(new SuggestionItem(true, entry.getSearch()));
-                                }
-                                return result;
-                            });
+                    // Only show remote suggestions if they are enabled in settings and
+                    // the query length is at least THRESHOLD_NETWORK_SUGGESTION
+                    final boolean shallShowRemoteSuggestionsNow = showRemoteSuggestions
+                            && query.length() >= THRESHOLD_NETWORK_SUGGESTION;
 
-                    if (query.length() < THRESHOLD_NETWORK_SUGGESTION) {
-                        // Only pass through if the query length
-                        // is equal or greater than THRESHOLD_NETWORK_SUGGESTION
-                        return local.materialize();
+                    if (showLocalSuggestions && shallShowRemoteSuggestionsNow) {
+                        return Observable.zip(
+                                getLocalSuggestionsObservable(query, 3),
+                                getRemoteSuggestionsObservable(query),
+                                (local, remote) -> {
+                                    remote.removeIf(remoteItem -> local.stream().anyMatch(
+                                            localItem -> localItem.equals(remoteItem)));
+                                    local.addAll(remote);
+                                    return local;
+                                })
+                                .materialize();
+                    } else if (showLocalSuggestions) {
+                        return getLocalSuggestionsObservable(query, 25)
+                                .materialize();
+                    } else if (shallShowRemoteSuggestionsNow) {
+                        return getRemoteSuggestionsObservable(query)
+                                .materialize();
+                    } else {
+                        return Single.fromCallable(Collections::<SuggestionItem>emptyList)
+                                .toObservable()
+                                .materialize();
                     }
-
-                    final Observable<List<SuggestionItem>> network = ExtractorHelper
-                            .suggestionsFor(serviceId, query)
-                            .onErrorReturn(throwable -> {
-                                if (!ExceptionUtils.isNetworkRelated(throwable)) {
-                                    showSnackBarError(new ErrorInfo(throwable,
-                                            UserAction.GET_SUGGESTIONS, searchString, serviceId));
-                                }
-                                return new ArrayList<>();
-                            })
-                            .toObservable()
-                            .map(strings -> {
-                                final List<SuggestionItem> result = new ArrayList<>();
-                                for (final String entry : strings) {
-                                    result.add(new SuggestionItem(false, entry));
-                                }
-                                return result;
-                            });
-
-                    return Observable.zip(local, network, (localResult, networkResult) -> {
-                        final List<SuggestionItem> result = new ArrayList<>();
-                        if (localResult.size() > 0) {
-                            result.addAll(localResult);
-                        }
-
-                        // Remove duplicates
-                        networkResult.removeIf(networkItem ->
-                                localResult.stream().anyMatch(localItem ->
-                                        localItem.query.equals(networkItem.query)));
-
-                        if (networkResult.size() > 0) {
-                            result.addAll(networkResult);
-                        }
-                        return result;
-                    }).materialize();
                 })
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
-                .subscribe(listNotification -> {
-                    if (listNotification.isOnNext()) {
-                        handleSuggestions(listNotification.getValue());
-                    } else if (listNotification.isOnError()) {
-                        showError(new ErrorInfo(listNotification.getError(),
-                                UserAction.GET_SUGGESTIONS, searchString, serviceId));
-                    }
-                });
+                .subscribe(
+                        listNotification -> {
+                            if (listNotification.isOnNext()) {
+                                if (listNotification.getValue() != null) {
+                                    handleSuggestions(listNotification.getValue());
+                                }
+                            } else if (listNotification.isOnError()
+                                    && listNotification.getError() != null
+                                    && !ExceptionUtils.isInterruptedCaused(
+                                            listNotification.getError())) {
+                                showSnackBarError(new ErrorInfo(listNotification.getError(),
+                                        UserAction.GET_SUGGESTIONS, searchString, serviceId));
+                            }
+                        }, throwable -> showSnackBarError(new ErrorInfo(
+                            throwable, UserAction.GET_SUGGESTIONS, searchString, serviceId)));
     }
 
     @Override

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

@@ -1,5 +1,7 @@
 package org.schabi.newpipe.fragments.list.search;
 
+import androidx.annotation.NonNull;
+
 public class SuggestionItem {
     final boolean fromHistory;
     public final String query;
@@ -9,6 +11,20 @@ public class SuggestionItem {
         this.query = query;
     }
 
+    @Override
+    public boolean equals(final Object o) {
+        if (o instanceof SuggestionItem) {
+            return query.equals(((SuggestionItem) o).query);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return query.hashCode();
+    }
+
+    @NonNull
     @Override
     public String toString() {
         return "[" + fromHistory + "→" + query + "]";

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

@@ -19,7 +19,6 @@ public class SuggestionListAdapter
     private final ArrayList<SuggestionItem> items = new ArrayList<>();
     private final Context context;
     private OnSuggestionItemSelected listener;
-    private boolean showSuggestionHistory = true;
 
     public SuggestionListAdapter(final Context context) {
         this.context = context;
@@ -27,16 +26,7 @@ public class SuggestionListAdapter
 
     public void setItems(final List<SuggestionItem> items) {
         this.items.clear();
-        if (showSuggestionHistory) {
-            this.items.addAll(items);
-        } else {
-            // remove history items if history is disabled
-            for (final SuggestionItem item : items) {
-                if (!item.fromHistory) {
-                    this.items.add(item);
-                }
-            }
-        }
+        this.items.addAll(items);
         notifyDataSetChanged();
     }
 
@@ -44,10 +34,6 @@ public class SuggestionListAdapter
         this.listener = listener;
     }
 
-    public void setShowSuggestionHistory(final boolean v) {
-        showSuggestionHistory = v;
-    }
-
     @Override
     public SuggestionItemHolder onCreateViewHolder(final ViewGroup parent, final int viewType) {
         return new SuggestionItemHolder(LayoutInflater.from(context)

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

@@ -6,8 +6,6 @@ import android.view.ViewGroup;
 
 import androidx.annotation.NonNull;
 
-import com.nostra13.universalimageloader.core.ImageLoader;
-
 import org.schabi.newpipe.extractor.InfoItem;
 import org.schabi.newpipe.extractor.channel.ChannelInfoItem;
 import org.schabi.newpipe.extractor.comments.CommentsInfoItem;
@@ -51,7 +49,6 @@ import org.schabi.newpipe.util.OnClickGesture;
 
 public class InfoItemBuilder {
     private final Context context;
-    private final ImageLoader imageLoader = ImageLoader.getInstance();
 
     private OnClickGesture<StreamInfoItem> onStreamSelectedListener;
     private OnClickGesture<ChannelInfoItem> onChannelSelectedListener;
@@ -101,10 +98,6 @@ public class InfoItemBuilder {
         return context;
     }
 
-    public ImageLoader getImageLoader() {
-        return imageLoader;
-    }
-
     public OnClickGesture<StreamInfoItem> getOnStreamSelectedListener() {
         return onStreamSelectedListener;
     }

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

@@ -3,13 +3,12 @@ package org.schabi.newpipe.info_list
 import android.view.View
 import android.widget.ImageView
 import android.widget.TextView
-import com.nostra13.universalimageloader.core.ImageLoader
 import com.xwray.groupie.GroupieViewHolder
 import com.xwray.groupie.Item
 import org.schabi.newpipe.R
 import org.schabi.newpipe.extractor.stream.StreamSegment
-import org.schabi.newpipe.util.ImageDisplayConstants
 import org.schabi.newpipe.util.Localization
+import org.schabi.newpipe.util.PicassoHelper
 
 class StreamSegmentItem(
     private val item: StreamSegment,
@@ -24,10 +23,8 @@ class StreamSegmentItem(
 
     override fun bind(viewHolder: GroupieViewHolder, position: Int) {
         item.previewUrl?.let {
-            ImageLoader.getInstance().displayImage(
-                it, viewHolder.root.findViewById<ImageView>(R.id.previewImage),
-                ImageDisplayConstants.DISPLAY_THUMBNAIL_OPTIONS
-            )
+            PicassoHelper.loadThumbnail(it)
+                .into(viewHolder.root.findViewById<ImageView>(R.id.previewImage))
         }
         viewHolder.root.findViewById<TextView>(R.id.textViewTitle).text = item.title
         if (item.channelName == null) {

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

@@ -8,7 +8,7 @@ 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.ImageDisplayConstants;
+import org.schabi.newpipe.util.PicassoHelper;
 import org.schabi.newpipe.util.Localization;
 
 import de.hdodenhof.circleimageview.CircleImageView;
@@ -43,10 +43,7 @@ public class ChannelMiniInfoItemHolder extends InfoItemHolder {
         itemTitleView.setText(item.getName());
         itemAdditionalDetailView.setText(getDetailLine(item));
 
-        itemBuilder.getImageLoader()
-                .displayImage(item.getThumbnailUrl(),
-                        itemThumbnailView,
-                        ImageDisplayConstants.DISPLAY_THUMBNAIL_OPTIONS);
+        PicassoHelper.loadThumbnail(item.getThumbnailUrl()).into(itemThumbnailView);
 
         itemView.setOnClickListener(view -> {
             if (itemBuilder.getOnChannelSelectedListener() != null) {

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

@@ -1,6 +1,8 @@
 package org.schabi.newpipe.info_list.holder;
 
+import android.view.View;
 import android.view.ViewGroup;
+import android.widget.ImageView;
 import android.widget.TextView;
 
 import org.schabi.newpipe.R;
@@ -31,11 +33,13 @@ import org.schabi.newpipe.local.history.HistoryRecordManager;
 
 public class CommentsInfoItemHolder extends CommentsMiniInfoItemHolder {
     public final TextView itemTitleView;
+    private final ImageView itemHeartView;
 
     public CommentsInfoItemHolder(final InfoItemBuilder infoItemBuilder, final ViewGroup parent) {
         super(infoItemBuilder, R.layout.list_comments_item, parent);
 
         itemTitleView = itemView.findViewById(R.id.itemTitleView);
+        itemHeartView = itemView.findViewById(R.id.detail_heart_image_view);
     }
 
     @Override
@@ -49,5 +53,7 @@ public class CommentsInfoItemHolder extends CommentsMiniInfoItemHolder {
         final CommentsInfoItem item = (CommentsInfoItem) infoItem;
 
         itemTitleView.setText(item.getUploaderName());
+
+        itemHeartView.setVisibility(item.isHeartedByUploader() ? View.VISIBLE : View.GONE);
     }
 }

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

@@ -1,17 +1,16 @@
 package org.schabi.newpipe.info_list.holder;
 
-import android.content.SharedPreferences;
 import android.text.TextUtils;
 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;
 import android.widget.RelativeLayout;
 import android.widget.TextView;
 
 import androidx.appcompat.app.AppCompatActivity;
-import androidx.preference.PreferenceManager;
 
 import org.schabi.newpipe.R;
 import org.schabi.newpipe.error.ErrorActivity;
@@ -21,30 +20,29 @@ 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.ImageDisplayConstants;
 import org.schabi.newpipe.util.Localization;
 import org.schabi.newpipe.util.NavigationHelper;
+import org.schabi.newpipe.util.external_communication.TimestampExtractor;
 import org.schabi.newpipe.util.external_communication.ShareUtils;
+import org.schabi.newpipe.util.PicassoHelper;
 
 import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 import de.hdodenhof.circleimageview.CircleImageView;
 
 public class CommentsMiniInfoItemHolder extends InfoItemHolder {
+    private static final String TAG = "CommentsMiniIIHolder";
+
     private static final int COMMENT_DEFAULT_LINES = 2;
     private static final int COMMENT_EXPANDED_LINES = 1000;
-    private static final Pattern PATTERN = Pattern.compile("(\\d+:)?(\\d+)?:(\\d+)");
-    private final String downloadThumbnailKey;
+
     private final int commentHorizontalPadding;
     private final int commentVerticalPadding;
 
-    private SharedPreferences preferences = null;
     private final RelativeLayout itemRoot;
     public final CircleImageView itemThumbnailView;
     private final TextView itemContentView;
     private final TextView itemLikesCountView;
-    private final TextView itemDislikesCountView;
     private final TextView itemPublishedTime;
 
     private String commentText;
@@ -53,20 +51,21 @@ public class CommentsMiniInfoItemHolder extends InfoItemHolder {
     private final Linkify.TransformFilter timestampLink = new Linkify.TransformFilter() {
         @Override
         public String transformUrl(final Matcher match, final String url) {
-            int timestamp = 0;
-            final String hours = match.group(1);
-            final String minutes = match.group(2);
-            final String seconds = match.group(3);
-            if (hours != null) {
-                timestamp += (Integer.parseInt(hours.replace(":", "")) * 3600);
+            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;
             }
-            if (minutes != null) {
-                timestamp += (Integer.parseInt(minutes.replace(":", "")) * 60);
-            }
-            if (seconds != null) {
-                timestamp += (Integer.parseInt(seconds));
-            }
-            return streamUrl + url.replace(match.group(0), "#timestamp=" + timestamp);
         }
     };
 
@@ -77,13 +76,9 @@ public class CommentsMiniInfoItemHolder extends InfoItemHolder {
         itemRoot = itemView.findViewById(R.id.itemRoot);
         itemThumbnailView = itemView.findViewById(R.id.itemThumbnailView);
         itemLikesCountView = itemView.findViewById(R.id.detail_thumbs_up_count_view);
-        itemDislikesCountView = itemView.findViewById(R.id.detail_thumbs_down_count_view);
         itemPublishedTime = itemView.findViewById(R.id.itemPublishedTime);
         itemContentView = itemView.findViewById(R.id.itemCommentContentView);
 
-        downloadThumbnailKey = infoItemBuilder.getContext().
-                getString(R.string.download_thumbnail_key);
-
         commentHorizontalPadding = (int) infoItemBuilder.getContext()
                 .getResources().getDimension(R.dimen.comments_horizontal_padding);
         commentVerticalPadding = (int) infoItemBuilder.getContext()
@@ -103,14 +98,8 @@ public class CommentsMiniInfoItemHolder extends InfoItemHolder {
         }
         final CommentsInfoItem item = (CommentsInfoItem) infoItem;
 
-        preferences = PreferenceManager.getDefaultSharedPreferences(itemBuilder.getContext());
-
-        itemBuilder.getImageLoader()
-                .displayImage(item.getUploaderAvatarUrl(),
-                        itemThumbnailView,
-                        ImageDisplayConstants.DISPLAY_THUMBNAIL_OPTIONS);
-
-        if (preferences.getBoolean(downloadThumbnailKey, true)) {
+        PicassoHelper.loadAvatar(item.getUploaderAvatarUrl()).into(itemThumbnailView);
+        if (PicassoHelper.getShouldLoadImages()) {
             itemThumbnailView.setVisibility(View.VISIBLE);
             itemRoot.setPadding(commentVerticalPadding, commentVerticalPadding,
                     commentVerticalPadding, commentVerticalPadding);
@@ -254,7 +243,14 @@ public class CommentsMiniInfoItemHolder extends InfoItemHolder {
     }
 
     private void linkify() {
-        Linkify.addLinks(itemContentView, Linkify.WEB_URLS);
-        Linkify.addLinks(itemContentView, PATTERN, null, null, timestampLink);
+        Linkify.addLinks(
+                itemContentView,
+                Linkify.WEB_URLS);
+        Linkify.addLinks(
+                itemContentView,
+                TimestampExtractor.TIMESTAMPS_PATTERN,
+                null,
+                null,
+                timestampLink);
     }
 }

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

@@ -9,7 +9,7 @@ import org.schabi.newpipe.extractor.InfoItem;
 import org.schabi.newpipe.extractor.playlist.PlaylistInfoItem;
 import org.schabi.newpipe.info_list.InfoItemBuilder;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
-import org.schabi.newpipe.util.ImageDisplayConstants;
+import org.schabi.newpipe.util.PicassoHelper;
 import org.schabi.newpipe.util.Localization;
 
 public class PlaylistMiniInfoItemHolder extends InfoItemHolder {
@@ -46,9 +46,7 @@ public class PlaylistMiniInfoItemHolder extends InfoItemHolder {
                 .localizeStreamCountMini(itemStreamCountView.getContext(), item.getStreamCount()));
         itemUploaderView.setText(item.getUploaderName());
 
-        itemBuilder.getImageLoader()
-                .displayImage(item.getThumbnailUrl(), itemThumbnailView,
-                        ImageDisplayConstants.DISPLAY_THUMBNAIL_OPTIONS);
+        PicassoHelper.loadPlaylistThumbnail(item.getThumbnailUrl()).into(itemThumbnailView);
 
         itemView.setOnClickListener(view -> {
             if (itemBuilder.getOnPlaylistSelectedListener() != null) {

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

@@ -15,7 +15,7 @@ import org.schabi.newpipe.extractor.stream.StreamType;
 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.ImageDisplayConstants;
+import org.schabi.newpipe.util.PicassoHelper;
 import org.schabi.newpipe.util.Localization;
 import org.schabi.newpipe.views.AnimatedProgressBar;
 
@@ -83,10 +83,7 @@ public class StreamMiniInfoItemHolder extends InfoItemHolder {
         }
 
         // Default thumbnail is shown on error, while loading and if the url is empty
-        itemBuilder.getImageLoader()
-                .displayImage(item.getThumbnailUrl(),
-                        itemThumbnailView,
-                        ImageDisplayConstants.DISPLAY_THUMBNAIL_OPTIONS);
+        PicassoHelper.loadThumbnail(item.getThumbnailUrl()).into(itemThumbnailView);
 
         itemView.setOnClickListener(view -> {
             if (itemBuilder.getOnStreamSelectedListener() != null) {

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

@@ -1,7 +1,6 @@
 package org.schabi.newpipe.local;
 
 import android.content.SharedPreferences;
-import android.content.res.Configuration;
 import android.content.res.Resources;
 import android.os.Bundle;
 import android.util.Log;
@@ -26,6 +25,7 @@ import org.schabi.newpipe.fragments.list.ListViewContract;
 
 import static org.schabi.newpipe.ktx.ViewUtils.animate;
 import static org.schabi.newpipe.ktx.ViewUtils.animateHideRecyclerViewAllowingScrolling;
+import static org.schabi.newpipe.util.ThemeHelper.shouldUseGridLayout;
 
 /**
  * This fragment is design to be used with persistent data such as
@@ -77,7 +77,7 @@ public abstract class BaseLocalListFragment<I, N> extends BaseStateFragment<I>
         super.onResume();
         if (updateFlags != 0) {
             if ((updateFlags & LIST_MODE_UPDATE_FLAG) != 0) {
-                final boolean useGrid = isGridLayout();
+                final boolean useGrid = shouldUseGridLayout(requireContext());
                 itemsList.setLayoutManager(
                         useGrid ? getGridLayoutManager() : getListLayoutManager());
                 itemListAdapter.setUseGridVariant(useGrid);
@@ -121,7 +121,7 @@ public abstract class BaseLocalListFragment<I, N> extends BaseStateFragment<I>
 
         itemListAdapter = new LocalItemListAdapter(activity);
 
-        final boolean useGrid = isGridLayout();
+        final boolean useGrid = shouldUseGridLayout(requireContext());
         itemsList = rootView.findViewById(R.id.items_list);
         itemsList.setLayoutManager(useGrid ? getGridLayoutManager() : getListLayoutManager());
 
@@ -260,17 +260,4 @@ public abstract class BaseLocalListFragment<I, N> extends BaseStateFragment<I>
             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);
-        }
-    }
 }

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

@@ -1,10 +1,6 @@
 package org.schabi.newpipe.local;
 
 import android.content.Context;
-import android.widget.ImageView;
-
-import com.nostra13.universalimageloader.core.DisplayImageOptions;
-import com.nostra13.universalimageloader.core.ImageLoader;
 
 import org.schabi.newpipe.database.LocalItem;
 import org.schabi.newpipe.util.OnClickGesture;
@@ -31,7 +27,6 @@ import org.schabi.newpipe.util.OnClickGesture;
 
 public class LocalItemBuilder {
     private final Context context;
-    private final ImageLoader imageLoader = ImageLoader.getInstance();
 
     private OnClickGesture<LocalItem> onSelectedListener;
 
@@ -43,11 +38,6 @@ public class LocalItemBuilder {
         return context;
     }
 
-    public void displayImage(final String url, final ImageView view,
-                             final DisplayImageOptions options) {
-        imageLoader.displayImage(url, view, options);
-    }
-
     public OnClickGesture<LocalItem> getOnItemSelectedListener() {
         return onSelectedListener;
     }

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

@@ -2,11 +2,11 @@ package org.schabi.newpipe.local.bookmark;
 
 import android.os.Bundle;
 import android.os.Parcelable;
+import android.text.InputType;
 import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
-import android.widget.EditText;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -22,6 +22,7 @@ import org.schabi.newpipe.database.LocalItem;
 import org.schabi.newpipe.database.playlist.PlaylistLocalItem;
 import org.schabi.newpipe.database.playlist.PlaylistMetadataEntry;
 import org.schabi.newpipe.database.playlist.model.PlaylistRemoteEntity;
+import org.schabi.newpipe.databinding.DialogEditTextBinding;
 import org.schabi.newpipe.error.ErrorInfo;
 import org.schabi.newpipe.error.UserAction;
 import org.schabi.newpipe.local.BaseLocalListFragment;
@@ -255,14 +256,18 @@ public final class BookmarkFragment extends BaseLocalListFragment<List<PlaylistL
     }
 
     private void showLocalDialog(final PlaylistMetadataEntry selectedItem) {
-        final View dialogView = View.inflate(getContext(), R.layout.dialog_bookmark, null);
-        final EditText editText = dialogView.findViewById(R.id.playlist_name_edit_text);
-        editText.setText(selectedItem.name);
+        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(dialogView)
+        builder.setView(dialogBinding.getRoot())
                 .setPositiveButton(R.string.rename_playlist, (dialog, which) ->
-                        changeLocalPlaylistName(selectedItem.uid, editText.getText().toString()))
+                        changeLocalPlaylistName(
+                                selectedItem.uid,
+                                dialogBinding.dialogEditText.getText().toString()))
                 .setNegativeButton(R.string.cancel, null)
                 .setNeutralButton(R.string.delete, (dialog, which) -> {
                     showDeleteDialog(selectedItem.name,

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

@@ -2,8 +2,7 @@ package org.schabi.newpipe.local.dialog;
 
 import android.app.Dialog;
 import android.os.Bundle;
-import android.view.View;
-import android.widget.EditText;
+import android.text.InputType;
 import android.widget.Toast;
 
 import androidx.annotation.NonNull;
@@ -13,6 +12,7 @@ import androidx.appcompat.app.AlertDialog;
 import org.schabi.newpipe.NewPipeDatabase;
 import org.schabi.newpipe.R;
 import org.schabi.newpipe.database.stream.model.StreamEntity;
+import org.schabi.newpipe.databinding.DialogEditTextBinding;
 import org.schabi.newpipe.local.playlist.LocalPlaylistManager;
 
 import java.util.List;
@@ -43,16 +43,18 @@ public final class PlaylistCreationDialog extends PlaylistDialog {
             return super.onCreateDialog(savedInstanceState);
         }
 
-        final View dialogView = View.inflate(getContext(), R.layout.dialog_playlist_name, null);
-        final EditText nameInput = dialogView.findViewById(R.id.playlist_name);
+        final DialogEditTextBinding dialogBinding
+                = DialogEditTextBinding.inflate(getLayoutInflater());
+        dialogBinding.dialogEditText.setHint(R.string.name);
+        dialogBinding.dialogEditText.setInputType(InputType.TYPE_CLASS_TEXT);
 
         final AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(requireContext())
                 .setTitle(R.string.create_playlist)
-                .setView(dialogView)
+                .setView(dialogBinding.getRoot())
                 .setCancelable(true)
                 .setNegativeButton(R.string.cancel, null)
                 .setPositiveButton(R.string.create, (dialogInterface, i) -> {
-                    final String name = nameInput.getText().toString();
+                    final String name = dialogBinding.dialogEditText.getText().toString();
                     final LocalPlaylistManager playlistManager =
                             new LocalPlaylistManager(NewPipeDatabase.getInstance(requireContext()));
                     final Toast successToast = Toast.makeText(getActivity(),

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

@@ -23,7 +23,6 @@ import android.annotation.SuppressLint
 import android.app.Activity
 import android.content.Intent
 import android.content.SharedPreferences
-import android.content.res.Configuration
 import android.os.Bundle
 import android.os.Parcelable
 import android.view.LayoutInflater
@@ -74,10 +73,10 @@ import org.schabi.newpipe.player.helper.PlayerHolder
 import org.schabi.newpipe.util.Localization
 import org.schabi.newpipe.util.NavigationHelper
 import org.schabi.newpipe.util.StreamDialogEntry
+import org.schabi.newpipe.util.ThemeHelper.getGridSpanCountStreams
+import org.schabi.newpipe.util.ThemeHelper.shouldUseGridLayout
 import java.time.OffsetDateTime
 import java.util.ArrayList
-import kotlin.math.floor
-import kotlin.math.max
 
 class FeedFragment : BaseStateFragment<FeedState>() {
     private var _feedBinding: FragmentFeedBinding? = null
@@ -97,6 +96,7 @@ class FeedFragment : BaseStateFragment<FeedState>() {
 
     private var onSettingsChangeListener: SharedPreferences.OnSharedPreferenceChangeListener? = null
     private var updateListViewModeOnResume = false
+    private var isRefreshing = false
 
     init {
         setHasOptionsMenu(true)
@@ -161,20 +161,12 @@ class FeedFragment : BaseStateFragment<FeedState>() {
 
     fun setupListViewMode() {
         // does everything needed to setup the layouts for grid or list modes
-        groupAdapter.spanCount = if (shouldUseGridLayout()) getGridSpanCount() else 1
+        groupAdapter.spanCount = if (shouldUseGridLayout(context)) getGridSpanCountStreams(context) else 1
         feedBinding.itemsList.layoutManager = GridLayoutManager(requireContext(), groupAdapter.spanCount).apply {
             spanSizeLookup = groupAdapter.spanSizeLookup
         }
     }
 
-    override fun setUserVisibleHint(isVisibleToUser: Boolean) {
-        super.setUserVisibleHint(isVisibleToUser)
-
-        if (!isVisibleToUser && view != null) {
-            updateRelativeTimeViews()
-        }
-    }
-
     override fun initListeners() {
         super.initListeners()
         feedBinding.refreshRootView.setOnClickListener { reloadContent() }
@@ -214,7 +206,7 @@ class FeedFragment : BaseStateFragment<FeedState>() {
                         putBoolean(getString(R.string.feed_use_dedicated_fetch_method_key), !usingDedicatedMethod)
                     }
                 }
-                .setPositiveButton(resources.getString(R.string.finish), null)
+                .setPositiveButton(resources.getString(R.string.ok), null)
                 .create()
                 .show()
             return true
@@ -268,6 +260,7 @@ class FeedFragment : BaseStateFragment<FeedState>() {
         feedBinding.refreshRootView.animate(false, 0)
         feedBinding.loadingProgressText.animate(true, 200)
         feedBinding.swipeRefreshLayout.isRefreshing = true
+        isRefreshing = true
     }
 
     override fun hideLoading() {
@@ -276,6 +269,7 @@ class FeedFragment : BaseStateFragment<FeedState>() {
         feedBinding.refreshRootView.animate(true, 200)
         feedBinding.loadingProgressText.animate(false, 0)
         feedBinding.swipeRefreshLayout.isRefreshing = false
+        isRefreshing = false
     }
 
     override fun showEmptyState() {
@@ -302,6 +296,7 @@ class FeedFragment : BaseStateFragment<FeedState>() {
         feedBinding.refreshRootView.animate(false, 0)
         feedBinding.loadingProgressText.animate(false, 0)
         feedBinding.swipeRefreshLayout.isRefreshing = false
+        isRefreshing = false
     }
 
     private fun handleProgressState(progressState: FeedState.ProgressState) {
@@ -331,7 +326,7 @@ class FeedFragment : BaseStateFragment<FeedState>() {
         if (context == null || context.resources == null || activity == null) return
 
         val entries = ArrayList<StreamDialogEntry>()
-        if (PlayerHolder.getType() != null) {
+        if (PlayerHolder.getInstance().getType() != null) {
             entries.add(StreamDialogEntry.enqueue)
         }
         if (item.streamType == StreamType.AUDIO_STREAM) {
@@ -355,6 +350,20 @@ class FeedFragment : BaseStateFragment<FeedState>() {
             )
         }
 
+        // show "mark as watched" only when watch history is enabled
+        val isWatchHistoryEnabled = PreferenceManager
+            .getDefaultSharedPreferences(context)
+            .getBoolean(getString(R.string.enable_watch_history_key), false)
+        if (item.streamType != StreamType.AUDIO_LIVE_STREAM &&
+            item.streamType != StreamType.LIVE_STREAM &&
+            isWatchHistoryEnabled
+        ) {
+            entries.add(
+                StreamDialogEntry.mark_as_watched
+            )
+        }
+        entries.add(StreamDialogEntry.show_channel_details)
+
         StreamDialogEntry.setEnabledEntries(entries)
         InfoItemDialog(activity, item, StreamDialogEntry.getCommands(context)) { _, which ->
             StreamDialogEntry.clickOn(which, this, item)
@@ -363,7 +372,7 @@ class FeedFragment : BaseStateFragment<FeedState>() {
 
     private val listenerStreamItem = object : OnItemClickListener, OnItemLongClickListener {
         override fun onItemClick(item: Item<*>, view: View) {
-            if (item is StreamItem) {
+            if (item is StreamItem && !isRefreshing) {
                 val stream = item.streamWithState.stream
                 NavigationHelper.openVideoDetailFragment(
                     requireContext(), fm,
@@ -373,7 +382,7 @@ class FeedFragment : BaseStateFragment<FeedState>() {
         }
 
         override fun onItemLongClick(item: Item<*>, view: View): Boolean {
-            if (item is StreamItem) {
+            if (item is StreamItem && !isRefreshing) {
                 showStreamDialog(item.streamWithState.stream.toStreamInfoItem())
                 return true
             }
@@ -384,7 +393,7 @@ class FeedFragment : BaseStateFragment<FeedState>() {
     @SuppressLint("StringFormatMatches")
     private fun handleLoadedState(loadedState: FeedState.LoadedState) {
 
-        val itemVersion = if (shouldUseGridLayout()) {
+        val itemVersion = if (shouldUseGridLayout(context)) {
             StreamItem.ItemVersion.GRID
         } else {
             StreamItem.ItemVersion.NORMAL
@@ -528,35 +537,6 @@ class FeedFragment : BaseStateFragment<FeedState>() {
         listState = null
     }
 
-    // /////////////////////////////////////////////////////////////////////////
-    // Grid Mode
-    // /////////////////////////////////////////////////////////////////////////
-
-    // TODO: Move these out of this class, as it can be reused
-
-    private fun shouldUseGridLayout(): Boolean {
-        val listMode = PreferenceManager.getDefaultSharedPreferences(requireContext())
-            .getString(getString(R.string.list_view_mode_key), getString(R.string.list_view_mode_value))
-
-        return when (listMode) {
-            getString(R.string.list_view_mode_auto_key) -> {
-                val configuration = resources.configuration
-
-                (
-                    configuration.orientation == Configuration.ORIENTATION_LANDSCAPE &&
-                        configuration.isLayoutSizeAtLeast(Configuration.SCREENLAYOUT_SIZE_LARGE)
-                    )
-            }
-            getString(R.string.list_view_mode_grid_key) -> true
-            else -> false
-        }
-    }
-
-    private fun getGridSpanCount(): Int {
-        val minWidth = resources.getDimensionPixelSize(R.dimen.video_item_grid_thumbnail_image_width)
-        return max(1, floor(resources.displayMetrics.widthPixels / minWidth.toDouble()).toInt())
-    }
-
     companion object {
         const val KEY_GROUP_ID = "ARG_GROUP_ID"
         const val KEY_GROUP_NAME = "ARG_GROUP_NAME"

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

@@ -5,7 +5,6 @@ import android.text.TextUtils
 import android.view.View
 import androidx.core.content.ContextCompat
 import androidx.preference.PreferenceManager
-import com.nostra13.universalimageloader.core.ImageLoader
 import com.xwray.groupie.viewbinding.BindableItem
 import org.schabi.newpipe.MainActivity
 import org.schabi.newpipe.R
@@ -16,8 +15,8 @@ import org.schabi.newpipe.extractor.stream.StreamType.AUDIO_LIVE_STREAM
 import org.schabi.newpipe.extractor.stream.StreamType.AUDIO_STREAM
 import org.schabi.newpipe.extractor.stream.StreamType.LIVE_STREAM
 import org.schabi.newpipe.extractor.stream.StreamType.VIDEO_STREAM
-import org.schabi.newpipe.util.ImageDisplayConstants
 import org.schabi.newpipe.util.Localization
+import org.schabi.newpipe.util.PicassoHelper
 import java.util.concurrent.TimeUnit
 
 data class StreamItem(
@@ -93,10 +92,7 @@ data class StreamItem(
             viewBinding.itemProgressView.visibility = View.GONE
         }
 
-        ImageLoader.getInstance().displayImage(
-            stream.thumbnailUrl, viewBinding.itemThumbnailView,
-            ImageDisplayConstants.DISPLAY_THUMBNAIL_OPTIONS
-        )
+        PicassoHelper.loadThumbnail(stream.thumbnailUrl).into(viewBinding.itemThumbnailView)
 
         if (itemVersion != ItemVersion.MINI) {
             viewBinding.itemAdditionalDetails.text =

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

@@ -300,6 +300,12 @@ class FeedLoadService : Service() {
                         .subscribeOn(Schedulers.io())
                         .observeOn(AndroidSchedulers.mainThread())
                         .subscribe { _, throwable ->
+                            // There seems to be a bug in the kotlin plugin as it tells you when
+                            // building that this can't be null:
+                            // "Condition 'throwable != null' is always 'true'"
+                            // However it can indeed be null
+                            // The suppression may be removed in further versions
+                            @Suppress("SENSELESS_COMPARISON")
                             if (throwable != null) {
                                 Log.e(TAG, "Error while storing result", throwable)
                                 handleError(throwable)

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

@@ -28,6 +28,7 @@ import org.schabi.newpipe.NewPipeDatabase;
 import org.schabi.newpipe.R;
 import org.schabi.newpipe.database.AppDatabase;
 import org.schabi.newpipe.database.LocalItem;
+import org.schabi.newpipe.database.feed.dao.FeedDAO;
 import org.schabi.newpipe.database.history.dao.SearchHistoryDAO;
 import org.schabi.newpipe.database.history.dao.StreamHistoryDAO;
 import org.schabi.newpipe.database.history.model.SearchHistoryEntry;
@@ -42,7 +43,10 @@ import org.schabi.newpipe.database.stream.model.StreamEntity;
 import org.schabi.newpipe.database.stream.model.StreamStateEntity;
 import org.schabi.newpipe.extractor.InfoItem;
 import org.schabi.newpipe.extractor.stream.StreamInfo;
+import org.schabi.newpipe.extractor.stream.StreamInfoItem;
+import org.schabi.newpipe.local.feed.FeedViewModel;
 import org.schabi.newpipe.player.playqueue.PlayQueueItem;
+import org.schabi.newpipe.util.ExtractorHelper;
 
 import java.time.OffsetDateTime;
 import java.time.ZoneOffset;
@@ -81,6 +85,68 @@ public class HistoryRecordManager {
     // Watch History
     ///////////////////////////////////////////////////////
 
+    /**
+     * 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 FeedDAO#getLiveOrNotPlayedStreams
+     * @see FeedViewModel#togglePlayedItems
+     * @param info the item to mark as watched
+     * @return a Maybe containing the ID of the item if successful
+     */
+    public Maybe<Long> markAsWatched(final StreamInfoItem info) {
+        if (!isStreamHistoryEnabled()) {
+            return Maybe.empty();
+        }
+
+        final OffsetDateTime currentTime = OffsetDateTime.now(ZoneOffset.UTC);
+        return Maybe.fromCallable(() -> database.runInTransaction(() -> {
+            final long streamId;
+            final long duration;
+            // Duration will not exist if the item was loaded with fast mode, so fetch it if empty
+            if (info.getDuration() < 0) {
+                final StreamInfo completeInfo = ExtractorHelper.getStreamInfo(
+                        info.getServiceId(),
+                        info.getUrl(),
+                        false
+                )
+                        .subscribeOn(Schedulers.io())
+                        .blockingGet();
+                duration = completeInfo.getDuration();
+                streamId = streamTable.upsert(new StreamEntity(completeInfo));
+            } else {
+                duration = info.getDuration();
+                streamId = streamTable.upsert(new StreamEntity(info));
+            }
+
+            // Update the stream progress to the full duration of the video
+            final List<StreamStateEntity> states = streamStateTable.getState(streamId)
+                    .blockingFirst();
+            if (!states.isEmpty()) {
+                final StreamStateEntity entity = states.get(0);
+                entity.setProgressMillis(duration * 1000);
+                streamStateTable.update(entity);
+            } else {
+                final StreamStateEntity entity = new StreamStateEntity(
+                        streamId,
+                        duration * 1000
+                );
+                streamStateTable.insert(entity);
+            }
+
+            // Add a history entry
+            final StreamHistoryEntity latestEntry = streamHistoryTable.getLatestEntry(streamId);
+            if (latestEntry != null) {
+                streamHistoryTable.delete(latestEntry);
+                latestEntry.setAccessDate(currentTime);
+                latestEntry.setRepeatCount(latestEntry.getRepeatCount() + 1);
+                return streamHistoryTable.insert(latestEntry);
+            } else {
+                return streamHistoryTable.insert(new StreamHistoryEntity(streamId, currentTime));
+            }
+        })).subscribeOn(Schedulers.io());
+    }
+
     public Maybe<Long> onViewed(final StreamInfo info) {
         if (!isStreamHistoryEnabled()) {
             return Maybe.empty();

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

@@ -53,8 +53,6 @@ import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
 import io.reactivex.rxjava3.disposables.CompositeDisposable;
 import io.reactivex.rxjava3.disposables.Disposable;
 
-import static org.schabi.newpipe.extractor.utils.Utils.isNullOrEmpty;
-
 public class StatisticsPlaylistFragment
         extends BaseLocalListFragment<List<StreamStatisticsEntry>, Void> {
     private final CompositeDisposable disposables = new CompositeDisposable();
@@ -340,7 +338,7 @@ public class StatisticsPlaylistFragment
 
         final ArrayList<StreamDialogEntry> entries = new ArrayList<>();
 
-        if (PlayerHolder.getType() != null) {
+        if (PlayerHolder.getInstance().getType() != null) {
             entries.add(StreamDialogEntry.enqueue);
         }
         if (infoItem.getStreamType() == StreamType.AUDIO_STREAM) {
@@ -363,10 +361,7 @@ public class StatisticsPlaylistFragment
         if (KoreUtils.shouldShowPlayWithKodi(context, infoItem.getServiceId())) {
             entries.add(StreamDialogEntry.play_with_kodi);
         }
-
-        if (!isNullOrEmpty(infoItem.getUploaderUrl())) {
-            entries.add(StreamDialogEntry.show_channel_details);
-        }
+        entries.add(StreamDialogEntry.show_channel_details);
 
         StreamDialogEntry.setEnabledEntries(entries);
 

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

@@ -7,7 +7,7 @@ import org.schabi.newpipe.database.LocalItem;
 import org.schabi.newpipe.database.playlist.PlaylistMetadataEntry;
 import org.schabi.newpipe.local.LocalItemBuilder;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
-import org.schabi.newpipe.util.ImageDisplayConstants;
+import org.schabi.newpipe.util.PicassoHelper;
 import org.schabi.newpipe.util.Localization;
 
 import java.time.format.DateTimeFormatter;
@@ -36,8 +36,7 @@ public class LocalPlaylistItemHolder extends PlaylistItemHolder {
                 itemStreamCountView.getContext(), item.streamCount));
         itemUploaderView.setVisibility(View.INVISIBLE);
 
-        itemBuilder.displayImage(item.thumbnailUrl, itemThumbnailView,
-                ImageDisplayConstants.DISPLAY_PLAYLIST_OPTIONS);
+        PicassoHelper.loadPlaylistThumbnail(item.thumbnailUrl).into(itemThumbnailView);
 
         super.updateFromItem(localItem, historyRecordManager, dateTimeFormatter);
     }

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

@@ -15,7 +15,7 @@ import org.schabi.newpipe.extractor.NewPipe;
 import org.schabi.newpipe.ktx.ViewUtils;
 import org.schabi.newpipe.local.LocalItemBuilder;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
-import org.schabi.newpipe.util.ImageDisplayConstants;
+import org.schabi.newpipe.util.PicassoHelper;
 import org.schabi.newpipe.util.Localization;
 import org.schabi.newpipe.views.AnimatedProgressBar;
 
@@ -81,8 +81,8 @@ public class LocalPlaylistStreamItemHolder extends LocalItemHolder {
         }
 
         // Default thumbnail is shown on error, while loading and if the url is empty
-        itemBuilder.displayImage(item.getStreamEntity().getThumbnailUrl(), itemThumbnailView,
-                ImageDisplayConstants.DISPLAY_THUMBNAIL_OPTIONS);
+        PicassoHelper.loadThumbnail(item.getStreamEntity().getThumbnailUrl())
+                .into(itemThumbnailView);
 
         itemView.setOnClickListener(view -> {
             if (itemBuilder.getOnItemSelectedListener() != null) {

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

@@ -15,7 +15,7 @@ import org.schabi.newpipe.extractor.NewPipe;
 import org.schabi.newpipe.ktx.ViewUtils;
 import org.schabi.newpipe.local.LocalItemBuilder;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
-import org.schabi.newpipe.util.ImageDisplayConstants;
+import org.schabi.newpipe.util.PicassoHelper;
 import org.schabi.newpipe.util.Localization;
 import org.schabi.newpipe.views.AnimatedProgressBar;
 
@@ -114,8 +114,8 @@ public class LocalStatisticStreamItemHolder extends LocalItemHolder {
         }
 
         // Default thumbnail is shown on error, while loading and if the url is empty
-        itemBuilder.displayImage(item.getStreamEntity().getThumbnailUrl(), itemThumbnailView,
-                ImageDisplayConstants.DISPLAY_THUMBNAIL_OPTIONS);
+        PicassoHelper.loadThumbnail(item.getStreamEntity().getThumbnailUrl())
+                .into(itemThumbnailView);
 
         itemView.setOnClickListener(view -> {
             if (itemBuilder.getOnItemSelectedListener() != null) {

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

@@ -8,7 +8,7 @@ import org.schabi.newpipe.database.playlist.model.PlaylistRemoteEntity;
 import org.schabi.newpipe.extractor.NewPipe;
 import org.schabi.newpipe.local.LocalItemBuilder;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
-import org.schabi.newpipe.util.ImageDisplayConstants;
+import org.schabi.newpipe.util.PicassoHelper;
 import org.schabi.newpipe.util.Localization;
 
 import java.time.format.DateTimeFormatter;
@@ -44,9 +44,7 @@ public class RemotePlaylistItemHolder extends PlaylistItemHolder {
             itemUploaderView.setText(NewPipe.getNameOfService(item.getServiceId()));
         }
 
-
-        itemBuilder.displayImage(item.getThumbnailUrl(), itemThumbnailView,
-                ImageDisplayConstants.DISPLAY_PLAYLIST_OPTIONS);
+        PicassoHelper.loadPlaylistThumbnail(item.getThumbnailUrl()).into(itemThumbnailView);
 
         super.updateFromItem(localItem, historyRecordManager, dateTimeFormatter);
     }

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

@@ -5,6 +5,7 @@ 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.view.LayoutInflater;
@@ -13,7 +14,6 @@ import android.view.MenuInflater;
 import android.view.MenuItem;
 import android.view.View;
 import android.view.ViewGroup;
-import android.widget.EditText;
 import android.widget.Toast;
 
 import androidx.annotation.NonNull;
@@ -32,6 +32,7 @@ import org.schabi.newpipe.database.history.model.StreamHistoryEntry;
 import org.schabi.newpipe.database.playlist.PlaylistStreamEntry;
 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;
 import org.schabi.newpipe.error.ErrorInfo;
@@ -66,8 +67,8 @@ import io.reactivex.rxjava3.disposables.Disposable;
 import io.reactivex.rxjava3.schedulers.Schedulers;
 import io.reactivex.rxjava3.subjects.PublishSubject;
 
-import static org.schabi.newpipe.extractor.utils.Utils.isNullOrEmpty;
 import static org.schabi.newpipe.ktx.ViewUtils.animate;
+import static org.schabi.newpipe.util.ThemeHelper.shouldUseGridLayout;
 
 public class LocalPlaylistFragment extends BaseLocalListFragment<List<PlaylistStreamEntry>, Void> {
     // Save the list 10 seconds after the last change occurred
@@ -525,18 +526,20 @@ public class LocalPlaylistFragment extends BaseLocalListFragment<List<PlaylistSt
             return;
         }
 
-        final View dialogView = View.inflate(getContext(), R.layout.dialog_playlist_name, null);
-        final EditText nameEdit = dialogView.findViewById(R.id.playlist_name);
-        nameEdit.setText(name);
-        nameEdit.setSelection(nameEdit.getText().length());
+        final DialogEditTextBinding dialogBinding
+                = DialogEditTextBinding.inflate(getLayoutInflater());
+        dialogBinding.dialogEditText.setHint(R.string.name);
+        dialogBinding.dialogEditText.setInputType(InputType.TYPE_CLASS_TEXT);
+        dialogBinding.dialogEditText.setSelection(dialogBinding.dialogEditText.getText().length());
+        dialogBinding.dialogEditText.setText(name);
 
         final AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(getContext())
                 .setTitle(R.string.rename_playlist)
-                .setView(dialogView)
+                .setView(dialogBinding.getRoot())
                 .setCancelable(true)
                 .setNegativeButton(R.string.cancel, null)
                 .setPositiveButton(R.string.rename, (dialogInterface, i) ->
-                        changePlaylistName(nameEdit.getText().toString()));
+                        changePlaylistName(dialogBinding.dialogEditText.getText().toString()));
 
         dialogBuilder.show();
     }
@@ -678,7 +681,7 @@ public class LocalPlaylistFragment extends BaseLocalListFragment<List<PlaylistSt
 
     private ItemTouchHelper.SimpleCallback getItemTouchCallback() {
         int directions = ItemTouchHelper.UP | ItemTouchHelper.DOWN;
-        if (isGridLayout()) {
+        if (shouldUseGridLayout(requireContext())) {
             directions |= ItemTouchHelper.LEFT | ItemTouchHelper.RIGHT;
         }
         return new ItemTouchHelper.SimpleCallback(directions,
@@ -749,7 +752,7 @@ public class LocalPlaylistFragment extends BaseLocalListFragment<List<PlaylistSt
 
         final ArrayList<StreamDialogEntry> entries = new ArrayList<>();
 
-        if (PlayerHolder.getType() != null) {
+        if (PlayerHolder.getInstance().getType() != null) {
             entries.add(StreamDialogEntry.enqueue);
         }
         if (infoItem.getStreamType() == StreamType.AUDIO_STREAM) {
@@ -774,10 +777,7 @@ public class LocalPlaylistFragment extends BaseLocalListFragment<List<PlaylistSt
         if (KoreUtils.shouldShowPlayWithKodi(context, infoItem.getServiceId())) {
             entries.add(StreamDialogEntry.play_with_kodi);
         }
-
-        if (!isNullOrEmpty(infoItem.getUploaderUrl())) {
-            entries.add(StreamDialogEntry.show_channel_details);
-        }
+        entries.add(StreamDialogEntry.show_channel_details);
 
         StreamDialogEntry.setEnabledEntries(entries);
 

app/src/main/java/org/schabi/newpipe/local/subscription/ImportConfirmationDialog.java

@@ -40,7 +40,7 @@ public class ImportConfirmationDialog extends DialogFragment {
                 .setMessage(R.string.import_network_expensive_warning)
                 .setCancelable(true)
                 .setNegativeButton(R.string.cancel, null)
-                .setPositiveButton(R.string.finish, (dialogInterface, i) -> {
+                .setPositiveButton(R.string.ok, (dialogInterface, i) -> {
                     if (resultServiceIntent != null && getContext() != null) {
                         getContext().startService(resultServiceIntent);
                     }

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

@@ -6,7 +6,6 @@ import android.content.Context
 import android.content.DialogInterface
 import android.content.Intent
 import android.content.IntentFilter
-import android.content.res.Configuration
 import android.os.Bundle
 import android.os.Parcelable
 import android.view.LayoutInflater
@@ -20,7 +19,6 @@ import androidx.activity.result.contract.ActivityResultContracts.StartActivityFo
 import androidx.appcompat.app.AlertDialog
 import androidx.lifecycle.ViewModelProvider
 import androidx.localbroadcastmanager.content.LocalBroadcastManager
-import androidx.preference.PreferenceManager
 import androidx.recyclerview.widget.GridLayoutManager
 import com.xwray.groupie.Group
 import com.xwray.groupie.GroupAdapter
@@ -60,12 +58,12 @@ import org.schabi.newpipe.local.subscription.services.SubscriptionsImportService
 import org.schabi.newpipe.streams.io.StoredFileHelper
 import org.schabi.newpipe.util.NavigationHelper
 import org.schabi.newpipe.util.OnClickGesture
+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
 import java.util.Locale
-import kotlin.math.floor
-import kotlin.math.max
 
 class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
     private var _binding: FragmentSubscriptionBinding? = null
@@ -112,13 +110,6 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
         setupInitialLayout()
     }
 
-    override fun setUserVisibleHint(isVisibleToUser: Boolean) {
-        super.setUserVisibleHint(isVisibleToUser)
-        if (activity != null && isVisibleToUser) {
-            setTitle(activity.getString(R.string.tab_subscriptions))
-        }
-    }
-
     override fun onAttach(context: Context) {
         super.onAttach(context)
         subscriptionManager = SubscriptionManager(requireContext())
@@ -156,11 +147,8 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
     override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
         super.onCreateOptionsMenu(menu, inflater)
 
-        val supportActionBar = activity.supportActionBar
-        if (supportActionBar != null) {
-            supportActionBar.setDisplayShowTitleEnabled(true)
-            setTitle(getString(R.string.tab_subscriptions))
-        }
+        activity.supportActionBar?.setDisplayShowTitleEnabled(true)
+        activity.supportActionBar?.setTitle(R.string.tab_subscriptions)
     }
 
     private fun setupBroadcastReceiver() {
@@ -191,7 +179,7 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
     }
 
     private fun onImportPreviousSelected() {
-        requestImportLauncher.launch(StoredFileHelper.getPicker(activity))
+        requestImportLauncher.launch(StoredFileHelper.getPicker(activity, JSON_MIME_TYPE))
     }
 
     private fun onExportSelected() {
@@ -199,7 +187,7 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
         val exportName = "newpipe_subscriptions_$date.json"
 
         requestExportLauncher.launch(
-            StoredFileHelper.getNewPicker(activity, exportName, "application/json", null)
+            StoredFileHelper.getNewPicker(activity, exportName, JSON_MIME_TYPE, null)
         )
     }
 
@@ -207,7 +195,7 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
         FeedGroupReorderDialog().show(parentFragmentManager, null)
     }
 
-    fun requestExportResult(result: ActivityResult) {
+    private fun requestExportResult(result: ActivityResult) {
         if (result.data != null && result.resultCode == Activity.RESULT_OK) {
             activity.startService(
                 Intent(activity, SubscriptionsExportService::class.java)
@@ -216,7 +204,7 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
         }
     }
 
-    fun requestImportResult(result: ActivityResult) {
+    private fun requestImportResult(result: ActivityResult) {
         if (result.data != null && result.resultCode == Activity.RESULT_OK) {
             ImportConfirmationDialog.show(
                 this,
@@ -279,8 +267,7 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
         super.initViews(rootView, savedInstanceState)
         _binding = FragmentSubscriptionBinding.bind(rootView)
 
-        val shouldUseGridLayout = shouldUseGridLayout()
-        groupAdapter.spanCount = if (shouldUseGridLayout) getGridSpanCount() else 1
+        groupAdapter.spanCount = if (shouldUseGridLayout(context)) getGridSpanCountChannels(context) else 1
         binding.itemsList.layoutManager = GridLayoutManager(requireContext(), groupAdapter.spanCount).apply {
             spanSizeLookup = groupAdapter.spanSizeLookup
         }
@@ -359,7 +346,7 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
     override fun handleResult(result: SubscriptionState) {
         super.handleResult(result)
 
-        val shouldUseGridLayout = shouldUseGridLayout()
+        val shouldUseGridLayout = shouldUseGridLayout(context)
         when (result) {
             is SubscriptionState.LoadedState -> {
                 result.subscriptions.forEach {
@@ -421,29 +408,7 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
         binding.itemsList.animate(true, 200)
     }
 
-    // /////////////////////////////////////////////////////////////////////////
-    // Grid Mode
-    // /////////////////////////////////////////////////////////////////////////
-
-    // TODO: Move these out of this class, as it can be reused
-
-    private fun shouldUseGridLayout(): Boolean {
-        val listMode = PreferenceManager.getDefaultSharedPreferences(requireContext())
-            .getString(getString(R.string.list_view_mode_key), getString(R.string.list_view_mode_value))
-
-        return when (listMode) {
-            getString(R.string.list_view_mode_auto_key) -> {
-                val configuration = resources.configuration
-                configuration.orientation == Configuration.ORIENTATION_LANDSCAPE &&
-                    configuration.isLayoutSizeAtLeast(Configuration.SCREENLAYOUT_SIZE_LARGE)
-            }
-            getString(R.string.list_view_mode_grid_key) -> true
-            else -> false
-        }
-    }
-
-    private fun getGridSpanCount(): Int {
-        val minWidth = resources.getDimensionPixelSize(R.dimen.channel_item_grid_min_width)
-        return max(1, floor(resources.displayMetrics.widthPixels / minWidth.toDouble()).toInt())
+    companion object {
+        const val JSON_MIME_TYPE = "application/json"
     }
 }

app/src/main/java/org/schabi/newpipe/local/subscription/SubscriptionsImportFragment.java

@@ -177,7 +177,8 @@ public class SubscriptionsImportFragment extends BaseFragment {
     }
 
     public void onImportFile() {
-        requestImportFileLauncher.launch(StoredFileHelper.getPicker(activity));
+        // leave */* mime type to support all services with different mime types and file extensions
+        requestImportFileLauncher.launch(StoredFileHelper.getPicker(activity, "*/*"));
     }
 
     private void requestImportFileResult(final ActivityResult result) {

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

@@ -143,21 +143,15 @@ class FeedGroupDialog : DialogFragment(), BackPressable {
         ).get(FeedGroupDialogViewModel::class.java)
 
         viewModel.groupLiveData.observe(viewLifecycleOwner, Observer(::handleGroup))
-        viewModel.subscriptionsLiveData.observe(
-            viewLifecycleOwner,
-            Observer {
-                setupSubscriptionPicker(it.first, it.second)
+        viewModel.subscriptionsLiveData.observe(viewLifecycleOwner) {
+            setupSubscriptionPicker(it.first, it.second)
+        }
+        viewModel.dialogEventLiveData.observe(viewLifecycleOwner) {
+            when (it) {
+                ProcessingEvent -> disableInput()
+                SuccessEvent -> dismiss()
             }
-        )
-        viewModel.dialogEventLiveData.observe(
-            viewLifecycleOwner,
-            Observer {
-                when (it) {
-                    ProcessingEvent -> disableInput()
-                    SuccessEvent -> dismiss()
-                }
-            }
-        )
+        }
 
         subscriptionGroupAdapter = GroupAdapter<GroupieViewHolder>().apply {
             add(subscriptionMainSection)
@@ -437,7 +431,7 @@ class FeedGroupDialog : DialogFragment(), BackPressable {
         feedGroupCreateBinding.confirmButton.setText(
             when {
                 currentScreen == InitialScreen && groupId == NO_GROUP_SELECTED -> R.string.create
-                else -> android.R.string.ok
+                else -> R.string.ok
             }
         )
 

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

@@ -3,14 +3,13 @@ package org.schabi.newpipe.local.subscription.item
 import android.content.Context
 import android.widget.ImageView
 import android.widget.TextView
-import com.nostra13.universalimageloader.core.ImageLoader
 import com.xwray.groupie.GroupieViewHolder
 import com.xwray.groupie.Item
 import org.schabi.newpipe.R
 import org.schabi.newpipe.extractor.channel.ChannelInfoItem
-import org.schabi.newpipe.util.ImageDisplayConstants
 import org.schabi.newpipe.util.Localization
 import org.schabi.newpipe.util.OnClickGesture
+import org.schabi.newpipe.util.PicassoHelper
 
 class ChannelItem(
     private val infoItem: ChannelInfoItem,
@@ -40,10 +39,7 @@ class ChannelItem(
             itemChannelDescriptionView.text = infoItem.description
         }
 
-        ImageLoader.getInstance().displayImage(
-            infoItem.thumbnailUrl, itemThumbnailView,
-            ImageDisplayConstants.DISPLAY_THUMBNAIL_OPTIONS
-        )
+        PicassoHelper.loadThumbnail(infoItem.thumbnailUrl).into(itemThumbnailView)
 
         gesturesListener?.run {
             viewHolder.root.setOnClickListener { selected(infoItem) }

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

@@ -1,23 +0,0 @@
-package org.schabi.newpipe.local.subscription.item
-
-import android.view.View
-import android.view.View.OnClickListener
-import com.xwray.groupie.viewbinding.BindableItem
-import org.schabi.newpipe.R
-import org.schabi.newpipe.databinding.HeaderItemBinding
-
-class HeaderItem(
-    val title: String,
-    private val onClickListener: (() -> Unit)? = null
-) : BindableItem<HeaderItemBinding>() {
-    override fun getLayout(): Int = R.layout.header_item
-
-    override fun bind(viewBinding: HeaderItemBinding, position: Int) {
-        viewBinding.headerTitle.text = title
-
-        val listener = onClickListener?.let { OnClickListener { onClickListener.invoke() } }
-        viewBinding.root.setOnClickListener(listener)
-    }
-
-    override fun initializeViewBinding(view: View) = HeaderItemBinding.bind(view)
-}

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

@@ -3,7 +3,6 @@ package org.schabi.newpipe.local.subscription.item
 import android.view.View
 import androidx.core.view.isGone
 import androidx.core.view.isVisible
-import com.nostra13.universalimageloader.core.ImageLoader
 import com.xwray.groupie.viewbinding.BindableItem
 import com.xwray.groupie.viewbinding.GroupieViewHolder
 import org.schabi.newpipe.R
@@ -11,7 +10,7 @@ import org.schabi.newpipe.database.subscription.SubscriptionEntity
 import org.schabi.newpipe.databinding.PickerSubscriptionItemBinding
 import org.schabi.newpipe.ktx.AnimationType
 import org.schabi.newpipe.ktx.animate
-import org.schabi.newpipe.util.ImageDisplayConstants
+import org.schabi.newpipe.util.PicassoHelper
 
 data class PickerSubscriptionItem(
     val subscriptionEntity: SubscriptionEntity,
@@ -22,11 +21,7 @@ data class PickerSubscriptionItem(
     override fun getSpanSize(spanCount: Int, position: Int): Int = 1
 
     override fun bind(viewBinding: PickerSubscriptionItemBinding, position: Int) {
-        ImageLoader.getInstance().displayImage(
-            subscriptionEntity.avatarUrl,
-            viewBinding.thumbnailView, ImageDisplayConstants.DISPLAY_AVATAR_OPTIONS
-        )
-
+        PicassoHelper.loadAvatar(subscriptionEntity.avatarUrl).into(viewBinding.thumbnailView)
         viewBinding.titleView.text = subscriptionEntity.name
         viewBinding.selectedHighlight.isVisible = isSelected
     }

app/src/main/java/org/schabi/newpipe/local/subscription/services/SubscriptionsImportService.java

@@ -19,6 +19,9 @@
 
 package org.schabi.newpipe.local.subscription.services;
 
+import static org.schabi.newpipe.MainActivity.DEBUG;
+import static org.schabi.newpipe.streams.io.StoredFileHelper.DEFAULT_MIME;
+
 import android.content.Intent;
 import android.net.Uri;
 import android.text.TextUtils;
@@ -46,6 +49,7 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
 import io.reactivex.rxjava3.core.Flowable;
@@ -54,9 +58,6 @@ import io.reactivex.rxjava3.functions.Consumer;
 import io.reactivex.rxjava3.functions.Function;
 import io.reactivex.rxjava3.schedulers.Schedulers;
 
-import static org.schabi.newpipe.MainActivity.DEBUG;
-import static org.schabi.newpipe.streams.io.StoredFileHelper.DEFAULT_MIME;
-
 public class SubscriptionsImportService extends BaseImportExportService {
     public static final int CHANNEL_URL_MODE = 0;
     public static final int INPUT_STREAM_MODE = 1;
@@ -89,6 +90,8 @@ public class SubscriptionsImportService extends BaseImportExportService {
     private String channelUrl;
     @Nullable
     private InputStream inputStream;
+    @Nullable
+    private String inputStreamType;
 
     @Override
     public int onStartCommand(final Intent intent, final int flags, final int startId) {
@@ -111,8 +114,20 @@ public class SubscriptionsImportService extends BaseImportExportService {
             }
 
             try {
-                inputStream = new SharpInputStream(
-                        new StoredFileHelper(this, uri, DEFAULT_MIME).getStream());
+                final StoredFileHelper fileHelper = new StoredFileHelper(this, uri, DEFAULT_MIME);
+                inputStream = new SharpInputStream(fileHelper.getStream());
+                inputStreamType = fileHelper.getType();
+
+                if (inputStreamType == null || inputStreamType.equals(DEFAULT_MIME)) {
+                    // mime type could not be determined, just take file extension
+                    final String name = fileHelper.getName();
+                    final int pointIndex = name.lastIndexOf('.');
+                    if (pointIndex == -1 || pointIndex >= name.length() - 1) {
+                        inputStreamType = DEFAULT_MIME; // no extension, will fail in the extractor
+                    } else {
+                        inputStreamType = name.substring(pointIndex + 1);
+                    }
+                }
             } catch (final IOException e) {
                 handleError(e);
                 return START_NOT_STICKY;
@@ -248,9 +263,9 @@ public class SubscriptionsImportService extends BaseImportExportService {
                 final Throwable error = notification.getError();
                 final Throwable cause = error.getCause();
                 if (error instanceof IOException) {
-                    throw (IOException) error;
+                    throw error;
                 } else if (cause instanceof IOException) {
-                    throw (IOException) cause;
+                    throw cause;
                 } else if (ExceptionUtils.isNetworkRelated(error)) {
                     throw new IOException(error);
                 }
@@ -280,9 +295,12 @@ public class SubscriptionsImportService extends BaseImportExportService {
     }
 
     private Flowable<List<SubscriptionItem>> importFromInputStream() {
+        Objects.requireNonNull(inputStream);
+        Objects.requireNonNull(inputStreamType);
+
         return Flowable.fromCallable(() -> NewPipe.getService(currentServiceId)
                 .getSubscriptionExtractor()
-                .fromInputStream(inputStream));
+                .fromInputStream(inputStream, inputStreamType));
     }
 
     private Flowable<List<SubscriptionItem>> importFromPreviousExport() {

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

@@ -24,7 +24,6 @@ import android.content.Context;
 import android.content.Intent;
 import android.os.Binder;
 import android.os.IBinder;
-import android.util.DisplayMetrics;
 import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;
@@ -36,6 +35,7 @@ import androidx.core.content.ContextCompat;
 
 import org.schabi.newpipe.App;
 import org.schabi.newpipe.databinding.PlayerBinding;
+import org.schabi.newpipe.util.DeviceUtils;
 import org.schabi.newpipe.util.ThemeHelper;
 
 import static org.schabi.newpipe.util.Localization.assureCorrectAppLanguage;
@@ -133,32 +133,29 @@ public final class MainPlayer extends Service {
         return START_NOT_STICKY;
     }
 
-    public void stop(final boolean autoplayEnabled) {
+    public void stopForImmediateReusing() {
         if (DEBUG) {
-            Log.d(TAG, "stop() called");
+            Log.d(TAG, "stopForImmediateReusing() called");
         }
 
         if (!player.exoPlayerIsNull()) {
             player.saveWasPlaying();
+
             // Releases wifi & cpu, disables keepScreenOn, etc.
-            if (!autoplayEnabled) {
-                player.pause();
-            }
             // We can't just pause the player here because it will make transition
             // from one stream to a new stream not smooth
             player.smoothStopPlayer();
             player.setRecovery();
+
             // Android TV will handle back button in case controls will be visible
             // (one more additional unneeded click while the player is hidden)
             player.hideControls(0, 0);
             player.closeItemsList();
+
             // Notification shows information about old stream but if a user selects
             // a stream from backStack it's not actual anymore
             // So we should hide the notification at all.
             // When autoplay enabled such notification flashing is annoying so skip this case
-            if (!autoplayEnabled) {
-                NotificationUtil.getInstance().cancelNotificationAndStopForeground(this);
-            }
         }
     }
 
@@ -178,7 +175,10 @@ public final class MainPlayer extends Service {
         if (DEBUG) {
             Log.d(TAG, "destroy() called");
         }
+        cleanup();
+    }
 
+    private void cleanup() {
         if (player != null) {
             // Exit from fullscreen when user closes the player via notification
             if (player.isFullscreen()) {
@@ -191,9 +191,14 @@ public final class MainPlayer extends Service {
             player.stopActivityBinding();
             player.removePopupFromView();
             player.destroy();
-        }
 
+            player = null;
+        }
+    }
+
+    public void stopService() {
         NotificationUtil.getInstance().cancelNotificationAndStopForeground(this);
+        cleanup();
         stopSelf();
     }
 
@@ -214,11 +219,8 @@ public final class MainPlayer extends Service {
     boolean isLandscape() {
         // DisplayMetrics from activity context knows about MultiWindow feature
         // while DisplayMetrics from app context doesn't
-        final DisplayMetrics metrics = (player != null
-                && player.getParentActivity() != null
-                ? player.getParentActivity().getResources()
-                : getResources()).getDisplayMetrics();
-        return metrics.heightPixels < metrics.widthPixels;
+        return DeviceUtils.isLandscape(player != null && player.getParentActivity() != null
+                ? player.getParentActivity() : this);
     }
 
     @Nullable

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

@@ -12,7 +12,6 @@ import android.view.Menu;
 import android.view.MenuItem;
 import android.view.View;
 import android.view.ViewGroup;
-import android.widget.PopupMenu;
 import android.widget.SeekBar;
 
 import androidx.annotation.Nullable;
@@ -40,14 +39,14 @@ import org.schabi.newpipe.player.playqueue.PlayQueueItemTouchCallback;
 import org.schabi.newpipe.util.Localization;
 import org.schabi.newpipe.util.NavigationHelper;
 import org.schabi.newpipe.util.PermissionHelper;
+import org.schabi.newpipe.util.ServiceHelper;
 import org.schabi.newpipe.util.ThemeHelper;
 
-import java.util.Collections;
 import java.util.List;
 
+import static org.schabi.newpipe.QueueItemMenuUtil.openPopupMenu;
 import static org.schabi.newpipe.player.helper.PlayerHelper.formatSpeed;
 import static org.schabi.newpipe.util.Localization.assureCorrectAppLanguage;
-import static org.schabi.newpipe.util.external_communication.ShareUtils.shareText;
 
 public final class PlayQueueActivity extends AppCompatActivity
         implements PlayerEventListener, SeekBar.OnSeekBarChangeListener,
@@ -55,7 +54,6 @@ public final class PlayQueueActivity extends AppCompatActivity
 
     private static final String TAG = PlayQueueActivity.class.getSimpleName();
 
-    private static final int RECYCLER_ITEM_POPUP_MENU_GROUP_ID = 47;
     private static final int SMOOTH_SCROLL_MAXIMUM_DISTANCE = 80;
 
     protected Player player;
@@ -83,7 +81,7 @@ public final class PlayQueueActivity extends AppCompatActivity
     protected void onCreate(final Bundle savedInstanceState) {
         assureCorrectAppLanguage(this);
         super.onCreate(savedInstanceState);
-        ThemeHelper.setTheme(this);
+        ThemeHelper.setTheme(this, ServiceHelper.getSelectedServiceId(this));
 
         queueControlBinding = ActivityPlayerQueueControlBinding.inflate(getLayoutInflater());
         setContentView(queueControlBinding.getRoot());
@@ -278,49 +276,6 @@ public final class PlayQueueActivity extends AppCompatActivity
         queueControlBinding.controlShuffle.setOnClickListener(this);
     }
 
-    private void buildItemPopupMenu(final PlayQueueItem item, final View view) {
-        final PopupMenu popupMenu = new PopupMenu(this, view);
-        final MenuItem remove = popupMenu.getMenu().add(RECYCLER_ITEM_POPUP_MENU_GROUP_ID, 0,
-                Menu.NONE, R.string.play_queue_remove);
-        remove.setOnMenuItemClickListener(menuItem -> {
-            if (player == null) {
-                return false;
-            }
-
-            final int index = player.getPlayQueue().indexOf(item);
-            if (index != -1) {
-                player.getPlayQueue().remove(index);
-            }
-            return true;
-        });
-
-        final MenuItem detail = popupMenu.getMenu().add(RECYCLER_ITEM_POPUP_MENU_GROUP_ID, 1,
-                Menu.NONE, R.string.play_queue_stream_detail);
-        detail.setOnMenuItemClickListener(menuItem -> {
-            // playQueue is null since we don't want any queue change
-            NavigationHelper.openVideoDetail(this, item.getServiceId(), item.getUrl(),
-                    item.getTitle(), null, false);
-            return true;
-        });
-
-        final MenuItem append = popupMenu.getMenu().add(RECYCLER_ITEM_POPUP_MENU_GROUP_ID, 2,
-                Menu.NONE, R.string.append_playlist);
-        append.setOnMenuItemClickListener(menuItem -> {
-            openPlaylistAppendDialog(Collections.singletonList(item));
-            return true;
-        });
-
-        final MenuItem share = popupMenu.getMenu().add(RECYCLER_ITEM_POPUP_MENU_GROUP_ID, 3,
-                Menu.NONE, R.string.share);
-        share.setOnMenuItemClickListener(menuItem -> {
-            shareText(getApplicationContext(), item.getTitle(), item.getUrl(),
-                    item.getThumbnailUrl());
-            return true;
-        });
-
-        popupMenu.show();
-    }
-
     ////////////////////////////////////////////////////////////////////////////
     // Component Helpers
     ////////////////////////////////////////////////////////////////////////////
@@ -368,13 +323,9 @@ public final class PlayQueueActivity extends AppCompatActivity
 
             @Override
             public void held(final PlayQueueItem item, final View view) {
-                if (player == null) {
-                    return;
-                }
-
-                final int index = player.getPlayQueue().indexOf(item);
-                if (index != -1) {
-                    buildItemPopupMenu(item, view);
+                if (player != null && player.getPlayQueue().indexOf(item) != -1) {
+                    openPopupMenu(player.getPlayQueue(), item, view, false,
+                            getSupportFragmentManager(), PlayQueueActivity.this);
                 }
             }
 

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

@@ -18,6 +18,7 @@ import android.graphics.BitmapFactory;
 import android.graphics.Color;
 import android.graphics.PorterDuff;
 import android.graphics.PorterDuffColorFilter;
+import android.graphics.drawable.Drawable;
 import android.media.AudioManager;
 import android.net.Uri;
 import android.os.Build;
@@ -27,12 +28,13 @@ import android.util.DisplayMetrics;
 import android.util.Log;
 import android.util.TypedValue;
 import android.view.ContextThemeWrapper;
-import android.view.GestureDetector;
+import android.view.Gravity;
 import android.view.KeyEvent;
 import android.view.LayoutInflater;
 import android.view.Menu;
 import android.view.MenuItem;
 import android.view.MotionEvent;
+import android.view.Surface;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.WindowManager;
@@ -54,8 +56,10 @@ import androidx.appcompat.app.AppCompatActivity;
 import androidx.appcompat.content.res.AppCompatResources;
 import androidx.appcompat.widget.AppCompatImageButton;
 import androidx.core.content.ContextCompat;
-import androidx.core.view.DisplayCutoutCompat;
+import androidx.core.graphics.Insets;
+import androidx.core.view.GestureDetectorCompat;
 import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowInsetsCompat;
 import androidx.preference.PreferenceManager;
 import androidx.recyclerview.widget.ItemTouchHelper;
 import androidx.recyclerview.widget.RecyclerView;
@@ -79,9 +83,8 @@ import com.google.android.exoplayer2.upstream.DefaultBandwidthMeter;
 import com.google.android.exoplayer2.util.Util;
 import com.google.android.exoplayer2.video.VideoListener;
 import com.google.android.material.floatingactionbutton.FloatingActionButton;
-import com.nostra13.universalimageloader.core.ImageLoader;
-import com.nostra13.universalimageloader.core.assist.FailReason;
-import com.nostra13.universalimageloader.core.listener.ImageLoadingListener;
+import com.squareup.picasso.Picasso;
+import com.squareup.picasso.Target;
 
 import org.schabi.newpipe.DownloaderImpl;
 import org.schabi.newpipe.MainActivity;
@@ -112,6 +115,7 @@ import org.schabi.newpipe.player.playback.CustomTrackSelector;
 import org.schabi.newpipe.player.playback.MediaSourceManager;
 import org.schabi.newpipe.player.playback.PlaybackListener;
 import org.schabi.newpipe.player.playback.PlayerMediaSession;
+import org.schabi.newpipe.player.playback.SurfaceHolderCallback;
 import org.schabi.newpipe.player.playqueue.PlayQueue;
 import org.schabi.newpipe.player.playqueue.PlayQueueAdapter;
 import org.schabi.newpipe.player.playqueue.PlayQueueItem;
@@ -121,11 +125,13 @@ import org.schabi.newpipe.player.playqueue.PlayQueueItemTouchCallback;
 import org.schabi.newpipe.player.resolver.AudioPlaybackResolver;
 import org.schabi.newpipe.player.resolver.MediaSourceTag;
 import org.schabi.newpipe.player.resolver.VideoPlaybackResolver;
+import org.schabi.newpipe.player.seekbarpreview.SeekbarPreviewThumbnailHelper;
+import org.schabi.newpipe.player.seekbarpreview.SeekbarPreviewThumbnailHolder;
 import org.schabi.newpipe.util.DeviceUtils;
-import org.schabi.newpipe.util.ImageDisplayConstants;
 import org.schabi.newpipe.util.external_communication.KoreUtils;
 import org.schabi.newpipe.util.ListHelper;
 import org.schabi.newpipe.util.NavigationHelper;
+import org.schabi.newpipe.util.PicassoHelper;
 import org.schabi.newpipe.util.SerializedCache;
 import org.schabi.newpipe.util.external_communication.ShareUtils;
 import org.schabi.newpipe.views.ExpandableSurfaceView;
@@ -153,7 +159,9 @@ import static com.google.android.exoplayer2.Player.REPEAT_MODE_OFF;
 import static com.google.android.exoplayer2.Player.REPEAT_MODE_ONE;
 import static com.google.android.exoplayer2.Player.RepeatMode;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.schabi.newpipe.QueueItemMenuUtil.openPopupMenu;
 import static org.schabi.newpipe.extractor.ServiceList.YouTube;
+import static org.schabi.newpipe.extractor.utils.Utils.isNullOrEmpty;
 import static org.schabi.newpipe.ktx.ViewUtils.animate;
 import static org.schabi.newpipe.ktx.ViewUtils.animateRotation;
 import static org.schabi.newpipe.player.MainPlayer.ACTION_CLOSE;
@@ -190,7 +198,6 @@ import static org.schabi.newpipe.util.Localization.containsCaseInsensitive;
 public final class Player implements
         EventListener,
         PlaybackListener,
-        ImageLoadingListener,
         VideoListener,
         SeekBar.OnSeekBarChangeListener,
         View.OnClickListener,
@@ -231,7 +238,7 @@ public final class Player implements
     //////////////////////////////////////////////////////////////////////////*/
 
     public static final int PLAY_PREV_ACTIVATION_LIMIT_MILLIS = 5000; // 5 seconds
-    public static final int PROGRESS_LOOP_INTERVAL_MILLIS = 500; // 500 millis
+    public static final int PROGRESS_LOOP_INTERVAL_MILLIS = 1000; // 1 second
     public static final int DEFAULT_CONTROLS_DURATION = 300; // 300 millis
     public static final int DEFAULT_CONTROLS_HIDE_TIME = 2000;  // 2 Seconds
     public static final int DPAD_CONTROLS_HIDE_TIME = 7000;  // 7 Seconds
@@ -267,6 +274,7 @@ public final class Player implements
     private SimpleExoPlayer simpleExoPlayer;
     private AudioReactor audioReactor;
     private MediaSessionManager mediaSessionManager;
+    @Nullable private SurfaceHolderCallback surfaceHolderCallback;
 
     @NonNull private final CustomTrackSelector trackSelector;
     @NonNull private final LoadController loadController;
@@ -353,7 +361,7 @@ public final class Player implements
     private static final float MAX_GESTURE_LENGTH = 0.75f;
 
     private int maxGestureLength; // scaled
-    private GestureDetector gestureDetector;
+    private GestureDetectorCompat gestureDetector;
 
     /*//////////////////////////////////////////////////////////////////////////
     // Listeners and disposables
@@ -376,12 +384,14 @@ public final class Player implements
     @NonNull private final SharedPreferences prefs;
     @NonNull private final HistoryRecordManager recordManager;
 
+    @NonNull private final SeekbarPreviewThumbnailHolder seekbarPreviewThumbnailHolder =
+            new SeekbarPreviewThumbnailHolder();
 
 
     /*//////////////////////////////////////////////////////////////////////////
     // Constructor
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Constructor
 
     public Player(@NonNull final MainPlayer service) {
         this.service = service;
@@ -428,7 +438,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Setup and initialization
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Setup and initialization
 
     public void setupFromView(@NonNull final PlayerBinding playerBinding) {
         initViews(playerBinding);
@@ -489,7 +499,7 @@ public final class Player implements
         registerBroadcastReceiver();
 
         // Setup video view
-        simpleExoPlayer.setVideoSurfaceView(binding.surfaceView);
+        setupVideoSurface();
         simpleExoPlayer.addVideoListener(this);
 
         // Setup subtitle view
@@ -517,7 +527,7 @@ public final class Player implements
         binding.playbackLiveSync.setOnClickListener(this);
 
         final PlayerGestureListener listener = new PlayerGestureListener(this, service);
-        gestureDetector = new GestureDetector(context, listener);
+        gestureDetector = new GestureDetectorCompat(context, listener);
         binding.getRoot().setOnTouchListener(listener);
 
         binding.queueButton.setOnClickListener(this);
@@ -552,10 +562,9 @@ public final class Player implements
         binding.getRoot().addOnLayoutChangeListener(this::onLayoutChange);
 
         ViewCompat.setOnApplyWindowInsetsListener(binding.itemsListPanel, (view, windowInsets) -> {
-            final DisplayCutoutCompat cutout = windowInsets.getDisplayCutout();
-            if (cutout != null) {
-                view.setPadding(cutout.getSafeInsetLeft(), cutout.getSafeInsetTop(),
-                        cutout.getSafeInsetRight(), cutout.getSafeInsetBottom());
+            final Insets cutout = windowInsets.getInsets(WindowInsetsCompat.Type.displayCutout());
+            if (!cutout.equals(Insets.NONE)) {
+                view.setPadding(cutout.left, cutout.top, cutout.right, cutout.bottom);
             }
             return windowInsets;
         });
@@ -577,7 +586,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Playback initialization via intent
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Playback initialization via intent
 
     public void handleIntent(@NonNull final Intent intent) {
         // fail fast if no play queue was provided
@@ -605,13 +614,16 @@ public final class Player implements
             playQueue.append(newQueue.getStreams());
 
             if ((intent.getBooleanExtra(SELECT_ON_APPEND, false)
-                    || currentState == STATE_COMPLETED) && newQueue.getStreams().size() > 0) {
+                    || currentState == STATE_COMPLETED) && !newQueue.getStreams().isEmpty()) {
                 playQueue.setIndex(sizeBeforeAppend);
             }
 
             return;
         }
 
+        // needed for tablets, check the function for a better explanation
+        directlyOpenFullscreenIfNeeded();
+
         final PlaybackParameters savedParameters = retrievePlaybackParametersFromPrefs(this);
         final float playbackSpeed = savedParameters.speed;
         final float playbackPitch = savedParameters.pitch;
@@ -663,6 +675,7 @@ public final class Player implements
                 && isPlaybackResumeEnabled(this)
                 && !samePlayQueue
                 && !newQueue.isEmpty()
+                && newQueue.getItem() != null
                 && newQueue.getItem().getRecoveryPosition() == PlayQueueItem.RECOVERY_UNSET) {
             databaseUpdateDisposable.add(recordManager.loadStreamState(newQueue.getItem())
                     .observeOn(AndroidSchedulers.mainThread())
@@ -734,6 +747,22 @@ public final class Player implements
         NavigationHelper.sendPlayerStartedEvent(context);
     }
 
+    /**
+     * Open fullscreen on tablets where the option to have the main player start automatically in
+     * fullscreen mode is on. Rotating the device to landscape is already done in {@link
+     * VideoDetailFragment#openVideoPlayer(boolean)} when the thumbnail is clicked, and that's
+     * enough for phones, but not for tablets since the mini player can be also shown in landscape.
+     */
+    private void directlyOpenFullscreenIfNeeded() {
+        if (fragmentListener != null
+                && PlayerHelper.isStartMainPlayerFullscreenEnabled(service)
+                && DeviceUtils.isTablet(service)
+                && videoPlayerSelected()
+                && PlayerHelper.globalScreenOrientationLocked(service)) {
+            fragmentListener.onScreenRotationButtonClicked();
+        }
+    }
+
     private void initPlayback(@NonNull final PlayQueue queue,
                               @RepeatMode final int repeatMode,
                               final float playbackSpeed,
@@ -766,14 +795,18 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Destroy and recovery
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Destroy and recovery
 
     private void destroyPlayer() {
         if (DEBUG) {
             Log.d(TAG, "destroyPlayer() called");
         }
+
+        cleanupVideoSurface();
+
         if (!exoPlayerIsNull()) {
             simpleExoPlayer.removeListener(this);
+            simpleExoPlayer.removeVideoListener(this);
             simpleExoPlayer.stop();
             simpleExoPlayer.release();
         }
@@ -808,7 +841,7 @@ public final class Player implements
 
         databaseUpdateDisposable.clear();
         progressUpdateDisposable.set(null);
-        ImageLoader.getInstance().stop();
+        PicassoHelper.cancelTag(PicassoHelper.PLAYER_THUMBNAIL_TAG); // cancel thumbnail loading
 
         if (binding != null) {
             binding.endScreen.setImageBitmap(null);
@@ -857,7 +890,7 @@ public final class Player implements
             Log.d(TAG, "onPlaybackShutdown() called");
         }
         // destroys the service, which in turn will destroy the player
-        service.onDestroy();
+        service.stopService();
     }
 
     public void smoothStopPlayer() {
@@ -871,7 +904,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Player type specific setup
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Player type specific setup
 
     private void initVideoPlayer() {
         // restore last resize mode
@@ -933,7 +966,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Elements visibility and size: popup and main players have different look
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Elements visibility and size: popup and main players have different look
 
     /**
      * This method ensures that popup and main players have different look.
@@ -1047,7 +1080,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Broadcast receiver
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Broadcast receiver
 
     private void setupBroadcastReceiver() {
         if (DEBUG) {
@@ -1097,7 +1130,7 @@ public final class Player implements
                 pause();
                 break;
             case ACTION_CLOSE:
-                service.onDestroy();
+                service.stopService();
                 break;
             case ACTION_PLAY_PAUSE:
                 playPause();
@@ -1199,18 +1232,49 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Thumbnail loading
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Thumbnail loading
 
     private void initThumbnail(final String url) {
         if (DEBUG) {
-            Log.d(TAG, "Thumbnail - initThumbnail() called");
+            Log.d(TAG, "Thumbnail - initThumbnail() called with url = ["
+                    + (url == null ? "null" : url) + "]");
         }
-        if (url == null || url.isEmpty()) {
+        if (isNullOrEmpty(url)) {
             return;
         }
-        ImageLoader.getInstance().resume();
-        ImageLoader.getInstance()
-                .loadImage(url, ImageDisplayConstants.DISPLAY_THUMBNAIL_OPTIONS, this);
+
+        // scale down the notification thumbnail for performance
+        PicassoHelper.loadScaledDownThumbnail(context, url).into(new Target() {
+            @Override
+            public void onBitmapLoaded(final Bitmap bitmap, final Picasso.LoadedFrom from) {
+                if (DEBUG) {
+                    Log.d(TAG, "Thumbnail - onLoadingComplete() called with: url = [" + url
+                            + "], " + "loadedImage = [" + bitmap + " -> " + bitmap.getWidth() + "x"
+                            + bitmap.getHeight() + "], from = [" + from + "]");
+                }
+
+                currentThumbnail = bitmap;
+                NotificationUtil.getInstance()
+                        .createNotificationIfNeededAndUpdate(Player.this, false);
+                // there is a new thumbnail, so changed the end screen thumbnail, too.
+                updateEndScreenThumbnail();
+            }
+
+            @Override
+            public void onBitmapFailed(final Exception e, final Drawable errorDrawable) {
+                Log.e(TAG, "Thumbnail - onBitmapFailed() called with: url = [" + url + "]", e);
+                currentThumbnail = null;
+                NotificationUtil.getInstance()
+                        .createNotificationIfNeededAndUpdate(Player.this, false);
+            }
+
+            @Override
+            public void onPrepareLoad(final Drawable placeHolderDrawable) {
+                if (DEBUG) {
+                    Log.d(TAG, "Thumbnail - onLoadingStarted() called with: url = [" + url + "]");
+                }
+            }
+        });
     }
 
     /**
@@ -1284,61 +1348,6 @@ public final class Player implements
             return Math.min(currentThumbnail.getHeight(), screenHeight);
         }
     }
-
-    @Override
-    public void onLoadingStarted(final String imageUri, final View view) {
-        if (DEBUG) {
-            Log.d(TAG, "Thumbnail - onLoadingStarted() called on: "
-                    + "imageUri = [" + imageUri + "], view = [" + view + "]");
-        }
-    }
-
-    @Override
-    public void onLoadingFailed(final String imageUri, final View view,
-                                final FailReason failReason) {
-        Log.e(TAG, "Thumbnail - onLoadingFailed() called on imageUri = [" + imageUri + "]",
-                failReason.getCause());
-        currentThumbnail = null;
-        NotificationUtil.getInstance().createNotificationIfNeededAndUpdate(this, false);
-    }
-
-    @Override
-    public void onLoadingComplete(final String imageUri, final View view,
-                                  final Bitmap loadedImage) {
-        // scale down the notification thumbnail for performance
-        final float notificationThumbnailWidth = Math.min(
-                context.getResources().getDimension(R.dimen.player_notification_thumbnail_width),
-                loadedImage.getWidth());
-        currentThumbnail = Bitmap.createScaledBitmap(
-                loadedImage,
-                (int) notificationThumbnailWidth,
-                (int) (loadedImage.getHeight()
-                        / (loadedImage.getWidth() / notificationThumbnailWidth)),
-                true);
-
-        if (DEBUG) {
-            Log.d(TAG, "Thumbnail - onLoadingComplete() called with: "
-                    + "imageUri = [" + imageUri + "], view = [" + view + "], "
-                    + "loadedImage = [" + loadedImage + "], "
-                    + loadedImage.getWidth() + "x" + loadedImage.getHeight()
-                    + ", scaled notification width = " + notificationThumbnailWidth);
-        }
-
-        NotificationUtil.getInstance().createNotificationIfNeededAndUpdate(this, false);
-
-        // there is a new thumbnail, thus the end screen thumbnail needs to be changed, too.
-        updateEndScreenThumbnail();
-    }
-
-    @Override
-    public void onLoadingCancelled(final String imageUri, final View view) {
-        if (DEBUG) {
-            Log.d(TAG, "Thumbnail - onLoadingCancelled() called with: "
-                    + "imageUri = [" + imageUri + "], view = [" + view + "]");
-        }
-        currentThumbnail = null;
-        NotificationUtil.getInstance().createNotificationIfNeededAndUpdate(this, false);
-    }
     //endregion
 
 
@@ -1346,7 +1355,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Popup player utils
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Popup player utils
 
     /**
      * Check if {@link #popupLayoutParams}' position is within a arbitrary boundary
@@ -1498,7 +1507,7 @@ public final class Player implements
                         Objects.requireNonNull(windowManager)
                                 .removeView(closeOverlayBinding.getRoot());
                         closeOverlayBinding = null;
-                        service.onDestroy();
+                        service.stopService();
                     }
                 }).start();
     }
@@ -1521,7 +1530,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Playback parameters
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Playback parameters
 
     public float getPlaybackSpeed() {
         return getPlaybackParameters().speed;
@@ -1574,7 +1583,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Progress loop and updates
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Progress loop and updates
 
     private void onUpdateProgress(final int currentProgress,
                                   final int duration,
@@ -1584,8 +1593,7 @@ public final class Player implements
         }
 
         if (duration != binding.playbackSeekBar.getMax()) {
-            binding.playbackEndTime.setText(getTimeString(duration));
-            binding.playbackSeekBar.setMax(duration);
+            setVideoDurationToControls(duration);
         }
         if (currentState != STATE_PAUSED) {
             if (currentState != STATE_PAUSED_SEEK) {
@@ -1669,12 +1677,67 @@ public final class Player implements
     @Override // seekbar listener
     public void onProgressChanged(final SeekBar seekBar, final int progress,
                                   final boolean fromUser) {
-        if (DEBUG && fromUser) {
+        // Currently we don't need method execution when fromUser is false
+        if (!fromUser) {
+            return;
+        }
+        if (DEBUG) {
             Log.d(TAG, "onProgressChanged() called with: "
                     + "seekBar = [" + seekBar + "], progress = [" + progress + "]");
         }
-        if (fromUser) {
-            binding.currentDisplaySeek.setText(getTimeString(progress));
+
+        binding.currentDisplaySeek.setText(getTimeString(progress));
+
+        // Seekbar Preview Thumbnail
+        SeekbarPreviewThumbnailHelper
+                .tryResizeAndSetSeekbarPreviewThumbnail(
+                        getContext(),
+                        seekbarPreviewThumbnailHolder.getBitmapAt(progress),
+                        binding.currentSeekbarPreviewThumbnail,
+                        binding.subtitleView::getWidth);
+
+        adjustSeekbarPreviewContainer();
+    }
+
+    private void adjustSeekbarPreviewContainer() {
+        try {
+            // Should only be required when an error occurred before
+            // and the layout was positioned in the center
+            binding.bottomSeekbarPreviewLayout.setGravity(Gravity.NO_GRAVITY);
+
+            // Calculate the current left position of seekbar progress in px
+            // More info: https://stackoverflow.com/q/20493577
+            final int currentSeekbarLeft =
+                    binding.playbackSeekBar.getLeft()
+                            + binding.playbackSeekBar.getPaddingLeft()
+                            + binding.playbackSeekBar.getThumb().getBounds().left;
+
+            // Calculate the (unchecked) left position of the container
+            final int uncheckedContainerLeft =
+                    currentSeekbarLeft - (binding.seekbarPreviewContainer.getWidth() / 2);
+
+            // Fix the position so it's within the boundaries
+            final int checkedContainerLeft =
+                    Math.max(
+                            Math.min(
+                                    uncheckedContainerLeft,
+                                    // Max left
+                                    binding.playbackWindowRoot.getWidth()
+                                            - binding.seekbarPreviewContainer.getWidth()
+                            ),
+                            0 // Min left
+                    );
+
+            // See also: https://stackoverflow.com/a/23249734
+            final LinearLayout.LayoutParams params =
+                    new LinearLayout.LayoutParams(
+                            binding.seekbarPreviewContainer.getLayoutParams());
+            params.setMarginStart(checkedContainerLeft);
+            binding.seekbarPreviewContainer.setLayoutParams(params);
+        } catch (final Exception ex) {
+            Log.e(TAG, "Failed to adjust seekbarPreviewContainer", ex);
+            // Fallback - position in the middle
+            binding.bottomSeekbarPreviewLayout.setGravity(Gravity.CENTER);
         }
     }
 
@@ -1695,6 +1758,8 @@ public final class Player implements
         showControls(0);
         animate(binding.currentDisplaySeek, true, DEFAULT_CONTROLS_DURATION,
                 AnimationType.SCALE_AND_ALPHA);
+        animate(binding.currentSeekbarPreviewThumbnail, true, DEFAULT_CONTROLS_DURATION,
+                AnimationType.SCALE_AND_ALPHA);
     }
 
     @Override // seekbar listener
@@ -1710,6 +1775,7 @@ public final class Player implements
 
         binding.playbackCurrentTime.setText(getTimeString(seekBar.getProgress()));
         animate(binding.currentDisplaySeek, false, 200, AnimationType.SCALE_AND_ALPHA);
+        animate(binding.currentSeekbarPreviewThumbnail, false, 200, AnimationType.SCALE_AND_ALPHA);
 
         if (currentState == STATE_PAUSED_SEEK) {
             changeState(STATE_BUFFERING);
@@ -1732,7 +1798,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Controls showing / hiding
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Controls showing / hiding
 
     public boolean isControlsVisible() {
         return binding != null && binding.playbackControlRoot.getVisibility() == View.VISIBLE;
@@ -1902,7 +1968,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Playback states
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Playback states
 
     @Override // exoplayer listener
     public void onPlayerStateChanged(final boolean playWhenReady, final int playbackState) {
@@ -2027,8 +2093,8 @@ public final class Player implements
             Log.d(TAG, "onPrepared() called with: playWhenReady = [" + playWhenReady + "]");
         }
 
-        binding.playbackSeekBar.setMax((int) simpleExoPlayer.getDuration());
-        binding.playbackEndTime.setText(getTimeString((int) simpleExoPlayer.getDuration()));
+        setVideoDurationToControls((int) simpleExoPlayer.getDuration());
+
         binding.playbackSpeed.setText(formatSpeed(getPlaybackSpeed()));
 
         if (playWhenReady) {
@@ -2223,7 +2289,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Repeat and shuffle
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Repeat and shuffle
 
     public void onRepeatClicked() {
         if (DEBUG) {
@@ -2260,7 +2326,7 @@ public final class Player implements
             Log.d(TAG, "ExoPlayer - onRepeatModeChanged() called with: "
                     + "repeatMode = [" + repeatMode + "]");
         }
-        setRepeatModeButton(((AppCompatImageButton) binding.repeatButton), repeatMode);
+        setRepeatModeButton(binding.repeatButton, repeatMode);
         onShuffleOrRepeatModeChanged();
     }
 
@@ -2312,7 +2378,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Mute / Unmute
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Mute / Unmute
 
     public void onMuteUnmuteButtonClicked() {
         if (DEBUG) {
@@ -2338,7 +2404,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // ExoPlayer listeners (that didn't fit in other categories)
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region ExoPlayer listeners (that didn't fit in other categories)
 
     @Override
     public void onTimelineChanged(@NonNull final Timeline timeline, final int reason) {
@@ -2426,7 +2492,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Errors
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Errors
     /**
      * Process exceptions produced by {@link com.google.android.exoplayer2.ExoPlayer ExoPlayer}.
      * <p>There are multiple types of errors:</p>
@@ -2527,7 +2593,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Playback position and seek
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Playback position and seek
 
     @Override // own playback listener (this is a getter)
     public boolean isApproachingPlaybackEdge(final long timeToEndMillis) {
@@ -2670,6 +2736,20 @@ public final class Player implements
             simpleExoPlayer.seekToDefaultPosition();
         }
     }
+
+    /**
+     * Sets the video duration time into all control components (e.g. seekbar).
+     * @param duration
+     */
+    private void setVideoDurationToControls(final int duration) {
+        binding.playbackEndTime.setText(getTimeString(duration));
+
+        binding.playbackSeekBar.setMax(duration);
+        // This is important for Android TVs otherwise it would apply the default from
+        // setMax/Min methods which is (max - min) / 20
+        binding.playbackSeekBar.setKeyProgressIncrement(
+                PlayerHelper.retrieveSeekDurationFromPreferences(this));
+    }
     //endregion
 
 
@@ -2677,7 +2757,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Player actions (play, pause, previous, fast-forward, ...)
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Player actions (play, pause, previous, fast-forward, ...)
 
     public void play() {
         if (DEBUG) {
@@ -2719,7 +2799,9 @@ public final class Player implements
             Log.d(TAG, "onPlayPause() called");
         }
 
-        if (getPlayWhenReady()) {
+        if (getPlayWhenReady()
+                // When state is completed (replay button is shown) then (re)play and do not pause
+                && currentState != STATE_COMPLETED) {
             pause();
         } else {
             play();
@@ -2785,7 +2867,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // StreamInfo history: views and progress
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region StreamInfo history: views and progress
 
     private void registerStreamViewed() {
         if (currentMetadata != null) {
@@ -2843,7 +2925,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Metadata
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Metadata
 
     private void onMetadataChanged(@NonNull final MediaSourceTag tag) {
         final StreamInfo info = tag.getMetadata();
@@ -2859,6 +2941,10 @@ public final class Player implements
         binding.titleTextView.setText(tag.getMetadata().getName());
         binding.channelTextView.setText(tag.getMetadata().getUploaderName());
 
+        this.seekbarPreviewThumbnailHolder.resetFrom(
+                this.getContext(),
+                tag.getMetadata().getPreviewFrames());
+
         NotificationUtil.getInstance().createNotificationIfNeededAndUpdate(this, false);
         notifyMetadataUpdateToListeners();
 
@@ -2948,7 +3034,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Play queue, segments and streams
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Play queue, segments and streams
 
     private void maybeAutoQueueNextStream(@NonNull final MediaSourceTag metadata) {
         if (playQueue == null || playQueue.getIndex() != playQueue.size() - 1
@@ -3103,7 +3189,7 @@ public final class Player implements
     private StreamSegmentAdapter.StreamSegmentListener getStreamSegmentListener() {
         return (item, seconds) -> {
             segmentAdapter.selectSegment(item);
-            seekTo(seconds * 1000);
+            seekTo(seconds * 1000L);
             triggerProgressUpdate();
         };
     }
@@ -3113,7 +3199,7 @@ public final class Player implements
         final List<StreamSegment> segments = currentMetadata.getMetadata().getStreamSegments();
 
         for (int i = 0; i < segments.size(); i++) {
-            if (segments.get(i).getStartTimeSeconds() * 1000 > playbackPosition) {
+            if (segments.get(i).getStartTimeSeconds() * 1000L > playbackPosition) {
                 break;
             }
             nearestPosition++;
@@ -3148,9 +3234,9 @@ public final class Player implements
 
             @Override
             public void held(final PlayQueueItem item, final View view) {
-                final int index = playQueue.indexOf(item);
-                if (index != -1) {
-                    playQueue.remove(index);
+                if (playQueue.indexOf(item) != -1) {
+                    openPopupMenu(playQueue, item, view, true,
+                            getParentActivity().getSupportFragmentManager(), context);
                 }
             }
 
@@ -3264,7 +3350,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Popup menus ("popup" means that they pop up, not that they belong to the popup player)
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Popup menus ("popup" means that they pop up, not that they belong to the popup player)
 
     private void buildQualityMenu() {
         if (qualityPopupMenu == null) {
@@ -3467,7 +3553,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Captions (text tracks)
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Captions (text tracks)
 
     private void setupSubtitleView() {
         final float captionScale = PlayerHelper.getCaptionScale(context);
@@ -3546,7 +3632,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Click listeners
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Click listeners
 
     @Override
     public void onClick(final View v) {
@@ -3734,7 +3820,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Video size, resize, orientation, fullscreen
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Video size, resize, orientation, fullscreen
 
     private void setupScreenRotationButton() {
         binding.screenRotationButton.setVisibility(videoPlayerSelected()
@@ -3789,11 +3875,9 @@ public final class Player implements
         if (DEBUG) {
             Log.d(TAG, "toggleFullscreen() called");
         }
-        if (popupPlayerSelected() || exoPlayerIsNull() || currentMetadata == null
-                || fragmentListener == null) {
+        if (popupPlayerSelected() || exoPlayerIsNull() || fragmentListener == null) {
             return;
         }
-        //changeState(STATE_BLOCKED); TODO check what this does
 
         isFullscreen = !isFullscreen;
         if (!isFullscreen) {
@@ -3841,7 +3925,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Gestures
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Gestures
 
     @SuppressWarnings("checkstyle:ParameterNumber")
     private void onLayoutChange(final View view, final int l, final int t, final int r, final int b,
@@ -3905,7 +3989,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Activity / fragment binding
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Activity / fragment binding
 
     public void setFragmentListener(final PlayerServiceEventListener listener) {
         fragmentListener = listener;
@@ -4044,7 +4128,7 @@ public final class Player implements
     /*//////////////////////////////////////////////////////////////////////////
     // Getters
     //////////////////////////////////////////////////////////////////////////*/
-    //region
+    //region Getters
 
     public int getCurrentState() {
         return currentState;
@@ -4125,7 +4209,7 @@ public final class Player implements
         return audioReactor;
     }
 
-    public GestureDetector getGestureDetector() {
+    public GestureDetectorCompat getGestureDetector() {
         return gestureDetector;
     }
 
@@ -4223,6 +4307,40 @@ public final class Player implements
     public PlayQueueAdapter getPlayQueueAdapter() {
         return playQueueAdapter;
     }
+    //endregion
 
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // SurfaceHolderCallback helpers
+    //////////////////////////////////////////////////////////////////////////*/
+    //region SurfaceHolderCallback helpers
+
+    private void setupVideoSurface() {
+        // make sure there is nothing left over from previous calls
+        cleanupVideoSurface();
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { // >=API23
+            surfaceHolderCallback = new SurfaceHolderCallback(context, simpleExoPlayer);
+            binding.surfaceView.getHolder().addCallback(surfaceHolderCallback);
+            final Surface surface = binding.surfaceView.getHolder().getSurface();
+            // initially set the surface manually otherwise
+            // onRenderedFirstFrame() will not be called
+            simpleExoPlayer.setVideoSurface(surface);
+        } else {
+            simpleExoPlayer.setVideoSurfaceView(binding.surfaceView);
+        }
+    }
+
+    private void cleanupVideoSurface() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { // >=API23
+            if (surfaceHolderCallback != null) {
+                if (binding != null) {
+                    binding.surfaceView.getHolder().removeCallback(surfaceHolderCallback);
+                }
+                surfaceHolderCallback.release();
+                surfaceHolderCallback = null;
+            }
+        }
+    }
     //endregion
 }

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

@@ -16,6 +16,7 @@ import androidx.media.AudioManagerCompat;
 
 import com.google.android.exoplayer2.SimpleExoPlayer;
 import com.google.android.exoplayer2.analytics.AnalyticsListener;
+import com.google.android.exoplayer2.decoder.DecoderCounters;
 
 public class AudioReactor implements AudioManager.OnAudioFocusChangeListener, AnalyticsListener {
 
@@ -50,6 +51,7 @@ public class AudioReactor implements AudioManager.OnAudioFocusChangeListener, An
     public void dispose() {
         abandonAudioFocus();
         player.removeAnalyticsListener(this);
+        notifyAudioSessionUpdate(false, player.getAudioSessionId());
     }
 
     /*//////////////////////////////////////////////////////////////////////////
@@ -149,11 +151,21 @@ public class AudioReactor implements AudioManager.OnAudioFocusChangeListener, An
 
     @Override
     public void onAudioSessionId(final EventTime eventTime, final int audioSessionId) {
+        notifyAudioSessionUpdate(true, audioSessionId);
+    }
+
+    @Override
+    public void onAudioDisabled(final EventTime eventTime, final DecoderCounters counters) {
+        notifyAudioSessionUpdate(false, player.getAudioSessionId());
+    }
+
+    private void notifyAudioSessionUpdate(final boolean active, final int audioSessionId) {
         if (!PlayerHelper.isUsingDSP()) {
             return;
         }
-
-        final Intent intent = new Intent(AudioEffect.ACTION_OPEN_AUDIO_EFFECT_CONTROL_SESSION);
+        final Intent intent = new Intent(active
+                ? AudioEffect.ACTION_OPEN_AUDIO_EFFECT_CONTROL_SESSION
+                : AudioEffect.ACTION_CLOSE_AUDIO_EFFECT_CONTROL_SESSION);
         intent.putExtra(AudioEffect.EXTRA_AUDIO_SESSION, audioSessionId);
         intent.putExtra(AudioEffect.EXTRA_PACKAGE_NAME, context.getPackageName());
         context.sendBroadcast(intent);

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

@@ -20,18 +20,16 @@ public class LoadController implements LoadControl {
     //////////////////////////////////////////////////////////////////////////*/
 
     public LoadController() {
-        this(PlayerHelper.getPlaybackStartBufferMs(),
-                PlayerHelper.getPlaybackMinimumBufferMs(),
-                PlayerHelper.getPlaybackOptimalBufferMs());
+        this(PlayerHelper.getPlaybackStartBufferMs());
     }
 
-    private LoadController(final int initialPlaybackBufferMs,
-                           final int minimumPlaybackBufferMs,
-                           final int optimalPlaybackBufferMs) {
+    private LoadController(final int initialPlaybackBufferMs) {
         this.initialPlaybackBufferUs = initialPlaybackBufferMs * 1000;
 
         final DefaultLoadControl.Builder builder = new DefaultLoadControl.Builder();
-        builder.setBufferDurationsMs(minimumPlaybackBufferMs, optimalPlaybackBufferMs,
+        builder.setBufferDurationsMs(
+                DefaultLoadControl.DEFAULT_MIN_BUFFER_MS,
+                DefaultLoadControl.DEFAULT_MAX_BUFFER_MS,
                 initialPlaybackBufferMs,
                 DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS);
         internalLoadControl = builder.build();

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

@@ -164,7 +164,7 @@ public class PlaybackParameterDialog extends DialogFragment {
                         setPlaybackParameters(initialTempo, initialPitch, initialSkipSilence))
                 .setNeutralButton(R.string.playback_reset, (dialogInterface, i) ->
                         setPlaybackParameters(DEFAULT_TEMPO, DEFAULT_PITCH, DEFAULT_SKIP_SILENCE))
-                .setPositiveButton(R.string.finish, (dialogInterface, i) ->
+                .setPositiveButton(R.string.ok, (dialogInterface, i) ->
                         setCurrentPlaybackParameters());
 
         return dialogBuilder.create();

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

@@ -239,6 +239,11 @@ public final class PlayerHelper {
                 .getBoolean(context.getString(R.string.brightness_gesture_control_key), true);
     }
 
+    public static boolean isStartMainPlayerFullscreenEnabled(@NonNull final Context context) {
+        return getPreferences(context)
+                .getBoolean(context.getString(R.string.start_main_player_fullscreen_key), false);
+    }
+
     public static boolean isAutoQueueEnabled(@NonNull final Context context) {
         return getPreferences(context)
                 .getBoolean(context.getString(R.string.auto_queue_key), false);
@@ -307,22 +312,6 @@ public final class PlayerHelper {
         return 500;
     }
 
-    /**
-     * @return the minimum number of milliseconds the player always buffers to
-     * after starting playback.
-     */
-    public static int getPlaybackMinimumBufferMs() {
-        return 25000;
-    }
-
-    /**
-     * @return the maximum/optimal number of milliseconds the player will buffer to once the buffer
-     * hits the point of {@link #getPlaybackMinimumBufferMs()}.
-     */
-    public static int getPlaybackOptimalBufferMs() {
-        return 60000;
-    }
-
     public static TrackSelection.Factory getQualitySelector() {
         return new AdaptiveTrackSelection.Factory(
                 1000,

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

@@ -8,6 +8,7 @@ import android.os.IBinder;
 import android.util.Log;
 
 import androidx.annotation.Nullable;
+import androidx.core.content.ContextCompat;
 
 import com.google.android.exoplayer2.ExoPlaybackException;
 import com.google.android.exoplayer2.PlaybackParameters;
@@ -22,18 +23,27 @@ import org.schabi.newpipe.player.event.PlayerServiceExtendedEventListener;
 import org.schabi.newpipe.player.playqueue.PlayQueue;
 
 public final class PlayerHolder {
+
     private PlayerHolder() {
     }
 
-    private static final boolean DEBUG = MainActivity.DEBUG;
-    private static final String TAG = "PlayerHolder";
+    private static PlayerHolder instance;
+    public static synchronized PlayerHolder getInstance() {
+        if (PlayerHolder.instance == null) {
+            PlayerHolder.instance = new PlayerHolder();
+        }
+        return PlayerHolder.instance;
+    }
 
-    private static PlayerServiceExtendedEventListener listener;
+    private final boolean DEBUG = MainActivity.DEBUG;
+    private final String TAG = PlayerHolder.class.getSimpleName();
 
-    private static ServiceConnection serviceConnection;
-    public static boolean bound;
-    private static MainPlayer playerService;
-    private static Player player;
+    private PlayerServiceExtendedEventListener listener;
+
+    private final PlayerServiceConnection serviceConnection = new PlayerServiceConnection();
+    public boolean bound;
+    private MainPlayer playerService;
+    private Player player;
 
     /**
      * Returns the current {@link MainPlayer.PlayerType} of the {@link MainPlayer} service,
@@ -42,26 +52,31 @@ public final class PlayerHolder {
      * @return Current PlayerType
      */
     @Nullable
-    public static MainPlayer.PlayerType getType() {
+    public MainPlayer.PlayerType getType() {
         if (player == null) {
             return null;
         }
         return player.getPlayerType();
     }
 
-    public static boolean isPlaying() {
+    public boolean isPlaying() {
         if (player == null) {
             return false;
         }
         return player.isPlaying();
     }
 
-    public static boolean isPlayerOpen() {
+    public boolean isPlayerOpen() {
         return player != null;
     }
 
-    public static void setListener(final PlayerServiceExtendedEventListener newListener) {
+    public void setListener(@Nullable final PlayerServiceExtendedEventListener newListener) {
         listener = newListener;
+
+        if (listener == null) {
+            return;
+        }
+
         // Force reload data from service
         if (player != null) {
             listener.onServiceConnected(player, playerService, false);
@@ -69,14 +84,15 @@ public final class PlayerHolder {
         }
     }
 
-    public static void removeListener() {
-        listener = null;
+    // helper to handle context in common place as using the same
+    // context to bind/unbind a service is crucial
+    private Context getCommonContext() {
+        return App.getApp();
     }
 
-
-    public static void startService(final Context context,
-                                    final boolean playAfterConnect,
-                                    final PlayerServiceExtendedEventListener newListener) {
+    public void startService(final boolean playAfterConnect,
+                             final PlayerServiceExtendedEventListener newListener) {
+        final Context context = getCommonContext();
         setListener(newListener);
         if (bound) {
             return;
@@ -85,58 +101,65 @@ public final class PlayerHolder {
         // and NullPointerExceptions inside the service because the service will be
         // bound twice. Prevent it with unbinding first
         unbind(context);
-        context.startService(new Intent(context, MainPlayer.class));
-        serviceConnection = getServiceConnection(context, playAfterConnect);
+        ContextCompat.startForegroundService(context, new Intent(context, MainPlayer.class));
+        serviceConnection.doPlayAfterConnect(playAfterConnect);
         bind(context);
     }
 
-    public static void stopService(final Context context) {
+    public void stopService() {
+        final Context context = getCommonContext();
         unbind(context);
         context.stopService(new Intent(context, MainPlayer.class));
     }
 
-    private static ServiceConnection getServiceConnection(final Context context,
-                                                          final boolean playAfterConnect) {
-        return new ServiceConnection() {
-            @Override
-            public void onServiceDisconnected(final ComponentName compName) {
-                if (DEBUG) {
-                    Log.d(TAG, "Player service is disconnected");
-                }
+    class PlayerServiceConnection implements ServiceConnection {
 
-                unbind(context);
+        private boolean playAfterConnect = false;
+
+        public void doPlayAfterConnect(final boolean playAfterConnection) {
+            this.playAfterConnect = playAfterConnection;
+        }
+
+        @Override
+        public void onServiceDisconnected(final ComponentName compName) {
+            if (DEBUG) {
+                Log.d(TAG, "Player service is disconnected");
             }
 
-            @Override
-            public void onServiceConnected(final ComponentName compName, final IBinder service) {
-                if (DEBUG) {
-                    Log.d(TAG, "Player service is connected");
-                }
-                final MainPlayer.LocalBinder localBinder = (MainPlayer.LocalBinder) service;
+            final Context context = getCommonContext();
+            unbind(context);
+        }
 
-                playerService = localBinder.getService();
-                player = localBinder.getPlayer();
-                if (listener != null) {
-                    listener.onServiceConnected(player, playerService, playAfterConnect);
-                }
-                startPlayerListener();
+        @Override
+        public void onServiceConnected(final ComponentName compName, final IBinder service) {
+            if (DEBUG) {
+                Log.d(TAG, "Player service is connected");
             }
-        };
-    }
+            final MainPlayer.LocalBinder localBinder = (MainPlayer.LocalBinder) service;
 
-    private static void bind(final Context context) {
+            playerService = localBinder.getService();
+            player = localBinder.getPlayer();
+            if (listener != null) {
+                listener.onServiceConnected(player, playerService, playAfterConnect);
+            }
+            startPlayerListener();
+        }
+    };
+
+    private void bind(final Context context) {
         if (DEBUG) {
             Log.d(TAG, "bind() called");
         }
 
         final Intent serviceIntent = new Intent(context, MainPlayer.class);
-        bound = context.bindService(serviceIntent, serviceConnection, Context.BIND_AUTO_CREATE);
+        bound = context.bindService(serviceIntent, serviceConnection,
+                Context.BIND_AUTO_CREATE);
         if (!bound) {
             context.unbindService(serviceConnection);
         }
     }
 
-    private static void unbind(final Context context) {
+    private void unbind(final Context context) {
         if (DEBUG) {
             Log.d(TAG, "unbind() called");
         }
@@ -153,21 +176,19 @@ public final class PlayerHolder {
         }
     }
 
-
-    private static void startPlayerListener() {
+    private void startPlayerListener() {
         if (player != null) {
-            player.setFragmentListener(INNER_LISTENER);
+            player.setFragmentListener(internalListener);
         }
     }
 
-    private static void stopPlayerListener() {
+    private void stopPlayerListener() {
         if (player != null) {
-            player.removeFragmentListener(INNER_LISTENER);
+            player.removeFragmentListener(internalListener);
         }
     }
 
-
-    private static final PlayerServiceEventListener INNER_LISTENER =
+    private final PlayerServiceEventListener internalListener =
             new PlayerServiceEventListener() {
                 @Override
                 public void onFullscreenStateChanged(final boolean fullscreen) {
@@ -242,7 +263,7 @@ public final class PlayerHolder {
                     if (listener != null) {
                         listener.onServiceStopped();
                     }
-                    unbind(App.getApp());
+                    unbind(getCommonContext());
                 }
             };
 }

app/src/main/java/org/schabi/newpipe/player/playback/SurfaceHolderCallback.java

@@ -0,0 +1,62 @@
+package org.schabi.newpipe.player.playback;
+
+import android.content.Context;
+import android.view.SurfaceHolder;
+
+import com.google.android.exoplayer2.SimpleExoPlayer;
+import com.google.android.exoplayer2.video.DummySurface;
+
+/**
+ * Prevent error message: 'Unrecoverable player error occurred'
+ * In case of rotation some users see this kind of an error which is preventable
+ * having a Callback that handles the lifecycle of the surface.
+ * <p>
+ * How?: In case we are no longer able to write to the surface eg. through rotation/putting in
+ * background we set set a DummySurface. Although it it works on API >= 23 only.
+ * Result: we get a little video interruption (audio is still fine) but we won't get the
+ * 'Unrecoverable player error occurred' error message.
+ * <p>
+ * This implementation is based on:
+ * 'ExoPlayer stuck in buffering after re-adding the surface view a few time #2703'
+ * <p>
+ * -> exoplayer fix suggestion link
+ * https://github.com/google/ExoPlayer/issues/2703#issuecomment-300599981
+ */
+public final class SurfaceHolderCallback implements SurfaceHolder.Callback {
+
+    private final Context context;
+    private final SimpleExoPlayer player;
+    private DummySurface dummySurface;
+
+    public SurfaceHolderCallback(final Context context, final SimpleExoPlayer player) {
+        this.context = context;
+        this.player = player;
+    }
+
+    @Override
+    public void surfaceCreated(final SurfaceHolder holder) {
+        player.setVideoSurface(holder.getSurface());
+    }
+
+    @Override
+    public void surfaceChanged(final SurfaceHolder holder,
+                               final int format,
+                               final int width,
+                               final int height) {
+    }
+
+    @Override
+    public void surfaceDestroyed(final SurfaceHolder holder) {
+        if (dummySurface == null) {
+            dummySurface = DummySurface.newInstanceV17(context, false);
+        }
+        player.setVideoSurface(dummySurface);
+    }
+
+    public void release() {
+        if (dummySurface != null) {
+            dummySurface.release();
+            dummySurface = null;
+        }
+    }
+}

app/src/main/java/org/schabi/newpipe/player/playqueue/PlayQueueItem.java

@@ -27,6 +27,7 @@ public class PlayQueueItem implements Serializable {
     private final String thumbnailUrl;
     @NonNull
     private final String uploader;
+    private final String uploaderUrl;
     @NonNull
     private final StreamType streamType;
 
@@ -37,7 +38,8 @@ public class PlayQueueItem implements Serializable {
 
     PlayQueueItem(@NonNull final StreamInfo info) {
         this(info.getName(), info.getUrl(), info.getServiceId(), info.getDuration(),
-                info.getThumbnailUrl(), info.getUploaderName(), info.getStreamType());
+                info.getThumbnailUrl(), info.getUploaderName(),
+                info.getUploaderUrl(), info.getStreamType());
 
         if (info.getStartPosition() > 0) {
             setRecoveryPosition(info.getStartPosition() * 1000);
@@ -46,38 +48,26 @@ public class PlayQueueItem implements Serializable {
 
     PlayQueueItem(@NonNull final StreamInfoItem item) {
         this(item.getName(), item.getUrl(), item.getServiceId(), item.getDuration(),
-                item.getThumbnailUrl(), item.getUploaderName(), item.getStreamType());
+                item.getThumbnailUrl(), item.getUploaderName(),
+                item.getUploaderUrl(), item.getStreamType());
     }
 
     private PlayQueueItem(@Nullable final String name, @Nullable final String url,
                           final int serviceId, final long duration,
                           @Nullable final String thumbnailUrl, @Nullable final String uploader,
-                          @NonNull final StreamType streamType) {
+                          final String uploaderUrl, @NonNull final StreamType streamType) {
         this.title = name != null ? name : EMPTY_STRING;
         this.url = url != null ? url : EMPTY_STRING;
         this.serviceId = serviceId;
         this.duration = duration;
         this.thumbnailUrl = thumbnailUrl != null ? thumbnailUrl : EMPTY_STRING;
         this.uploader = uploader != null ? uploader : EMPTY_STRING;
+        this.uploaderUrl = uploaderUrl;
         this.streamType = streamType;
 
         this.recoveryPosition = RECOVERY_UNSET;
     }
 
-    @Override
-    public boolean equals(final Object o) {
-        if (o instanceof PlayQueueItem) {
-            return url.equals(((PlayQueueItem) o).url);
-        } else {
-            return false;
-        }
-    }
-
-    @Override
-    public int hashCode() {
-        return url.hashCode();
-    }
-
     @NonNull
     public String getTitle() {
         return title;
@@ -106,6 +96,10 @@ public class PlayQueueItem implements Serializable {
         return uploader;
     }
 
+    public String getUploaderUrl() {
+        return uploaderUrl;
+    }
+
     @NonNull
     public StreamType getStreamType() {
         return streamType;

app/src/main/java/org/schabi/newpipe/player/playqueue/PlayQueueItemBuilder.java

@@ -5,11 +5,9 @@ import android.text.TextUtils;
 import android.view.MotionEvent;
 import android.view.View;
 
-import com.nostra13.universalimageloader.core.ImageLoader;
-
 import org.schabi.newpipe.extractor.NewPipe;
-import org.schabi.newpipe.util.ImageDisplayConstants;
 import org.schabi.newpipe.util.Localization;
+import org.schabi.newpipe.util.PicassoHelper;
 
 public class PlayQueueItemBuilder {
     private static final String TAG = PlayQueueItemBuilder.class.toString();
@@ -35,8 +33,7 @@ public class PlayQueueItemBuilder {
             holder.itemDurationView.setVisibility(View.GONE);
         }
 
-        ImageLoader.getInstance().displayImage(item.getThumbnailUrl(), holder.itemThumbnailView,
-                ImageDisplayConstants.DISPLAY_THUMBNAIL_OPTIONS);
+        PicassoHelper.loadThumbnail(item.getThumbnailUrl()).into(holder.itemThumbnailView);
 
         holder.itemRoot.setOnClickListener(view -> {
             if (onItemClickListener != null) {

app/src/main/java/org/schabi/newpipe/player/seekbarpreview/SeekbarPreviewThumbnailHelper.java

@@ -0,0 +1,108 @@
+package org.schabi.newpipe.player.seekbarpreview;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.util.Log;
+import android.view.View;
+import android.widget.ImageView;
+
+import androidx.annotation.IntDef;
+import androidx.annotation.NonNull;
+import androidx.preference.PreferenceManager;
+
+import org.schabi.newpipe.R;
+import org.schabi.newpipe.util.DeviceUtils;
+
+import java.lang.annotation.Retention;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.IntSupplier;
+
+import static java.lang.annotation.RetentionPolicy.SOURCE;
+import static org.schabi.newpipe.player.seekbarpreview.SeekbarPreviewThumbnailHelper.SeekbarPreviewThumbnailType.HIGH_QUALITY;
+import static org.schabi.newpipe.player.seekbarpreview.SeekbarPreviewThumbnailHelper.SeekbarPreviewThumbnailType.LOW_QUALITY;
+import static org.schabi.newpipe.player.seekbarpreview.SeekbarPreviewThumbnailHelper.SeekbarPreviewThumbnailType.NONE;
+
+/**
+ * Helper for the seekbar preview.
+ */
+public final class SeekbarPreviewThumbnailHelper {
+
+    // This has to be <= 23 chars on devices running Android 7 or lower (API <= 25)
+    // or it fails with an IllegalArgumentException
+    // https://stackoverflow.com/a/54744028
+    public static final String TAG = "SeekbarPrevThumbHelper";
+
+    private SeekbarPreviewThumbnailHelper() {
+        // No impl pls
+    }
+
+    @Retention(SOURCE)
+    @IntDef({HIGH_QUALITY, LOW_QUALITY,
+            NONE})
+    public @interface SeekbarPreviewThumbnailType {
+        int HIGH_QUALITY = 0;
+        int LOW_QUALITY = 1;
+        int NONE = 2;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Settings Resolution
+    ///////////////////////////////////////////////////////////////////////////
+
+    @SeekbarPreviewThumbnailType
+    public static int getSeekbarPreviewThumbnailType(@NonNull final Context context) {
+        final String type = PreferenceManager.getDefaultSharedPreferences(context).getString(
+                context.getString(R.string.seekbar_preview_thumbnail_key), "");
+        if (type.equals(context.getString(R.string.seekbar_preview_thumbnail_none))) {
+            return NONE;
+        } else if (type.equals(context.getString(R.string.seekbar_preview_thumbnail_low_quality))) {
+            return LOW_QUALITY;
+        } else {
+            return HIGH_QUALITY; // default
+        }
+    }
+
+    public static void tryResizeAndSetSeekbarPreviewThumbnail(
+            @NonNull final Context context,
+            @NonNull final Optional<Bitmap> optPreviewThumbnail,
+            @NonNull final ImageView currentSeekbarPreviewThumbnail,
+            @NonNull final IntSupplier baseViewWidthSupplier) {
+
+        if (!optPreviewThumbnail.isPresent()) {
+            currentSeekbarPreviewThumbnail.setVisibility(View.GONE);
+            return;
+        }
+
+        currentSeekbarPreviewThumbnail.setVisibility(View.VISIBLE);
+        final Bitmap srcBitmap = optPreviewThumbnail.get();
+
+        // Resize original bitmap
+        try {
+            Objects.requireNonNull(srcBitmap);
+
+            final int srcWidth = srcBitmap.getWidth() > 0 ? srcBitmap.getWidth() : 1;
+            final int newWidth = Math.max(
+                    Math.min(
+                            // Use 1/4 of the width for the preview
+                            Math.round(baseViewWidthSupplier.getAsInt() / 4f),
+                            // Scaling more than that factor looks really pixelated -> max
+                            Math.round(srcWidth * 2.5f)
+                    ),
+                    // Min width = 10dp
+                    DeviceUtils.dpToPx(10, context)
+            );
+
+            final float scaleFactor = (float) newWidth / srcWidth;
+            final int newHeight = (int) (srcBitmap.getHeight() * scaleFactor);
+
+            currentSeekbarPreviewThumbnail.setImageBitmap(
+                    Bitmap.createScaledBitmap(srcBitmap, newWidth, newHeight, true));
+        } catch (final Exception ex) {
+            Log.e(TAG, "Failed to resize and set seekbar preview thumbnail", ex);
+            currentSeekbarPreviewThumbnail.setVisibility(View.GONE);
+        } finally {
+            srcBitmap.recycle();
+        }
+    }
+}

app/src/main/java/org/schabi/newpipe/player/seekbarpreview/SeekbarPreviewThumbnailHolder.java

@@ -0,0 +1,239 @@
+package org.schabi.newpipe.player.seekbarpreview;
+
+import static org.schabi.newpipe.player.seekbarpreview.SeekbarPreviewThumbnailHelper.SeekbarPreviewThumbnailType;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.google.common.base.Stopwatch;
+
+import org.schabi.newpipe.extractor.stream.Frameset;
+import org.schabi.newpipe.util.PicassoHelper;
+
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.function.Supplier;
+
+public class SeekbarPreviewThumbnailHolder {
+
+    // This has to be <= 23 chars on devices running Android 7 or lower (API <= 25)
+    // or it fails with an IllegalArgumentException
+    // https://stackoverflow.com/a/54744028
+    public static final String TAG = "SeekbarPrevThumbHolder";
+
+    // Key = Position of the picture in milliseconds
+    // Supplier = Supplies the bitmap for that position
+    private final Map<Integer, Supplier<Bitmap>> seekbarPreviewData = new ConcurrentHashMap<>();
+
+    // This ensures that if the reset is still undergoing
+    // and another reset starts, only the last reset is processed
+    private UUID currentUpdateRequestIdentifier = UUID.randomUUID();
+
+    public synchronized void resetFrom(
+            @NonNull final Context context,
+            final List<Frameset> framesets) {
+
+        final int seekbarPreviewType =
+                SeekbarPreviewThumbnailHelper.getSeekbarPreviewThumbnailType(context);
+
+        final UUID updateRequestIdentifier = UUID.randomUUID();
+        this.currentUpdateRequestIdentifier = updateRequestIdentifier;
+
+        final ExecutorService executorService = Executors.newSingleThreadExecutor();
+        executorService.submit(() -> {
+            try {
+                resetFromAsync(seekbarPreviewType, framesets, updateRequestIdentifier);
+            } catch (final Exception ex) {
+                Log.e(TAG, "Failed to execute async", ex);
+            }
+        });
+        // ensure that the executorService stops/destroys it's threads
+        // after the task is finished
+        executorService.shutdown();
+    }
+
+    private void resetFromAsync(
+            final int seekbarPreviewType,
+            final List<Frameset> framesets,
+            final UUID updateRequestIdentifier) {
+
+        Log.d(TAG, "Clearing seekbarPreviewData");
+        seekbarPreviewData.clear();
+
+        if (seekbarPreviewType == SeekbarPreviewThumbnailType.NONE) {
+            Log.d(TAG, "Not processing seekbarPreviewData due to settings");
+            return;
+        }
+
+        final Frameset frameset = getFrameSetForType(framesets, seekbarPreviewType);
+        if (frameset == null) {
+            Log.d(TAG, "No frameset was found to fill seekbarPreviewData");
+            return;
+        }
+
+        Log.d(TAG, "Frameset quality info: "
+                + "[width=" + frameset.getFrameWidth()
+                + ", heigh=" + frameset.getFrameHeight() + "]");
+
+        // Abort method execution if we are not the latest request
+        if (!isRequestIdentifierCurrent(updateRequestIdentifier)) {
+            return;
+        }
+
+        generateDataFrom(frameset, updateRequestIdentifier);
+    }
+
+    private Frameset getFrameSetForType(
+            final List<Frameset> framesets,
+            final int seekbarPreviewType) {
+
+        if (seekbarPreviewType == SeekbarPreviewThumbnailType.HIGH_QUALITY) {
+            Log.d(TAG, "Strategy for seekbarPreviewData: high quality");
+            return framesets.stream()
+                    .max(Comparator.comparingInt(fs -> fs.getFrameHeight() * fs.getFrameWidth()))
+                    .orElse(null);
+        } else {
+            Log.d(TAG, "Strategy for seekbarPreviewData: low quality");
+            return framesets.stream()
+                    .min(Comparator.comparingInt(fs -> fs.getFrameHeight() * fs.getFrameWidth()))
+                    .orElse(null);
+        }
+    }
+
+    private void generateDataFrom(
+            final Frameset frameset,
+            final UUID updateRequestIdentifier) {
+
+        Log.d(TAG, "Starting generation of seekbarPreviewData");
+        final Stopwatch sw = Log.isLoggable(TAG, Log.DEBUG) ? Stopwatch.createStarted() : null;
+
+        int currentPosMs = 0;
+        int pos = 1;
+
+        final int frameCountPerUrl = frameset.getFramesPerPageX() * frameset.getFramesPerPageY();
+
+        // Process each url in the frameset
+        for (final String url : frameset.getUrls()) {
+            // get the bitmap
+            final Bitmap srcBitMap = getBitMapFrom(url);
+
+            // The data is not added directly to "seekbarPreviewData" due to
+            // concurrency and checks for "updateRequestIdentifier"
+            final Map<Integer, Supplier<Bitmap>> generatedDataForUrl = new HashMap<>();
+
+            // The bitmap consists of several images, which we process here
+            // foreach frame in the returned bitmap
+            for (int i = 0; i < frameCountPerUrl; i++) {
+                // Frames outside the video length are skipped
+                if (pos > frameset.getTotalCount()) {
+                    break;
+                }
+
+                // Get the bounds where the frame is found
+                final int[] bounds = frameset.getFrameBoundsAt(currentPosMs);
+                generatedDataForUrl.put(currentPosMs, () -> {
+                    // It can happen, that the original bitmap could not be downloaded
+                    // In such a case - we don't want a NullPointer - simply return null
+                    if (srcBitMap == null) {
+                        return null;
+                    }
+
+                    // Cut out the corresponding bitmap form the "srcBitMap"
+                    return Bitmap.createBitmap(srcBitMap, bounds[1], bounds[2],
+                            frameset.getFrameWidth(), frameset.getFrameHeight());
+                });
+
+                currentPosMs += frameset.getDurationPerFrame();
+                pos++;
+            }
+
+            // Check if we are still the latest request
+            // If not abort method execution
+            if (isRequestIdentifierCurrent(updateRequestIdentifier)) {
+                seekbarPreviewData.putAll(generatedDataForUrl);
+            } else {
+                Log.d(TAG, "Aborted of generation of seekbarPreviewData");
+                break;
+            }
+        }
+
+        if (sw != null) {
+            Log.d(TAG, "Generation of seekbarPreviewData took " + sw.stop().toString());
+        }
+    }
+
+    @Nullable
+    private Bitmap getBitMapFrom(final String url) {
+        if (url == null) {
+            Log.w(TAG, "url is null; This should never happen");
+            return null;
+        }
+
+        final Stopwatch sw = Log.isLoggable(TAG, Log.DEBUG) ? Stopwatch.createStarted() : null;
+        try {
+            Log.d(TAG, "Downloading bitmap for seekbarPreview from '" + url + "'");
+
+            // Gets the bitmap within the timeout of 15 seconds imposed by default by OkHttpClient
+            // Ensure that your are not running on the main-Thread this will otherwise hang
+            final Bitmap bitmap = PicassoHelper.loadSeekbarThumbnailPreview(url).get();
+
+            if (sw != null) {
+                Log.d(TAG,
+                        "Download of bitmap for seekbarPreview from '" + url
+                                + "' took " + sw.stop().toString());
+            }
+
+            return bitmap;
+        } catch (final Exception ex) {
+            Log.w(TAG,
+                    "Failed to get bitmap for seekbarPreview from url='" + url
+                            + "' in time",
+                    ex);
+            return null;
+        }
+    }
+
+    private boolean isRequestIdentifierCurrent(final UUID requestIdentifier) {
+        return this.currentUpdateRequestIdentifier.equals(requestIdentifier);
+    }
+
+
+    public Optional<Bitmap> getBitmapAt(final int positionInMs) {
+        // Check if the BitmapData is empty
+        if (seekbarPreviewData.isEmpty()) {
+            return Optional.empty();
+        }
+
+        // Get the closest frame to the requested position
+        final int closestIndexPosition =
+                seekbarPreviewData.keySet().stream()
+                        .min(Comparator.comparingInt(i -> Math.abs(i - positionInMs)))
+                        .orElse(-1);
+
+        // this should never happen, because
+        // it indicates that "seekbarPreviewData" is empty which was already checked
+        if (closestIndexPosition == -1) {
+            return Optional.empty();
+        }
+
+        try {
+            // Get the bitmap for the position (executes the supplier)
+            return Optional.ofNullable(seekbarPreviewData.get(closestIndexPosition).get());
+        } catch (final Exception ex) {
+            // If there is an error, log it and return Optional.empty
+            Log.w(TAG, "Unable to get seekbar preview", ex);
+            return Optional.empty();
+        }
+    }
+}

app/src/main/java/org/schabi/newpipe/settings/ContentSettingsFragment.java

@@ -12,14 +12,11 @@ import android.widget.Toast;
 import androidx.activity.result.ActivityResult;
 import androidx.activity.result.ActivityResultLauncher;
 import androidx.activity.result.contract.ActivityResultContracts.StartActivityForResult;
-import androidx.annotation.Nullable;
 import androidx.appcompat.app.AlertDialog;
 import androidx.core.content.ContextCompat;
 import androidx.preference.Preference;
 import androidx.preference.PreferenceManager;
 
-import com.nostra13.universalimageloader.core.ImageLoader;
-
 import org.schabi.newpipe.DownloaderImpl;
 import org.schabi.newpipe.NewPipeDatabase;
 import org.schabi.newpipe.R;
@@ -30,9 +27,11 @@ import org.schabi.newpipe.extractor.localization.ContentCountry;
 import org.schabi.newpipe.extractor.localization.Localization;
 import org.schabi.newpipe.streams.io.StoredFileHelper;
 import org.schabi.newpipe.util.NavigationHelper;
+import org.schabi.newpipe.util.PicassoHelper;
 import org.schabi.newpipe.util.ZipHelper;
 
 import java.io.File;
+import java.io.IOException;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.Locale;
@@ -43,16 +42,15 @@ import static org.schabi.newpipe.util.Localization.assureCorrectAppLanguage;
 
 public class ContentSettingsFragment extends BasePreferenceFragment {
     private static final String ZIP_MIME_TYPE = "application/zip";
-    private static final SimpleDateFormat EXPORT_DATE_FORMAT
+
+    private final SimpleDateFormat exportDateFormat
             = new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US);
 
     private ContentSettingsManager manager;
 
     private String importExportDataPathKey;
-    private String thumbnailLoadToggleKey;
     private String youtubeRestrictedModeEnabledKey;
 
-    @Nullable private Uri lastImportExportDataUri = null;
     private Localization initialSelectedLocalization;
     private ContentCountry initialSelectedContentCountry;
     private String initialLanguage;
@@ -69,7 +67,6 @@ public class ContentSettingsFragment extends BasePreferenceFragment {
         manager.deleteSettingsFile();
 
         importExportDataPathKey = getString(R.string.import_export_data_path);
-        thumbnailLoadToggleKey = getString(R.string.download_thumbnail_key);
         youtubeRestrictedModeEnabledKey = getString(R.string.youtube_restricted_mode_enabled);
 
         addPreferencesFromResource(R.xml.content_settings);
@@ -77,7 +74,8 @@ public class ContentSettingsFragment extends BasePreferenceFragment {
         final Preference importDataPreference = requirePreference(R.string.import_data);
         importDataPreference.setOnPreferenceClickListener((Preference p) -> {
             requestImportPathLauncher.launch(
-                    StoredFileHelper.getPicker(requireContext(), getImportExportDataUri()));
+                    StoredFileHelper.getPicker(requireContext(),
+                            ZIP_MIME_TYPE, getImportExportDataUri()));
             return true;
         });
 
@@ -86,7 +84,7 @@ public class ContentSettingsFragment extends BasePreferenceFragment {
 
             requestExportPathLauncher.launch(
                     StoredFileHelper.getNewPicker(requireContext(),
-                            "NewPipeData-" + EXPORT_DATE_FORMAT.format(new Date()) + ".zip",
+                            "NewPipeData-" + exportDateFormat.format(new Date()) + ".zip",
                             ZIP_MIME_TYPE, getImportExportDataUri()));
             return true;
         });
@@ -95,8 +93,7 @@ public class ContentSettingsFragment extends BasePreferenceFragment {
                 .getPreferredLocalization(requireContext());
         initialSelectedContentCountry = org.schabi.newpipe.util.Localization
                 .getPreferredContentCountry(requireContext());
-        initialLanguage = PreferenceManager
-                .getDefaultSharedPreferences(requireContext()).getString("app_language_key", "en");
+        initialLanguage = defaultPreferences.getString(getString(R.string.app_language_key), "en");
 
         final Preference clearCookiePref = requirePreference(R.string.clear_cookie_key);
         clearCookiePref.setOnPreferenceClickListener(preference -> {
@@ -112,20 +109,24 @@ public class ContentSettingsFragment extends BasePreferenceFragment {
         if (defaultPreferences.getString(getString(R.string.recaptcha_cookies_key), "").isEmpty()) {
             clearCookiePref.setVisible(false);
         }
+
+        findPreference(getString(R.string.download_thumbnail_key)).setOnPreferenceChangeListener(
+                (preference, newValue) -> {
+                    PicassoHelper.setShouldLoadImages((Boolean) newValue);
+                    try {
+                        PicassoHelper.clearCache(preference.getContext());
+                        Toast.makeText(preference.getContext(),
+                                R.string.thumbnail_cache_wipe_complete_notice, Toast.LENGTH_SHORT)
+                                .show();
+                    } catch (final IOException e) {
+                        Log.e(TAG, "Unable to clear Picasso cache", e);
+                    }
+                    return true;
+                });
     }
 
     @Override
     public boolean onPreferenceTreeClick(final Preference preference) {
-        if (preference.getKey().equals(thumbnailLoadToggleKey)) {
-            final ImageLoader imageLoader = ImageLoader.getInstance();
-            imageLoader.stop();
-            imageLoader.clearDiskCache();
-            imageLoader.clearMemoryCache();
-            imageLoader.resume();
-            Toast.makeText(preference.getContext(), R.string.thumbnail_cache_wipe_complete_notice,
-                    Toast.LENGTH_SHORT).show();
-        }
-
         if (preference.getKey().equals(youtubeRestrictedModeEnabledKey)) {
             final Context context = getContext();
             if (context != null) {
@@ -146,8 +147,8 @@ public class ContentSettingsFragment extends BasePreferenceFragment {
                 .getPreferredLocalization(requireContext());
         final ContentCountry selectedContentCountry = org.schabi.newpipe.util.Localization
                 .getPreferredContentCountry(requireContext());
-        final String selectedLanguage = PreferenceManager
-                .getDefaultSharedPreferences(requireContext()).getString("app_language_key", "en");
+        final String selectedLanguage =
+                defaultPreferences.getString(getString(R.string.app_language_key), "en");
 
         if (!selectedLocalization.equals(initialSelectedLocalization)
                 || !selectedContentCountry.equals(initialSelectedContentCountry)
@@ -162,27 +163,29 @@ public class ContentSettingsFragment extends BasePreferenceFragment {
     private void requestExportPathResult(final ActivityResult result) {
         assureCorrectAppLanguage(getContext());
         if (result.getResultCode() == Activity.RESULT_OK && result.getData() != null) {
-            lastImportExportDataUri = result.getData().getData(); // will be saved only on success
+            // will be saved only on success
+            final Uri lastExportDataUri = result.getData().getData();
 
             final StoredFileHelper file
                     = new StoredFileHelper(getContext(), result.getData().getData(), ZIP_MIME_TYPE);
 
-            exportDatabase(file);
+            exportDatabase(file, lastExportDataUri);
         }
     }
 
     private void requestImportPathResult(final ActivityResult result) {
         assureCorrectAppLanguage(getContext());
         if (result.getResultCode() == Activity.RESULT_OK && result.getData() != null) {
-            lastImportExportDataUri = result.getData().getData(); // will be saved only on success
+            // will be saved only on success
+            final Uri lastImportDataUri = result.getData().getData();
 
             final StoredFileHelper file
                     = new StoredFileHelper(getContext(), result.getData().getData(), ZIP_MIME_TYPE);
 
             new AlertDialog.Builder(requireActivity())
                     .setMessage(R.string.override_current_data)
-                    .setPositiveButton(R.string.finish, (d, id) ->
-                            importDatabase(file))
+                    .setPositiveButton(R.string.ok, (d, id) ->
+                            importDatabase(file, lastImportDataUri))
                     .setNegativeButton(R.string.cancel, (d, id) ->
                             d.cancel())
                     .create()
@@ -190,33 +193,33 @@ public class ContentSettingsFragment extends BasePreferenceFragment {
         }
     }
 
-    private void exportDatabase(final StoredFileHelper file) {
+    private void exportDatabase(final StoredFileHelper file, final Uri exportDataUri) {
         try {
             //checkpoint before export
             NewPipeDatabase.checkpoint();
 
             final SharedPreferences preferences = PreferenceManager
-                .getDefaultSharedPreferences(requireContext());
+                    .getDefaultSharedPreferences(requireContext());
             manager.exportDatabase(preferences, file);
 
-            saveLastImportExportDataUri(false); // save export path only on success
+            saveLastImportExportDataUri(exportDataUri); // save export path only on success
             Toast.makeText(getContext(), R.string.export_complete_toast, Toast.LENGTH_SHORT).show();
         } catch (final Exception e) {
             ErrorActivity.reportUiErrorInSnackbar(this, "Exporting database", e);
         }
     }
 
-    private void importDatabase(final StoredFileHelper file) {
+    private void importDatabase(final StoredFileHelper file, final Uri importDataUri) {
         // check if file is supported
         if (!ZipHelper.isValidZipFile(file)) {
             Toast.makeText(getContext(), R.string.no_valid_zip_file, Toast.LENGTH_SHORT)
-                .show();
+                    .show();
             return;
         }
 
         try {
             if (!manager.ensureDbDirectoryExists()) {
-                throw new Exception("Could not create databases dir");
+                throw new IOException("Could not create databases dir");
             }
 
             if (!manager.extractDb(file)) {
@@ -229,19 +232,19 @@ public class ContentSettingsFragment extends BasePreferenceFragment {
                 final AlertDialog.Builder alert = new AlertDialog.Builder(requireContext());
                 alert.setTitle(R.string.import_settings);
 
-                alert.setNegativeButton(android.R.string.no, (dialog, which) -> {
+                alert.setNegativeButton(R.string.cancel, (dialog, which) -> {
                     dialog.dismiss();
-                    finishImport();
+                    finishImport(importDataUri);
                 });
-                alert.setPositiveButton(getString(R.string.finish), (dialog, which) -> {
+                alert.setPositiveButton(R.string.ok, (dialog, which) -> {
                     dialog.dismiss();
                     manager.loadSharedPreferences(PreferenceManager
-                        .getDefaultSharedPreferences(requireContext()));
-                    finishImport();
+                            .getDefaultSharedPreferences(requireContext()));
+                    finishImport(importDataUri);
                 });
                 alert.show();
             } else {
-                finishImport();
+                finishImport(importDataUri);
             }
         } catch (final Exception e) {
             ErrorActivity.reportUiErrorInSnackbar(this, "Importing database", e);
@@ -250,10 +253,12 @@ public class ContentSettingsFragment extends BasePreferenceFragment {
 
     /**
      * Save import path and restart system.
+     *
+     * @param importDataUri The import path to save
      */
-    private void finishImport() {
-        // save import path only on success; save immediately because app is about to exit
-        saveLastImportExportDataUri(true);
+    private void finishImport(final Uri importDataUri) {
+        // save import path only on success
+        saveLastImportExportDataUri(importDataUri);
         // restart app to properly load db
         NavigationHelper.restartApp(requireActivity());
     }
@@ -263,16 +268,9 @@ public class ContentSettingsFragment extends BasePreferenceFragment {
         return isBlank(path) ? null : Uri.parse(path);
     }
 
-    private void saveLastImportExportDataUri(final boolean immediately) {
-        if (lastImportExportDataUri != null) {
-            final SharedPreferences.Editor editor = defaultPreferences.edit()
-                    .putString(importExportDataPathKey, lastImportExportDataUri.toString());
-            if (immediately) {
-                // noinspection ApplySharedPref
-                editor.commit(); // app about to be restarted, commit immediately
-            } else {
-                editor.apply();
-            }
-        }
+    private void saveLastImportExportDataUri(final Uri importExportDataUri) {
+        final SharedPreferences.Editor editor = defaultPreferences.edit()
+                .putString(importExportDataPathKey, importExportDataUri.toString());
+        editor.apply();
     }
 }

app/src/main/java/org/schabi/newpipe/settings/DownloadSettingsFragment.java

@@ -9,6 +9,9 @@ import android.os.Build;
 import android.os.Bundle;
 import android.util.Log;
 
+import androidx.activity.result.ActivityResult;
+import androidx.activity.result.ActivityResultLauncher;
+import androidx.activity.result.contract.ActivityResultContracts.StartActivityForResult;
 import androidx.annotation.NonNull;
 import androidx.annotation.StringRes;
 import androidx.appcompat.app.AlertDialog;
@@ -18,6 +21,7 @@ import androidx.preference.SwitchPreferenceCompat;
 import com.nononsenseapps.filepicker.Utils;
 
 import org.schabi.newpipe.R;
+import org.schabi.newpipe.streams.io.StoredDirectoryHelper;
 import org.schabi.newpipe.util.FilePickerActivityHelper;
 
 import java.io.File;
@@ -27,14 +31,10 @@ import java.net.URI;
 import java.net.URLDecoder;
 import java.nio.charset.StandardCharsets;
 
-import org.schabi.newpipe.streams.io.StoredDirectoryHelper;
-
 import static org.schabi.newpipe.util.Localization.assureCorrectAppLanguage;
 
 public class DownloadSettingsFragment extends BasePreferenceFragment {
     public static final boolean IGNORE_RELEASE_ON_OLD_PATH = true;
-    private static final int REQUEST_DOWNLOAD_VIDEO_PATH = 0x1235;
-    private static final int REQUEST_DOWNLOAD_AUDIO_PATH = 0x1236;
     private String downloadPathVideoPreference;
     private String downloadPathAudioPreference;
     private String storageUseSafPreference;
@@ -44,6 +44,12 @@ public class DownloadSettingsFragment extends BasePreferenceFragment {
     private Preference prefStorageAsk;
 
     private Context ctx;
+    private final ActivityResultLauncher<Intent> requestDownloadVideoPathLauncher =
+            registerForActivityResult(
+                    new StartActivityForResult(), this::requestDownloadVideoPathResult);
+    private final ActivityResultLauncher<Intent> requestDownloadAudioPathLauncher =
+            registerForActivityResult(
+                    new StartActivityForResult(), this::requestDownloadAudioPathResult);
 
     @Override
     public void onCreatePreferences(final Bundle savedInstanceState, final String rootKey) {
@@ -173,7 +179,7 @@ public class DownloadSettingsFragment extends BasePreferenceFragment {
         final AlertDialog.Builder msg = new AlertDialog.Builder(ctx);
         msg.setTitle(title);
         msg.setMessage(message);
-        msg.setPositiveButton(getString(R.string.finish), null);
+        msg.setPositiveButton(getString(R.string.ok), null);
         msg.show();
     }
 
@@ -185,7 +191,6 @@ public class DownloadSettingsFragment extends BasePreferenceFragment {
         }
 
         final String key = preference.getKey();
-        final int request;
 
         if (key.equals(storageUseSafPreference)) {
             if (!NewPipeSettings.useStorageAccessFramework(ctx)) {
@@ -198,43 +203,39 @@ public class DownloadSettingsFragment extends BasePreferenceFragment {
             updatePreferencesSummary();
             return true;
         } else if (key.equals(downloadPathVideoPreference)) {
-            request = REQUEST_DOWNLOAD_VIDEO_PATH;
+            launchDirectoryPicker(requestDownloadVideoPathLauncher);
         } else if (key.equals(downloadPathAudioPreference)) {
-            request = REQUEST_DOWNLOAD_AUDIO_PATH;
+            launchDirectoryPicker(requestDownloadAudioPathLauncher);
         } else {
             return super.onPreferenceTreeClick(preference);
         }
 
-        startActivityForResult(StoredDirectoryHelper.getPicker(ctx), request);
-
         return true;
     }
 
-    @Override
-    public void onActivityResult(final int requestCode, final int resultCode, final Intent data) {
+    private void launchDirectoryPicker(final ActivityResultLauncher<Intent> launcher) {
+        launcher.launch(StoredDirectoryHelper.getPicker(ctx));
+    }
+
+    private void requestDownloadVideoPathResult(final ActivityResult result) {
+        requestDownloadPathResult(result, downloadPathVideoPreference);
+    }
+
+    private void requestDownloadAudioPathResult(final ActivityResult result) {
+        requestDownloadPathResult(result, downloadPathAudioPreference);
+    }
+
+    private void requestDownloadPathResult(final ActivityResult result, final String key) {
         assureCorrectAppLanguage(getContext());
-        super.onActivityResult(requestCode, resultCode, data);
-        if (DEBUG) {
-            Log.d(TAG, "onActivityResult() called with: "
-                    + "requestCode = [" + requestCode + "], "
-                    + "resultCode = [" + resultCode + "], data = [" + data + "]"
-            );
-        }
 
-        if (resultCode != Activity.RESULT_OK) {
+        if (result.getResultCode() != Activity.RESULT_OK) {
             return;
         }
 
-        final String key;
-        if (requestCode == REQUEST_DOWNLOAD_VIDEO_PATH) {
-            key = downloadPathVideoPreference;
-        } else if (requestCode == REQUEST_DOWNLOAD_AUDIO_PATH) {
-            key = downloadPathAudioPreference;
-        } else {
-            return;
+        Uri uri = null;
+        if (result.getData() != null) {
+            uri = result.getData().getData();
         }
-
-        Uri uri = data.getData();
         if (uri == null) {
             showMessageDialog(R.string.general_error, R.string.invalid_directory);
             return;

app/src/main/java/org/schabi/newpipe/settings/NewPipeSettings.java

@@ -6,6 +6,7 @@ import android.os.Build;
 import android.os.Environment;
 
 import androidx.annotation.NonNull;
+import androidx.annotation.StringRes;
 import androidx.preference.PreferenceManager;
 
 import org.schabi.newpipe.R;
@@ -59,6 +60,10 @@ public final class NewPipeSettings {
             isFirstRun = true;
         }
 
+        // first run migrations, then setDefaultValues, since the latter requires the correct types
+        SettingMigrations.initMigrations(context, isFirstRun);
+
+        // readAgain is true so that if new settings are added their default value is set
         PreferenceManager.setDefaultValues(context, R.xml.main_settings, true);
         PreferenceManager.setDefaultValues(context, R.xml.video_audio_settings, true);
         PreferenceManager.setDefaultValues(context, R.xml.download_settings, true);
@@ -71,8 +76,6 @@ public final class NewPipeSettings {
 
         saveDefaultVideoDownloadDirectory(context);
         saveDefaultAudioDownloadDirectory(context);
-
-        SettingMigrations.initMigrations(context, isFirstRun);
     }
 
     static void saveDefaultVideoDownloadDirectory(final Context context) {
@@ -124,4 +127,29 @@ public final class NewPipeSettings {
 
         return prefs.getBoolean(key, true);
     }
+
+    private static boolean showSearchSuggestions(final Context context,
+                                                 final SharedPreferences sharedPreferences,
+                                                 @StringRes final int key) {
+        final Set<String> enabledSearchSuggestions = sharedPreferences.getStringSet(
+                context.getString(R.string.show_search_suggestions_key), null);
+
+        if (enabledSearchSuggestions == null) {
+            return true; // defaults to true
+        } else {
+            return enabledSearchSuggestions.contains(context.getString(key));
+        }
+    }
+
+    public static boolean showLocalSearchSuggestions(final Context context,
+                                                     final SharedPreferences sharedPreferences) {
+        return showSearchSuggestions(context, sharedPreferences,
+                R.string.show_local_search_suggestions_key);
+    }
+
+    public static boolean showRemoteSearchSuggestions(final Context context,
+                                                      final SharedPreferences sharedPreferences) {
+        return showSearchSuggestions(context, sharedPreferences,
+                R.string.show_remote_search_suggestions_key);
+    }
 }

app/src/main/java/org/schabi/newpipe/settings/PeertubeInstanceListFragment.java

@@ -12,7 +12,6 @@ import android.view.MenuItem;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
-import android.widget.EditText;
 import android.widget.ImageView;
 import android.widget.ProgressBar;
 import android.widget.RadioButton;
@@ -35,6 +34,7 @@ import com.grack.nanojson.JsonStringWriter;
 import com.grack.nanojson.JsonWriter;
 
 import org.schabi.newpipe.R;
+import org.schabi.newpipe.databinding.DialogEditTextBinding;
 import org.schabi.newpipe.extractor.services.peertube.PeertubeInstance;
 import org.schabi.newpipe.util.Constants;
 import org.schabi.newpipe.util.PeertubeHelper;
@@ -207,20 +207,22 @@ public class PeertubeInstanceListFragment extends Fragment {
     }
 
     private void showAddItemDialog(final Context c) {
-        final EditText urlET = new EditText(c);
-        urlET.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_URI);
-        urlET.setHint(R.string.peertube_instance_add_help);
-        final AlertDialog dialog = new AlertDialog.Builder(c)
+        final DialogEditTextBinding dialogBinding
+                = DialogEditTextBinding.inflate(getLayoutInflater());
+        dialogBinding.dialogEditText.setInputType(
+                InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_URI);
+        dialogBinding.dialogEditText.setHint(R.string.peertube_instance_add_help);
+
+        new AlertDialog.Builder(c)
                 .setTitle(R.string.peertube_instance_add_title)
                 .setIcon(R.drawable.place_holder_peertube)
+                .setView(dialogBinding.getRoot())
                 .setNegativeButton(R.string.cancel, null)
-                .setPositiveButton(R.string.finish, (dialog1, which) -> {
-                    final String url = urlET.getText().toString();
+                .setPositiveButton(R.string.ok, (dialog1, which) -> {
+                    final String url = dialogBinding.dialogEditText.getText().toString();
                     addInstance(url);
                 })
-                .create();
-        dialog.setView(urlET, 50, 0, 50, 0);
-        dialog.show();
+                .show();
     }
 
     private void addInstance(final String url) {

app/src/main/java/org/schabi/newpipe/settings/SelectChannelFragment.java

@@ -14,13 +14,11 @@ import androidx.fragment.app.DialogFragment;
 import androidx.recyclerview.widget.LinearLayoutManager;
 import androidx.recyclerview.widget.RecyclerView;
 
-import com.nostra13.universalimageloader.core.DisplayImageOptions;
-import com.nostra13.universalimageloader.core.ImageLoader;
-
 import org.schabi.newpipe.R;
 import org.schabi.newpipe.database.subscription.SubscriptionEntity;
 import org.schabi.newpipe.error.ErrorActivity;
 import org.schabi.newpipe.local.subscription.SubscriptionManager;
+import org.schabi.newpipe.util.PicassoHelper;
 import org.schabi.newpipe.util.ThemeHelper;
 
 import java.util.List;
@@ -54,13 +52,6 @@ import io.reactivex.rxjava3.schedulers.Schedulers;
  */
 
 public class SelectChannelFragment extends DialogFragment {
-    /**
-     * This contains the base display options for images.
-     */
-    private static final DisplayImageOptions DISPLAY_IMAGE_OPTIONS
-            = new DisplayImageOptions.Builder().cacheInMemory(true).build();
-
-    private final ImageLoader imageLoader = ImageLoader.getInstance();
 
     private OnSelectedListener onSelectedListener = null;
     private OnCancelListener onCancelListener = null;
@@ -199,8 +190,7 @@ public class SelectChannelFragment extends DialogFragment {
             final SubscriptionEntity entry = subscriptions.get(position);
             holder.titleView.setText(entry.getName());
             holder.view.setOnClickListener(view -> clickedItem(position));
-            imageLoader.displayImage(entry.getAvatarUrl(), holder.thumbnailView,
-                    DISPLAY_IMAGE_OPTIONS);
+            PicassoHelper.loadAvatar(entry.getAvatarUrl()).into(holder.thumbnailView);
         }
 
         @Override

app/src/main/java/org/schabi/newpipe/settings/SelectPlaylistFragment.java

@@ -14,9 +14,6 @@ import androidx.fragment.app.DialogFragment;
 import androidx.recyclerview.widget.LinearLayoutManager;
 import androidx.recyclerview.widget.RecyclerView;
 
-import com.nostra13.universalimageloader.core.DisplayImageOptions;
-import com.nostra13.universalimageloader.core.ImageLoader;
-
 import org.schabi.newpipe.NewPipeDatabase;
 import org.schabi.newpipe.R;
 import org.schabi.newpipe.database.AppDatabase;
@@ -29,6 +26,7 @@ import org.schabi.newpipe.error.ErrorInfo;
 import org.schabi.newpipe.error.UserAction;
 import org.schabi.newpipe.local.playlist.LocalPlaylistManager;
 import org.schabi.newpipe.local.playlist.RemotePlaylistManager;
+import org.schabi.newpipe.util.PicassoHelper;
 
 import java.util.List;
 import java.util.Vector;
@@ -38,13 +36,6 @@ import io.reactivex.rxjava3.core.Flowable;
 import io.reactivex.rxjava3.disposables.Disposable;
 
 public class SelectPlaylistFragment extends DialogFragment {
-    /**
-     * This contains the base display options for images.
-     */
-    private static final DisplayImageOptions DISPLAY_IMAGE_OPTIONS
-            = new DisplayImageOptions.Builder().cacheInMemory(true).build();
-
-    private final ImageLoader imageLoader = ImageLoader.getInstance();
 
     private OnSelectedListener onSelectedListener = null;
 
@@ -170,16 +161,15 @@ public class SelectPlaylistFragment extends DialogFragment {
 
                 holder.titleView.setText(entry.name);
                 holder.view.setOnClickListener(view -> clickedItem(position));
-                imageLoader.displayImage(entry.thumbnailUrl, holder.thumbnailView,
-                        DISPLAY_IMAGE_OPTIONS);
+                PicassoHelper.loadPlaylistThumbnail(entry.thumbnailUrl).into(holder.thumbnailView);
 
             } else if (selectedItem instanceof PlaylistRemoteEntity) {
                 final PlaylistRemoteEntity entry = ((PlaylistRemoteEntity) selectedItem);
 
                 holder.titleView.setText(entry.getName());
                 holder.view.setOnClickListener(view -> clickedItem(position));
-                imageLoader.displayImage(entry.getThumbnailUrl(), holder.thumbnailView,
-                        DISPLAY_IMAGE_OPTIONS);
+                PicassoHelper.loadPlaylistThumbnail(entry.getThumbnailUrl())
+                        .into(holder.thumbnailView);
             }
         }
 

app/src/main/java/org/schabi/newpipe/settings/SettingMigrations.java

@@ -13,14 +13,22 @@ import org.schabi.newpipe.error.ErrorInfo;
 import org.schabi.newpipe.error.UserAction;
 import org.schabi.newpipe.util.DeviceUtils;
 
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
 import static org.schabi.newpipe.MainActivity.DEBUG;
 
+/**
+ * In order to add a migration, follow these steps, given P is the previous version:<br>
+ * - in the class body add a new {@code MIGRATION_P_P+1 = new Migration(P, P+1) { ... }} and put in
+ *   the {@code migrate()} method the code that need to be run when migrating from P to P+1<br>
+ * - add {@code MIGRATION_P_P+1} at the end of {@link SettingMigrations#SETTING_MIGRATIONS}<br>
+ * - increment {@link SettingMigrations#VERSION}'s value by 1 (so it should become P+1)
+ */
 public final class SettingMigrations {
+
     private static final String TAG = SettingMigrations.class.toString();
-    /**
-     * Version number for preferences. Must be incremented every time a migration is necessary.
-     */
-    public static final int VERSION = 3;
     private static SharedPreferences sp;
 
     public static final Migration MIGRATION_0_1 = new Migration(0, 1) {
@@ -72,6 +80,35 @@ public final class SettingMigrations {
         }
     };
 
+    public static final Migration MIGRATION_3_4 = new Migration(3, 4) {
+        @Override
+        protected void migrate(final Context context) {
+            // Pull request #3546 added support for choosing the type of search suggestions to
+            // show, replacing the on-off switch used before, so migrate the previous user choice
+
+            final String showSearchSuggestionsKey =
+                    context.getString(R.string.show_search_suggestions_key);
+
+            boolean addAllSearchSuggestionTypes;
+            try {
+                addAllSearchSuggestionTypes = sp.getBoolean(showSearchSuggestionsKey, true);
+            } catch (final ClassCastException e) {
+                // just in case it was not a boolean for some reason, let's consider it a "true"
+                addAllSearchSuggestionTypes = true;
+            }
+
+            final Set<String> showSearchSuggestionsValueList = new HashSet<>();
+            if (addAllSearchSuggestionTypes) {
+                // if the preference was true, all suggestions will be shown, otherwise none
+                Collections.addAll(showSearchSuggestionsValueList, context.getResources()
+                        .getStringArray(R.array.show_search_suggestions_value_list));
+            }
+
+            sp.edit().putStringSet(
+                    showSearchSuggestionsKey, showSearchSuggestionsValueList).apply();
+        }
+    };
+
     /**
      * List of all implemented migrations.
      * <p>
@@ -81,9 +118,15 @@ public final class SettingMigrations {
     private static final Migration[] SETTING_MIGRATIONS = {
             MIGRATION_0_1,
             MIGRATION_1_2,
-            MIGRATION_2_3
+            MIGRATION_2_3,
+            MIGRATION_3_4,
     };
 
+    /**
+     * Version number for preferences. Must be incremented every time a migration is necessary.
+     */
+    public static final int VERSION = 4;
+
 
     public static void initMigrations(final Context context, final boolean isFirstRun) {
         // setup migrations and check if there is something to do

app/src/main/java/org/schabi/newpipe/streams/io/StoredFileHelper.java

@@ -8,6 +8,7 @@ import android.net.Uri;
 import android.os.Build;
 import android.os.Environment;
 import android.provider.DocumentsContract;
+import android.util.Log;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -15,6 +16,7 @@ import androidx.documentfile.provider.DocumentFile;
 
 import com.nononsenseapps.filepicker.Utils;
 
+import org.schabi.newpipe.MainActivity;
 import org.schabi.newpipe.settings.NewPipeSettings;
 import org.schabi.newpipe.util.FilePickerActivityHelper;
 
@@ -27,6 +29,9 @@ import us.shandian.giga.io.FileStream;
 import us.shandian.giga.io.FileStreamSAF;
 
 public class StoredFileHelper implements Serializable {
+    private static final boolean DEBUG = MainActivity.DEBUG;
+    private static final String TAG = StoredFileHelper.class.getSimpleName();
+
     private static final long serialVersionUID = 0L;
     public static final String DEFAULT_MIME = "application/octet-stream";
 
@@ -285,7 +290,13 @@ public class StoredFileHelper implements Serializable {
     }
 
     public boolean existsAsFile() {
-        if (source == null) {
+        if (source == null || (docFile == null && ioFile == null)) {
+            if (DEBUG) {
+                Log.d(TAG, "existsAsFile called but something is null: source = ["
+                        + (source == null ? "null => storage is invalid" : source)
+                        + "], docFile = [" + (docFile == null ? "null" : docFile)
+                        + "], ioFile = [" + (ioFile == null ? "null" : ioFile) + "]");
+            }
             return false;
         }
 
@@ -448,11 +459,12 @@ public class StoredFileHelper implements Serializable {
         return !str1.equals(str2);
     }
 
-    public static Intent getPicker(@NonNull final Context ctx) {
+    public static Intent getPicker(@NonNull final Context ctx,
+                                   @NonNull final String mimeType) {
         if (NewPipeSettings.useStorageAccessFramework(ctx)) {
             return new Intent(Intent.ACTION_OPEN_DOCUMENT)
                     .putExtra("android.content.extra.SHOW_ADVANCED", true)
-                    .setType("*/*")
+                    .setType(mimeType)
                     .addCategory(Intent.CATEGORY_OPENABLE)
                     .addFlags(Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION
                             | StoredDirectoryHelper.PERMISSION_FLAGS);
@@ -466,8 +478,10 @@ public class StoredFileHelper implements Serializable {
         }
     }
 
-    public static Intent getPicker(@NonNull final Context ctx, @Nullable final Uri initialPath) {
-        return applyInitialPathToPickerIntent(ctx, getPicker(ctx), initialPath, null);
+    public static Intent getPicker(@NonNull final Context ctx,
+                                   @NonNull final String mimeType,
+                                   @Nullable final Uri initialPath) {
+        return applyInitialPathToPickerIntent(ctx, getPicker(ctx, mimeType), initialPath, null);
     }
 
     public static Intent getNewPicker(@NonNull final Context ctx,

app/src/main/java/org/schabi/newpipe/util/DeviceUtils.java

@@ -11,6 +11,7 @@ import android.view.KeyEvent;
 
 import androidx.annotation.Dimension;
 import androidx.annotation.NonNull;
+import androidx.appcompat.app.AppCompatActivity;
 import androidx.core.content.ContextCompat;
 import androidx.preference.PreferenceManager;
 
@@ -130,4 +131,13 @@ public final class DeviceUtils {
                 && !HI3798MV200
                 && !CVT_MT5886_EU_1G;
     }
+
+    public static boolean isLandscape(final Context context) {
+        return context.getResources().getDisplayMetrics().heightPixels < context.getResources()
+                .getDisplayMetrics().widthPixels;
+    }
+
+    public static boolean isInMultiWindow(final AppCompatActivity activity) {
+        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && activity.isInMultiWindowMode();
+    }
 }

app/src/main/java/org/schabi/newpipe/util/ImageDisplayConstants.java

@@ -1,60 +0,0 @@
-package org.schabi.newpipe.util;
-
-import android.graphics.Bitmap;
-
-import com.nostra13.universalimageloader.core.DisplayImageOptions;
-import com.nostra13.universalimageloader.core.assist.ImageScaleType;
-import com.nostra13.universalimageloader.core.display.FadeInBitmapDisplayer;
-
-import org.schabi.newpipe.R;
-
-public final class ImageDisplayConstants {
-    private static final int BITMAP_FADE_IN_DURATION_MILLIS = 250;
-
-    /**
-     * This constant contains the base display options.
-     */
-    private static final DisplayImageOptions BASE_DISPLAY_IMAGE_OPTIONS =
-            new DisplayImageOptions.Builder()
-                    .cacheInMemory(true)
-                    .cacheOnDisk(true)
-                    .resetViewBeforeLoading(true)
-                    .bitmapConfig(Bitmap.Config.RGB_565)
-                    .imageScaleType(ImageScaleType.EXACTLY)
-                    .displayer(new FadeInBitmapDisplayer(BITMAP_FADE_IN_DURATION_MILLIS))
-                    .build();
-
-    /*//////////////////////////////////////////////////////////////////////////
-    // DisplayImageOptions default configurations
-    //////////////////////////////////////////////////////////////////////////*/
-
-    public static final DisplayImageOptions DISPLAY_AVATAR_OPTIONS =
-            new DisplayImageOptions.Builder()
-                    .cloneFrom(BASE_DISPLAY_IMAGE_OPTIONS)
-                    .showImageForEmptyUri(R.drawable.buddy)
-                    .showImageOnFail(R.drawable.buddy)
-                    .build();
-
-    public static final DisplayImageOptions DISPLAY_THUMBNAIL_OPTIONS =
-            new DisplayImageOptions.Builder()
-                    .cloneFrom(BASE_DISPLAY_IMAGE_OPTIONS)
-                    .showImageForEmptyUri(R.drawable.dummy_thumbnail)
-                    .showImageOnFail(R.drawable.dummy_thumbnail)
-                    .build();
-
-    public static final DisplayImageOptions DISPLAY_BANNER_OPTIONS =
-            new DisplayImageOptions.Builder()
-                    .cloneFrom(BASE_DISPLAY_IMAGE_OPTIONS)
-                    .showImageForEmptyUri(R.drawable.channel_banner)
-                    .showImageOnFail(R.drawable.channel_banner)
-                    .build();
-
-    public static final DisplayImageOptions DISPLAY_PLAYLIST_OPTIONS =
-            new DisplayImageOptions.Builder()
-                    .cloneFrom(BASE_DISPLAY_IMAGE_OPTIONS)
-                    .showImageForEmptyUri(R.drawable.dummy_thumbnail_playlist)
-                    .showImageOnFail(R.drawable.dummy_thumbnail_playlist)
-                    .build();
-
-    private ImageDisplayConstants() { }
-}

app/src/main/java/org/schabi/newpipe/util/Localization.java

@@ -226,6 +226,16 @@ public final class Localization {
                 shortCount(context, subscriberCount));
     }
 
+    public static String downloadCount(final Context context, final int downloadCount) {
+        return getQuantity(context, R.plurals.download_finished_notification, 0,
+                downloadCount, shortCount(context, downloadCount));
+    }
+
+    public static String deletedDownloadCount(final Context context, final int deletedCount) {
+        return getQuantity(context, R.plurals.deleted_downloads_toast, 0,
+                deletedCount, shortCount(context, deletedCount));
+    }
+
     private static String getQuantity(final Context context, @PluralsRes final int pluralId,
                                       @StringRes final int zeroCaseStringId, final long count,
                                       final String formattedCount) {

app/src/main/java/org/schabi/newpipe/util/NavigationHelper.java

@@ -18,8 +18,6 @@ import androidx.fragment.app.Fragment;
 import androidx.fragment.app.FragmentManager;
 import androidx.fragment.app.FragmentTransaction;
 
-import com.nostra13.universalimageloader.core.ImageLoader;
-
 import org.schabi.newpipe.MainActivity;
 import org.schabi.newpipe.NewPipeDatabase;
 import org.schabi.newpipe.R;
@@ -60,6 +58,8 @@ import java.util.ArrayList;
 
 import static org.schabi.newpipe.util.external_communication.ShareUtils.installApp;
 
+import com.jakewharton.processphoenix.ProcessPhoenix;
+
 public final class NavigationHelper {
     public static final String MAIN_FRAGMENT_TAG = "main_fragment_tag";
     public static final String SEARCH_FRAGMENT_TAG = "search_fragment_tag";
@@ -259,10 +259,9 @@ public final class NavigationHelper {
             if (context instanceof Activity) {
                 new AlertDialog.Builder(context)
                         .setMessage(R.string.no_player_found)
-                        .setPositiveButton(R.string.install, (dialog, which) -> {
-                            ShareUtils.openUrlInBrowser(context,
-                                    context.getString(R.string.fdroid_vlc_url), false);
-                        })
+                        .setPositiveButton(R.string.install,
+                                (dialog, which) -> ShareUtils.openUrlInBrowser(context,
+                                        context.getString(R.string.fdroid_vlc_url), false))
                         .setNegativeButton(R.string.cancel, (dialog, which)
                                 -> Log.i("NavigationHelper", "You unlocked a secret unicorn."))
                         .show();
@@ -284,8 +283,6 @@ public final class NavigationHelper {
     }
 
     public static void gotoMainFragment(final FragmentManager fragmentManager) {
-        ImageLoader.getInstance().clearMemoryCache();
-
         final boolean popped = fragmentManager.popBackStackImmediate(MAIN_FRAGMENT_TAG, 0);
         if (!popped) {
             openMainFragment(fragmentManager);
@@ -350,13 +347,13 @@ public final class NavigationHelper {
                                                final boolean switchingPlayers) {
 
         final boolean autoPlay;
-        @Nullable final MainPlayer.PlayerType playerType = PlayerHolder.getType();
+        @Nullable final MainPlayer.PlayerType playerType = PlayerHolder.getInstance().getType();
         if (playerType == null) {
             // no player open
             autoPlay = PlayerHelper.isAutoplayAllowedByUser(context);
         } else if (switchingPlayers) {
             // switching player to main player
-            autoPlay = PlayerHolder.isPlaying(); // keep play/pause state
+            autoPlay = PlayerHolder.getInstance().isPlaying(); // keep play/pause state
         } else if (playerType == MainPlayer.PlayerType.VIDEO) {
             // opening new stream while already playing in main player
             autoPlay = PlayerHelper.isAutoplayAllowedByUser(context);
@@ -365,13 +362,15 @@ public final class NavigationHelper {
             autoPlay = false;
         }
 
-        final RunnableWithVideoDetailFragment onVideoDetailFragmentReady = (detailFragment) -> {
+        final RunnableWithVideoDetailFragment onVideoDetailFragmentReady = detailFragment -> {
             expandMainPlayer(detailFragment.requireActivity());
             detailFragment.setAutoPlay(autoPlay);
             if (switchingPlayers) {
                 // Situation when user switches from players to main player. All needed data is
                 // here, we can start watching (assuming newQueue equals playQueue).
-                detailFragment.openVideoPlayer();
+                // Starting directly in fullscreen if the previous player type was popup.
+                detailFragment.openVideoPlayer(playerType == MainPlayer.PlayerType.POPUP
+                        || PlayerHelper.isStartMainPlayerFullscreenEnabled(context));
             } else {
                 detailFragment.selectAndLoadVideo(serviceId, url, title, playQueue);
             }
@@ -610,8 +609,7 @@ public final class NavigationHelper {
      */
     public static void restartApp(final Activity activity) {
         NewPipeDatabase.close();
-        activity.finishAffinity();
-        final Intent intent = new Intent(activity, MainActivity.class);
-        activity.startActivity(intent);
+
+        ProcessPhoenix.triggerRebirth(activity.getApplicationContext());
     }
 }

app/src/main/java/org/schabi/newpipe/util/PermissionHelper.java

@@ -119,7 +119,7 @@ public final class PermissionHelper {
 
     public static boolean isPopupEnabled(final Context context) {
         return Build.VERSION.SDK_INT < Build.VERSION_CODES.M
-                || PermissionHelper.checkSystemAlertWindowPermission(context);
+                || checkSystemAlertWindowPermission(context);
     }
 
     public static void showPopupEnablementToast(final Context context) {

app/src/main/java/org/schabi/newpipe/util/PicassoHelper.java

@@ -0,0 +1,171 @@
+package org.schabi.newpipe.util;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.graphics.Bitmap;
+
+import com.squareup.picasso.Cache;
+import com.squareup.picasso.LruCache;
+import com.squareup.picasso.OkHttp3Downloader;
+import com.squareup.picasso.Picasso;
+import com.squareup.picasso.RequestCreator;
+import com.squareup.picasso.Transformation;
+
+import org.schabi.newpipe.R;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+
+import okhttp3.OkHttpClient;
+
+import static org.schabi.newpipe.extractor.utils.Utils.isBlank;
+
+public final class PicassoHelper {
+    public static final String PLAYER_THUMBNAIL_TAG = "PICASSO_PLAYER_THUMBNAIL_TAG";
+    private static final String PLAYER_THUMBNAIL_TRANSFORMATION_KEY
+            = "PICASSO_PLAYER_THUMBNAIL_TRANSFORMATION_KEY";
+
+    private PicassoHelper() {
+    }
+
+    private static Cache picassoCache;
+    private static OkHttpClient picassoDownloaderClient;
+
+    // suppress because terminate() is called in App.onTerminate(), preventing leaks
+    @SuppressLint("StaticFieldLeak")
+    private static Picasso picassoInstance;
+
+    private static boolean shouldLoadImages;
+
+    public static void init(final Context context) {
+        picassoCache = new LruCache(10 * 1024 * 1024);
+        picassoDownloaderClient = new OkHttpClient.Builder()
+                .cache(new okhttp3.Cache(new File(context.getExternalCacheDir(), "picasso"),
+                        50 * 1024 * 1024))
+                // this should already be the default timeout in OkHttp3, but just to be sure...
+                .callTimeout(15, TimeUnit.SECONDS)
+                .build();
+
+        picassoInstance = new Picasso.Builder(context)
+                .memoryCache(picassoCache) // memory cache
+                .downloader(new OkHttp3Downloader(picassoDownloaderClient)) // disk cache
+                .defaultBitmapConfig(Bitmap.Config.RGB_565)
+                .build();
+    }
+
+    public static void terminate() {
+        picassoCache = null;
+        picassoDownloaderClient = null;
+
+        if (picassoInstance != null) {
+            picassoInstance.shutdown();
+            picassoInstance = null;
+        }
+    }
+
+    public static void clearCache(final Context context) throws IOException {
+        picassoInstance.shutdown();
+        picassoCache.clear(); // clear memory cache
+        final okhttp3.Cache diskCache = picassoDownloaderClient.cache();
+        if (diskCache != null) {
+            diskCache.delete(); // clear disk cache
+        }
+        init(context);
+    }
+
+    public static void cancelTag(final Object tag) {
+        picassoInstance.cancelTag(tag);
+    }
+
+    public static void setIndicatorsEnabled(final boolean enabled) {
+        picassoInstance.setIndicatorsEnabled(enabled); // useful for debugging
+    }
+
+    public static void setShouldLoadImages(final boolean shouldLoadImages) {
+        PicassoHelper.shouldLoadImages = shouldLoadImages;
+    }
+
+    public static boolean getShouldLoadImages() {
+        return shouldLoadImages;
+    }
+
+
+    public static RequestCreator loadAvatar(final String url) {
+        return loadImageDefault(url, R.drawable.buddy);
+    }
+
+    public static RequestCreator loadThumbnail(final String url) {
+        return loadImageDefault(url, R.drawable.dummy_thumbnail);
+    }
+
+    public static RequestCreator loadBanner(final String url) {
+        return loadImageDefault(url, R.drawable.channel_banner);
+    }
+
+    public static RequestCreator loadPlaylistThumbnail(final String url) {
+        return loadImageDefault(url, R.drawable.dummy_thumbnail_playlist);
+    }
+
+    public static RequestCreator loadSeekbarThumbnailPreview(final String url) {
+        return picassoInstance.load(url);
+    }
+
+
+    public static RequestCreator loadScaledDownThumbnail(final Context context, final String url) {
+        // scale down the notification thumbnail for performance
+        return PicassoHelper.loadThumbnail(url)
+                .tag(PLAYER_THUMBNAIL_TAG)
+                .transform(new Transformation() {
+                    @Override
+                    public Bitmap transform(final Bitmap source) {
+                        final float notificationThumbnailWidth = Math.min(
+                                context.getResources()
+                                        .getDimension(R.dimen.player_notification_thumbnail_width),
+                                source.getWidth());
+
+                        final Bitmap result = Bitmap.createScaledBitmap(
+                                source,
+                                (int) notificationThumbnailWidth,
+                                (int) (source.getHeight()
+                                        / (source.getWidth() / notificationThumbnailWidth)),
+                                true);
+
+                        if (result == source) {
+                            // create a new mutable bitmap to prevent strange crashes on some
+                            // devices (see #4638)
+                            final Bitmap copied = Bitmap.createScaledBitmap(
+                                    source,
+                                    (int) notificationThumbnailWidth - 1,
+                                    (int) (source.getHeight() / (source.getWidth()
+                                            / (notificationThumbnailWidth - 1))),
+                                    true);
+                            source.recycle();
+                            return copied;
+                        } else {
+                            source.recycle();
+                            return result;
+                        }
+                    }
+
+                    @Override
+                    public String key() {
+                        return PLAYER_THUMBNAIL_TRANSFORMATION_KEY;
+                    }
+                });
+    }
+
+
+    private static RequestCreator loadImageDefault(final String url, final int placeholderResId) {
+        if (!shouldLoadImages || isBlank(url)) {
+            return picassoInstance
+                    .load((String) null)
+                    .placeholder(placeholderResId) // show placeholder when no image should load
+                    .error(placeholderResId);
+        } else {
+            return picassoInstance
+                    .load(url)
+                    .error(placeholderResId); // don't show placeholder while loading, only on error
+        }
+    }
+}

app/src/main/java/org/schabi/newpipe/util/SavedState.kt

@@ -1,7 +1,7 @@
 package org.schabi.newpipe.util
 
 import android.os.Parcelable
-import kotlinx.android.parcel.Parcelize
+import kotlinx.parcelize.Parcelize
 
 /**
  * Information about the saved state on the disk.