FocusOverlayView: Avoid accessing restricted API

Signed-off-by: Aayush Gupta <aayushgupta219@gmail.com>

.github/workflows/ci.yml

@@ -69,7 +69,7 @@ jobs:
     strategy:
       matrix:
         include:
-          - api-level: 23
+          - api-level: 21
             target: default
             arch: x86
           - api-level: 35

.gitignore

@@ -11,7 +11,6 @@ captures/
 *.class
 app/debug/
 app/release/
-.kotlin/
 
 # vscode / eclipse files
 *.classpath
@@ -20,6 +19,3 @@ app/release/
 bin/
 .vscode/
 *.code-workspace
-
-# logs
-*.log

app/build.gradle.kts

@@ -2,21 +2,16 @@
  * SPDX-FileCopyrightText: 2025 NewPipe e.V. <https://newpipe-ev.de>
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
-import com.mikepenz.aboutlibraries.plugin.DuplicateMode
 
 import com.android.build.api.dsl.ApplicationExtension
 
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.jetbrains.kotlin.android)
-    alias(libs.plugins.jetbrains.kotlin.compose)
     alias(libs.plugins.jetbrains.kotlin.kapt)
-    alias(libs.plugins.jetbrains.kotlin.parcelize)
-    alias(libs.plugins.jetbrains.kotlinx.serialization)
     alias(libs.plugins.google.ksp)
+    alias(libs.plugins.jetbrains.kotlin.parcelize)
     alias(libs.plugins.sonarqube)
-    alias(libs.plugins.hilt)
-    alias(libs.plugins.about.libraries)
     checkstyle
 }
 
@@ -46,7 +41,7 @@ configure<ApplicationExtension> {
     defaultConfig {
         applicationId = "org.schabi.newpipe"
         resValue("string", "app_name", "NewPipe")
-        minSdk = 23
+        minSdk = 21
         targetSdk = 35
 
         versionCode = System.getProperty("versionCodeOverride")?.toInt() ?: 1008
@@ -84,7 +79,7 @@ configure<ApplicationExtension> {
                 resValue("string", "app_name", "NewPipe $suffix")
             }
             isMinifyEnabled = true
-            isShrinkResources = false // disabled to fix F-Droid"s reproducible build
+            isShrinkResources = true
             proguardFiles(
                 getDefaultProguardFile("proguard-android-optimize.txt"),
                 "proguard-rules.pro"
@@ -93,13 +88,7 @@ configure<ApplicationExtension> {
     }
 
     lint {
-        checkReleaseBuilds = false
-        // Or, if you prefer, you can continue to check for errors in release builds,
-        // but continue the build even when errors are found:
-        abortOnError = false
-        // suppress false warning ("Resource IDs will be non-final in Android Gradle Plugin version
-        // 5.0, avoid using them in switch case statements"), which affects only library projects
-        disable += "NonConstantResourceId"
+        lintConfig = file("lint.xml")
     }
 
     compileOptions {
@@ -120,7 +109,6 @@ configure<ApplicationExtension> {
 
     buildFeatures {
         viewBinding = true
-        compose = true
         buildConfig = true
         resValues = true
     }
@@ -220,13 +208,6 @@ sonar {
     }
 }
 
-aboutLibraries {
-    // note: offline mode prevents the plugin from fetching licenses at build time, which would be
-    // harmful for reproducible builds
-    offlineMode = true
-    duplicationMode = DuplicateMode.MERGE
-}
-
 dependencies {
     /** Desugaring **/
     coreLibraryDesugaring(libs.android.desugar)
@@ -240,18 +221,16 @@ dependencies {
     checkstyle(libs.puppycrawl.checkstyle)
     ktlint(libs.pinterest.ktlint)
 
-    /** Kotlin **/
-    implementation(libs.kotlin.stdlib)
-
     /** AndroidX **/
     implementation(libs.androidx.appcompat)
     implementation(libs.androidx.cardview)
     implementation(libs.androidx.constraintlayout)
-    implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.core)
     implementation(libs.androidx.documentfile)
-    implementation(libs.androidx.fragment.compose)
+    implementation(libs.androidx.fragment)
     implementation(libs.androidx.lifecycle.livedata)
-    implementation(libs.androidx.lifecycle.viewmodel.ktx)
+    implementation(libs.androidx.lifecycle.viewmodel)
+    implementation(libs.androidx.localbroadcastmanager)
     implementation(libs.androidx.media)
     implementation(libs.androidx.preference)
     implementation(libs.androidx.recyclerview)
@@ -259,44 +238,13 @@ dependencies {
     implementation(libs.androidx.room.rxjava3)
     ksp(libs.androidx.room.compiler)
     implementation(libs.androidx.swiperefreshlayout)
-    implementation(libs.androidx.work.runtime.ktx)
+    implementation(libs.androidx.viewpager2)
+    implementation(libs.androidx.work.runtime)
     implementation(libs.androidx.work.rxjava3)
     implementation(libs.google.android.material)
     implementation(libs.androidx.webkit)
 
-    /** Compose & other modern patterns **/
-    // Jetpack Compose
-    implementation(platform(libs.androidx.compose.bom))
-    implementation(libs.androidx.compose.material3)
-    implementation(libs.androidx.compose.adaptive)
-    implementation(libs.androidx.activity.compose)
-    implementation(libs.androidx.compose.ui.tooling.preview)
-    implementation(libs.androidx.lifecycle.viewmodel.compose)
-    implementation(libs.androidx.compose.ui.text) // Needed for parsing HTML to AnnotatedString
-    implementation(libs.androidx.compose.material.icons.extended)
-
-    // Jetpack Compose related dependencies
-    implementation(libs.androidx.paging.compose)
-    implementation(libs.androidx.navigation.compose)
-
-    // Coroutines interop
-    implementation(libs.kotlinx.coroutines.rx3)
-
-    // Library loading for About screen
-    implementation(libs.about.libraries.compose.m3)
-
-    // Hilt
-    implementation(libs.hilt.android)
-    ksp(libs.hilt.compiler)
-
-    // Scroll
-    implementation(libs.lazy.column.scrollbar)
-
-    // Kotlinx Serialization
-    implementation(libs.kotlinx.serialization.json)
-
     /** Third-party libraries **/
-    // Instance state boilerplate elimination
     implementation(libs.livefront.bridge)
     implementation(libs.evernote.statesaver.core)
     kapt(libs.evernote.statesaver.compiler)
@@ -322,8 +270,7 @@ dependencies {
     implementation(libs.lisawray.groupie.viewbinding)
 
     // Image loading
-    implementation(libs.coil.compose)
-    implementation(libs.coil.network.okhttp)
+    implementation(libs.squareup.picasso)
 
     // Markdown library for Android
     implementation(libs.noties.markwon.core)
@@ -355,9 +302,6 @@ dependencies {
     debugImplementation(libs.facebook.stetho.core)
     debugImplementation(libs.facebook.stetho.okhttp3)
 
-    // Jetpack Compose
-    debugImplementation(libs.androidx.compose.ui.tooling)
-
     /** Testing **/
     testImplementation(libs.junit)
     testImplementation(libs.mockito.core)
@@ -366,7 +310,4 @@ dependencies {
     androidTestImplementation(libs.androidx.runner)
     androidTestImplementation(libs.androidx.room.testing)
     androidTestImplementation(libs.assertj.core)
-    androidTestImplementation(platform(libs.androidx.compose.bom))
-    androidTestImplementation(libs.androidx.compose.ui.test.junit4)
-    debugImplementation(libs.androidx.compose.ui.test.manifest)
 }

app/check-dependencies.gradle

@@ -1,48 +0,0 @@
-tasks.register('checkDependenciesOrder') {
-    group = 'verification'
-    description = 'Checks that each section in libs.versions.toml is sorted alphabetically'
-
-    def tomlFile = file('../gradle/libs.versions.toml')
-
-    doLast {
-        if (!tomlFile.exists()) {
-            throw new GradleException('TOML file not found')
-        }
-
-        def lines = tomlFile.readLines()
-        def nonSortedBlocks = []
-        def currentBlock = []
-        def prevLine = ''
-        def prevIndex = 0
-
-        lines.eachWithIndex { line, lineIndex ->
-            if (line.trim() && !line.startsWith('#')) {
-                if (line.startsWith('[')) {
-                    prevLine = ''
-                } else {
-                    def currIndex = lineIndex + 1
-                    if (prevLine > line) {
-                        if (currentBlock && currentBlock[-1] == "${prevIndex}: ${prevLine}") {
-                            currentBlock.add("${currIndex}: ${line}")
-                        } else {
-                            if (!currentBlock.isEmpty()) {
-                                nonSortedBlocks.add(currentBlock)
-                                currentBlock = []
-                            }
-                            currentBlock.add("${prevIndex}: ${prevLine}")
-                            currentBlock.add("${currIndex}: ${line}")
-                        }
-                    }
-                    prevLine = line
-                    prevIndex = lineIndex + 1
-                }
-            }
-        }
-
-        if (!currentBlock.isEmpty()) {
-            nonSortedBlocks.add(currentBlock)
-            throw new GradleException("The following lines were not sorted:\n" +
-                    nonSortedBlocks.collect { it.join("\n") }.join("\n\n"))
-        }
-    }
-}

app/lint.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ SPDX-FileCopyrightText: 2026 NewPipe e.V. <https://newpipe-ev.de>
+  ~ SPDX-License-Identifier: GPL-3.0-or-later
+  -->
+<lint>
+    <issue id="MissingTranslation" severity="ignore" />
+    <issue id="MissingQuantity" severity="ignore" />
+    <issue id="ImpliedQuantity" severity="ignore" />
+</lint>

app/proguard-rules.pro

@@ -40,21 +40,6 @@
 ## For some reason NotificationModeConfigFragment wasn't kept (only referenced in a preference xml)
 -keep class org.schabi.newpipe.settings.notifications.** { *; }
 
-## Keep Kotlinx Serialization classes
--keepclassmembers class kotlinx.serialization.json.** {
-    *** Companion;
-}
--keepclasseswithmembers class kotlinx.serialization.json.** {
-    kotlinx.serialization.KSerializer serializer(...);
-}
--keep,includedescriptorclasses class org.schabi.newpipe.**$$serializer { *; }
--keepclassmembers class org.schabi.newpipe.** {
-    *** Companion;
-}
--keepclasseswithmembers class org.schabi.newpipe.** {
-    kotlinx.serialization.KSerializer serializer(...);
-}
-
 # Prevent R8 from stripping or renaming Protobuf internal fields
 -keepclassmembers class * extends com.google.protobuf.GeneratedMessageLite {
     <fields>;

app/src/androidTest/java/org/schabi/newpipe/error/ErrorInfoTest.java

@@ -0,0 +1,62 @@
+package org.schabi.newpipe.error;
+
+import android.os.Parcel;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.filters.LargeTest;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.schabi.newpipe.R;
+import org.schabi.newpipe.extractor.ServiceList;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+
+import java.util.Arrays;
+import java.util.Objects;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Instrumented tests for {@link ErrorInfo}.
+ */
+@RunWith(AndroidJUnit4.class)
+@LargeTest
+public class ErrorInfoTest {
+
+    /**
+     * @param errorInfo the error info to access
+     * @return the private field errorInfo.message.stringRes using reflection
+     */
+    private int getMessageFromErrorInfo(final ErrorInfo errorInfo)
+            throws NoSuchFieldException, IllegalAccessException {
+        final var message = ErrorInfo.class.getDeclaredField("message");
+        message.setAccessible(true);
+        final var messageValue = (ErrorInfo.Companion.ErrorMessage) message.get(errorInfo);
+
+        final var stringRes = ErrorInfo.Companion.ErrorMessage.class.getDeclaredField("stringRes");
+        stringRes.setAccessible(true);
+        return (int) Objects.requireNonNull(stringRes.get(messageValue));
+    }
+
+    @Test
+    public void errorInfoTestParcelable() throws NoSuchFieldException, IllegalAccessException {
+        final ErrorInfo info = new ErrorInfo(new ParsingException("Hello"),
+                UserAction.USER_REPORT, "request", ServiceList.YouTube.getServiceId());
+        // Obtain a Parcel object and write the parcelable object to it:
+        final Parcel parcel = Parcel.obtain();
+        info.writeToParcel(parcel, 0);
+        parcel.setDataPosition(0);
+        final ErrorInfo infoFromParcel = (ErrorInfo) ErrorInfo.CREATOR.createFromParcel(parcel);
+
+        assertTrue(Arrays.toString(infoFromParcel.getStackTraces())
+                .contains(ErrorInfoTest.class.getSimpleName()));
+        assertEquals(UserAction.USER_REPORT, infoFromParcel.getUserAction());
+        assertEquals(ServiceList.YouTube.getServiceInfo().getName(),
+                infoFromParcel.getServiceName());
+        assertEquals("request", infoFromParcel.getRequest());
+        assertEquals(R.string.parsing_error, getMessageFromErrorInfo(infoFromParcel));
+
+        parcel.recycle();
+    }
+}

app/src/androidTest/java/org/schabi/newpipe/error/ErrorInfoTest.kt

@@ -1,127 +0,0 @@
-package org.schabi.newpipe.error
-
-import android.content.Context
-import android.os.Parcel
-import android.os.Parcelable
-import androidx.test.core.app.ApplicationProvider
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.filters.LargeTest
-import java.io.IOException
-import java.net.SocketTimeoutException
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertTrue
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.schabi.newpipe.R
-import org.schabi.newpipe.extractor.ServiceList
-import org.schabi.newpipe.extractor.exceptions.ParsingException
-import org.schabi.newpipe.extractor.exceptions.ReCaptchaException
-
-/**
- * Instrumented tests for {@link ErrorInfo}.
- */
-@RunWith(AndroidJUnit4::class)
-@LargeTest
-class ErrorInfoTest {
-    private val context: Context by lazy { ApplicationProvider.getApplicationContext() }
-
-    /**
-     * @param errorInfo the error info to access
-     * @return the private field errorInfo.message.stringRes using reflection
-     */
-    @Throws(NoSuchFieldException::class, IllegalAccessException::class)
-    private fun getMessageFromErrorInfo(errorInfo: ErrorInfo): Int {
-        val message = ErrorInfo::class.java.getDeclaredField("message")
-        message.isAccessible = true
-        val messageValue = message.get(errorInfo) as ErrorInfo.Companion.ErrorMessage
-
-        val stringRes = ErrorInfo.Companion.ErrorMessage::class.java.getDeclaredField("stringRes")
-        stringRes.isAccessible = true
-        return stringRes.get(messageValue) as Int
-    }
-
-    @Test
-    @Throws(NoSuchFieldException::class, IllegalAccessException::class)
-    fun errorInfoTestParcelable() {
-        val info = ErrorInfo(
-            ParsingException("Hello"),
-            UserAction.USER_REPORT,
-            "request",
-            ServiceList.YouTube.serviceId
-        )
-        // Obtain a Parcel object and write the parcelable object to it:
-        val parcel = Parcel.obtain()
-        info.writeToParcel(parcel, 0)
-        parcel.setDataPosition(0)
-        val creatorField = ErrorInfo::class.java.getDeclaredField("CREATOR")
-        val creator = creatorField.get(null)
-        check(creator is Parcelable.Creator<*>)
-        val infoFromParcel = requireNotNull(
-            creator.createFromParcel(parcel) as? ErrorInfo
-        )
-        assertTrue(
-            infoFromParcel.stackTraces.contentToString()
-                .contains(ErrorInfoTest::class.java.simpleName)
-        )
-        assertEquals(UserAction.USER_REPORT, infoFromParcel.userAction)
-        assertEquals(
-            ServiceList.YouTube.serviceInfo.name,
-            infoFromParcel.getServiceName()
-        )
-        assertEquals("request", infoFromParcel.request)
-        assertEquals(R.string.parsing_error, getMessageFromErrorInfo(infoFromParcel))
-
-        parcel.recycle()
-    }
-
-    /**
-     * Test: Network error on initial load (Resource.Error)
-     */
-
-    @Test
-    fun testInitialCommentNetworkError() {
-        val errorInfo = ErrorInfo(
-            throwable = SocketTimeoutException("Connection timeout"),
-            userAction = UserAction.REQUESTED_COMMENTS,
-            request = "comments"
-        )
-        assertEquals(context.getString(R.string.network_error), errorInfo.getMessage(context))
-        assertTrue(errorInfo.isReportable)
-        assertTrue(errorInfo.isRetryable)
-        assertNull(errorInfo.recaptchaUrl)
-    }
-
-    /**
-     * Test: Network error on paging (LoadState.Error)
-     */
-    @Test
-    fun testPagingNetworkError() {
-        val errorInfo = ErrorInfo(
-            throwable = IOException("Paging failed"),
-            userAction = UserAction.REQUESTED_COMMENTS,
-            request = "comments"
-        )
-        assertEquals(context.getString(R.string.network_error), errorInfo.getMessage(context))
-        assertTrue(errorInfo.isReportable)
-        assertTrue(errorInfo.isRetryable)
-        assertNull(errorInfo.recaptchaUrl)
-    }
-
-    /**
-     * Test: ReCaptcha during comments load
-     */
-    @Test
-    fun testReCaptchaDuringComments() {
-        val url = "https://www.google.com/recaptcha/api/fallback?k=test"
-        val errorInfo = ErrorInfo(
-            throwable = ReCaptchaException("ReCaptcha needed", url),
-            userAction = UserAction.REQUESTED_COMMENTS,
-            request = "comments"
-        )
-        assertEquals(context.getString(R.string.recaptcha_request_toast), errorInfo.getMessage(context))
-        assertEquals(url, errorInfo.recaptchaUrl)
-        assertTrue(errorInfo.isReportable)
-        assertTrue(errorInfo.isRetryable)
-    }
-}

app/src/androidTest/java/org/schabi/newpipe/ui/components/common/ErrorPanelTest.kt

@@ -1,126 +0,0 @@
-package org.schabi.newpipe.ui.components.common
-
-import androidx.activity.ComponentActivity
-import androidx.annotation.StringRes
-import androidx.compose.ui.test.assertIsDisplayed
-import androidx.compose.ui.test.junit4.createAndroidComposeRule
-import androidx.compose.ui.test.onNodeWithText
-import androidx.compose.ui.test.performClick
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import java.net.UnknownHostException
-import org.junit.Rule
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.schabi.newpipe.R
-import org.schabi.newpipe.error.ErrorInfo
-import org.schabi.newpipe.error.UserAction
-import org.schabi.newpipe.extractor.exceptions.ReCaptchaException
-import org.schabi.newpipe.extractor.exceptions.UnsupportedContentInCountryException
-import org.schabi.newpipe.ui.theme.AppTheme
-
-@RunWith(AndroidJUnit4::class)
-class ErrorPanelTest {
-    @get:Rule
-    val composeRule = createAndroidComposeRule<ComponentActivity>()
-
-    private fun setErrorPanel(errorInfo: ErrorInfo, onRetry: (() -> Unit)? = null) {
-        composeRule.setContent {
-            AppTheme {
-                ErrorPanel(errorInfo = errorInfo, onRetry = onRetry)
-            }
-        }
-    }
-    private fun text(@StringRes id: Int) = composeRule.activity.getString(id)
-
-    /**
-     * Test Network Error
-     */
-    @Test
-    fun testNetworkErrorShowsRetryWithoutReportButton() {
-        val networkErrorInfo = ErrorInfo(
-            throwable = UnknownHostException("offline"),
-            userAction = UserAction.REQUESTED_STREAM,
-            request = "https://example.com/watch?v=foo"
-        )
-
-        setErrorPanel(networkErrorInfo, onRetry = {})
-        composeRule.onNodeWithText(text(R.string.network_error)).assertIsDisplayed()
-        composeRule.onNodeWithText(text(R.string.retry), ignoreCase = true).assertIsDisplayed()
-        composeRule.onNodeWithText(text(R.string.error_snackbar_action), ignoreCase = true)
-            .assertDoesNotExist()
-        composeRule.onNodeWithText(text(R.string.recaptcha_solve), ignoreCase = true)
-            .assertDoesNotExist()
-    }
-
-    /**
-     * Test Unexpected Error, Shows Report and Retry buttons
-     */
-    @Test
-    fun unexpectedErrorShowsReportAndRetryButtons() {
-        val unexpectedErrorInfo = ErrorInfo(
-            throwable = RuntimeException("Unexpected error"),
-            userAction = UserAction.REQUESTED_STREAM,
-            request = "https://example.com/watch?v=bar"
-        )
-
-        setErrorPanel(unexpectedErrorInfo, onRetry = {})
-        composeRule.onNodeWithText(text(R.string.error_snackbar_message)).assertIsDisplayed()
-        composeRule.onNodeWithText(text(R.string.retry), ignoreCase = true).assertIsDisplayed()
-        composeRule.onNodeWithText(text(R.string.error_snackbar_action), ignoreCase = true)
-            .assertIsDisplayed()
-    }
-
-    /**
-     * Test Recaptcha Error shows all buttons: solve, retry, open in browser, report
-     */
-    @Test
-    fun recaptchaErrorShowsAllButtons() {
-        var retryClicked = false
-        val recaptchaErrorInfo = ErrorInfo(
-            throwable = ReCaptchaException(
-                "Recaptcha required",
-                "https://example.com/captcha"
-            ),
-            userAction = UserAction.REQUESTED_STREAM,
-            request = "https://example.com/watch?v=baz",
-            openInBrowserUrl = "https://example.com/watch?v=baz"
-        )
-
-        setErrorPanel(
-            errorInfo = recaptchaErrorInfo,
-            onRetry = { retryClicked = true }
-
-        )
-        composeRule.onNodeWithText(text(R.string.recaptcha_solve), ignoreCase = true)
-            .assertIsDisplayed()
-        composeRule.onNodeWithText(text(R.string.retry), ignoreCase = true)
-            .assertIsDisplayed()
-            .performClick()
-        composeRule.onNodeWithText(text(R.string.open_in_browser), ignoreCase = true)
-            .assertIsDisplayed()
-        composeRule.onNodeWithText(text(R.string.error_snackbar_action), ignoreCase = true)
-            .assertIsDisplayed()
-        assert(retryClicked) { "onRetry callback should have been invoked" }
-    }
-
-    /**
-     * Test Content Not Available Error hides retry button
-     */
-    @Test
-    fun testNonRetryableErrorHidesRetryAndReportButtons() {
-        val contentNotAvailable = ErrorInfo(
-            throwable = UnsupportedContentInCountryException("Not available here"),
-            userAction = UserAction.REQUESTED_STREAM,
-            request = "https://example.com/watch?v=qux"
-        )
-
-        setErrorPanel(contentNotAvailable)
-
-        composeRule.onNodeWithText(text(R.string.unsupported_content_in_country))
-            .assertIsDisplayed()
-        composeRule.onNodeWithText(text(R.string.retry), ignoreCase = true)
-            .assertDoesNotExist()
-        composeRule.onNodeWithText(text(R.string.error_snackbar_action), ignoreCase = true)
-            .assertDoesNotExist()
-    }
-}

app/src/androidTest/java/org/schabi/newpipe/ui/components/video/comment/CommentSectionInstrumentedTest.kt

@@ -1,364 +0,0 @@
-package org.schabi.newpipe.ui.components.video.comment
-
-import androidx.annotation.StringRes
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.heightIn
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.rememberLazyListState
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.input.nestedscroll.nestedScroll
-import androidx.compose.ui.platform.rememberNestedScrollInteropConnection
-import androidx.compose.ui.platform.testTag
-import androidx.compose.ui.res.pluralStringResource
-import androidx.compose.ui.test.ExperimentalTestApi
-import androidx.compose.ui.test.assertIsDisplayed
-import androidx.compose.ui.test.hasClickAction
-import androidx.compose.ui.test.hasText
-import androidx.compose.ui.test.junit4.createAndroidComposeRule
-import androidx.compose.ui.test.onNodeWithTag
-import androidx.compose.ui.test.onNodeWithText
-import androidx.compose.ui.test.performClick
-import androidx.compose.ui.test.performScrollTo
-import androidx.compose.ui.test.performScrollToNode
-import androidx.compose.ui.unit.dp
-import androidx.paging.LoadState
-import androidx.paging.LoadStates
-import androidx.paging.PagingData
-import androidx.paging.compose.collectAsLazyPagingItems
-import java.net.UnknownHostException
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import org.junit.Before
-import org.junit.Rule
-import org.junit.Test
-import org.schabi.newpipe.R
-import org.schabi.newpipe.error.ErrorInfo
-import org.schabi.newpipe.error.UserAction
-import org.schabi.newpipe.extractor.Page
-import org.schabi.newpipe.extractor.comments.CommentsInfoItem
-import org.schabi.newpipe.extractor.exceptions.ReCaptchaException
-import org.schabi.newpipe.extractor.stream.Description
-import org.schabi.newpipe.ui.components.common.ErrorPanel
-import org.schabi.newpipe.ui.components.common.LazyColumnThemedScrollbar
-import org.schabi.newpipe.ui.components.common.LoadingIndicator
-import org.schabi.newpipe.ui.emptystate.EmptyStateComposable
-import org.schabi.newpipe.ui.emptystate.EmptyStateSpec
-import org.schabi.newpipe.ui.theme.AppTheme
-import org.schabi.newpipe.viewmodels.util.Resource
-
-class CommentSectionInstrumentedTest {
-
-    @get:Rule
-    val composeRule = createAndroidComposeRule<androidx.activity.ComponentActivity>()
-
-    private val uiStateFlow = MutableStateFlow<Resource<CommentInfo>>(Resource.Loading)
-    private val pagingFlow = MutableStateFlow(PagingData.empty<CommentsInfoItem>())
-    private fun string(@StringRes resId: Int) = composeRule.activity.getString(resId)
-
-    @Before
-    fun setUp() {
-        composeRule.setContent {
-            AppTheme {
-                TestCommentSection(uiStateFlow = uiStateFlow, commentsFlow = pagingFlow)
-            }
-        }
-    }
-
-    private fun successState(commentCount: Int) = Resource.Success(
-        CommentInfo(
-            serviceId = 0,
-            url = "",
-            comments = emptyList(),
-            nextPage = null,
-            commentCount = commentCount,
-            isCommentsDisabled = false
-        )
-    )
-
-    @Test
-    fun commentListLoadsAndScrolls() {
-        val comments = (1..25).map { index ->
-            CommentsInfoItem(
-                commentText = Description("Comment $index", Description.PLAIN_TEXT),
-                uploaderName = "Uploader $index",
-                replies = Page(""),
-                replyCount = 0
-            )
-        }
-        uiStateFlow.value = successState(comments.size)
-        pagingFlow.value = PagingData.from(comments)
-        composeRule.waitForIdle()
-        composeRule.onNodeWithText("Comment 1").assertIsDisplayed()
-        composeRule.onNodeWithTag("comment_list")
-            .performScrollToNode(hasText("Comment 25"))
-        composeRule.onNodeWithText("Comment 25").assertIsDisplayed()
-    }
-
-    @OptIn(ExperimentalTestApi::class)
-    @Test
-    fun pagingErrorShowsErrorPanelAndAllowsRetry() {
-        uiStateFlow.value = successState(10)
-        pagingFlow.value = PagingData.from(
-            data = emptyList(),
-            sourceLoadStates = LoadStates(
-                refresh = LoadState.Error(ReCaptchaException("captcha required", "https://example.com")),
-                prepend = LoadState.NotLoading(true),
-                append = LoadState.NotLoading(true)
-            )
-        )
-        composeRule.waitForIdle()
-
-        val solveMatcher = hasText(string(R.string.recaptcha_solve), ignoreCase = true)
-            .and(hasClickAction())
-        val retryMatcher = hasText(string(R.string.retry), ignoreCase = true)
-            .and(hasClickAction())
-
-        composeRule.waitUntil(timeoutMillis = 5_000) {
-            composeRule.onAllNodes(solveMatcher).fetchSemanticsNodes().isNotEmpty()
-        }
-        composeRule.waitUntil(timeoutMillis = 5_000) {
-            composeRule.onAllNodes(retryMatcher).fetchSemanticsNodes().isNotEmpty()
-        }
-
-        composeRule.onNode(retryMatcher)
-            .performScrollTo()
-            .performClick()
-
-        val recoveredComment = CommentsInfoItem(
-            commentText = Description("Recovered comment", Description.PLAIN_TEXT),
-            uploaderName = "Uploader",
-            replies = Page(""),
-            replyCount = 0
-        )
-
-        uiStateFlow.value = successState(1)
-        pagingFlow.value = PagingData.from(
-            data = listOf(recoveredComment),
-            sourceLoadStates = LoadStates(
-                refresh = LoadState.NotLoading(false),
-                prepend = LoadState.NotLoading(true),
-                append = LoadState.NotLoading(true)
-            )
-        )
-        composeRule.waitForIdle()
-
-        composeRule.waitUntil(timeoutMillis = 5_000) {
-            composeRule.onAllNodes(hasText("Recovered comment"))
-                .fetchSemanticsNodes()
-                .isNotEmpty()
-        }
-        composeRule.onNodeWithText("Recovered comment").assertIsDisplayed()
-
-        composeRule.onNode(solveMatcher).assertDoesNotExist()
-        composeRule.onNode(retryMatcher).assertDoesNotExist()
-    }
-
-    @OptIn(ExperimentalTestApi::class)
-    @Test
-    fun resourceErrorShowsErrorPanelAndRetry() {
-        uiStateFlow.value = Resource.Error(UnknownHostException("offline"))
-        composeRule.waitForIdle()
-
-        composeRule.onNodeWithText(string(R.string.network_error)).assertIsDisplayed()
-        val retryMatcher = hasText(string(R.string.retry), ignoreCase = true)
-            .and(hasClickAction())
-        composeRule.waitUntil(timeoutMillis = 5_000) {
-            composeRule.onAllNodes(retryMatcher).fetchSemanticsNodes().isNotEmpty()
-        }
-
-        composeRule.onNode(retryMatcher)
-            .performScrollTo()
-            .performClick()
-
-        val recoveredComment = CommentsInfoItem(
-            commentText = Description("Recovered comment", Description.PLAIN_TEXT),
-            uploaderName = "Uploader",
-            replies = Page(""),
-            replyCount = 0
-        )
-
-        uiStateFlow.value = successState(1)
-        pagingFlow.value = PagingData.from(
-            data = listOf(recoveredComment),
-            sourceLoadStates = LoadStates(
-                refresh = LoadState.NotLoading(false),
-                prepend = LoadState.NotLoading(true),
-                append = LoadState.NotLoading(true)
-            )
-        )
-        composeRule.waitForIdle()
-
-        composeRule.waitUntil(timeoutMillis = 5_000) {
-            composeRule.onAllNodes(hasText("Recovered comment"))
-                .fetchSemanticsNodes()
-                .isNotEmpty()
-        }
-        composeRule.onNodeWithText("Recovered comment").assertIsDisplayed()
-
-        composeRule.onNodeWithText(string(R.string.network_error))
-            .assertDoesNotExist()
-        composeRule.onNode(retryMatcher).assertDoesNotExist()
-    }
-
-    @OptIn(ExperimentalTestApi::class)
-    @Test
-    fun retryAfterErrorRecoversList() {
-        uiStateFlow.value = Resource.Error(RuntimeException("boom"))
-        composeRule.waitForIdle()
-
-        val retryMatcher = hasText(string(R.string.retry), ignoreCase = true)
-            .and(hasClickAction())
-        composeRule.waitUntil(timeoutMillis = 5_000) {
-            composeRule.onAllNodes(retryMatcher).fetchSemanticsNodes().isNotEmpty()
-        }
-        composeRule.onNode(retryMatcher)
-            .performScrollTo()
-            .performClick()
-
-        val firstComment = CommentsInfoItem(
-            commentText = Description("First comment", Description.PLAIN_TEXT),
-            uploaderName = "Uploader",
-            replies = Page(""),
-            replyCount = 0
-        )
-
-        uiStateFlow.value = successState(1)
-        pagingFlow.value = PagingData.from(
-            data = listOf(firstComment),
-            sourceLoadStates = LoadStates(
-                refresh = LoadState.NotLoading(false),
-                prepend = LoadState.NotLoading(true),
-                append = LoadState.NotLoading(true)
-            )
-        )
-        composeRule.waitForIdle()
-        composeRule.waitUntil(timeoutMillis = 5_000) {
-            composeRule.onAllNodes(hasText("First comment"))
-                .fetchSemanticsNodes()
-                .isNotEmpty()
-        }
-        composeRule.onNodeWithText("First comment").assertIsDisplayed()
-
-        composeRule.onNodeWithText(string(R.string.network_error))
-            .assertDoesNotExist()
-        composeRule.onNode(retryMatcher).assertDoesNotExist()
-    }
-}
-
-@Composable
-private fun TestCommentSection(
-    uiStateFlow: StateFlow<Resource<CommentInfo>>,
-    commentsFlow: Flow<PagingData<CommentsInfoItem>>
-) {
-    val uiState by uiStateFlow.collectAsState()
-    val comments = commentsFlow.collectAsLazyPagingItems()
-    val nestedScrollInterop = rememberNestedScrollInteropConnection()
-    val listState = rememberLazyListState()
-    val COMMENT_LIST_TAG = "comment_list"
-
-    LazyColumnThemedScrollbar(state = listState) {
-        LazyColumn(
-            modifier = Modifier
-                .testTag(COMMENT_LIST_TAG)
-                .nestedScroll(nestedScrollInterop),
-            state = listState
-        ) {
-            when (uiState) {
-                is Resource.Loading -> item {
-                    LoadingIndicator(modifier = Modifier.padding(top = 8.dp))
-                }
-
-                is Resource.Success -> {
-                    val commentInfo = (uiState as Resource.Success<CommentInfo>).data
-                    val count = commentInfo.commentCount
-
-                    when {
-                        commentInfo.isCommentsDisabled -> item {
-                            EmptyStateComposable(
-                                spec = EmptyStateSpec.DisabledComments,
-                                modifier = Modifier
-                                    .fillMaxWidth()
-                                    .heightIn(min = 128.dp)
-                            )
-                        }
-
-                        count == 0 -> item {
-                            EmptyStateComposable(
-                                spec = EmptyStateSpec.NoComments,
-                                modifier = Modifier
-                                    .fillMaxWidth()
-                                    .heightIn(min = 128.dp)
-                            )
-                        }
-
-                        else -> {
-                            if (count >= 0) {
-                                item {
-                                    Text(
-                                        modifier = Modifier
-                                            .padding(start = 12.dp, end = 12.dp, bottom = 4.dp),
-                                        text = pluralStringResource(R.plurals.comments, count, count),
-                                        maxLines = 1,
-                                        style = MaterialTheme.typography.titleMedium
-                                    )
-                                }
-                            }
-                            when (val refresh = comments.loadState.refresh) {
-                                is LoadState.Loading -> item {
-                                    LoadingIndicator(modifier = Modifier.padding(top = 8.dp))
-                                }
-
-                                is LoadState.Error -> item {
-                                    Box(
-                                        modifier = Modifier.fillMaxWidth()
-                                    ) {
-                                        ErrorPanel(
-                                            errorInfo = ErrorInfo(
-                                                throwable = refresh.error,
-                                                userAction = UserAction.REQUESTED_COMMENTS,
-                                                request = "comments"
-                                            ),
-                                            onRetry = { comments.retry() },
-                                            modifier = Modifier.align(Alignment.Center)
-                                        )
-                                    }
-                                }
-
-                                else -> items(comments.itemCount) { index ->
-                                    Comment(comment = comments[index]!!) {}
-                                }
-                            }
-                        }
-                    }
-                }
-
-                is Resource.Error -> item {
-                    Box(
-                        modifier = Modifier.fillMaxSize(),
-                        contentAlignment = Alignment.Center
-                    ) {
-                        ErrorPanel(
-                            errorInfo = ErrorInfo(
-                                throwable = (uiState as Resource.Error).throwable,
-                                userAction = UserAction.REQUESTED_COMMENTS,
-                                request = "comments"
-                            ),
-                            onRetry = { comments.retry() },
-                            modifier = Modifier.align(Alignment.Center)
-                        )
-                    }
-                }
-            }
-        }
-    }
-}

app/src/main/AndroidManifest.xml

@@ -91,25 +91,28 @@
             android:exported="false"
             android:label="@string/settings" />
 
-        <activity
-            android:name=".settings.SettingsV2Activity"
-            android:exported="true"
-            android:label="@string/settings" />
-
         <activity
             android:name=".about.AboutActivity"
             android:exported="false"
             android:label="@string/title_activity_about" />
 
         <service
-            android:name="androidx.work.impl.foreground.SystemForegroundService"
-            android:foregroundServiceType="dataSync"
-            tools:node="merge" />
+            android:name=".local.subscription.services.SubscriptionsImportService"
+            android:foregroundServiceType="dataSync" />
+
+        <service
+            android:name=".local.subscription.services.SubscriptionsExportService"
+            android:foregroundServiceType="dataSync" />
 
         <service
             android:name=".local.feed.service.FeedLoadService"
             android:foregroundServiceType="dataSync" />
 
+        <service
+            android:name="androidx.work.impl.foreground.SystemForegroundService"
+            android:foregroundServiceType="dataSync"
+            tools:node="merge" />
+
         <activity
             android:name=".PanicResponderActivity"
             android:exported="true"
@@ -140,8 +143,7 @@
             android:label="@string/app_name"
             android:launchMode="singleTask" />
 
-        <service
-            android:name="us.shandian.giga.service.DownloadManagerService"
+        <service android:name="us.shandian.giga.service.DownloadManagerService"
             android:foregroundServiceType="dataSync" />
 
         <activity

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

@@ -0,0 +1,285 @@
+package org.schabi.newpipe;
+
+import android.app.Application;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.core.app.NotificationChannelCompat;
+import androidx.core.app.NotificationManagerCompat;
+import androidx.preference.PreferenceManager;
+
+import com.jakewharton.processphoenix.ProcessPhoenix;
+
+import org.acra.ACRA;
+import org.acra.config.CoreConfigurationBuilder;
+import org.schabi.newpipe.error.ReCaptchaActivity;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.downloader.Downloader;
+import org.schabi.newpipe.extractor.services.youtube.extractors.YoutubeStreamExtractor;
+import org.schabi.newpipe.ktx.ExceptionUtils;
+import org.schabi.newpipe.settings.NewPipeSettings;
+import org.schabi.newpipe.util.BridgeStateSaverInitializer;
+import org.schabi.newpipe.util.Localization;
+import org.schabi.newpipe.util.ServiceHelper;
+import org.schabi.newpipe.util.StateSaver;
+import org.schabi.newpipe.util.image.ImageStrategy;
+import org.schabi.newpipe.util.image.PicassoHelper;
+import org.schabi.newpipe.util.image.PreferredImageQuality;
+import org.schabi.newpipe.util.potoken.PoTokenProviderImpl;
+
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.net.SocketException;
+import java.util.List;
+import java.util.Objects;
+
+import io.reactivex.rxjava3.exceptions.CompositeException;
+import io.reactivex.rxjava3.exceptions.MissingBackpressureException;
+import io.reactivex.rxjava3.exceptions.OnErrorNotImplementedException;
+import io.reactivex.rxjava3.exceptions.UndeliverableException;
+import io.reactivex.rxjava3.functions.Consumer;
+import io.reactivex.rxjava3.plugins.RxJavaPlugins;
+
+/*
+ * Copyright (C) Hans-Christoph Steiner 2016 <hans@eds.org>
+ * App.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class App extends Application {
+    public static final String PACKAGE_NAME = BuildConfig.APPLICATION_ID;
+    private static final String TAG = App.class.toString();
+
+    private boolean isFirstRun = false;
+    private boolean notificationsRequested = false;
+
+    private static App app;
+
+    @NonNull
+    public static App getApp() {
+        return app;
+    }
+
+    public boolean getNotificationsRequested() {
+        return notificationsRequested;
+    }
+
+    public void setNotificationsRequested() {
+        notificationsRequested = true;
+    }
+
+    @Override
+    protected void attachBaseContext(final Context base) {
+        super.attachBaseContext(base);
+        initACRA();
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+
+        app = this;
+
+        if (ProcessPhoenix.isPhoenixProcess(this)) {
+            Log.i(TAG, "This is a phoenix process! "
+                    + "Aborting initialization of App[onCreate]");
+            return;
+        }
+
+        // check if the last used preference version is set
+        // to determine whether this is the first app run
+        final int lastUsedPrefVersion = PreferenceManager.getDefaultSharedPreferences(this)
+                .getInt(getString(R.string.last_used_preferences_version), -1);
+        isFirstRun = lastUsedPrefVersion == -1;
+
+        // Initialize settings first because other initializations can use its values
+        NewPipeSettings.initSettings(this);
+
+        NewPipe.init(getDownloader(),
+            Localization.getPreferredLocalization(this),
+            Localization.getPreferredContentCountry(this));
+        Localization.initPrettyTime(Localization.resolvePrettyTime());
+
+        BridgeStateSaverInitializer.init(this);
+        StateSaver.init(this);
+        initNotificationChannels();
+
+        ServiceHelper.initServices(this);
+
+        // Initialize image loader
+        final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
+        PicassoHelper.init(this);
+        ImageStrategy.setPreferredImageQuality(PreferredImageQuality.fromPreferenceKey(this,
+                prefs.getString(getString(R.string.image_quality_key),
+                        getString(R.string.image_quality_default))));
+        PicassoHelper.setIndicatorsEnabled(MainActivity.DEBUG
+                && prefs.getBoolean(getString(R.string.show_image_indicators_key), false));
+
+        configureRxJavaErrorHandler();
+
+        YoutubeStreamExtractor.setPoTokenProvider(PoTokenProviderImpl.INSTANCE);
+    }
+
+    @Override
+    public void onTerminate() {
+        super.onTerminate();
+        PicassoHelper.terminate();
+    }
+
+    protected Downloader getDownloader() {
+        final DownloaderImpl downloader = DownloaderImpl.init(null);
+        setCookiesToDownloader(downloader);
+        return downloader;
+    }
+
+    protected void setCookiesToDownloader(final DownloaderImpl downloader) {
+        final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(
+                getApplicationContext());
+        final String key = getApplicationContext().getString(R.string.recaptcha_cookies_key);
+        downloader.setCookie(ReCaptchaActivity.RECAPTCHA_COOKIES_KEY, prefs.getString(key, null));
+        downloader.updateYoutubeRestrictedModeCookies(getApplicationContext());
+    }
+
+    private void configureRxJavaErrorHandler() {
+        // https://github.com/ReactiveX/RxJava/wiki/What's-different-in-2.0#error-handling
+        RxJavaPlugins.setErrorHandler(new Consumer<Throwable>() {
+            @Override
+            public void accept(@NonNull final Throwable throwable) {
+                Log.e(TAG, "RxJavaPlugins.ErrorHandler called with -> : "
+                        + "throwable = [" + throwable.getClass().getName() + "]");
+
+                final Throwable actualThrowable;
+                if (throwable instanceof UndeliverableException) {
+                    // As UndeliverableException is a wrapper,
+                    // get the cause of it to get the "real" exception
+                    actualThrowable = Objects.requireNonNull(throwable.getCause());
+                } else {
+                    actualThrowable = throwable;
+                }
+
+                final List<Throwable> errors;
+                if (actualThrowable instanceof CompositeException) {
+                    errors = ((CompositeException) actualThrowable).getExceptions();
+                } else {
+                    errors = List.of(actualThrowable);
+                }
+
+                for (final Throwable error : errors) {
+                    if (isThrowableIgnored(error)) {
+                        return;
+                    }
+                    if (isThrowableCritical(error)) {
+                        reportException(error);
+                        return;
+                    }
+                }
+
+                // Out-of-lifecycle exceptions should only be reported if a debug user wishes so,
+                // When exception is not reported, log it
+                if (isDisposedRxExceptionsReported()) {
+                    reportException(actualThrowable);
+                } else {
+                    Log.e(TAG, "RxJavaPlugin: Undeliverable Exception received: ", actualThrowable);
+                }
+            }
+
+            private boolean isThrowableIgnored(@NonNull final Throwable throwable) {
+                // Don't crash the application over a simple network problem
+                return ExceptionUtils.hasAssignableCause(throwable,
+                        // network api cancellation
+                        IOException.class, SocketException.class,
+                        // blocking code disposed
+                        InterruptedException.class, InterruptedIOException.class);
+            }
+
+            private boolean isThrowableCritical(@NonNull final Throwable throwable) {
+                // Though these exceptions cannot be ignored
+                return ExceptionUtils.hasAssignableCause(throwable,
+                        NullPointerException.class, IllegalArgumentException.class, // bug in app
+                        OnErrorNotImplementedException.class, MissingBackpressureException.class,
+                        IllegalStateException.class); // bug in operator
+            }
+
+            private void reportException(@NonNull final Throwable throwable) {
+                // Throw uncaught exception that will trigger the report system
+                Thread.currentThread().getUncaughtExceptionHandler()
+                        .uncaughtException(Thread.currentThread(), throwable);
+            }
+        });
+    }
+
+    /**
+     * 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.
+     */
+    protected void initACRA() {
+        if (ACRA.isACRASenderServiceProcess()) {
+            return;
+        }
+
+        final CoreConfigurationBuilder acraConfig = new CoreConfigurationBuilder()
+                .withBuildConfigClass(BuildConfig.class);
+        ACRA.init(this, acraConfig);
+    }
+
+    private void initNotificationChannels() {
+        // Keep the importance below DEFAULT to avoid making noise on every notification update for
+        // the main and update channels
+        final List<NotificationChannelCompat> notificationChannelCompats = List.of(
+                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(),
+                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(),
+                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(),
+                new NotificationChannelCompat.Builder(getString(R.string.error_report_channel_id),
+                        NotificationManagerCompat.IMPORTANCE_LOW)
+                        .setName(getString(R.string.error_report_channel_name))
+                        .setDescription(getString(R.string.error_report_channel_description))
+                        .build(),
+                new NotificationChannelCompat
+                        .Builder(getString(R.string.streams_notification_channel_id),
+                        NotificationManagerCompat.IMPORTANCE_DEFAULT)
+                        .setName(getString(R.string.streams_notification_channel_name))
+                        .setDescription(
+                                getString(R.string.streams_notification_channel_description))
+                        .build()
+        );
+
+        final NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
+        notificationManager.createNotificationChannelsCompat(notificationChannelCompats);
+    }
+
+    protected boolean isDisposedRxExceptionsReported() {
+        return false;
+    }
+
+    public boolean isFirstRun() {
+        return isFirstRun;
+    }
+}

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

@@ -1,295 +0,0 @@
-package org.schabi.newpipe
-
-import android.app.ActivityManager
-import android.app.Application
-import android.content.Context
-import android.util.Log
-import androidx.core.app.NotificationChannelCompat
-import androidx.core.app.NotificationManagerCompat
-import androidx.core.content.getSystemService
-import androidx.preference.PreferenceManager
-import coil3.ImageLoader
-import coil3.SingletonImageLoader
-import coil3.network.okhttp.OkHttpNetworkFetcherFactory
-import coil3.request.allowRgb565
-import coil3.request.crossfade
-import coil3.util.DebugLogger
-import com.jakewharton.processphoenix.ProcessPhoenix
-import dagger.hilt.android.HiltAndroidApp
-import io.reactivex.rxjava3.exceptions.CompositeException
-import io.reactivex.rxjava3.exceptions.MissingBackpressureException
-import io.reactivex.rxjava3.exceptions.OnErrorNotImplementedException
-import io.reactivex.rxjava3.exceptions.UndeliverableException
-import io.reactivex.rxjava3.functions.Consumer
-import io.reactivex.rxjava3.plugins.RxJavaPlugins
-import java.io.IOException
-import java.io.InterruptedIOException
-import java.net.SocketException
-import org.acra.ACRA.init
-import org.acra.ACRA.isACRASenderServiceProcess
-import org.acra.config.CoreConfigurationBuilder
-import org.schabi.newpipe.error.ReCaptchaActivity
-import org.schabi.newpipe.extractor.NewPipe
-import org.schabi.newpipe.extractor.downloader.Downloader
-import org.schabi.newpipe.extractor.services.youtube.extractors.YoutubeStreamExtractor
-import org.schabi.newpipe.ktx.hasAssignableCause
-import org.schabi.newpipe.settings.NewPipeSettings
-import org.schabi.newpipe.util.BridgeStateSaverInitializer
-import org.schabi.newpipe.util.Localization
-import org.schabi.newpipe.util.ServiceHelper
-import org.schabi.newpipe.util.StateSaver
-import org.schabi.newpipe.util.image.ImageStrategy
-import org.schabi.newpipe.util.image.PreferredImageQuality
-import org.schabi.newpipe.util.potoken.PoTokenProviderImpl
-
-/*
- * Copyright (C) Hans-Christoph Steiner 2016 <hans@eds.org>
- * App.kt is part of NewPipe.
- *
- * NewPipe is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * NewPipe is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
- */
-@HiltAndroidApp
-open class App :
-    Application(),
-    SingletonImageLoader.Factory {
-    var isFirstRun = false
-        private set
-    var notificationsRequested = false
-        private set
-
-    fun setNotificationsRequested() {
-        notificationsRequested = true
-    }
-
-    override fun attachBaseContext(base: Context?) {
-        super.attachBaseContext(base)
-        initACRA()
-    }
-
-    override fun onCreate() {
-        super.onCreate()
-
-        instance = this
-
-        if (ProcessPhoenix.isPhoenixProcess(this)) {
-            Log.i(TAG, "This is a phoenix process! Aborting initialization of App[onCreate]")
-            return
-        }
-
-        // check if the last used preference version is set
-        // to determine whether this is the first app run
-        val lastUsedPrefVersion =
-            PreferenceManager
-                .getDefaultSharedPreferences(this)
-                .getInt(getString(R.string.last_used_preferences_version), -1)
-        isFirstRun = lastUsedPrefVersion == -1
-
-        // Initialize settings first because other initializations can use its values
-        NewPipeSettings.initSettings(this)
-
-        NewPipe.init(
-            getDownloader(),
-            Localization.getPreferredLocalization(this),
-            Localization.getPreferredContentCountry(this)
-        )
-        Localization.initPrettyTime(Localization.resolvePrettyTime())
-
-        BridgeStateSaverInitializer.init(this)
-        StateSaver.init(this)
-        initNotificationChannels()
-
-        ServiceHelper.initServices(this)
-
-        // Initialize image loader
-        val prefs = PreferenceManager.getDefaultSharedPreferences(this)
-        ImageStrategy.setPreferredImageQuality(
-            PreferredImageQuality.fromPreferenceKey(
-                this,
-                prefs.getString(
-                    getString(R.string.image_quality_key),
-                    getString(R.string.image_quality_default)
-                )
-            )
-        )
-
-        configureRxJavaErrorHandler()
-
-        YoutubeStreamExtractor.setPoTokenProvider(PoTokenProviderImpl)
-    }
-
-    override fun newImageLoader(context: Context): ImageLoader = ImageLoader
-        .Builder(this)
-        .logger(if (BuildConfig.DEBUG) DebugLogger() else null)
-        .allowRgb565(getSystemService<ActivityManager>()!!.isLowRamDevice)
-        .crossfade(true)
-        .components {
-            add(OkHttpNetworkFetcherFactory(callFactory = DownloaderImpl.getInstance().client))
-        }.build()
-
-    protected open fun getDownloader(): Downloader {
-        val downloader = DownloaderImpl.init(null)
-        setCookiesToDownloader(downloader)
-        return downloader
-    }
-
-    protected fun setCookiesToDownloader(downloader: DownloaderImpl) {
-        val prefs = PreferenceManager.getDefaultSharedPreferences(this)
-        val key = getString(R.string.recaptcha_cookies_key)
-        downloader.setCookie(ReCaptchaActivity.RECAPTCHA_COOKIES_KEY, prefs.getString(key, null))
-        downloader.updateYoutubeRestrictedModeCookies(this)
-    }
-
-    private fun configureRxJavaErrorHandler() {
-        // https://github.com/ReactiveX/RxJava/wiki/What's-different-in-2.0#error-handling
-        RxJavaPlugins.setErrorHandler(
-            object : Consumer<Throwable> {
-                override fun accept(throwable: Throwable) {
-                    Log.e(TAG, "RxJavaPlugins.ErrorHandler called with -> : throwable = [${throwable.javaClass.getName()}]")
-
-                    // As UndeliverableException is a wrapper,
-                    // get the cause of it to get the "real" exception
-                    val actualThrowable = (throwable as? UndeliverableException)?.cause ?: throwable
-
-                    val errors = (actualThrowable as? CompositeException)?.exceptions ?: listOf(actualThrowable)
-
-                    for (error in errors) {
-                        if (isThrowableIgnored(error)) {
-                            return
-                        }
-                        if (isThrowableCritical(error)) {
-                            reportException(error)
-                            return
-                        }
-                    }
-
-                    // Out-of-lifecycle exceptions should only be reported if a debug user wishes so,
-                    // When exception is not reported, log it
-                    if (isDisposedRxExceptionsReported()) {
-                        reportException(actualThrowable)
-                    } else {
-                        Log.e(TAG, "RxJavaPlugin: Undeliverable Exception received: ", actualThrowable)
-                    }
-                }
-
-                fun isThrowableIgnored(throwable: Throwable): Boolean {
-                    // Don't crash the application over a simple network problem
-                    return throwable // network api cancellation
-                        .hasAssignableCause(
-                            IOException::class.java,
-                            SocketException::class.java, // blocking code disposed
-                            InterruptedException::class.java,
-                            InterruptedIOException::class.java
-                        )
-                }
-
-                fun isThrowableCritical(throwable: Throwable): Boolean {
-                    // Though these exceptions cannot be ignored
-                    return throwable
-                        .hasAssignableCause(
-                            // bug in app
-                            NullPointerException::class.java,
-                            IllegalArgumentException::class.java,
-                            OnErrorNotImplementedException::class.java,
-                            MissingBackpressureException::class.java,
-                            // bug in operator
-                            IllegalStateException::class.java
-                        )
-                }
-
-                fun reportException(throwable: Throwable) {
-                    // Throw uncaught exception that will trigger the report system
-                    Thread
-                        .currentThread()
-                        .uncaughtExceptionHandler
-                        .uncaughtException(Thread.currentThread(), throwable)
-                }
-            }
-        )
-    }
-
-    /**
-     * Called in [.attachBaseContext] after calling the `super` method.
-     * Should be overridden if MultiDex is enabled, since it has to be initialized before ACRA.
-     */
-    protected fun initACRA() {
-        if (isACRASenderServiceProcess()) {
-            return
-        }
-
-        val acraConfig =
-            CoreConfigurationBuilder()
-                .withBuildConfigClass(BuildConfig::class.java)
-        init(this, acraConfig)
-    }
-
-    private fun initNotificationChannels() {
-        // Keep the importance below DEFAULT to avoid making noise on every notification update for
-        // the main and update channels
-        val mainChannel =
-            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()
-        val appUpdateChannel =
-            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()
-        val hashChannel =
-            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()
-        val errorReportChannel =
-            NotificationChannelCompat
-                .Builder(
-                    getString(R.string.error_report_channel_id),
-                    NotificationManagerCompat.IMPORTANCE_LOW
-                ).setName(getString(R.string.error_report_channel_name))
-                .setDescription(getString(R.string.error_report_channel_description))
-                .build()
-        val newStreamChannel =
-            NotificationChannelCompat
-                .Builder(
-                    getString(R.string.streams_notification_channel_id),
-                    NotificationManagerCompat.IMPORTANCE_DEFAULT
-                ).setName(getString(R.string.streams_notification_channel_name))
-                .setDescription(getString(R.string.streams_notification_channel_description))
-                .build()
-
-        val channels = listOf(mainChannel, appUpdateChannel, hashChannel, errorReportChannel, newStreamChannel)
-
-        NotificationManagerCompat.from(this).createNotificationChannelsCompat(channels)
-    }
-
-    protected open fun isDisposedRxExceptionsReported(): Boolean = false
-
-    companion object {
-        const val PACKAGE_NAME: String = BuildConfig.APPLICATION_ID
-        private val TAG = App::class.java.toString()
-
-        @JvmStatic
-        lateinit var instance: App
-            private set
-    }
-}

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

@@ -1,22 +0,0 @@
-package org.schabi.newpipe
-
-import android.content.Context
-import android.content.SharedPreferences
-import androidx.preference.PreferenceManager
-import dagger.Module
-import dagger.Provides
-import dagger.hilt.InstallIn
-import dagger.hilt.android.qualifiers.ApplicationContext
-import dagger.hilt.components.SingletonComponent
-import javax.inject.Singleton
-
-@Module
-@InstallIn(SingletonComponent::class)
-class AppModule {
-
-    @Provides
-    @Singleton
-    fun providesSharedPreference(@ApplicationContext context: Context): SharedPreferences {
-        return PreferenceManager.getDefaultSharedPreferences(context)
-    }
-}

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

@@ -48,11 +48,6 @@ public final class DownloaderImpl extends Downloader {
         this.mCookies = new HashMap<>();
     }
 
-    @NonNull
-    public OkHttpClient getClient() {
-        return client;
-    }
-
     /**
      * It's recommended to call exactly once in the entire lifetime of the application.
      *

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

@@ -43,6 +43,7 @@ import android.widget.FrameLayout;
 import android.widget.Spinner;
 
 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import androidx.appcompat.app.ActionBar;
 import androidx.appcompat.app.ActionBarDrawerToggle;
 import androidx.appcompat.app.AppCompatActivity;
@@ -51,6 +52,7 @@ import androidx.core.content.ContextCompat;
 import androidx.core.view.GravityCompat;
 import androidx.drawerlayout.widget.DrawerLayout;
 import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentContainerView;
 import androidx.fragment.app.FragmentManager;
 import androidx.preference.PreferenceManager;
 
@@ -64,11 +66,13 @@ import org.schabi.newpipe.databinding.ToolbarLayoutBinding;
 import org.schabi.newpipe.error.ErrorUtil;
 import org.schabi.newpipe.extractor.NewPipe;
 import org.schabi.newpipe.extractor.StreamingService;
+import org.schabi.newpipe.extractor.comments.CommentsInfoItem;
 import org.schabi.newpipe.extractor.exceptions.ExtractionException;
 import org.schabi.newpipe.extractor.services.peertube.PeertubeInstance;
 import org.schabi.newpipe.fragments.BackPressable;
 import org.schabi.newpipe.fragments.MainFragment;
 import org.schabi.newpipe.fragments.detail.VideoDetailFragment;
+import org.schabi.newpipe.fragments.list.comments.CommentRepliesFragment;
 import org.schabi.newpipe.fragments.list.search.SearchFragment;
 import org.schabi.newpipe.local.feed.notifications.NotificationWorker;
 import org.schabi.newpipe.player.Player;
@@ -187,7 +191,7 @@ public class MainActivity extends AppCompatActivity {
             NotificationWorker.initialize(this);
         }
         if (!UpdateSettingsFragment.wasUserAskedForConsent(this)
-                && !App.getInstance().isFirstRun()
+                && !App.getApp().isFirstRun()
                 && ReleaseVersionUtil.INSTANCE.isReleaseApk()) {
             UpdateSettingsFragment.askForConsentToUpdateChecks(this);
         }
@@ -199,7 +203,7 @@ public class MainActivity extends AppCompatActivity {
     protected void onPostCreate(final Bundle savedInstanceState) {
         super.onPostCreate(savedInstanceState);
 
-        final App app = App.getInstance();
+        final App app = App.getApp();
 
         if (sharedPreferences.getBoolean(app.getString(R.string.update_app_key), false)
                 && sharedPreferences
@@ -305,25 +309,21 @@ public class MainActivity extends AppCompatActivity {
     }
 
     private boolean drawerItemSelected(final MenuItem item) {
-        switch (item.getGroupId()) {
-            case R.id.menu_services_group:
-                changeService(item);
-                break;
-            case R.id.menu_tabs_group:
-                tabSelected(item);
-                break;
-            case R.id.menu_kiosks_group:
-                try {
-                    kioskSelected(item);
-                } catch (final Exception e) {
-                    ErrorUtil.showUiErrorSnackbar(this, "Selecting drawer kiosk", e);
-                }
-                break;
-            case R.id.menu_options_about_group:
-                optionsAboutSelected(item);
-                break;
-            default:
-                return false;
+        final int groupId = item.getGroupId();
+        if (groupId == R.id.menu_services_group) {
+            changeService(item);
+        } else if (groupId == R.id.menu_tabs_group) {
+            tabSelected(item);
+        } else if (groupId == R.id.menu_kiosks_group) {
+            try {
+                kioskSelected(item);
+            } catch (final Exception e) {
+                ErrorUtil.showUiErrorSnackbar(this, "Selecting drawer kiosk", e);
+            }
+        } else if (groupId == R.id.menu_options_about_group) {
+            optionsAboutSelected(item);
+        } else {
+            return false;
         }
 
         mainBinding.getRoot().closeDrawers();
@@ -599,27 +599,39 @@ public class MainActivity extends AppCompatActivity {
         // In case bottomSheet is not visible on the screen or collapsed we can assume that the user
         // interacts with a fragment inside fragment_holder so all back presses should be
         // handled by it
-        final var fragmentManager = getSupportFragmentManager();
-
         if (bottomSheetHiddenOrCollapsed()) {
-            final var fragment = fragmentManager.findFragmentById(R.id.fragment_holder);
+            final FragmentManager fm = getSupportFragmentManager();
+            final Fragment fragment = fm.findFragmentById(R.id.fragment_holder);
             // If current fragment implements BackPressable (i.e. can/wanna handle back press)
             // delegate the back press to it
-            if (fragment instanceof BackPressable backPressable && backPressable.onBackPressed()) {
+            if (fragment instanceof BackPressable) {
+                if (((BackPressable) fragment).onBackPressed()) {
+                    return;
+                }
+            } else if (fragment instanceof CommentRepliesFragment) {
+                // expand DetailsFragment if CommentRepliesFragment was opened
+                // to show the top level comments again
+                // Expand DetailsFragment if CommentRepliesFragment was opened
+                // and no other CommentRepliesFragments are on top of the back stack
+                // to show the top level comments again.
+                openDetailFragmentFromCommentReplies(fm, false);
+            }
+
+        } else {
+            final Fragment fragmentPlayer = getSupportFragmentManager()
+                    .findFragmentById(R.id.fragment_player_holder);
+            // If current fragment implements BackPressable (i.e. can/wanna handle back press)
+            // delegate the back press to it
+            if (fragmentPlayer instanceof BackPressable) {
+                if (!((BackPressable) fragmentPlayer).onBackPressed()) {
+                    BottomSheetBehavior.from(mainBinding.fragmentPlayerHolder)
+                            .setState(BottomSheetBehavior.STATE_COLLAPSED);
+                }
                 return;
             }
-        } else {
-            final var player = fragmentManager.findFragmentById(R.id.fragment_player_holder);
-            // If current fragment implements BackPressable (i.e. can/wanna handle back press)
-            // delegate the back press to it
-            if (player instanceof BackPressable backPressable && !backPressable.onBackPressed()) {
-                BottomSheetBehavior.from(mainBinding.fragmentPlayerHolder)
-                        .setState(BottomSheetBehavior.STATE_COLLAPSED);
-            }
-            return;
         }
 
-        if (fragmentManager.getBackStackEntryCount() == 1) {
+        if (getSupportFragmentManager().getBackStackEntryCount() == 1) {
             finish();
         } else {
             super.onBackPressed();
@@ -678,9 +690,15 @@ public class MainActivity extends AppCompatActivity {
      * </pre>
      */
     private void onHomeButtonPressed() {
-        final var fm = getSupportFragmentManager();
+        final FragmentManager fm = getSupportFragmentManager();
+        final Fragment fragment = fm.findFragmentById(R.id.fragment_holder);
 
-        if (!NavigationHelper.tryGotoSearchFragment(fm)) {
+        if (fragment instanceof CommentRepliesFragment) {
+            // Expand DetailsFragment if CommentRepliesFragment was opened
+            // and no other CommentRepliesFragments are on top of the back stack
+            // to show the top level comments again.
+            openDetailFragmentFromCommentReplies(fm, true);
+        } else if (!NavigationHelper.tryGotoSearchFragment(fm)) {
             // If search fragment wasn't found in the backstack go to the main fragment
             NavigationHelper.gotoMainFragment(fm);
         }
@@ -854,7 +872,7 @@ public class MainActivity extends AppCompatActivity {
             return;
         }
 
-        if (PlayerHolder.INSTANCE.isPlayerOpen()) {
+        if (PlayerHolder.getInstance().isPlayerOpen()) {
             // if the player is already open, no need for a broadcast receiver
             openMiniPlayerIfMissing();
         } else {
@@ -864,7 +882,7 @@ public class MainActivity extends AppCompatActivity {
                 public void onReceive(final Context context, final Intent intent) {
                     if (Objects.equals(intent.getAction(),
                             VideoDetailFragment.ACTION_PLAYER_STARTED)
-                            && PlayerHolder.INSTANCE.isPlayerOpen()) {
+                            && PlayerHolder.getInstance().isPlayerOpen()) {
                         openMiniPlayerIfMissing();
                         // At this point the player is added 100%, we can unregister. Other actions
                         // are useless since the fragment will not be removed after that.
@@ -880,10 +898,72 @@ public class MainActivity extends AppCompatActivity {
 
             // If the PlayerHolder is not bound yet, but the service is running, try to bind to it.
             // Once the connection is established, the ACTION_PLAYER_STARTED will be sent.
-            PlayerHolder.INSTANCE.tryBindIfNeeded(this);
+            PlayerHolder.getInstance().tryBindIfNeeded(this);
         }
     }
 
+    private void openDetailFragmentFromCommentReplies(
+            @NonNull final FragmentManager fm,
+            final boolean popBackStack
+    ) {
+        // obtain the name of the fragment under the replies fragment that's going to be popped
+        @Nullable final String fragmentUnderEntryName;
+        if (fm.getBackStackEntryCount() < 2) {
+            fragmentUnderEntryName = null;
+        } else {
+            fragmentUnderEntryName = fm.getBackStackEntryAt(fm.getBackStackEntryCount() - 2)
+                    .getName();
+        }
+
+        // the root comment is the comment for which the user opened the replies page
+        @Nullable final CommentRepliesFragment repliesFragment =
+                (CommentRepliesFragment) fm.findFragmentByTag(CommentRepliesFragment.TAG);
+        @Nullable final CommentsInfoItem rootComment =
+                repliesFragment == null ? null : repliesFragment.getCommentsInfoItem();
+
+        // sometimes this function pops the backstack, other times it's handled by the system
+        if (popBackStack) {
+            fm.popBackStackImmediate();
+        }
+
+        // only expand the bottom sheet back if there are no more nested comment replies fragments
+        // stacked under the one that is currently being popped
+        if (CommentRepliesFragment.TAG.equals(fragmentUnderEntryName)) {
+            return;
+        }
+
+        final BottomSheetBehavior<FragmentContainerView> behavior = BottomSheetBehavior
+                .from(mainBinding.fragmentPlayerHolder);
+        // do not return to the comment if the details fragment was closed
+        if (behavior.getState() == BottomSheetBehavior.STATE_HIDDEN) {
+            return;
+        }
+
+        // scroll to the root comment once the bottom sheet expansion animation is finished
+        behavior.addBottomSheetCallback(new BottomSheetBehavior.BottomSheetCallback() {
+            @Override
+            public void onStateChanged(@NonNull final View bottomSheet,
+                                       final int newState) {
+                if (newState == BottomSheetBehavior.STATE_EXPANDED) {
+                    final Fragment detailFragment = fm.findFragmentById(
+                            R.id.fragment_player_holder);
+                    if (detailFragment instanceof VideoDetailFragment && rootComment != null) {
+                        // should always be the case
+                        ((VideoDetailFragment) detailFragment).scrollToComment(rootComment);
+                    }
+                    behavior.removeBottomSheetCallback(this);
+                }
+            }
+
+            @Override
+            public void onSlide(@NonNull final View bottomSheet, final float slideOffset) {
+                // not needed, listener is removed once the sheet is expanded
+            }
+        });
+
+        behavior.setState(BottomSheetBehavior.STATE_EXPANDED);
+    }
+
     private boolean bottomSheetHiddenOrCollapsed() {
         final BottomSheetBehavior<FrameLayout> bottomSheetBehavior =
                 BottomSheetBehavior.from(mainBinding.fragmentPlayerHolder);

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

@@ -82,7 +82,9 @@ class NewVersionWorker(
             )
 
         val notificationManager = NotificationManagerCompat.from(applicationContext)
-        notificationManager.notify(2000, notificationBuilder.build())
+        if (notificationManager.areNotificationsEnabled()) {
+            notificationManager.notify(2000, notificationBuilder.build())
+        }
     }
 
     @Throws(IOException::class, ReCaptchaException::class)

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

@@ -41,50 +41,50 @@ public final class QueueItemMenuUtil {
         }
 
         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:
-                    PlaylistDialog.createCorrespondingDialog(
-                            context,
-                            List.of(new StreamEntity(item)),
-                            dialog -> dialog.show(
-                                    fragmentManager,
-                                    "QueueItemMenuUtil@append_playlist"
-                            )
-                    );
+            final int itemId = menuItem.getItemId();
+            if (itemId == R.id.menu_item_remove) {
+                final int index = playQueue.indexOf(item);
+                playQueue.remove(index);
+                return true;
+            } else if (itemId == 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;
+            } else if (itemId == R.id.menu_item_append_playlist) {
+                PlaylistDialog.createCorrespondingDialog(
+                        context,
+                        List.of(new StreamEntity(item)),
+                        dialog -> dialog.show(
+                                fragmentManager,
+                                "QueueItemMenuUtil@append_playlist"
+                        )
+                );
 
-                    return true;
-                case R.id.menu_item_channel_details:
-                    SparseItemUtil.fetchUploaderUrlIfSparse(context, item.getServiceId(),
-                            item.getUrl(), item.getUploaderUrl(),
-                            // An intent must be used here.
-                            // Opening with FragmentManager transactions is not working,
-                            // as PlayQueueActivity doesn't use fragments.
-                            uploaderUrl -> NavigationHelper.openChannelFragmentUsingIntent(
-                                    context, item.getServiceId(), uploaderUrl, item.getUploader()
-                            ));
-                    return true;
-                case R.id.menu_item_share:
-                    shareText(context, item.getTitle(), item.getUrl(),
-                            item.getThumbnails());
-                    return true;
-                case R.id.menu_item_download:
-                    fetchStreamInfoAndSaveToDatabase(context, item.getServiceId(), item.getUrl(),
-                            info -> {
-                                final DownloadDialog downloadDialog = new DownloadDialog(context,
-                                        info);
-                                downloadDialog.show(fragmentManager, "downloadDialog");
-                            });
-                    return true;
+                return true;
+            } else if (itemId == R.id.menu_item_channel_details) {
+                SparseItemUtil.fetchUploaderUrlIfSparse(context, item.getServiceId(),
+                        item.getUrl(), item.getUploaderUrl(),
+                        // An intent must be used here.
+                        // Opening with FragmentManager transactions is not working,
+                        // as PlayQueueActivity doesn't use fragments.
+                        uploaderUrl -> NavigationHelper.openChannelFragmentUsingIntent(
+                                context, item.getServiceId(), uploaderUrl, item.getUploader()
+                        ));
+                return true;
+            } else if (itemId == R.id.menu_item_share) {
+                shareText(context, item.getTitle(), item.getUrl(),
+                        item.getThumbnails());
+                return true;
+            } else if (itemId == R.id.menu_item_download) {
+                fetchStreamInfoAndSaveToDatabase(context, item.getServiceId(), item.getUrl(),
+                        info -> {
+                            final DownloadDialog downloadDialog = new DownloadDialog(context,
+                                    info);
+                            downloadDialog.show(fragmentManager, "downloadDialog");
+                        });
+                return true;
             }
             return false;
         });

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

@@ -361,9 +361,15 @@ public class RouterActivity extends AppCompatActivity {
         // Default / Ask always
         final List<AdapterChoiceItem> availableChoices = choiceChecker.getAvailableChoices();
         switch (availableChoices.size()) {
-            case 1 -> handleChoice(availableChoices.get(0).key);
-            case 0 -> handleChoice(getString(R.string.show_info_key));
-            default -> showDialog(availableChoices);
+            case 1:
+                handleChoice(availableChoices.get(0).key);
+                break;
+            case 0:
+                handleChoice(getString(R.string.show_info_key));
+                break;
+            default:
+                showDialog(availableChoices);
+                break;
         }
     }
 
@@ -537,7 +543,7 @@ public class RouterActivity extends AppCompatActivity {
             // Enqueue is only shown if the current queue is not empty.
             // However, if the playqueue or the player is cleared after this item was chosen and
             // while the item is extracted, it will automatically fall back to background player.
-            if (PlayerHolder.INSTANCE.getQueueSize() > 0) {
+            if (PlayerHolder.getInstance().getQueueSize() > 0) {
                 returnedItems.add(new AdapterChoiceItem(getString(R.string.enqueue_key),
                         getString(R.string.enqueue_stream), R.drawable.ic_add));
             }
@@ -680,7 +686,7 @@ public class RouterActivity extends AppCompatActivity {
         }
 
         // ...the player is not running or in normal Video-mode/type
-        final PlayerType playerType = PlayerHolder.INSTANCE.getType();
+        final PlayerType playerType = PlayerHolder.getInstance().getType();
         return playerType == null || playerType == PlayerType.MAIN;
     }
 

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

@@ -1,29 +1,260 @@
 package org.schabi.newpipe.about
 
 import android.os.Bundle
-import androidx.activity.compose.setContent
-import androidx.activity.enableEdgeToEdge
+import android.view.LayoutInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
+import android.widget.Button
+import androidx.annotation.StringRes
 import androidx.appcompat.app.AppCompatActivity
-import androidx.compose.ui.res.stringResource
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import androidx.viewpager2.adapter.FragmentStateAdapter
+import com.google.android.material.tabs.TabLayoutMediator
+import org.schabi.newpipe.BuildConfig
 import org.schabi.newpipe.R
-import org.schabi.newpipe.ui.components.common.ScaffoldWithToolbar
-import org.schabi.newpipe.ui.screens.AboutScreen
-import org.schabi.newpipe.ui.theme.AppTheme
+import org.schabi.newpipe.databinding.ActivityAboutBinding
+import org.schabi.newpipe.databinding.FragmentAboutBinding
+import org.schabi.newpipe.util.ThemeHelper
+import org.schabi.newpipe.util.external_communication.ShareUtils
 
 class AboutActivity : AppCompatActivity() {
-    override fun onCreate(savedInstanceState: Bundle?) {
-        enableEdgeToEdge()
-        super.onCreate(savedInstanceState)
 
-        setContent {
-            AppTheme {
-                ScaffoldWithToolbar(
-                    title = stringResource(R.string.title_activity_about),
-                    onBackClick = { onBackPressedDispatcher.onBackPressed() }
-                ) { padding ->
-                    AboutScreen(padding)
-                }
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        ThemeHelper.setTheme(this)
+        title = getString(R.string.title_activity_about)
+
+        val aboutBinding = ActivityAboutBinding.inflate(layoutInflater)
+        setContentView(aboutBinding.root)
+        setSupportActionBar(aboutBinding.aboutToolbar)
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+
+        // Create the adapter that will return a fragment for each of the three
+        // primary sections of the activity.
+        val mAboutStateAdapter = AboutStateAdapter(this)
+        // Set up the ViewPager with the sections adapter.
+        aboutBinding.aboutViewPager2.adapter = mAboutStateAdapter
+        TabLayoutMediator(
+            aboutBinding.aboutTabLayout,
+            aboutBinding.aboutViewPager2
+        ) { tab, position ->
+            tab.setText(mAboutStateAdapter.getPageTitle(position))
+        }.attach()
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        if (item.itemId == android.R.id.home) {
+            finish()
+            return true
+        }
+        return super.onOptionsItemSelected(item)
+    }
+
+    /**
+     * A placeholder fragment containing a simple view.
+     */
+    class AboutFragment : Fragment() {
+        private fun Button.openLink(@StringRes url: Int) {
+            setOnClickListener {
+                ShareUtils.openUrlInApp(context, requireContext().getString(url))
+            }
+        }
+
+        override fun onCreateView(
+            inflater: LayoutInflater,
+            container: ViewGroup?,
+            savedInstanceState: Bundle?
+        ): View {
+            FragmentAboutBinding.inflate(inflater, container, false).apply {
+                aboutAppVersion.text = BuildConfig.VERSION_NAME
+                aboutGithubLink.openLink(R.string.github_url)
+                aboutDonationLink.openLink(R.string.donation_url)
+                aboutWebsiteLink.openLink(R.string.website_url)
+                aboutPrivacyPolicyLink.openLink(R.string.privacy_policy_url)
+                faqLink.openLink(R.string.faq_url)
+                return root
             }
         }
     }
+
+    /**
+     * A [FragmentStateAdapter] that returns a fragment corresponding to
+     * one of the sections/tabs/pages.
+     */
+    private class AboutStateAdapter(fa: FragmentActivity) : FragmentStateAdapter(fa) {
+        private val posAbout = 0
+        private val posLicense = 1
+        private val totalCount = 2
+
+        override fun createFragment(position: Int): Fragment {
+            return when (position) {
+                posAbout -> AboutFragment()
+                posLicense -> LicenseFragment.newInstance(SOFTWARE_COMPONENTS)
+                else -> throw IllegalArgumentException("Unknown position for ViewPager2")
+            }
+        }
+
+        override fun getItemCount(): Int {
+            // Show 2 total pages.
+            return totalCount
+        }
+
+        fun getPageTitle(position: Int): Int {
+            return when (position) {
+                posAbout -> R.string.tab_about
+                posLicense -> R.string.tab_licenses
+                else -> throw IllegalArgumentException("Unknown position for ViewPager2")
+            }
+        }
+    }
+
+    companion object {
+        /**
+         * List of all software components.
+         */
+        private val SOFTWARE_COMPONENTS = arrayListOf(
+            SoftwareComponent(
+                "ACRA",
+                "2013",
+                "Kevin Gaudin",
+                "https://github.com/ACRA/acra",
+                StandardLicenses.APACHE2
+            ),
+            SoftwareComponent(
+                "AndroidX",
+                "2005 - 2011",
+                "The Android Open Source Project",
+                "https://developer.android.com/jetpack",
+                StandardLicenses.APACHE2
+            ),
+            SoftwareComponent(
+                "ExoPlayer",
+                "2014 - 2020",
+                "Google, Inc.",
+                "https://github.com/google/ExoPlayer",
+                StandardLicenses.APACHE2
+            ),
+            SoftwareComponent(
+                "GigaGet",
+                "2014 - 2015",
+                "Peter Cai",
+                "https://github.com/PaperAirplane-Dev-Team/GigaGet",
+                StandardLicenses.GPL3
+            ),
+            SoftwareComponent(
+                "Groupie",
+                "2016",
+                "Lisa Wray",
+                "https://github.com/lisawray/groupie",
+                StandardLicenses.MIT
+            ),
+            SoftwareComponent(
+                "Android-State",
+                "2018",
+                "Evernote",
+                "https://github.com/Evernote/android-state",
+                StandardLicenses.EPL1
+            ),
+            SoftwareComponent(
+                "Bridge",
+                "2021",
+                "Livefront",
+                "https://github.com/livefront/bridge",
+                StandardLicenses.APACHE2
+            ),
+            SoftwareComponent(
+                "Jsoup",
+                "2009 - 2020",
+                "Jonathan Hedley",
+                "https://github.com/jhy/jsoup",
+                StandardLicenses.MIT
+            ),
+            SoftwareComponent(
+                "Markwon",
+                "2019",
+                "Dimitry Ivanov",
+                "https://github.com/noties/Markwon",
+                StandardLicenses.APACHE2
+            ),
+            SoftwareComponent(
+                "Material Components for Android",
+                "2016 - 2020",
+                "Google, Inc.",
+                "https://github.com/material-components/material-components-android",
+                StandardLicenses.APACHE2
+            ),
+            SoftwareComponent(
+                "NewPipe Extractor",
+                "2017 - 2020",
+                "Christian Schabesberger",
+                "https://github.com/TeamNewPipe/NewPipeExtractor",
+                StandardLicenses.GPL3
+            ),
+            SoftwareComponent(
+                "NoNonsense-FilePicker",
+                "2016",
+                "Jonas Kalderstam",
+                "https://github.com/spacecowboy/NoNonsense-FilePicker",
+                StandardLicenses.MPL2
+            ),
+            SoftwareComponent(
+                "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
+            ),
+            SoftwareComponent(
+                "RxBinding",
+                "2015",
+                "Jake Wharton",
+                "https://github.com/JakeWharton/RxBinding",
+                StandardLicenses.APACHE2
+            ),
+            SoftwareComponent(
+                "RxJava",
+                "2016 - 2020",
+                "RxJava Contributors",
+                "https://github.com/ReactiveX/RxJava",
+                StandardLicenses.APACHE2
+            ),
+            SoftwareComponent(
+                "SearchPreference",
+                "2018",
+                "ByteHamster",
+                "https://github.com/ByteHamster/SearchPreference",
+                StandardLicenses.MIT
+            )
+        )
+    }
 }

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

@@ -0,0 +1,11 @@
+package org.schabi.newpipe.about
+
+import android.os.Parcelable
+import java.io.Serializable
+import kotlinx.parcelize.Parcelize
+
+/**
+ * Class for storing information about a software license.
+ */
+@Parcelize
+class License(val name: String, val abbreviation: String, val filename: String) : Parcelable, Serializable

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

@@ -0,0 +1,142 @@
+package org.schabi.newpipe.about
+
+import android.os.Bundle
+import android.util.Base64
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.webkit.WebView
+import androidx.appcompat.app.AlertDialog
+import androidx.core.os.BundleCompat
+import androidx.core.os.bundleOf
+import androidx.fragment.app.Fragment
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.disposables.CompositeDisposable
+import io.reactivex.rxjava3.disposables.Disposable
+import io.reactivex.rxjava3.schedulers.Schedulers
+import org.schabi.newpipe.BuildConfig
+import org.schabi.newpipe.R
+import org.schabi.newpipe.databinding.FragmentLicensesBinding
+import org.schabi.newpipe.databinding.ItemSoftwareComponentBinding
+import org.schabi.newpipe.ktx.parcelableArrayList
+import org.schabi.newpipe.util.external_communication.ShareUtils
+
+/**
+ * Fragment containing the software licenses.
+ */
+class LicenseFragment : Fragment() {
+    private lateinit var softwareComponents: List<SoftwareComponent>
+    private var activeSoftwareComponent: SoftwareComponent? = null
+    private val compositeDisposable = CompositeDisposable()
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        softwareComponents = arguments?.parcelableArrayList<SoftwareComponent>(ARG_COMPONENTS)!!
+            .sortedBy { it.name } // Sort components by name
+        activeSoftwareComponent = savedInstanceState?.let {
+            BundleCompat.getSerializable(it, SOFTWARE_COMPONENT_KEY, SoftwareComponent::class.java)
+        }
+    }
+
+    override fun onDestroy() {
+        compositeDisposable.dispose()
+        super.onDestroy()
+    }
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        val binding = FragmentLicensesBinding.inflate(inflater, container, false)
+        binding.licensesAppReadLicense.setOnClickListener {
+            compositeDisposable.add(
+                showLicense(NEWPIPE_SOFTWARE_COMPONENT)
+            )
+        }
+        for (component in softwareComponents) {
+            val componentBinding = ItemSoftwareComponentBinding
+                .inflate(inflater, container, false)
+            componentBinding.name.text = component.name
+            componentBinding.copyright.text = getString(
+                R.string.copyright,
+                component.years,
+                component.copyrightOwner,
+                component.license.abbreviation
+            )
+            val root: View = componentBinding.root
+            root.tag = component
+            root.setOnClickListener {
+                compositeDisposable.add(
+                    showLicense(component)
+                )
+            }
+            binding.licensesSoftwareComponents.addView(root)
+            registerForContextMenu(root)
+        }
+        activeSoftwareComponent?.let { compositeDisposable.add(showLicense(it)) }
+        return binding.root
+    }
+
+    override fun onSaveInstanceState(savedInstanceState: Bundle) {
+        super.onSaveInstanceState(savedInstanceState)
+        activeSoftwareComponent?.let { savedInstanceState.putSerializable(SOFTWARE_COMPONENT_KEY, it) }
+    }
+
+    private fun showLicense(
+        softwareComponent: SoftwareComponent
+    ): Disposable {
+        return if (context == null) {
+            Disposable.empty()
+        } else {
+            val context = requireContext()
+            activeSoftwareComponent = softwareComponent
+            Observable.fromCallable { getFormattedLicense(context, softwareComponent.license) }
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe { formattedLicense ->
+                    val webViewData = Base64.encodeToString(
+                        formattedLicense.toByteArray(),
+                        Base64.NO_PADDING
+                    )
+                    val webView = WebView(context)
+                    webView.loadData(webViewData, "text/html; charset=UTF-8", "base64")
+
+                    val builder = AlertDialog.Builder(requireContext())
+                        .setTitle(softwareComponent.name)
+                        .setView(webView)
+                        .setOnCancelListener { activeSoftwareComponent = null }
+                        .setOnDismissListener { activeSoftwareComponent = null }
+                        .setPositiveButton(R.string.done) { dialog, _ -> dialog.dismiss() }
+
+                    if (softwareComponent != NEWPIPE_SOFTWARE_COMPONENT) {
+                        builder.setNeutralButton(R.string.open_website_license) { _, _ ->
+                            ShareUtils.openUrlInApp(requireContext(), softwareComponent.link)
+                        }
+                    }
+
+                    builder.show()
+                }
+        }
+    }
+
+    companion object {
+        private const val ARG_COMPONENTS = "components"
+        private const val SOFTWARE_COMPONENT_KEY = "ACTIVE_SOFTWARE_COMPONENT"
+        private val NEWPIPE_SOFTWARE_COMPONENT = SoftwareComponent(
+            "NewPipe",
+            "2014-2023",
+            "Team NewPipe",
+            "https://newpipe.net/",
+            StandardLicenses.GPL3,
+            BuildConfig.VERSION_NAME
+        )
+
+        fun newInstance(softwareComponents: ArrayList<SoftwareComponent>): LicenseFragment {
+            val fragment = LicenseFragment()
+            fragment.arguments = bundleOf(ARG_COMPONENTS to softwareComponents)
+            return fragment
+        }
+    }
+}

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

@@ -0,0 +1,55 @@
+package org.schabi.newpipe.about
+
+import android.content.Context
+import java.io.IOException
+import org.schabi.newpipe.R
+import org.schabi.newpipe.util.ThemeHelper
+
+/**
+ * @param context the context to use
+ * @param license the license
+ * @return String which contains a HTML formatted license page
+ * styled according to the context's theme
+ */
+fun getFormattedLicense(context: Context, license: License): String {
+    try {
+        return context.assets.open(license.filename).bufferedReader().use { it.readText() }
+            // split the HTML file and insert the stylesheet into the HEAD of the file
+            .replace("</head>", "<style>${getLicenseStylesheet(context)}</style></head>")
+    } catch (e: IOException) {
+        throw IllegalArgumentException("Could not get license file: ${license.filename}", e)
+    }
+}
+
+/**
+ * @param context the Android context
+ * @return String which is a CSS stylesheet according to the context's theme
+ */
+fun getLicenseStylesheet(context: Context): String {
+    val isLightTheme = ThemeHelper.isLightThemeSelected(context)
+    val licenseBackgroundColor = getHexRGBColor(
+        context,
+        if (isLightTheme) R.color.light_license_background_color else R.color.dark_license_background_color
+    )
+    val licenseTextColor = getHexRGBColor(
+        context,
+        if (isLightTheme) R.color.light_license_text_color else R.color.dark_license_text_color
+    )
+    val youtubePrimaryColor = getHexRGBColor(
+        context,
+        if (isLightTheme) R.color.light_youtube_primary_color else R.color.dark_youtube_primary_color
+    )
+    return "body{padding:12px 15px;margin:0;background:#$licenseBackgroundColor;color:#$licenseTextColor}" +
+        "a[href]{color:#$youtubePrimaryColor}pre{white-space:pre-wrap}"
+}
+
+/**
+ * Cast R.color to a hexadecimal color value.
+ *
+ * @param context the context to use
+ * @param color   the color number from R.color
+ * @return a six characters long String with hexadecimal RGB values
+ */
+fun getHexRGBColor(context: Context, color: Int): String {
+    return context.getString(color).substring(3)
+}

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

@@ -0,0 +1,17 @@
+package org.schabi.newpipe.about
+
+import android.os.Parcelable
+import java.io.Serializable
+import kotlinx.parcelize.Parcelize
+
+@Parcelize
+class SoftwareComponent
+@JvmOverloads
+constructor(
+    val name: String,
+    val years: String,
+    val copyrightOwner: String,
+    val link: String,
+    val license: License,
+    val version: String? = null
+) : Parcelable, Serializable

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

@@ -0,0 +1,21 @@
+package org.schabi.newpipe.about
+
+/**
+ * Class containing information about standard software licenses.
+ */
+object StandardLicenses {
+    @JvmField
+    val GPL3 = License("GNU General Public License, Version 3.0", "GPLv3", "gpl_3.html")
+
+    @JvmField
+    val APACHE2 = License("Apache License, Version 2.0", "ALv2", "apache2.html")
+
+    @JvmField
+    val MPL2 = License("Mozilla Public License, Version 2.0", "MPL 2.0", "mpl2.html")
+
+    @JvmField
+    val MIT = License("MIT License", "MIT", "mit.html")
+
+    @JvmField
+    val EPL1 = License("Eclipse Public License, Version 1.0", "EPL 1.0", "epl1.html")
+}

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

@@ -8,7 +8,6 @@ import androidx.room.Query
 import androidx.room.Transaction
 import io.reactivex.rxjava3.core.Completable
 import io.reactivex.rxjava3.core.Flowable
-import io.reactivex.rxjava3.core.Maybe
 import java.time.OffsetDateTime
 import org.schabi.newpipe.database.BasicDAO
 import org.schabi.newpipe.database.stream.model.StreamEntity
@@ -28,7 +27,7 @@ abstract class StreamDAO : BasicDAO<StreamEntity> {
     abstract override fun listByService(serviceId: Int): Flowable<List<StreamEntity>>
 
     @Query("SELECT * FROM streams WHERE url = :url AND service_id = :serviceId")
-    abstract fun getStream(serviceId: Long, url: String): Maybe<StreamEntity>
+    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

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

@@ -12,7 +12,6 @@ import androidx.room.OnConflictStrategy
 import androidx.room.Query
 import androidx.room.Transaction
 import io.reactivex.rxjava3.core.Flowable
-import io.reactivex.rxjava3.core.Maybe
 import org.schabi.newpipe.database.BasicDAO
 import org.schabi.newpipe.database.stream.model.StreamStateEntity
 
@@ -30,12 +29,12 @@ interface StreamStateDAO : BasicDAO<StreamStateEntity> {
     }
 
     @Query("SELECT * FROM " + StreamStateEntity.STREAM_STATE_TABLE + " WHERE " + StreamStateEntity.JOIN_STREAM_ID + " = :streamId")
-    fun getState(streamId: Long): Maybe<StreamStateEntity>
+    fun getState(streamId: Long): Flowable<MutableList<StreamStateEntity>>
 
     @Query("DELETE FROM " + StreamStateEntity.STREAM_STATE_TABLE + " WHERE " + StreamStateEntity.JOIN_STREAM_ID + " = :streamId")
     fun deleteState(streamId: Long): Int
 
-    @Insert(onConflict = OnConflictStrategy.IGNORE)
+    @Insert(onConflict = OnConflictStrategy.Companion.IGNORE)
     fun silentInsertInternal(streamState: StreamStateEntity)
 
     @Transaction

app/src/main/java/org/schabi/newpipe/database/subscription/SubscriptionDAO.kt

@@ -90,7 +90,7 @@ abstract class SubscriptionDAO : BasicDAO<SubscriptionEntity> {
     internal abstract fun silentInsertAllInternal(entities: List<SubscriptionEntity>): List<Long>
 
     @Transaction
-    open fun upsertAll(entities: List<SubscriptionEntity>) {
+    open fun upsertAll(entities: List<SubscriptionEntity>): List<SubscriptionEntity> {
         val insertUidList = silentInsertAllInternal(entities)
 
         insertUidList.forEachIndexed { index: Int, uidFromInsert: Long ->
@@ -106,5 +106,7 @@ abstract class SubscriptionDAO : BasicDAO<SubscriptionEntity> {
                 update(entity)
             }
         }
+
+        return entities
     }
 }

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

@@ -16,6 +16,7 @@ import android.os.IBinder;
 import android.provider.Settings;
 import android.util.Log;
 import android.view.LayoutInflater;
+import android.view.MenuItem;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.AdapterView;
@@ -31,7 +32,6 @@ import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.StringRes;
 import androidx.appcompat.app.AlertDialog;
-import androidx.appcompat.view.menu.ActionMenuItemView;
 import androidx.appcompat.widget.Toolbar;
 import androidx.collection.SparseArrayCompat;
 import androidx.documentfile.provider.DocumentFile;
@@ -113,7 +113,7 @@ public class DownloadDialog extends DialogFragment
     private StoredDirectoryHelper mainStorageAudio = null;
     private StoredDirectoryHelper mainStorageVideo = null;
     private DownloadManager downloadManager = null;
-    private ActionMenuItemView okButton = null;
+    private MenuItem okButton = null;
     private Context context = null;
     private boolean askForSavePath;
 
@@ -558,17 +558,13 @@ public class DownloadDialog extends DialogFragment
         }
         boolean flag = true;
 
-        switch (checkedId) {
-            case R.id.audio_button:
-                setupAudioSpinner();
-                break;
-            case R.id.video_button:
-                setupVideoSpinner();
-                break;
-            case R.id.subtitle_button:
-                setupSubtitleSpinner();
-                flag = false;
-                break;
+        if (checkedId == R.id.audio_button) {
+            setupAudioSpinner();
+        } else if (checkedId == R.id.video_button) {
+            setupVideoSpinner();
+        } else if (checkedId == R.id.subtitle_button) {
+            setupSubtitleSpinner();
+            flag = false;
         }
 
         dialogBinding.threads.setEnabled(flag);
@@ -585,29 +581,26 @@ public class DownloadDialog extends DialogFragment
                     + "position = [" + position + "], id = [" + id + "]");
         }
 
-        switch (parent.getId()) {
-            case R.id.quality_spinner:
-                switch (dialogBinding.videoAudioGroup.getCheckedRadioButtonId()) {
-                    case R.id.video_button:
-                        selectedVideoIndex = position;
-                        onVideoStreamSelected();
-                        break;
-                    case R.id.subtitle_button:
-                        selectedSubtitleIndex = position;
-                        break;
-                }
-                onItemSelectedSetFileName();
-                break;
-            case R.id.audio_track_spinner:
-                final boolean trackChanged = selectedAudioTrackIndex != position;
-                selectedAudioTrackIndex = position;
-                if (trackChanged) {
-                    updateSecondaryStreams();
-                    fetchStreamsSize();
-                }
-                break;
-            case R.id.audio_stream_spinner:
-                selectedAudioIndex = position;
+        final int parentId = parent.getId();
+        if (parentId == R.id.quality_spinner) {
+            final int checkedRadioButtonId = dialogBinding.videoAudioGroup
+                    .getCheckedRadioButtonId();
+            if (checkedRadioButtonId == R.id.video_button) {
+                selectedVideoIndex = position;
+                onVideoStreamSelected();
+            } else if (checkedRadioButtonId == R.id.subtitle_button) {
+                selectedSubtitleIndex = position;
+            }
+            onItemSelectedSetFileName();
+        } else if (parentId == R.id.audio_track_spinner) {
+            final boolean trackChanged = selectedAudioTrackIndex != position;
+            selectedAudioTrackIndex = position;
+            if (trackChanged) {
+                updateSecondaryStreams();
+                fetchStreamsSize();
+            }
+        } else if (parentId == R.id.audio_stream_spinner) {
+            selectedAudioIndex = position;
         }
     }
 
@@ -622,23 +615,20 @@ public class DownloadDialog extends DialogFragment
                 || prevFileName.startsWith(getString(R.string.caption_file_name, fileName, ""))) {
             // only update the file name field if it was not edited by the user
 
-            switch (dialogBinding.videoAudioGroup.getCheckedRadioButtonId()) {
-                case R.id.audio_button:
-                case R.id.video_button:
-                    if (!prevFileName.equals(fileName)) {
-                        // since the user might have switched between audio and video, the correct
-                        // text might already be in place, so avoid resetting the cursor position
-                        dialogBinding.fileName.setText(fileName);
-                    }
-                    break;
-
-                case R.id.subtitle_button:
-                    final String setSubtitleLanguageCode = subtitleStreamsAdapter
-                            .getItem(selectedSubtitleIndex).getLanguageTag();
-                    // this will reset the cursor position, which is bad UX, but it can't be avoided
-                    dialogBinding.fileName.setText(getString(
-                            R.string.caption_file_name, fileName, setSubtitleLanguageCode));
-                    break;
+            final int radioButtonId = dialogBinding.videoAudioGroup
+                    .getCheckedRadioButtonId();
+            if (radioButtonId == R.id.audio_button || radioButtonId == R.id.video_button) {
+                if (!prevFileName.equals(fileName)) {
+                    // since the user might have switched between audio and video, the correct
+                    // text might already be in place, so avoid resetting the cursor position
+                    dialogBinding.fileName.setText(fileName);
+                }
+            } else if (radioButtonId == R.id.subtitle_button) {
+                final String setSubtitleLanguageCode = subtitleStreamsAdapter
+                        .getItem(selectedSubtitleIndex).getLanguageTag();
+                // this will reset the cursor position, which is bad UX, but it can't be avoided
+                dialogBinding.fileName.setText(getString(
+                        R.string.caption_file_name, fileName, setSubtitleLanguageCode));
             }
         }
     }
@@ -770,47 +760,44 @@ public class DownloadDialog extends DialogFragment
 
         filenameTmp = getNameEditText().concat(".");
 
-        switch (dialogBinding.videoAudioGroup.getCheckedRadioButtonId()) {
-            case R.id.audio_button:
-                selectedMediaType = getString(R.string.last_download_type_audio_key);
-                mainStorage = mainStorageAudio;
-                format = audioStreamsAdapter.getItem(selectedAudioIndex).getFormat();
-                size = getWrappedAudioStreams().getSizeInBytes(selectedAudioIndex);
-                if (format == MediaFormat.WEBMA_OPUS) {
-                    mimeTmp = "audio/ogg";
-                    filenameTmp += "opus";
-                } else if (format != null) {
-                    mimeTmp = format.mimeType;
-                    filenameTmp += format.getSuffix();
-                }
-                break;
-            case R.id.video_button:
-                selectedMediaType = getString(R.string.last_download_type_video_key);
-                mainStorage = mainStorageVideo;
-                format = videoStreamsAdapter.getItem(selectedVideoIndex).getFormat();
-                size = wrappedVideoStreams.getSizeInBytes(selectedVideoIndex);
-                if (format != null) {
-                    mimeTmp = format.mimeType;
-                    filenameTmp += format.getSuffix();
-                }
-                break;
-            case R.id.subtitle_button:
-                selectedMediaType = getString(R.string.last_download_type_subtitle_key);
-                mainStorage = mainStorageVideo; // subtitle & video files go together
-                format = subtitleStreamsAdapter.getItem(selectedSubtitleIndex).getFormat();
-                size = wrappedSubtitleStreams.getSizeInBytes(selectedSubtitleIndex);
-                if (format != null) {
-                    mimeTmp = format.mimeType;
-                }
+        final int checkedRadioButtonId = dialogBinding.videoAudioGroup.getCheckedRadioButtonId();
+        if (checkedRadioButtonId == R.id.audio_button) {
+            selectedMediaType = getString(R.string.last_download_type_audio_key);
+            mainStorage = mainStorageAudio;
+            format = audioStreamsAdapter.getItem(selectedAudioIndex).getFormat();
+            size = getWrappedAudioStreams().getSizeInBytes(selectedAudioIndex);
+            if (format == MediaFormat.WEBMA_OPUS) {
+                mimeTmp = "audio/ogg";
+                filenameTmp += "opus";
+            } else if (format != null) {
+                mimeTmp = format.mimeType;
+                filenameTmp += format.getSuffix();
+            }
+        } else if (checkedRadioButtonId == R.id.video_button) {
+            selectedMediaType = getString(R.string.last_download_type_video_key);
+            mainStorage = mainStorageVideo;
+            format = videoStreamsAdapter.getItem(selectedVideoIndex).getFormat();
+            size = wrappedVideoStreams.getSizeInBytes(selectedVideoIndex);
+            if (format != null) {
+                mimeTmp = format.mimeType;
+                filenameTmp += format.getSuffix();
+            }
+        } else if (checkedRadioButtonId == R.id.subtitle_button) {
+            selectedMediaType = getString(R.string.last_download_type_subtitle_key);
+            mainStorage = mainStorageVideo; // subtitle & video files go together
+            format = subtitleStreamsAdapter.getItem(selectedSubtitleIndex).getFormat();
+            size = wrappedSubtitleStreams.getSizeInBytes(selectedSubtitleIndex);
+            if (format != null) {
+                mimeTmp = format.mimeType;
+            }
 
-                if (format == MediaFormat.TTML) {
-                    filenameTmp += MediaFormat.SRT.getSuffix();
-                } else if (format != null) {
-                    filenameTmp += format.getSuffix();
-                }
-                break;
-            default:
-                throw new RuntimeException("No stream selected");
+            if (format == MediaFormat.TTML) {
+                filenameTmp += MediaFormat.SRT.getSuffix();
+            } else if (format != null) {
+                filenameTmp += format.getSuffix();
+            }
+        } else {
+            throw new RuntimeException("No stream selected");
         }
 
         if (!askForSavePath && (mainStorage == null
@@ -1057,59 +1044,56 @@ public class DownloadDialog extends DialogFragment
         long nearLength = 0;
 
         // more download logic: select muxer, subtitle converter, etc.
-        switch (dialogBinding.videoAudioGroup.getCheckedRadioButtonId()) {
-            case R.id.audio_button:
-                kind = 'a';
-                selectedStream = audioStreamsAdapter.getItem(selectedAudioIndex);
+        final int checkedRadioButtonId = dialogBinding.videoAudioGroup.getCheckedRadioButtonId();
+        if (checkedRadioButtonId == R.id.audio_button) {
+            kind = 'a';
+            selectedStream = audioStreamsAdapter.getItem(selectedAudioIndex);
 
-                if (selectedStream.getFormat() == MediaFormat.M4A) {
-                    psName = Postprocessing.ALGORITHM_M4A_NO_DASH;
-                } else if (selectedStream.getFormat() == MediaFormat.WEBMA_OPUS) {
-                    psName = Postprocessing.ALGORITHM_OGG_FROM_WEBM_DEMUXER;
+            if (selectedStream.getFormat() == MediaFormat.M4A) {
+                psName = Postprocessing.ALGORITHM_M4A_NO_DASH;
+            } else if (selectedStream.getFormat() == MediaFormat.WEBMA_OPUS) {
+                psName = Postprocessing.ALGORITHM_OGG_FROM_WEBM_DEMUXER;
+            }
+        } else if (checkedRadioButtonId == R.id.video_button) {
+            kind = 'v';
+            selectedStream = videoStreamsAdapter.getItem(selectedVideoIndex);
+
+            final SecondaryStreamHelper<AudioStream> secondary = videoStreamsAdapter
+                    .getAllSecondary()
+                    .get(wrappedVideoStreams.getStreamsList().indexOf(selectedStream));
+
+            if (secondary != null) {
+                secondaryStream = secondary.getStream();
+
+                if (selectedStream.getFormat() == MediaFormat.MPEG_4) {
+                    psName = Postprocessing.ALGORITHM_MP4_FROM_DASH_MUXER;
+                } else {
+                    psName = Postprocessing.ALGORITHM_WEBM_MUXER;
                 }
-                break;
-            case R.id.video_button:
-                kind = 'v';
-                selectedStream = videoStreamsAdapter.getItem(selectedVideoIndex);
 
-                final SecondaryStreamHelper<AudioStream> secondary = videoStreamsAdapter
-                        .getAllSecondary()
-                        .get(wrappedVideoStreams.getStreamsList().indexOf(selectedStream));
+                final long videoSize = wrappedVideoStreams.getSizeInBytes(
+                        (VideoStream) selectedStream);
 
-                if (secondary != null) {
-                    secondaryStream = secondary.getStream();
-
-                    if (selectedStream.getFormat() == MediaFormat.MPEG_4) {
-                        psName = Postprocessing.ALGORITHM_MP4_FROM_DASH_MUXER;
-                    } else {
-                        psName = Postprocessing.ALGORITHM_WEBM_MUXER;
-                    }
-
-                    final long videoSize = wrappedVideoStreams.getSizeInBytes(
-                            (VideoStream) selectedStream);
-
-                    // set nearLength, only, if both sizes are fetched or known. This probably
-                    // does not work on slow networks but is later updated in the downloader
-                    if (secondary.getSizeInBytes() > 0 && videoSize > 0) {
-                        nearLength = secondary.getSizeInBytes() + videoSize;
-                    }
+                // set nearLength, only, if both sizes are fetched or known. This probably
+                // does not work on slow networks but is later updated in the downloader
+                if (secondary.getSizeInBytes() > 0 && videoSize > 0) {
+                    nearLength = secondary.getSizeInBytes() + videoSize;
                 }
-                break;
-            case R.id.subtitle_button:
-                threads = 1; // use unique thread for subtitles due small file size
-                kind = 's';
-                selectedStream = subtitleStreamsAdapter.getItem(selectedSubtitleIndex);
+            }
+        } else if (checkedRadioButtonId == R.id.subtitle_button) {
+            threads = 1; // use unique thread for subtitles due small file size
+            kind = 's';
+            selectedStream = subtitleStreamsAdapter.getItem(selectedSubtitleIndex);
 
-                if (selectedStream.getFormat() == MediaFormat.TTML) {
-                    psName = Postprocessing.ALGORITHM_TTML_CONVERTER;
-                    psArgs = new String[] {
-                            selectedStream.getFormat().getSuffix(),
-                            "false" // ignore empty frames
-                    };
-                }
-                break;
-            default:
-                return;
+            if (selectedStream.getFormat() == MediaFormat.TTML) {
+                psName = Postprocessing.ALGORITHM_TTML_CONVERTER;
+                psArgs = new String[]{
+                        selectedStream.getFormat().getSuffix(),
+                        "false" // ignore empty frames
+                };
+            }
+        } else {
+            return;
         }
 
         if (secondaryStream == null) {

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

@@ -9,6 +9,7 @@ import com.google.auto.service.AutoService;
 import org.acra.config.CoreConfiguration;
 import org.acra.sender.ReportSender;
 import org.acra.sender.ReportSenderFactory;
+import org.schabi.newpipe.App;
 
 /*
  * Created by Christian Schabesberger on 13.09.16.

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

@@ -133,17 +133,16 @@ public class ErrorActivity extends AppCompatActivity {
 
     @Override
     public boolean onOptionsItemSelected(final MenuItem item) {
-        switch (item.getItemId()) {
-            case android.R.id.home:
-                onBackPressed();
-                return true;
-            case R.id.menu_item_share_error:
-                ShareUtils.shareText(getApplicationContext(),
-                        getString(R.string.error_report_title), buildJson());
-                return true;
-            default:
-                return false;
+        final int itemId = item.getItemId();
+        if (itemId == android.R.id.home) {
+            onBackPressed();
+            return true;
+        } else if (itemId == R.id.menu_item_share_error) {
+            ShareUtils.shareText(getApplicationContext(),
+                    getString(R.string.error_report_title), buildJson());
+            return true;
         }
+        return false;
     }
 
     private void openPrivacyPolicyDialog(final Context context, final String action) {
@@ -307,7 +306,8 @@ public class ErrorActivity extends AppCompatActivity {
     }
 
     private String getOsString() {
-        final String osBase = Build.VERSION.BASE_OS;
+        final String osBase = Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
+                ? Build.VERSION.BASE_OS : "Android";
         return System.getProperty("os.name")
                 + " " + (osBase.isEmpty() ? "Android" : osBase)
                 + " " + Build.VERSION.RELEASE

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

@@ -3,6 +3,7 @@ package org.schabi.newpipe.error
 import android.content.Context
 import android.os.Parcelable
 import androidx.annotation.StringRes
+import androidx.core.content.ContextCompat
 import com.google.android.exoplayer2.ExoPlaybackException
 import com.google.android.exoplayer2.upstream.HttpDataSource
 import com.google.android.exoplayer2.upstream.Loader
@@ -28,7 +29,6 @@ import org.schabi.newpipe.extractor.exceptions.YoutubeMusicPremiumContentExcepti
 import org.schabi.newpipe.ktx.isNetworkRelated
 import org.schabi.newpipe.player.mediasource.FailedMediaSource
 import org.schabi.newpipe.player.resolver.PlaybackResolver
-import org.schabi.newpipe.util.Localization
 
 /**
  * An error has occurred in the app. This class contains plain old parcelable data that can be used
@@ -147,11 +147,13 @@ class ErrorInfo private constructor(
             private vararg val formatArgs: String
         ) : Parcelable {
             fun getString(context: Context): String {
-                // use Localization.compatGetString() just in case context is not AppCompatActivity
                 return if (formatArgs.isEmpty()) {
-                    Localization.compatGetString(context, stringRes)
+                    // use ContextCompat.getString() just in case context is not AppCompatActivity
+                    ContextCompat.getString(context, stringRes)
                 } else {
-                    Localization.compatGetString(context, stringRes, *formatArgs)
+                    // ContextCompat.getString() with formatArgs does not exist, so we just
+                    // replicate its source code but with formatArgs
+                    ContextCompat.getContextForLanguage(context).getString(stringRes, *formatArgs)
                 }
             }
         }
@@ -160,7 +162,7 @@ class ErrorInfo private constructor(
 
         private fun getServiceName(serviceId: Int?) = // not using getNameOfServiceById since we want to accept a nullable serviceId and we
             // want to default to SERVICE_NONE
-            ServiceList.all()?.firstOrNull { it.serviceId == serviceId }?.serviceInfo?.name
+            ServiceList.all().firstOrNull { it.serviceId == serviceId }?.serviceInfo?.name
                 ?: SERVICE_NONE
 
         fun throwableToStringList(throwable: Throwable) = arrayOf(throwable.stackTraceToString())

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

@@ -134,8 +134,11 @@ class ErrorUtil {
                         )
                     )
 
-            NotificationManagerCompat.from(context)
-                .notify(ERROR_REPORT_NOTIFICATION_ID, notificationBuilder.build())
+            val notificationManager = NotificationManagerCompat.from(context)
+            if (notificationManager.areNotificationsEnabled()) {
+                notificationManager
+                    .notify(ERROR_REPORT_NOTIFICATION_ID, notificationBuilder.build())
+            }
 
             ContextCompat.getMainExecutor(context).execute {
                 // since the notification is silent, also show a toast, otherwise the user is confused

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

@@ -126,6 +126,7 @@ public class ReCaptchaActivity extends AppCompatActivity {
     }
 
     @Override
+    @SuppressLint("MissingSuperCall")
     public void onBackPressed() {
         saveCookiesAndFinish();
     }

app/src/main/java/org/schabi/newpipe/fragments/EmptyFragment.java

@@ -6,11 +6,9 @@ import android.view.View;
 import android.view.ViewGroup;
 
 import androidx.annotation.Nullable;
-import androidx.compose.ui.platform.ComposeView;
 
 import org.schabi.newpipe.BaseFragment;
 import org.schabi.newpipe.R;
-import org.schabi.newpipe.ui.emptystate.EmptyStateUtil;
 
 public class EmptyFragment extends BaseFragment {
     private static final String SHOW_MESSAGE = "SHOW_MESSAGE";
@@ -28,10 +26,8 @@ public class EmptyFragment extends BaseFragment {
                              final Bundle savedInstanceState) {
         final boolean showMessage = getArguments().getBoolean(SHOW_MESSAGE);
         final View view = inflater.inflate(R.layout.fragment_empty, container, false);
-
-        final ComposeView composeView = view.findViewById(R.id.empty_state_view);
-        EmptyStateUtil.setEmptyStateComposable(composeView);
-        composeView.setVisibility(showMessage ? View.VISIBLE : View.GONE);
+        view.findViewById(R.id.empty_state_view).setVisibility(
+                showMessage ? View.VISIBLE : View.GONE);
         return view;
     }
 }

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

@@ -3,7 +3,6 @@ package org.schabi.newpipe.fragments.list.channel;
 import static org.schabi.newpipe.ktx.TextViewUtils.animateTextColor;
 import static org.schabi.newpipe.ktx.ViewUtils.animate;
 import static org.schabi.newpipe.ktx.ViewUtils.animateBackgroundColor;
-import static org.schabi.newpipe.ui.emptystate.EmptyStateUtil.setEmptyStateComposable;
 
 import android.content.Context;
 import android.content.SharedPreferences;
@@ -11,6 +10,7 @@ import android.graphics.Color;
 import android.os.Bundle;
 import android.text.TextUtils;
 import android.util.Log;
+import android.util.TypedValue;
 import android.view.LayoutInflater;
 import android.view.Menu;
 import android.view.MenuInflater;
@@ -45,7 +45,6 @@ import org.schabi.newpipe.fragments.detail.TabAdapter;
 import org.schabi.newpipe.ktx.AnimationType;
 import org.schabi.newpipe.local.feed.notifications.NotificationHelper;
 import org.schabi.newpipe.local.subscription.SubscriptionManager;
-import org.schabi.newpipe.ui.emptystate.EmptyStateSpec;
 import org.schabi.newpipe.util.ChannelTabHelper;
 import org.schabi.newpipe.util.Constants;
 import org.schabi.newpipe.util.ExtractorHelper;
@@ -54,14 +53,13 @@ import org.schabi.newpipe.util.NavigationHelper;
 import org.schabi.newpipe.util.StateSaver;
 import org.schabi.newpipe.util.ThemeHelper;
 import org.schabi.newpipe.util.external_communication.ShareUtils;
-import org.schabi.newpipe.util.image.CoilHelper;
 import org.schabi.newpipe.util.image.ImageStrategy;
+import org.schabi.newpipe.util.image.PicassoHelper;
 
 import java.util.List;
 import java.util.Queue;
 import java.util.concurrent.TimeUnit;
 
-import coil3.util.CoilUtils;
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
 import io.reactivex.rxjava3.core.Observable;
 import io.reactivex.rxjava3.disposables.CompositeDisposable;
@@ -75,6 +73,7 @@ public class ChannelFragment extends BaseStateFragment<ChannelInfo>
         implements StateSaver.WriteRead {
 
     private static final int BUTTON_DEBOUNCE_INTERVAL = 100;
+    private static final String PICASSO_CHANNEL_TAG = "PICASSO_CHANNEL_TAG";
 
     @State
     protected int serviceId = Constants.NO_SERVICE_ID;
@@ -161,34 +160,29 @@ public class ChannelFragment extends BaseStateFragment<ChannelInfo>
 
                 @Override
                 public boolean onMenuItemSelected(@NonNull final MenuItem item) {
-                    switch (item.getItemId()) {
-                        case R.id.menu_item_notify:
-                            final boolean value = !item.isChecked();
-                            item.setEnabled(false);
-                            setNotify(value);
-                            break;
-                        case R.id.action_settings:
-                            NavigationHelper.openSettings(requireContext());
-                            break;
-                        case R.id.menu_item_rss:
-                            if (currentInfo != null) {
-                                ShareUtils.openUrlInApp(requireContext(), currentInfo.getFeedUrl());
-                            }
-                            break;
-                        case R.id.menu_item_openInBrowser:
-                            if (currentInfo != null) {
-                                ShareUtils.openUrlInBrowser(requireContext(),
-                                        currentInfo.getOriginalUrl());
-                            }
-                            break;
-                        case R.id.menu_item_share:
-                            if (currentInfo != null) {
-                                ShareUtils.shareText(requireContext(), name,
-                                        currentInfo.getOriginalUrl(), currentInfo.getAvatars());
-                            }
-                            break;
-                        default:
-                            return false;
+                    final int itemId = item.getItemId();
+                    if (itemId == R.id.menu_item_notify) {
+                        final boolean value = !item.isChecked();
+                        item.setEnabled(false);
+                        setNotify(value);
+                    } else if (itemId == R.id.action_settings) {
+                        NavigationHelper.openSettings(requireContext());
+                    } else if (itemId == R.id.menu_item_rss) {
+                        if (currentInfo != null) {
+                            ShareUtils.openUrlInApp(requireContext(), currentInfo.getFeedUrl());
+                        }
+                    } else if (itemId == R.id.menu_item_openInBrowser) {
+                        if (currentInfo != null) {
+                            ShareUtils.openUrlInBrowser(requireContext(),
+                                    currentInfo.getOriginalUrl());
+                        }
+                    } else if (itemId == R.id.menu_item_share) {
+                        if (currentInfo != null) {
+                            ShareUtils.shareText(requireContext(), name,
+                                    currentInfo.getOriginalUrl(), currentInfo.getAvatars());
+                        }
+                    } else {
+                        return false;
                     }
                     return true;
                 }
@@ -200,8 +194,6 @@ public class ChannelFragment extends BaseStateFragment<ChannelInfo>
     protected void initViews(final View rootView, final Bundle savedInstanceState) {
         super.initViews(rootView, savedInstanceState);
 
-        setEmptyStateComposable(binding.emptyStateView, EmptyStateSpec.ContentNotSupported);
-
         tabAdapter = new TabAdapter(getChildFragmentManager());
         binding.viewPager.setAdapter(tabAdapter);
         binding.tabLayout.setupWithViewPager(binding.viewPager);
@@ -586,9 +578,7 @@ public class ChannelFragment extends BaseStateFragment<ChannelInfo>
     @Override
     public void showLoading() {
         super.showLoading();
-        CoilUtils.dispose(binding.channelAvatarView);
-        CoilUtils.dispose(binding.channelBannerImage);
-        CoilUtils.dispose(binding.subChannelAvatarView);
+        PicassoHelper.cancelTag(PICASSO_CHANNEL_TAG);
         animate(binding.channelSubscribeButton, false, 100);
     }
 
@@ -599,15 +589,17 @@ public class ChannelFragment extends BaseStateFragment<ChannelInfo>
         setInitialData(result.getServiceId(), result.getOriginalUrl(), result.getName());
 
         if (ImageStrategy.shouldLoadImages() && !result.getBanners().isEmpty()) {
-            CoilHelper.INSTANCE.loadBanner(binding.channelBannerImage, result.getBanners());
+            PicassoHelper.loadBanner(result.getBanners()).tag(PICASSO_CHANNEL_TAG)
+                    .into(binding.channelBannerImage);
         } else {
             // do not waste space for the banner, if the user disabled images or there is not one
             binding.channelBannerImage.setImageDrawable(null);
         }
 
-        CoilHelper.INSTANCE.loadAvatar(binding.channelAvatarView, result.getAvatars());
-        CoilHelper.INSTANCE.loadAvatar(binding.subChannelAvatarView,
-                result.getParentChannelAvatars());
+        PicassoHelper.loadAvatar(result.getAvatars()).tag(PICASSO_CHANNEL_TAG)
+                .into(binding.channelAvatarView);
+        PicassoHelper.loadAvatar(result.getParentChannelAvatars()).tag(PICASSO_CHANNEL_TAG)
+                .into(binding.subChannelAvatarView);
 
         binding.channelTitleView.setText(result.getName());
         binding.channelSubscriberView.setVisibility(View.VISIBLE);
@@ -655,6 +647,8 @@ public class ChannelFragment extends BaseStateFragment<ChannelInfo>
             return;
         }
 
-        binding.emptyStateView.setVisibility(View.VISIBLE);
+        binding.errorContentNotSupported.setVisibility(View.VISIBLE);
+        binding.channelKaomoji.setText("(︶︹︺)");
+        binding.channelKaomoji.setTextSize(TypedValue.COMPLEX_UNIT_SP, 45f);
     }
 }

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

@@ -26,7 +26,6 @@ import org.schabi.newpipe.fragments.list.BaseListInfoFragment;
 import org.schabi.newpipe.fragments.list.playlist.PlaylistControlViewHolder;
 import org.schabi.newpipe.player.playqueue.ChannelTabPlayQueue;
 import org.schabi.newpipe.player.playqueue.PlayQueue;
-import org.schabi.newpipe.ui.emptystate.EmptyStateUtil;
 import org.schabi.newpipe.util.ChannelTabHelper;
 import org.schabi.newpipe.util.ExtractorHelper;
 import org.schabi.newpipe.util.PlayButtonHelper;
@@ -80,12 +79,6 @@ public class ChannelTabFragment extends BaseListInfoFragment<InfoItem, ChannelTa
         return inflater.inflate(R.layout.fragment_channel_tab, container, false);
     }
 
-    @Override
-    public void onViewCreated(@NonNull final View rootView, final Bundle savedInstanceState) {
-        super.onViewCreated(rootView, savedInstanceState);
-        EmptyStateUtil.setEmptyStateComposable(rootView.findViewById(R.id.empty_state_view));
-    }
-
     @Override
     public void onDestroyView() {
         super.onDestroyView();

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

@@ -0,0 +1,172 @@
+package org.schabi.newpipe.fragments.list.comments;
+
+import static org.schabi.newpipe.util.ServiceHelper.getServiceById;
+
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.constraintlayout.widget.ConstraintLayout;
+import androidx.core.text.HtmlCompat;
+
+import com.evernote.android.state.State;
+
+import org.schabi.newpipe.R;
+import org.schabi.newpipe.databinding.CommentRepliesHeaderBinding;
+import org.schabi.newpipe.error.UserAction;
+import org.schabi.newpipe.extractor.ListExtractor;
+import org.schabi.newpipe.extractor.comments.CommentsInfoItem;
+import org.schabi.newpipe.fragments.list.BaseListInfoFragment;
+import org.schabi.newpipe.info_list.ItemViewMode;
+import org.schabi.newpipe.util.DeviceUtils;
+import org.schabi.newpipe.util.ExtractorHelper;
+import org.schabi.newpipe.util.Localization;
+import org.schabi.newpipe.util.NavigationHelper;
+import org.schabi.newpipe.util.image.ImageStrategy;
+import org.schabi.newpipe.util.image.PicassoHelper;
+import org.schabi.newpipe.util.text.TextLinkifier;
+import org.schabi.newpipe.util.text.LongPressLinkMovementMethod;
+
+import java.util.Queue;
+import java.util.function.Supplier;
+
+import io.reactivex.rxjava3.core.Single;
+import io.reactivex.rxjava3.disposables.CompositeDisposable;
+
+public final class CommentRepliesFragment
+        extends BaseListInfoFragment<CommentsInfoItem, CommentRepliesInfo> {
+
+    public static final String TAG = CommentRepliesFragment.class.getSimpleName();
+
+    @State
+    CommentsInfoItem commentsInfoItem; // the comment to show replies of
+    private final CompositeDisposable disposables = new CompositeDisposable();
+
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Constructors and lifecycle
+    //////////////////////////////////////////////////////////////////////////*/
+
+    // only called by the Android framework, after which readFrom is called and restores all data
+    public CommentRepliesFragment() {
+        super(UserAction.REQUESTED_COMMENT_REPLIES);
+    }
+
+    public CommentRepliesFragment(@NonNull final CommentsInfoItem commentsInfoItem) {
+        this();
+        this.commentsInfoItem = commentsInfoItem;
+        // setting "" as title since the title will be properly set right after
+        setInitialData(commentsInfoItem.getServiceId(), commentsInfoItem.getUrl(), "");
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull final LayoutInflater inflater,
+                             @Nullable final ViewGroup container,
+                             @Nullable final Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.fragment_comments, container, false);
+    }
+
+    @Override
+    public void onDestroyView() {
+        disposables.clear();
+        super.onDestroyView();
+    }
+
+    @Override
+    protected Supplier<View> getListHeaderSupplier() {
+        return () -> {
+            final CommentRepliesHeaderBinding binding = CommentRepliesHeaderBinding
+                    .inflate(activity.getLayoutInflater(), itemsList, false);
+            final CommentsInfoItem item = commentsInfoItem;
+
+            // load the author avatar
+            PicassoHelper.loadAvatar(item.getUploaderAvatars()).into(binding.authorAvatar);
+            binding.authorAvatar.setVisibility(ImageStrategy.shouldLoadImages()
+                    ? View.VISIBLE : View.GONE);
+
+            // setup author name and comment date
+            binding.authorName.setText(item.getUploaderName());
+            binding.uploadDate.setText(Localization.relativeTimeOrTextual(
+                    getContext(), item.getUploadDate(), item.getTextualUploadDate()));
+            binding.authorTouchArea.setOnClickListener(
+                    v -> NavigationHelper.openCommentAuthorIfPresent(requireActivity(), item));
+
+            // setup like count, hearted and pinned
+            binding.thumbsUpCount.setText(
+                    Localization.likeCount(requireContext(), item.getLikeCount()));
+            // for heartImage goneMarginEnd was used, but there is no way to tell ConstraintLayout
+            // not to use a different margin only when both the next two views are gone
+            ((ConstraintLayout.LayoutParams) binding.thumbsUpCount.getLayoutParams())
+                    .setMarginEnd(DeviceUtils.dpToPx(
+                            (item.isHeartedByUploader() || item.isPinned() ? 8 : 16),
+                            requireContext()));
+            binding.heartImage.setVisibility(item.isHeartedByUploader() ? View.VISIBLE : View.GONE);
+            binding.pinnedImage.setVisibility(item.isPinned() ? View.VISIBLE : View.GONE);
+
+            // setup comment content
+            TextLinkifier.fromDescription(binding.commentContent, item.getCommentText(),
+                    HtmlCompat.FROM_HTML_MODE_LEGACY, getServiceById(item.getServiceId()),
+                    item.getUrl(), disposables, null);
+            binding.commentContent.setMovementMethod(LongPressLinkMovementMethod.getInstance());
+            return binding.getRoot();
+        };
+    }
+
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // State saving
+    //////////////////////////////////////////////////////////////////////////*/
+
+    @Override
+    public void writeTo(final Queue<Object> objectsToSave) {
+        super.writeTo(objectsToSave);
+        objectsToSave.add(commentsInfoItem);
+    }
+
+    @Override
+    public void readFrom(@NonNull final Queue<Object> savedObjects) throws Exception {
+        super.readFrom(savedObjects);
+        commentsInfoItem = (CommentsInfoItem) savedObjects.poll();
+    }
+
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Data loading
+    //////////////////////////////////////////////////////////////////////////*/
+
+    @Override
+    protected Single<CommentRepliesInfo> loadResult(final boolean forceLoad) {
+        return Single.fromCallable(() -> new CommentRepliesInfo(commentsInfoItem,
+                // the reply count string will be shown as the activity title
+                Localization.replyCount(requireContext(), commentsInfoItem.getReplyCount())));
+    }
+
+    @Override
+    protected Single<ListExtractor.InfoItemsPage<CommentsInfoItem>> loadMoreItemsLogic() {
+        // commentsInfoItem.getUrl() should contain the url of the original
+        // ListInfo<CommentsInfoItem>, which should be the stream url
+        return ExtractorHelper.getMoreCommentItems(
+                serviceId, commentsInfoItem.getUrl(), currentNextPage);
+    }
+
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Utils
+    //////////////////////////////////////////////////////////////////////////*/
+
+    @Override
+    protected ItemViewMode getItemViewMode() {
+        return ItemViewMode.LIST;
+    }
+
+    /**
+     * @return the comment to which the replies are shown
+     */
+    public CommentsInfoItem getCommentsInfoItem() {
+        return commentsInfoItem;
+    }
+}

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

@@ -0,0 +1,22 @@
+package org.schabi.newpipe.fragments.list.comments;
+
+import org.schabi.newpipe.extractor.ListInfo;
+import org.schabi.newpipe.extractor.comments.CommentsInfoItem;
+import org.schabi.newpipe.extractor.linkhandler.ListLinkHandler;
+
+import java.util.Collections;
+
+public final class CommentRepliesInfo extends ListInfo<CommentsInfoItem> {
+    /**
+     * This class is used to wrap the comment replies page into a ListInfo object.
+     *
+     * @param comment the comment from which to get replies
+     * @param name will be shown as the fragment title
+     */
+    public CommentRepliesInfo(final CommentsInfoItem comment, final String name) {
+        super(comment.getServiceId(),
+                new ListLinkHandler("", "", "", Collections.emptyList(), null), name);
+        setNextPage(comment.getReplies());
+        setRelatedItems(Collections.emptyList()); // since it must be non-null
+    }
+}

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

@@ -0,0 +1,123 @@
+package org.schabi.newpipe.fragments.list.comments;
+
+import android.os.Bundle;
+import android.view.LayoutInflater;
+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;
+
+import org.schabi.newpipe.R;
+import org.schabi.newpipe.error.UserAction;
+import org.schabi.newpipe.extractor.ListExtractor;
+import org.schabi.newpipe.extractor.comments.CommentsInfo;
+import org.schabi.newpipe.extractor.comments.CommentsInfoItem;
+import org.schabi.newpipe.fragments.list.BaseListInfoFragment;
+import org.schabi.newpipe.info_list.ItemViewMode;
+import org.schabi.newpipe.ktx.ViewUtils;
+import org.schabi.newpipe.util.ExtractorHelper;
+
+import io.reactivex.rxjava3.core.Single;
+import io.reactivex.rxjava3.disposables.CompositeDisposable;
+
+public class CommentsFragment extends BaseListInfoFragment<CommentsInfoItem, 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();
+        instance.setInitialData(serviceId, url, name);
+        return instance;
+    }
+
+    public CommentsFragment() {
+        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
+    //////////////////////////////////////////////////////////////////////////*/
+
+    @Override
+    public View onCreateView(@NonNull final LayoutInflater inflater,
+                             @Nullable final ViewGroup container,
+                             @Nullable final Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.fragment_comments, container, false);
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        disposables.clear();
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Load and handle
+    //////////////////////////////////////////////////////////////////////////*/
+
+    @Override
+    protected Single<ListExtractor.InfoItemsPage<CommentsInfoItem>> loadMoreItemsLogic() {
+        return ExtractorHelper.getMoreCommentItems(serviceId, currentInfo, currentNextPage);
+    }
+
+    @Override
+    protected Single<CommentsInfo> loadResult(final boolean forceLoad) {
+        return ExtractorHelper.getCommentsInfo(serviceId, url, forceLoad);
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Contract
+    //////////////////////////////////////////////////////////////////////////*/
+
+    @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();
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Utils
+    //////////////////////////////////////////////////////////////////////////*/
+
+    @Override
+    public void setTitle(final String title) { }
+
+    @Override
+    public void onCreateOptionsMenu(@NonNull final Menu menu,
+                                    @NonNull final MenuInflater inflater) { }
+
+    @Override
+    protected ItemViewMode getItemViewMode() {
+        return ItemViewMode.LIST;
+    }
+
+    public boolean scrollToComment(final CommentsInfoItem comment) {
+        final int position = infoListAdapter.getItemsList().indexOf(comment);
+        if (position < 0) {
+            return false;
+        }
+
+        itemsList.scrollToPosition(position);
+        return true;
+    }
+}

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

@@ -1,34 +0,0 @@
-package org.schabi.newpipe.fragments.list.comments
-
-import android.os.Bundle
-import android.view.LayoutInflater
-import android.view.ViewGroup
-import androidx.compose.material3.Surface
-import androidx.core.os.bundleOf
-import androidx.fragment.app.Fragment
-import androidx.fragment.compose.content
-import org.schabi.newpipe.ui.components.video.comment.CommentSection
-import org.schabi.newpipe.ui.theme.AppTheme
-import org.schabi.newpipe.util.KEY_SERVICE_ID
-import org.schabi.newpipe.util.KEY_URL
-
-class CommentsFragment : Fragment() {
-    override fun onCreateView(
-        inflater: LayoutInflater,
-        container: ViewGroup?,
-        savedInstanceState: Bundle?
-    ) = content {
-        AppTheme {
-            Surface {
-                CommentSection()
-            }
-        }
-    }
-
-    companion object {
-        @JvmStatic
-        fun getInstance(serviceId: Int, url: String?) = CommentsFragment().apply {
-            arguments = bundleOf(KEY_SERVICE_ID to serviceId, KEY_URL to url)
-        }
-    }
-}

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

@@ -53,7 +53,7 @@ import org.schabi.newpipe.util.Localization;
 import org.schabi.newpipe.util.NavigationHelper;
 import org.schabi.newpipe.util.PlayButtonHelper;
 import org.schabi.newpipe.util.external_communication.ShareUtils;
-import org.schabi.newpipe.util.image.CoilHelper;
+import org.schabi.newpipe.util.image.PicassoHelper;
 import org.schabi.newpipe.util.text.TextEllipsizer;
 
 import java.util.ArrayList;
@@ -62,7 +62,6 @@ import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
-import coil3.util.CoilUtils;
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
 import io.reactivex.rxjava3.core.Flowable;
 import io.reactivex.rxjava3.core.Single;
@@ -72,6 +71,8 @@ import io.reactivex.rxjava3.disposables.Disposable;
 public class PlaylistFragment extends BaseListInfoFragment<StreamInfoItem, PlaylistInfo>
         implements PlaylistControlViewHolder {
 
+    private static final String PICASSO_PLAYLIST_TAG = "PICASSO_PLAYLIST_TAG";
+
     private CompositeDisposable disposables;
     private Subscription bookmarkReactor;
     private AtomicBoolean isBookmarkButtonReady;
@@ -231,35 +232,30 @@ public class PlaylistFragment extends BaseListInfoFragment<StreamInfoItem, Playl
 
     @Override
     public boolean onOptionsItemSelected(final MenuItem item) {
-        switch (item.getItemId()) {
-            case R.id.action_settings:
-                NavigationHelper.openSettings(requireContext());
-                break;
-            case R.id.menu_item_openInBrowser:
-                ShareUtils.openUrlInBrowser(requireContext(), url);
-                break;
-            case R.id.menu_item_share:
-                ShareUtils.shareText(requireContext(), name, url,
-                        currentInfo == null ? List.of() : currentInfo.getThumbnails());
-                break;
-            case R.id.menu_item_bookmark:
-                onBookmarkClicked();
-                break;
-            case R.id.menu_item_append_playlist:
-                if (currentInfo != null) {
-                    disposables.add(PlaylistDialog.createCorrespondingDialog(
-                            getContext(),
-                            getPlayQueue()
-                                    .getStreams()
-                                    .stream()
-                                    .map(StreamEntity::new)
-                                    .collect(Collectors.toList()),
-                            dialog -> dialog.show(getFM(), TAG)
-                    ));
-                }
-                break;
-            default:
-                return super.onOptionsItemSelected(item);
+        final int itemId = item.getItemId();
+        if (itemId == R.id.action_settings) {
+            NavigationHelper.openSettings(requireContext());
+        } else if (itemId == R.id.menu_item_openInBrowser) {
+            ShareUtils.openUrlInBrowser(requireContext(), url);
+        } else if (itemId == R.id.menu_item_share) {
+            ShareUtils.shareText(requireContext(), name, url,
+                    currentInfo == null ? List.of() : currentInfo.getThumbnails());
+        } else if (itemId == R.id.menu_item_bookmark) {
+            onBookmarkClicked();
+        } else if (itemId == R.id.menu_item_append_playlist) {
+            if (currentInfo != null) {
+                disposables.add(PlaylistDialog.createCorrespondingDialog(
+                        getContext(),
+                        getPlayQueue()
+                                .getStreams()
+                                .stream()
+                                .map(StreamEntity::new)
+                                .collect(Collectors.toList()),
+                        dialog -> dialog.show(getFM(), TAG)
+                ));
+            }
+        } else {
+            return super.onOptionsItemSelected(item);
         }
         return true;
     }
@@ -275,7 +271,7 @@ public class PlaylistFragment extends BaseListInfoFragment<StreamInfoItem, Playl
         animate(headerBinding.getRoot(), false, 200);
         animateHideRecyclerViewAllowingScrolling(itemsList);
 
-        CoilUtils.dispose(headerBinding.uploaderAvatarView);
+        PicassoHelper.cancelTag(PICASSO_PLAYLIST_TAG);
         animate(headerBinding.uploaderLayout, false, 200);
     }
 
@@ -326,8 +322,8 @@ public class PlaylistFragment extends BaseListInfoFragment<StreamInfoItem, Playl
                     R.drawable.ic_radio)
             );
         } else {
-            CoilHelper.INSTANCE.loadAvatar(headerBinding.uploaderAvatarView,
-                    result.getUploaderAvatars());
+            PicassoHelper.loadAvatar(result.getUploaderAvatars()).tag(PICASSO_PLAYLIST_TAG)
+                    .into(headerBinding.uploaderAvatarView);
         }
 
         streamCount = result.getStreamCount();

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

@@ -3,7 +3,6 @@ package org.schabi.newpipe.fragments.list.search;
 import static androidx.recyclerview.widget.ItemTouchHelper.Callback.makeMovementFlags;
 import static org.schabi.newpipe.extractor.utils.Utils.isBlank;
 import static org.schabi.newpipe.ktx.ViewUtils.animate;
-import static org.schabi.newpipe.ui.emptystate.EmptyStateUtil.setEmptyStateComposable;
 import static org.schabi.newpipe.util.ExtractorHelper.showMetaInfoInTextView;
 import static java.util.Arrays.asList;
 
@@ -66,7 +65,6 @@ 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.ui.emptystate.EmptyStateSpec;
 import org.schabi.newpipe.util.Constants;
 import org.schabi.newpipe.util.DeviceUtils;
 import org.schabi.newpipe.util.ExtractorHelper;
@@ -357,8 +355,6 @@ public class SearchFragment extends BaseListFragment<SearchInfo, ListExtractor.I
     protected void initViews(final View rootView, final Bundle savedInstanceState) {
         super.initViews(rootView, savedInstanceState);
 
-        setEmptyStateComposable(searchBinding.emptyStateView, EmptyStateSpec.NoSearchResult);
-
         searchBinding.suggestionsList.setAdapter(suggestionListAdapter);
         // animations are just strange and useless, since the suggestions keep changing too much
         searchBinding.suggestionsList.setItemAnimator(null);

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

@@ -0,0 +1,202 @@
+package org.schabi.newpipe.fragments.list.videos;
+
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+import androidx.preference.PreferenceManager;
+
+import org.schabi.newpipe.R;
+import org.schabi.newpipe.databinding.RelatedItemsHeaderBinding;
+import org.schabi.newpipe.error.UserAction;
+import org.schabi.newpipe.extractor.InfoItem;
+import org.schabi.newpipe.extractor.ListExtractor;
+import org.schabi.newpipe.extractor.stream.StreamInfo;
+import org.schabi.newpipe.extractor.stream.StreamInfoItem;
+import org.schabi.newpipe.fragments.list.BaseListInfoFragment;
+import org.schabi.newpipe.info_list.ItemViewMode;
+import org.schabi.newpipe.info_list.dialog.InfoItemDialog;
+import org.schabi.newpipe.ktx.ViewUtils;
+
+import java.io.Serializable;
+import java.util.function.Supplier;
+
+import io.reactivex.rxjava3.core.Single;
+
+public class RelatedItemsFragment extends BaseListInfoFragment<InfoItem, RelatedItemsInfo>
+        implements SharedPreferences.OnSharedPreferenceChangeListener {
+    private static final String INFO_KEY = "related_info_key";
+
+    private RelatedItemsInfo relatedItemsInfo;
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Views
+    //////////////////////////////////////////////////////////////////////////*/
+
+    private RelatedItemsHeaderBinding headerBinding;
+
+    public static RelatedItemsFragment getInstance(final StreamInfo info) {
+        final RelatedItemsFragment instance = new RelatedItemsFragment();
+        instance.setInitialData(info);
+        return instance;
+    }
+
+    public RelatedItemsFragment() {
+        super(UserAction.REQUESTED_STREAM);
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // LifeCycle
+    //////////////////////////////////////////////////////////////////////////*/
+
+    @Override
+    public View onCreateView(@NonNull final LayoutInflater inflater,
+                             @Nullable final ViewGroup container,
+                             @Nullable final Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.fragment_related_items, container, false);
+    }
+
+    @Override
+    public void onDestroyView() {
+        headerBinding = null;
+        super.onDestroyView();
+    }
+
+    @Override
+    protected Supplier<View> getListHeaderSupplier() {
+        if (relatedItemsInfo == null || relatedItemsInfo.getRelatedItems() == null) {
+            return null;
+        }
+
+        headerBinding = RelatedItemsHeaderBinding
+                .inflate(activity.getLayoutInflater(), itemsList, false);
+
+        final SharedPreferences pref = PreferenceManager
+                .getDefaultSharedPreferences(requireContext());
+        final boolean autoplay = pref.getBoolean(getString(R.string.auto_queue_key), false);
+        headerBinding.autoplaySwitch.setChecked(autoplay);
+        headerBinding.autoplaySwitch.setOnCheckedChangeListener((compoundButton, b) ->
+                PreferenceManager.getDefaultSharedPreferences(requireContext()).edit()
+                        .putBoolean(getString(R.string.auto_queue_key), b).apply());
+
+        return headerBinding::getRoot;
+    }
+
+    @Override
+    protected Single<ListExtractor.InfoItemsPage<InfoItem>> loadMoreItemsLogic() {
+        return Single.fromCallable(ListExtractor.InfoItemsPage::emptyPage);
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Contract
+    //////////////////////////////////////////////////////////////////////////*/
+
+    @Override
+    protected Single<RelatedItemsInfo> loadResult(final boolean forceLoad) {
+        return Single.fromCallable(() -> relatedItemsInfo);
+    }
+
+    @Override
+    public void showLoading() {
+        super.showLoading();
+        if (headerBinding != null) {
+            headerBinding.getRoot().setVisibility(View.INVISIBLE);
+        }
+    }
+
+    @Override
+    public void handleResult(@NonNull final RelatedItemsInfo result) {
+        super.handleResult(result);
+
+        if (headerBinding != null) {
+            headerBinding.getRoot().setVisibility(View.VISIBLE);
+        }
+        ViewUtils.slideUp(requireView(), 120, 96, 0.06f);
+
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Utils
+    //////////////////////////////////////////////////////////////////////////*/
+
+    @Override
+    public void setTitle(final String title) {
+        // Nothing to do - override parent
+    }
+
+    @Override
+    public void onCreateOptionsMenu(@NonNull final Menu menu,
+                                    @NonNull final MenuInflater inflater) {
+        // Nothing to do - override parent
+    }
+
+    private void setInitialData(final StreamInfo info) {
+        super.setInitialData(info.getServiceId(), info.getUrl(), info.getName());
+        if (this.relatedItemsInfo == null) {
+            this.relatedItemsInfo = new RelatedItemsInfo(info);
+        }
+    }
+
+    @Override
+    public void onSaveInstanceState(@NonNull final Bundle outState) {
+        super.onSaveInstanceState(outState);
+        outState.putSerializable(INFO_KEY, relatedItemsInfo);
+    }
+
+    @Override
+    protected void onRestoreInstanceState(@NonNull final Bundle savedState) {
+        super.onRestoreInstanceState(savedState);
+        final Serializable serializable = savedState.getSerializable(INFO_KEY);
+        if (serializable instanceof RelatedItemsInfo) {
+            this.relatedItemsInfo = (RelatedItemsInfo) serializable;
+        }
+    }
+
+    @Override
+    public void onSharedPreferenceChanged(final SharedPreferences sharedPreferences,
+                                          final String key) {
+        if (headerBinding != null && getString(R.string.auto_queue_key).equals(key)) {
+            headerBinding.autoplaySwitch.setChecked(sharedPreferences.getBoolean(key, false));
+        }
+    }
+
+    @Override
+    protected ItemViewMode getItemViewMode() {
+        ItemViewMode mode = super.getItemViewMode();
+        // Only list mode is supported. Either List or card will be used.
+        if (mode != ItemViewMode.LIST && mode != ItemViewMode.CARD) {
+            mode = ItemViewMode.LIST;
+        }
+        return mode;
+    }
+
+    @Override
+    protected void showInfoItemDialog(final StreamInfoItem item) {
+        // Try and attach the InfoItemDialog to the parent fragment of the RelatedItemsFragment
+        // so that its context is not lost when the RelatedItemsFragment is reinitialized,
+        // e.g. when a new stream is loaded in a parent VideoDetailFragment.
+        final Fragment parentFragment = getParentFragment();
+        if (parentFragment != null) {
+            try {
+                new InfoItemDialog.Builder(
+                        parentFragment.getActivity(),
+                        parentFragment.getContext(),
+                        parentFragment,
+                        item
+                ).create().show();
+            } catch (final IllegalArgumentException e) {
+                InfoItemDialog.Builder.reportErrorDuringInitialization(e, item);
+            }
+        } else {
+            super.showInfoItemDialog(item);
+        }
+    }
+
+}

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

@@ -1,35 +0,0 @@
-package org.schabi.newpipe.fragments.list.videos
-
-import android.os.Bundle
-import android.view.LayoutInflater
-import android.view.ViewGroup
-import androidx.compose.material3.Surface
-import androidx.core.os.bundleOf
-import androidx.fragment.app.Fragment
-import androidx.fragment.compose.content
-import org.schabi.newpipe.extractor.stream.StreamInfo
-import org.schabi.newpipe.ktx.serializable
-import org.schabi.newpipe.ui.components.video.RelatedItems
-import org.schabi.newpipe.ui.theme.AppTheme
-import org.schabi.newpipe.util.KEY_INFO
-
-class RelatedItemsFragment : Fragment() {
-    override fun onCreateView(
-        inflater: LayoutInflater,
-        container: ViewGroup?,
-        savedInstanceState: Bundle?
-    ) = content {
-        AppTheme {
-            Surface {
-                RelatedItems(requireArguments().serializable<StreamInfo>(KEY_INFO)!!)
-            }
-        }
-    }
-
-    companion object {
-        @JvmStatic
-        fun getInstance(info: StreamInfo) = RelatedItemsFragment().apply {
-            arguments = bundleOf(KEY_INFO to info)
-        }
-    }
-}

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

@@ -0,0 +1,22 @@
+package org.schabi.newpipe.fragments.list.videos;
+
+import org.schabi.newpipe.extractor.InfoItem;
+import org.schabi.newpipe.extractor.ListInfo;
+import org.schabi.newpipe.extractor.linkhandler.ListLinkHandler;
+import org.schabi.newpipe.extractor.stream.StreamInfo;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+public final class RelatedItemsInfo extends ListInfo<InfoItem> {
+    /**
+     * This class is used to wrap the related items of a StreamInfo into a ListInfo object.
+     *
+     * @param info the stream info from which to get related items
+     */
+    public RelatedItemsInfo(final StreamInfo info) {
+        super(info.getServiceId(), new ListLinkHandler(info.getOriginalUrl(), info.getUrl(),
+                info.getId(), Collections.emptyList(), null), info.getName());
+        setRelatedItems(new ArrayList<>(info.getRelatedItems()));
+    }
+}

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

@@ -13,6 +13,7 @@ import org.schabi.newpipe.extractor.playlist.PlaylistInfoItem;
 import org.schabi.newpipe.extractor.stream.StreamInfoItem;
 import org.schabi.newpipe.info_list.holder.ChannelInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.ChannelMiniInfoItemHolder;
+import org.schabi.newpipe.info_list.holder.CommentInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.InfoItemHolder;
 import org.schabi.newpipe.info_list.holder.PlaylistInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.PlaylistMiniInfoItemHolder;
@@ -74,16 +75,21 @@ public class InfoItemBuilder {
     private InfoItemHolder holderFromInfoType(@NonNull final ViewGroup parent,
                                               @NonNull final InfoItem.InfoType infoType,
                                               final boolean useMiniVariant) {
-        return switch (infoType) {
-            case STREAM -> useMiniVariant ? new StreamMiniInfoItemHolder(this, parent)
-                    : new StreamInfoItemHolder(this, parent);
-            case CHANNEL -> useMiniVariant ? new ChannelMiniInfoItemHolder(this, parent)
-                    : new ChannelInfoItemHolder(this, parent);
-            case PLAYLIST -> useMiniVariant ? new PlaylistMiniInfoItemHolder(this, parent)
-                    : new PlaylistInfoItemHolder(this, parent);
-            case COMMENT ->
-                    throw new IllegalArgumentException("Comments should be rendered using Compose");
-        };
+        switch (infoType) {
+            case STREAM:
+                return useMiniVariant ? new StreamMiniInfoItemHolder(this, parent)
+                        : new StreamInfoItemHolder(this, parent);
+            case CHANNEL:
+                return useMiniVariant ? new ChannelMiniInfoItemHolder(this, parent)
+                        : new ChannelInfoItemHolder(this, parent);
+            case PLAYLIST:
+                return useMiniVariant ? new PlaylistMiniInfoItemHolder(this, parent)
+                        : new PlaylistInfoItemHolder(this, parent);
+            case COMMENT:
+                return new CommentInfoItemHolder(this, parent);
+            default:
+                throw new RuntimeException("InfoType not expected = " + infoType.name());
+        }
     }
 
     public Context getContext() {

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

@@ -21,6 +21,7 @@ import org.schabi.newpipe.info_list.holder.ChannelCardInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.ChannelGridInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.ChannelInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.ChannelMiniInfoItemHolder;
+import org.schabi.newpipe.info_list.holder.CommentInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.InfoItemHolder;
 import org.schabi.newpipe.info_list.holder.PlaylistCardInfoItemHolder;
 import org.schabi.newpipe.info_list.holder.PlaylistGridInfoItemHolder;
@@ -282,32 +283,46 @@ public class InfoListAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolde
             Log.d(TAG, "onCreateViewHolder() called with: "
                     + "parent = [" + parent + "], type = [" + type + "]");
         }
-        return switch (type) {
+        switch (type) {
             // #4475 and #3368
             // Always create a new instance otherwise the same instance
             // is sometimes reused which causes a crash
-            case HEADER_TYPE -> new HFHolder(headerSupplier.get());
-            case FOOTER_TYPE -> new HFHolder(PignateFooterBinding
-                    .inflate(layoutInflater, parent, false)
-                    .getRoot()
-            );
-            case MINI_STREAM_HOLDER_TYPE -> new StreamMiniInfoItemHolder(infoItemBuilder, parent);
-            case STREAM_HOLDER_TYPE -> new StreamInfoItemHolder(infoItemBuilder, parent);
-            case GRID_STREAM_HOLDER_TYPE -> new StreamGridInfoItemHolder(infoItemBuilder, parent);
-            case CARD_STREAM_HOLDER_TYPE -> new StreamCardInfoItemHolder(infoItemBuilder, parent);
-            case MINI_CHANNEL_HOLDER_TYPE -> new ChannelMiniInfoItemHolder(infoItemBuilder, parent);
-            case CHANNEL_HOLDER_TYPE -> new ChannelInfoItemHolder(infoItemBuilder, parent);
-            case CARD_CHANNEL_HOLDER_TYPE -> new ChannelCardInfoItemHolder(infoItemBuilder, parent);
-            case GRID_CHANNEL_HOLDER_TYPE -> new ChannelGridInfoItemHolder(infoItemBuilder, parent);
-            case MINI_PLAYLIST_HOLDER_TYPE ->
-                    new PlaylistMiniInfoItemHolder(infoItemBuilder, parent);
-            case PLAYLIST_HOLDER_TYPE -> new PlaylistInfoItemHolder(infoItemBuilder, parent);
-            case GRID_PLAYLIST_HOLDER_TYPE ->
-                    new PlaylistGridInfoItemHolder(infoItemBuilder, parent);
-            case CARD_PLAYLIST_HOLDER_TYPE ->
-                    new PlaylistCardInfoItemHolder(infoItemBuilder, parent);
-            default -> new FallbackViewHolder(new View(parent.getContext()));
-        };
+            case HEADER_TYPE:
+                return new HFHolder(headerSupplier.get());
+            case FOOTER_TYPE:
+                return new HFHolder(PignateFooterBinding
+                        .inflate(layoutInflater, parent, false)
+                        .getRoot()
+                );
+            case MINI_STREAM_HOLDER_TYPE:
+                return new StreamMiniInfoItemHolder(infoItemBuilder, parent);
+            case STREAM_HOLDER_TYPE:
+                return new StreamInfoItemHolder(infoItemBuilder, parent);
+            case GRID_STREAM_HOLDER_TYPE:
+                return new StreamGridInfoItemHolder(infoItemBuilder, parent);
+            case CARD_STREAM_HOLDER_TYPE:
+                return new StreamCardInfoItemHolder(infoItemBuilder, parent);
+            case MINI_CHANNEL_HOLDER_TYPE:
+                return new ChannelMiniInfoItemHolder(infoItemBuilder, parent);
+            case CHANNEL_HOLDER_TYPE:
+                return new ChannelInfoItemHolder(infoItemBuilder, parent);
+            case CARD_CHANNEL_HOLDER_TYPE:
+                return new ChannelCardInfoItemHolder(infoItemBuilder, parent);
+            case GRID_CHANNEL_HOLDER_TYPE:
+                return new ChannelGridInfoItemHolder(infoItemBuilder, parent);
+            case MINI_PLAYLIST_HOLDER_TYPE:
+                return new PlaylistMiniInfoItemHolder(infoItemBuilder, parent);
+            case PLAYLIST_HOLDER_TYPE:
+                return new PlaylistInfoItemHolder(infoItemBuilder, parent);
+            case GRID_PLAYLIST_HOLDER_TYPE:
+                return new PlaylistGridInfoItemHolder(infoItemBuilder, parent);
+            case CARD_PLAYLIST_HOLDER_TYPE:
+                return new PlaylistCardInfoItemHolder(infoItemBuilder, parent);
+            case COMMENT_HOLDER_TYPE:
+                return new CommentInfoItemHolder(infoItemBuilder, parent);
+            default:
+                return new FallbackViewHolder(new View(parent.getContext()));
+        }
     }
 
     @Override

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

@@ -1,18 +1,19 @@
 package org.schabi.newpipe.info_list
 
 import android.view.View
-import com.xwray.groupie.viewbinding.BindableItem
-import com.xwray.groupie.viewbinding.GroupieViewHolder
+import android.widget.ImageView
+import android.widget.TextView
+import com.xwray.groupie.GroupieViewHolder
+import com.xwray.groupie.Item
 import org.schabi.newpipe.R
-import org.schabi.newpipe.databinding.ItemStreamSegmentBinding
 import org.schabi.newpipe.extractor.stream.StreamSegment
 import org.schabi.newpipe.util.Localization
-import org.schabi.newpipe.util.image.CoilHelper
+import org.schabi.newpipe.util.image.PicassoHelper
 
 class StreamSegmentItem(
     private val item: StreamSegment,
     private val onClick: StreamSegmentAdapter.StreamSegmentListener
-) : BindableItem<ItemStreamSegmentBinding>() {
+) : Item<GroupieViewHolder>() {
 
     companion object {
         const val PAYLOAD_SELECT = 1
@@ -20,35 +21,34 @@ class StreamSegmentItem(
 
     var isSelected = false
 
-    override fun bind(viewBinding: ItemStreamSegmentBinding, position: Int) {
-        CoilHelper.loadThumbnail(viewBinding.previewImage, item.previewUrl)
-        viewBinding.textViewTitle.text = item.title
+    override fun bind(viewHolder: GroupieViewHolder, position: Int) {
+        item.previewUrl?.let {
+            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) {
-            viewBinding.textViewChannel.visibility = View.GONE
+            viewHolder.root.findViewById<TextView>(R.id.textViewChannel).visibility = View.GONE
             // When the channel name is displayed there is less space
             // and thus the segment title needs to be only one line height.
             // But when there is no channel name displayed, the title can be two lines long.
             // The default maxLines value is set to 1 to display all elements in the AS preview,
-            viewBinding.textViewTitle.maxLines = 2
+            viewHolder.root.findViewById<TextView>(R.id.textViewTitle).maxLines = 2
         } else {
-            viewBinding.textViewChannel.text = item.channelName
-            viewBinding.textViewChannel.visibility = View.VISIBLE
+            viewHolder.root.findViewById<TextView>(R.id.textViewChannel).text = item.channelName
+            viewHolder.root.findViewById<TextView>(R.id.textViewChannel).visibility = View.VISIBLE
         }
-        viewBinding.textViewStartSeconds.text =
+        viewHolder.root.findViewById<TextView>(R.id.textViewStartSeconds).text =
             Localization.getDurationString(item.startTimeSeconds.toLong())
-        viewBinding.root.setOnClickListener { onClick.onItemClick(this, item.startTimeSeconds) }
-        viewBinding.root.setOnLongClickListener {
+        viewHolder.root.setOnClickListener { onClick.onItemClick(this, item.startTimeSeconds) }
+        viewHolder.root.setOnLongClickListener {
             onClick.onItemLongClick(this, item.startTimeSeconds)
             true
         }
-        viewBinding.root.isSelected = isSelected
+        viewHolder.root.isSelected = isSelected
     }
 
-    override fun bind(
-        viewHolder: GroupieViewHolder<ItemStreamSegmentBinding>,
-        position: Int,
-        payloads: MutableList<Any>
-    ) {
+    override fun bind(viewHolder: GroupieViewHolder, position: Int, payloads: MutableList<Any>) {
         if (payloads.contains(PAYLOAD_SELECT)) {
             viewHolder.root.isSelected = isSelected
             return
@@ -57,6 +57,4 @@ class StreamSegmentItem(
     }
 
     override fun getLayout() = R.layout.item_stream_segment
-
-    override fun initializeViewBinding(view: View) = ItemStreamSegmentBinding.bind(view)
 }

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

@@ -252,7 +252,7 @@ public final class InfoItemDialog {
          * @return the current {@link Builder} instance
          */
         public Builder addEnqueueEntriesIfNeeded() {
-            final PlayerHolder holder = PlayerHolder.INSTANCE;
+            final PlayerHolder holder = PlayerHolder.getInstance();
             if (holder.isPlayQueueReady()) {
                 addEntry(StreamDialogDefaultEntry.ENQUEUE);
 
@@ -346,7 +346,7 @@ public final class InfoItemDialog {
 
         public static void reportErrorDuringInitialization(final Throwable throwable,
                                                            final InfoItem item) {
-            ErrorUtil.showSnackbar(App.getInstance().getBaseContext(), new ErrorInfo(
+            ErrorUtil.showSnackbar(App.getApp().getBaseContext(), new ErrorInfo(
                     throwable,
                     UserAction.OPEN_INFO_ITEM_DIALOG,
                     "none",

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

@@ -44,11 +44,10 @@ import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
  * </p>
  */
 public enum StreamDialogDefaultEntry {
-    SHOW_CHANNEL_DETAILS(R.string.show_channel_details, (fragment, item) -> {
-        final var activity = fragment.requireActivity();
-        fetchUploaderUrlIfSparse(activity, item.getServiceId(), item.getUrl(),
-                item.getUploaderUrl(), url -> openChannelFragment(activity, item, url));
-    }),
+    SHOW_CHANNEL_DETAILS(R.string.show_channel_details, (fragment, item) ->
+            fetchUploaderUrlIfSparse(fragment.requireContext(), item.getServiceId(), item.getUrl(),
+                    item.getUploaderUrl(), url -> openChannelFragment(fragment, item, url))
+    ),
 
     /**
      * Enqueues the stream automatically to the current PlayerType.

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

@@ -13,8 +13,8 @@ import org.schabi.newpipe.extractor.channel.ChannelInfoItem;
 import org.schabi.newpipe.extractor.utils.Utils;
 import org.schabi.newpipe.info_list.InfoItemBuilder;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
+import org.schabi.newpipe.util.image.PicassoHelper;
 import org.schabi.newpipe.util.Localization;
-import org.schabi.newpipe.util.image.CoilHelper;
 
 public class ChannelMiniInfoItemHolder extends InfoItemHolder {
     private final ImageView itemThumbnailView;
@@ -56,7 +56,7 @@ public class ChannelMiniInfoItemHolder extends InfoItemHolder {
             itemAdditionalDetailView.setText(getDetailLine(item));
         }
 
-        CoilHelper.INSTANCE.loadAvatar(itemThumbnailView, item.getThumbnails());
+        PicassoHelper.loadAvatar(item.getThumbnails()).into(itemThumbnailView);
 
         itemView.setOnClickListener(view -> {
             if (itemBuilder.getOnChannelSelectedListener() != null) {

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

@@ -0,0 +1,212 @@
+package org.schabi.newpipe.info_list.holder;
+
+import static org.schabi.newpipe.util.ServiceHelper.getServiceById;
+import static org.schabi.newpipe.util.text.TouchUtils.getOffsetForHorizontalLine;
+
+import android.text.Spanned;
+import android.text.method.LinkMovementMethod;
+import android.text.style.ClickableSpan;
+import android.text.style.URLSpan;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.ImageView;
+import android.widget.RelativeLayout;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.fragment.app.FragmentActivity;
+
+import org.schabi.newpipe.R;
+import org.schabi.newpipe.extractor.InfoItem;
+import org.schabi.newpipe.extractor.comments.CommentsInfoItem;
+import org.schabi.newpipe.info_list.InfoItemBuilder;
+import org.schabi.newpipe.local.history.HistoryRecordManager;
+import org.schabi.newpipe.util.DeviceUtils;
+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.image.ImageStrategy;
+import org.schabi.newpipe.util.image.PicassoHelper;
+import org.schabi.newpipe.util.text.TextEllipsizer;
+
+public class CommentInfoItemHolder extends InfoItemHolder {
+
+    private static final int COMMENT_DEFAULT_LINES = 2;
+    private final int commentHorizontalPadding;
+    private final int commentVerticalPadding;
+
+    private final RelativeLayout itemRoot;
+    private final ImageView itemThumbnailView;
+    private final TextView itemContentView;
+    private final ImageView itemThumbsUpView;
+    private final TextView itemLikesCountView;
+    private final TextView itemTitleView;
+    private final ImageView itemHeartView;
+    private final ImageView itemPinnedView;
+    private final Button repliesButton;
+
+    @NonNull
+    private final TextEllipsizer textEllipsizer;
+
+    public CommentInfoItemHolder(final InfoItemBuilder infoItemBuilder,
+                                 final ViewGroup parent) {
+        super(infoItemBuilder, R.layout.list_comment_item, parent);
+
+        itemRoot = itemView.findViewById(R.id.itemRoot);
+        itemThumbnailView = itemView.findViewById(R.id.itemThumbnailView);
+        itemContentView = itemView.findViewById(R.id.itemCommentContentView);
+        itemThumbsUpView = itemView.findViewById(R.id.detail_thumbs_up_img_view);
+        itemLikesCountView = itemView.findViewById(R.id.detail_thumbs_up_count_view);
+        itemTitleView = itemView.findViewById(R.id.itemTitleView);
+        itemHeartView = itemView.findViewById(R.id.detail_heart_image_view);
+        itemPinnedView = itemView.findViewById(R.id.detail_pinned_view);
+        repliesButton = itemView.findViewById(R.id.replies_button);
+
+        commentHorizontalPadding = (int) infoItemBuilder.getContext()
+                .getResources().getDimension(R.dimen.comments_horizontal_padding);
+        commentVerticalPadding = (int) infoItemBuilder.getContext()
+                .getResources().getDimension(R.dimen.comments_vertical_padding);
+
+        textEllipsizer = new TextEllipsizer(itemContentView, COMMENT_DEFAULT_LINES, null);
+        textEllipsizer.setStateChangeListener(isEllipsized -> {
+            if (Boolean.TRUE.equals(isEllipsized)) {
+                denyLinkFocus();
+            } else {
+                determineMovementMethod();
+            }
+        });
+    }
+
+    @Override
+    public void updateFromItem(final InfoItem infoItem,
+                               final HistoryRecordManager historyRecordManager) {
+        if (!(infoItem instanceof CommentsInfoItem)) {
+            return;
+        }
+        final CommentsInfoItem item = (CommentsInfoItem) infoItem;
+
+
+        // load the author avatar
+        PicassoHelper.loadAvatar(item.getUploaderAvatars()).into(itemThumbnailView);
+        if (ImageStrategy.shouldLoadImages()) {
+            itemThumbnailView.setVisibility(View.VISIBLE);
+            itemRoot.setPadding(commentVerticalPadding, commentVerticalPadding,
+                    commentVerticalPadding, commentVerticalPadding);
+        } else {
+            itemThumbnailView.setVisibility(View.GONE);
+            itemRoot.setPadding(commentHorizontalPadding, commentVerticalPadding,
+                    commentHorizontalPadding, commentVerticalPadding);
+        }
+        itemThumbnailView.setOnClickListener(view -> openCommentAuthor(item));
+
+        // setup the top row, with pinned icon, author name and comment date
+        itemPinnedView.setVisibility(item.isPinned() ? View.VISIBLE : View.GONE);
+        final String uploaderName = Localization.localizeUserName(item.getUploaderName());
+        itemTitleView.setText(Localization.concatenateStrings(
+                uploaderName,
+                Localization.relativeTimeOrTextual(
+                        itemBuilder.getContext(),
+                        item.getUploadDate(),
+                        item.getTextualUploadDate())));
+
+        // setup bottom row, with likes, heart and replies button
+        itemLikesCountView.setText(
+                Localization.likeCount(itemBuilder.getContext(), item.getLikeCount()));
+
+        itemHeartView.setVisibility(item.isHeartedByUploader() ? View.VISIBLE : View.GONE);
+
+        final boolean hasReplies = item.getReplies() != null;
+        repliesButton.setOnClickListener(hasReplies ? v -> openCommentReplies(item) : null);
+        repliesButton.setVisibility(hasReplies ? View.VISIBLE : View.GONE);
+        repliesButton.setText(hasReplies
+                ? Localization.replyCount(itemBuilder.getContext(), item.getReplyCount()) : "");
+        ((RelativeLayout.LayoutParams) itemThumbsUpView.getLayoutParams()).topMargin =
+                hasReplies ? 0 : DeviceUtils.dpToPx(6, itemBuilder.getContext());
+
+
+        // setup comment content and click listeners to expand/ellipsize it
+        textEllipsizer.setStreamingService(getServiceById(item.getServiceId()));
+        textEllipsizer.setStreamUrl(item.getUrl());
+        textEllipsizer.setContent(item.getCommentText());
+        textEllipsizer.ellipsize();
+
+        //noinspection ClickableViewAccessibility
+        itemContentView.setOnTouchListener((v, event) -> {
+            final CharSequence text = itemContentView.getText();
+            if (text instanceof Spanned buffer) {
+                final int action = event.getAction();
+
+                if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_DOWN) {
+                    final int offset = getOffsetForHorizontalLine(itemContentView, event);
+                    final var links = buffer.getSpans(offset, offset, ClickableSpan.class);
+
+                    if (links.length != 0) {
+                        if (action == MotionEvent.ACTION_UP) {
+                            links[0].onClick(itemContentView);
+                        }
+                        // we handle events that intersect links, so return true
+                        return true;
+                    }
+                }
+            }
+            return false;
+        });
+
+        itemView.setOnClickListener(view -> {
+            textEllipsizer.toggle();
+            if (itemBuilder.getOnCommentsSelectedListener() != null) {
+                itemBuilder.getOnCommentsSelectedListener().selected(item);
+            }
+        });
+
+        itemView.setOnLongClickListener(view -> {
+            if (DeviceUtils.isTv(itemBuilder.getContext())) {
+                openCommentAuthor(item);
+            } else {
+                final CharSequence text = itemContentView.getText();
+                if (text != null) {
+                    ShareUtils.copyToClipboard(itemBuilder.getContext(), text.toString());
+                }
+            }
+            return true;
+        });
+    }
+
+    private void openCommentAuthor(@NonNull final CommentsInfoItem item) {
+        NavigationHelper.openCommentAuthorIfPresent((FragmentActivity) itemBuilder.getContext(),
+                item);
+    }
+
+    private void openCommentReplies(@NonNull final CommentsInfoItem item) {
+        NavigationHelper.openCommentRepliesFragment((FragmentActivity) itemBuilder.getContext(),
+                item);
+    }
+
+    private void allowLinkFocus() {
+        itemContentView.setMovementMethod(LinkMovementMethod.getInstance());
+    }
+
+    private void denyLinkFocus() {
+        itemContentView.setMovementMethod(null);
+    }
+
+    private boolean shouldFocusLinks() {
+        if (itemView.isInTouchMode()) {
+            return false;
+        }
+
+        final URLSpan[] urls = itemContentView.getUrls();
+
+        return urls != null && urls.length != 0;
+    }
+
+    private void determineMovementMethod() {
+        if (shouldFocusLinks()) {
+            allowLinkFocus();
+        } else {
+            denyLinkFocus();
+        }
+    }
+}

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

@@ -9,8 +9,8 @@ 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.image.PicassoHelper;
 import org.schabi.newpipe.util.Localization;
-import org.schabi.newpipe.util.image.CoilHelper;
 
 public class PlaylistMiniInfoItemHolder extends InfoItemHolder {
     public final ImageView itemThumbnailView;
@@ -46,7 +46,7 @@ public class PlaylistMiniInfoItemHolder extends InfoItemHolder {
                 .localizeStreamCountMini(itemStreamCountView.getContext(), item.getStreamCount()));
         itemUploaderView.setText(item.getUploaderName());
 
-        CoilHelper.INSTANCE.loadPlaylistThumbnail(itemThumbnailView, item.getThumbnails());
+        PicassoHelper.loadPlaylistThumbnail(item.getThumbnails()).into(itemThumbnailView);
 
         itemView.setOnClickListener(view -> {
             if (itemBuilder.getOnPlaylistSelectedListener() != null) {

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

@@ -16,8 +16,8 @@ import org.schabi.newpipe.ktx.ViewUtils;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
 import org.schabi.newpipe.util.DependentPreferenceHelper;
 import org.schabi.newpipe.util.Localization;
+import org.schabi.newpipe.util.image.PicassoHelper;
 import org.schabi.newpipe.util.StreamTypeUtil;
-import org.schabi.newpipe.util.image.CoilHelper;
 import org.schabi.newpipe.views.AnimatedProgressBar;
 
 import java.util.concurrent.TimeUnit;
@@ -64,7 +64,8 @@ public class StreamMiniInfoItemHolder extends InfoItemHolder {
             StreamStateEntity state2 = null;
             if (DependentPreferenceHelper
                     .getPositionsInListsEnabled(itemProgressView.getContext())) {
-                state2 = historyRecordManager.loadStreamState(infoItem).blockingGet();
+                state2 = historyRecordManager.loadStreamState(infoItem)
+                        .blockingGet()[0];
             }
             if (state2 != null) {
                 itemProgressView.setVisibility(View.VISIBLE);
@@ -86,7 +87,7 @@ public class StreamMiniInfoItemHolder extends InfoItemHolder {
         }
 
         // Default thumbnail is shown on error, while loading and if the url is empty
-        CoilHelper.INSTANCE.loadThumbnail(itemThumbnailView, item.getThumbnails());
+        PicassoHelper.loadThumbnail(item.getThumbnails()).into(itemThumbnailView);
 
         itemView.setOnClickListener(view -> {
             if (itemBuilder.getOnStreamSelectedListener() != null) {
@@ -119,7 +120,7 @@ public class StreamMiniInfoItemHolder extends InfoItemHolder {
         if (DependentPreferenceHelper.getPositionsInListsEnabled(itemProgressView.getContext())) {
             state = historyRecordManager
                     .loadStreamState(infoItem)
-                    .blockingGet();
+                    .blockingGet()[0];
         }
         if (state != null && item.getDuration() > 0
                 && !StreamTypeUtil.isLiveStream(item.getStreamType())) {

app/src/main/java/org/schabi/newpipe/ktx/Bitmap.kt

@@ -1,13 +0,0 @@
-package org.schabi.newpipe.ktx
-
-import android.graphics.Bitmap
-import android.graphics.Rect
-import androidx.core.graphics.BitmapCompat
-
-@Suppress("NOTHING_TO_INLINE")
-inline fun Bitmap.scale(
-    width: Int,
-    height: Int,
-    srcRect: Rect? = null,
-    scaleInLinearSpace: Boolean = true
-) = BitmapCompat.createScaledBitmap(this, width, height, srcRect, scaleInLinearSpace)

app/src/main/java/org/schabi/newpipe/ktx/Bundle.kt

@@ -1,11 +1,11 @@
 package org.schabi.newpipe.ktx
 
 import android.os.Bundle
+import android.os.Parcelable
 import androidx.core.os.BundleCompat
-import java.io.Serializable
 
-inline fun <reified T : Serializable> Bundle.serializable(key: String?): T? {
-    return BundleCompat.getSerializable(this, key, T::class.java)
+inline fun <reified T : Parcelable> Bundle.parcelableArrayList(key: String?): ArrayList<T>? {
+    return BundleCompat.getParcelableArrayList(this, key, T::class.java)
 }
 
 fun Bundle?.toDebugString(): String {

app/src/main/java/org/schabi/newpipe/ktx/Context.kt

@@ -1,13 +0,0 @@
-package org.schabi.newpipe.ktx
-
-import android.content.Context
-import android.content.ContextWrapper
-import androidx.fragment.app.FragmentActivity
-
-tailrec fun Context.findFragmentActivity(): FragmentActivity {
-    return when (this) {
-        is FragmentActivity -> this
-        is ContextWrapper -> baseContext.findFragmentActivity()
-        else -> throw IllegalStateException("Unable to find FragmentActivity")
-    }
-}

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

@@ -16,7 +16,6 @@ import android.view.ViewGroup;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.appcompat.app.AlertDialog;
-import androidx.compose.ui.platform.ComposeView;
 import androidx.fragment.app.FragmentManager;
 import androidx.recyclerview.widget.ItemTouchHelper;
 import androidx.recyclerview.widget.RecyclerView;
@@ -40,8 +39,6 @@ import org.schabi.newpipe.local.holder.LocalBookmarkPlaylistItemHolder;
 import org.schabi.newpipe.local.holder.RemoteBookmarkPlaylistItemHolder;
 import org.schabi.newpipe.local.playlist.LocalPlaylistManager;
 import org.schabi.newpipe.local.playlist.RemotePlaylistManager;
-import org.schabi.newpipe.ui.emptystate.EmptyStateSpec;
-import org.schabi.newpipe.ui.emptystate.EmptyStateUtil;
 import org.schabi.newpipe.util.NavigationHelper;
 import org.schabi.newpipe.util.OnClickGesture;
 import org.schabi.newpipe.util.debounce.DebounceSavable;
@@ -127,8 +124,6 @@ public final class BookmarkFragment extends BaseLocalListFragment<List<PlaylistL
         super.initViews(rootView, savedInstanceState);
 
         itemListAdapter.setUseItemHandle(true);
-        final ComposeView emptyView = rootView.findViewById(R.id.empty_state_view);
-        EmptyStateUtil.setEmptyStateComposable(emptyView, EmptyStateSpec.NoBookmarkedPlaylist);
     }
 
     @Override

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

@@ -76,7 +76,6 @@ import org.schabi.newpipe.ktx.slideUp
 import org.schabi.newpipe.local.feed.item.StreamItem
 import org.schabi.newpipe.local.feed.service.FeedLoadService
 import org.schabi.newpipe.local.subscription.SubscriptionManager
-import org.schabi.newpipe.ui.emptystate.setEmptyStateComposable
 import org.schabi.newpipe.util.DeviceUtils
 import org.schabi.newpipe.util.Localization
 import org.schabi.newpipe.util.NavigationHelper
@@ -136,7 +135,6 @@ class FeedFragment : BaseStateFragment<FeedState>() {
     override fun onViewCreated(rootView: View, savedInstanceState: Bundle?) {
         // super.onViewCreated() calls initListeners() which require the binding to be initialized
         _feedBinding = FragmentFeedBinding.bind(rootView)
-        feedBinding.emptyStateView.setEmptyStateComposable()
         super.onViewCreated(rootView, savedInstanceState)
 
         val factory = FeedViewModel.getFactory(requireContext(), groupId)
@@ -206,7 +204,6 @@ class FeedFragment : BaseStateFragment<FeedState>() {
     // Menu
     // /////////////////////////////////////////////////////////////////////////
 
-    @Deprecated("Deprecated in Java")
     override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
         super.onCreateOptionsMenu(menu, inflater)
 
@@ -217,7 +214,6 @@ class FeedFragment : BaseStateFragment<FeedState>() {
         inflater.inflate(R.menu.menu_feed_fragment, menu)
     }
 
-    @Deprecated("Deprecated in Java")
     override fun onOptionsItemSelected(item: MenuItem): Boolean {
         if (item.itemId == R.id.menu_item_feed_help) {
             val sharedPreferences = PreferenceManager.getDefaultSharedPreferences(requireContext())
@@ -273,7 +269,6 @@ class FeedFragment : BaseStateFragment<FeedState>() {
             .show()
     }
 
-    @Deprecated("Deprecated in Java")
     override fun onDestroyOptionsMenu() {
         super.onDestroyOptionsMenu()
         if (

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

@@ -169,7 +169,7 @@ class FeedViewModel(
         fun getFactory(context: Context, groupId: Long) = viewModelFactory {
             initializer {
                 FeedViewModel(
-                    App.instance,
+                    App.getApp(),
                     groupId,
                     // Read initial value from preferences
                     getShowPlayedItemsFromPreferences(context.applicationContext),

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

@@ -21,7 +21,7 @@ import org.schabi.newpipe.extractor.stream.StreamType.POST_LIVE_STREAM
 import org.schabi.newpipe.extractor.stream.StreamType.VIDEO_STREAM
 import org.schabi.newpipe.util.Localization
 import org.schabi.newpipe.util.StreamTypeUtil
-import org.schabi.newpipe.util.image.CoilHelper
+import org.schabi.newpipe.util.image.PicassoHelper
 
 data class StreamItem(
     val streamWithState: StreamWithState,
@@ -101,7 +101,7 @@ data class StreamItem(
             viewBinding.itemProgressView.visibility = View.GONE
         }
 
-        CoilHelper.loadThumbnail(viewBinding.itemThumbnailView, stream.thumbnailUrl)
+        PicassoHelper.loadThumbnail(stream.thumbnailUrl).into(viewBinding.itemThumbnailView)
 
         if (itemVersion != ItemVersion.MINI) {
             viewBinding.itemAdditionalDetails.text =

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

@@ -6,6 +6,7 @@ import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
 import android.graphics.Bitmap
+import android.graphics.drawable.Drawable
 import android.net.Uri
 import android.os.Build
 import android.provider.Settings
@@ -16,17 +17,20 @@ import androidx.core.content.ContextCompat
 import androidx.core.content.getSystemService
 import androidx.core.net.toUri
 import androidx.preference.PreferenceManager
+import com.squareup.picasso.Picasso
+import com.squareup.picasso.Target
 import org.schabi.newpipe.R
 import org.schabi.newpipe.extractor.stream.StreamInfoItem
 import org.schabi.newpipe.local.feed.service.FeedUpdateInfo
 import org.schabi.newpipe.util.NavigationHelper
-import org.schabi.newpipe.util.image.CoilHelper
+import org.schabi.newpipe.util.image.PicassoHelper
 
 /**
  * Helper for everything related to show notifications about new streams to the user.
  */
 class NotificationHelper(val context: Context) {
     private val manager = NotificationManagerCompat.from(context)
+    private val iconLoadingTargets = ArrayList<Target>()
 
     /**
      * Show notifications for new streams from a single channel. The individual notifications are
@@ -67,38 +71,75 @@ class NotificationHelper(val context: Context) {
         summaryBuilder.setStyle(style)
 
         // open the channel page when clicking on the summary notification
-        val intent = NavigationHelper
-            .getChannelIntent(context, data.serviceId, data.url)
-            .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
         summaryBuilder.setContentIntent(
-            PendingIntentCompat.getActivity(context, data.pseudoId, intent, 0, false)
+            PendingIntentCompat.getActivity(
+                context,
+                data.pseudoId,
+                NavigationHelper
+                    .getChannelIntent(context, data.serviceId, data.url)
+                    .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK),
+                0,
+                false
+            )
         )
 
-        val avatarIcon =
-            CoilHelper.loadBitmapBlocking(context, data.avatarUrl, R.drawable.ic_newpipe_triangle_white)
+        // a Target is like a listener for image loading events
+        val target = object : Target {
+            override fun onBitmapLoaded(bitmap: Bitmap, from: Picasso.LoadedFrom) {
+                // set channel icon only if there is actually one (for Android versions < 7.0)
+                summaryBuilder.setLargeIcon(bitmap)
 
-        summaryBuilder.setLargeIcon(avatarIcon)
+                // Show individual stream notifications, set channel icon only if there is actually
+                // one
+                showStreamNotifications(newStreams, data.serviceId, data.url, bitmap)
+                // Show summary notification if enabled
+                if (manager.areNotificationsEnabled()) {
+                    manager.notify(data.pseudoId, summaryBuilder.build())
+                }
 
-        // Show individual stream notifications, set channel icon only if there is actually one
-        showStreamNotifications(newStreams, data.serviceId, avatarIcon)
-        // Show summary notification
-        manager.notify(data.pseudoId, summaryBuilder.build())
+                iconLoadingTargets.remove(this) // allow it to be garbage-collected
+            }
+
+            override fun onBitmapFailed(e: Exception, errorDrawable: Drawable) {
+                // Show individual stream notifications
+                showStreamNotifications(newStreams, data.serviceId, data.url, null)
+                // Show summary notification if enabled
+                if (manager.areNotificationsEnabled()) {
+                    manager.notify(data.pseudoId, summaryBuilder.build())
+                }
+                iconLoadingTargets.remove(this) // allow it to be garbage-collected
+            }
+
+            override fun onPrepareLoad(placeHolderDrawable: Drawable) {
+                // Nothing to do
+            }
+        }
+
+        // add the target to the list to hold a strong reference and prevent it from being garbage
+        // collected, since Picasso only holds weak references to targets
+        iconLoadingTargets.add(target)
+
+        PicassoHelper.loadNotificationIcon(data.avatarUrl).into(target)
     }
 
     private fun showStreamNotifications(
         newStreams: List<StreamInfoItem>,
         serviceId: Int,
+        channelUrl: String,
         channelIcon: Bitmap?
     ) {
         for (stream in newStreams) {
-            val notification = createStreamNotification(stream, serviceId, channelIcon)
-            manager.notify(stream.url.hashCode(), notification)
+            val notification = createStreamNotification(stream, serviceId, channelUrl, channelIcon)
+            if (manager.areNotificationsEnabled()) {
+                manager.notify(stream.url.hashCode(), notification)
+            }
         }
     }
 
     private fun createStreamNotification(
         item: StreamInfoItem,
         serviceId: Int,
+        channelUrl: String,
         channelIcon: Bitmap?
     ): Notification {
         return NotificationCompat.Builder(
@@ -109,7 +150,7 @@ class NotificationHelper(val context: Context) {
             .setLargeIcon(channelIcon)
             .setContentTitle(item.name)
             .setContentText(item.uploaderName)
-            .setGroup(item.uploaderUrl)
+            .setGroup(channelUrl)
             .setColor(ContextCompat.getColor(context, R.color.ic_launcher_background))
             .setColorized(true)
             .setAutoCancel(true)

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

@@ -185,7 +185,9 @@ class FeedLoadService : Service() {
             }
         }
 
-        notificationManager.notify(NOTIFICATION_ID, notificationBuilder.build())
+        if (notificationManager.areNotificationsEnabled()) {
+            notificationManager.notify(NOTIFICATION_ID, notificationBuilder.build())
+        }
     }
 
     // /////////////////////////////////////////////////////////////////////////

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

@@ -18,13 +18,10 @@ package org.schabi.newpipe.local.history;
  * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-import static org.schabi.newpipe.util.ExtractorHelper.getStreamInfo;
-
 import android.content.Context;
 import android.content.SharedPreferences;
 
 import androidx.annotation.NonNull;
-import androidx.collection.LongLongPair;
 import androidx.preference.PreferenceManager;
 
 import org.schabi.newpipe.NewPipeDatabase;
@@ -48,6 +45,7 @@ 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;
@@ -93,39 +91,47 @@ public class HistoryRecordManager {
      * @param info the item to mark as watched
      * @return a Maybe containing the ID of the item if successful
      */
-    public Completable markAsWatched(final StreamInfoItem info) {
+    public Maybe<Long> markAsWatched(final StreamInfoItem info) {
         if (!isStreamHistoryEnabled()) {
-            return Completable.complete();
+            return Maybe.empty();
         }
 
-        final var remoteInfo = getStreamInfo(info.getServiceId(), info.getUrl(), false)
-            .map(item ->
-                new LongLongPair(item.getDuration(), streamTable.upsert(new StreamEntity(item))));
-
-        return Single.just(info)
-                .filter(item -> item.getDuration() >= 0)
-                .map(item ->
-                    new LongLongPair(item.getDuration(), streamTable.upsert(new StreamEntity(item)))
+        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
                 )
-                .switchIfEmpty(remoteInfo)
-                .flatMapCompletable(pair -> Completable.fromRunnable(() -> {
-                    final long duration = pair.getFirst();
-                    final long streamId = pair.getSecond();
+                        .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 var entity = new StreamStateEntity(streamId, duration * 1000);
-                    streamStateTable.upsert(entity);
+            // Update the stream progress to the full duration of the video
+            final StreamStateEntity entity = new StreamStateEntity(
+                    streamId,
+                    duration * 1000
+            );
+            streamStateTable.upsert(entity);
 
-                    // Add a history entry
-                    final var latestEntry = streamHistoryTable.getLatestEntry(streamId);
-                    if (latestEntry == null) {
-                        final var currentTime = OffsetDateTime.now(ZoneOffset.UTC);
-                        // never actually viewed: add history entry but with 0 views
-                        final var entry = new StreamHistoryEntity(streamId, currentTime, 0);
-                        streamHistoryTable.insert(entry);
-                    }
-                }))
-                .subscribeOn(Schedulers.io());
+            // Add a history entry
+            final StreamHistoryEntity latestEntry = streamHistoryTable.getLatestEntry(streamId);
+            if (latestEntry == null) {
+                // never actually viewed: add history entry but with 0 views
+                return streamHistoryTable.insert(new StreamHistoryEntity(streamId, currentTime, 0));
+            } else {
+                return 0L;
+            }
+        })).subscribeOn(Schedulers.io());
     }
 
     public Maybe<Long> onViewed(final StreamInfo info) {
@@ -215,7 +221,7 @@ public class HistoryRecordManager {
     public Flowable<List<String>> getRelatedSearches(final String query,
                                                      final int similarQueryLimit,
                                                      final int uniqueQueryLimit) {
-        return !query.isEmpty()
+        return query.length() > 0
                 ? searchHistoryTable.getSimilarEntries(query, similarQueryLimit)
                 : searchHistoryTable.getUniqueEntries(uniqueQueryLimit);
     }
@@ -230,31 +236,47 @@ public class HistoryRecordManager {
 
     public Maybe<StreamStateEntity> loadStreamState(final PlayQueueItem queueItem) {
         return queueItem.getStream()
-                .flatMapMaybe(this::loadStreamState)
+                .map(info -> streamTable.upsert(new StreamEntity(info)))
+                .flatMapPublisher(streamStateTable::getState)
+                .firstElement()
+                .flatMap(list -> list.isEmpty() ? Maybe.empty() : Maybe.just(list.get(0)))
                 .filter(state -> state.isValid(queueItem.getDuration()))
                 .subscribeOn(Schedulers.io());
     }
 
     public Maybe<StreamStateEntity> loadStreamState(final StreamInfo info) {
         return Single.fromCallable(() -> streamTable.upsert(new StreamEntity(info)))
-                .flatMapMaybe(streamStateTable::getState)
+                .flatMapPublisher(streamStateTable::getState)
+                .firstElement()
+                .flatMap(list -> list.isEmpty() ? Maybe.empty() : Maybe.just(list.get(0)))
+                .filter(state -> state.isValid(info.getDuration()))
                 .subscribeOn(Schedulers.io());
     }
 
     public Completable saveStreamState(@NonNull final StreamInfo info, final long progressMillis) {
         return Completable.fromAction(() -> database.runInTransaction(() -> {
             final long streamId = streamTable.upsert(new StreamEntity(info));
-            final var state = new StreamStateEntity(streamId, progressMillis);
+            final StreamStateEntity state = new StreamStateEntity(streamId, progressMillis);
             if (state.isValid(info.getDuration())) {
                 streamStateTable.upsert(state);
             }
         })).subscribeOn(Schedulers.io());
     }
 
-    public Maybe<StreamStateEntity> loadStreamState(final InfoItem info) {
-        return streamTable.getStream(info.getServiceId(), info.getUrl())
-                .flatMap(entity -> streamStateTable.getState(entity.getUid()))
-                .subscribeOn(Schedulers.io());
+    public Single<StreamStateEntity[]> loadStreamState(final InfoItem info) {
+        return Single.fromCallable(() -> {
+            final List<StreamEntity> entities = streamTable
+                    .getStream(info.getServiceId(), info.getUrl()).blockingFirst();
+            if (entities.isEmpty()) {
+                return new StreamStateEntity[]{null};
+            }
+            final List<StreamStateEntity> states = streamStateTable
+                    .getState(entities.get(0).getUid()).blockingFirst();
+            if (states.isEmpty()) {
+                return new StreamStateEntity[]{null};
+            }
+            return new StreamStateEntity[]{states.get(0)};
+        }).subscribeOn(Schedulers.io());
     }
 
     public Single<List<StreamStateEntity>> loadLocalStreamStateBatch(
@@ -273,7 +295,13 @@ public class HistoryRecordManager {
                     result.add(null);
                     continue;
                 }
-                result.add(streamStateTable.getState(streamId).blockingGet());
+                final List<StreamStateEntity> states = streamStateTable.getState(streamId)
+                        .blockingFirst();
+                if (states.isEmpty()) {
+                    result.add(null);
+                } else {
+                    result.add(states.get(0));
+                }
             }
             return result;
         }).subscribeOn(Schedulers.io());

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

@@ -8,8 +8,8 @@ import org.schabi.newpipe.database.playlist.PlaylistDuplicatesEntry;
 import org.schabi.newpipe.database.playlist.PlaylistMetadataEntry;
 import org.schabi.newpipe.local.LocalItemBuilder;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
+import org.schabi.newpipe.util.image.PicassoHelper;
 import org.schabi.newpipe.util.Localization;
-import org.schabi.newpipe.util.image.CoilHelper;
 
 import java.time.format.DateTimeFormatter;
 
@@ -30,16 +30,17 @@ public class LocalPlaylistItemHolder extends PlaylistItemHolder {
     public void updateFromItem(final LocalItem localItem,
                                final HistoryRecordManager historyRecordManager,
                                final DateTimeFormatter dateTimeFormatter) {
-        if (!(localItem instanceof PlaylistMetadataEntry item)) {
+        if (!(localItem instanceof PlaylistMetadataEntry)) {
             return;
         }
+        final PlaylistMetadataEntry item = (PlaylistMetadataEntry) localItem;
 
         itemTitleView.setText(item.getOrderingName());
         itemStreamCountView.setText(Localization.localizeStreamCountMini(
                 itemStreamCountView.getContext(), item.getStreamCount()));
         itemUploaderView.setVisibility(View.INVISIBLE);
 
-        CoilHelper.INSTANCE.loadPlaylistThumbnail(itemThumbnailView, item.getThumbnailUrl());
+        PicassoHelper.loadPlaylistThumbnail(item.getThumbnailUrl()).into(itemThumbnailView);
 
         if (item instanceof PlaylistDuplicatesEntry
                 && ((PlaylistDuplicatesEntry) item).getTimesStreamIsContained() > 0) {

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

@@ -16,8 +16,8 @@ import org.schabi.newpipe.local.LocalItemBuilder;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
 import org.schabi.newpipe.util.DependentPreferenceHelper;
 import org.schabi.newpipe.util.Localization;
+import org.schabi.newpipe.util.image.PicassoHelper;
 import org.schabi.newpipe.util.ServiceHelper;
-import org.schabi.newpipe.util.image.CoilHelper;
 import org.schabi.newpipe.views.AnimatedProgressBar;
 
 import java.time.format.DateTimeFormatter;
@@ -83,8 +83,8 @@ public class LocalPlaylistStreamItemHolder extends LocalItemHolder {
         }
 
         // Default thumbnail is shown on error, while loading and if the url is empty
-        CoilHelper.INSTANCE.loadThumbnail(itemThumbnailView,
-                item.getStreamEntity().getThumbnailUrl());
+        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

@@ -16,8 +16,8 @@ import org.schabi.newpipe.local.LocalItemBuilder;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
 import org.schabi.newpipe.util.DependentPreferenceHelper;
 import org.schabi.newpipe.util.Localization;
+import org.schabi.newpipe.util.image.PicassoHelper;
 import org.schabi.newpipe.util.ServiceHelper;
-import org.schabi.newpipe.util.image.CoilHelper;
 import org.schabi.newpipe.views.AnimatedProgressBar;
 
 import java.time.format.DateTimeFormatter;
@@ -117,8 +117,8 @@ public class LocalStatisticStreamItemHolder extends LocalItemHolder {
         }
 
         // Default thumbnail is shown on error, while loading and if the url is empty
-        CoilHelper.INSTANCE.loadThumbnail(itemThumbnailView,
-                item.getStreamEntity().getThumbnailUrl());
+        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,8 +8,8 @@ import org.schabi.newpipe.database.playlist.model.PlaylistRemoteEntity;
 import org.schabi.newpipe.local.LocalItemBuilder;
 import org.schabi.newpipe.local.history.HistoryRecordManager;
 import org.schabi.newpipe.util.Localization;
+import org.schabi.newpipe.util.image.PicassoHelper;
 import org.schabi.newpipe.util.ServiceHelper;
-import org.schabi.newpipe.util.image.CoilHelper;
 
 import java.time.format.DateTimeFormatter;
 
@@ -29,9 +29,10 @@ public class RemotePlaylistItemHolder extends PlaylistItemHolder {
     public void updateFromItem(final LocalItem localItem,
                                final HistoryRecordManager historyRecordManager,
                                final DateTimeFormatter dateTimeFormatter) {
-        if (!(localItem instanceof PlaylistRemoteEntity item)) {
+        if (!(localItem instanceof PlaylistRemoteEntity)) {
             return;
         }
+        final PlaylistRemoteEntity item = (PlaylistRemoteEntity) localItem;
 
         itemTitleView.setText(item.getOrderingName());
         itemStreamCountView.setText(Localization.localizeStreamCountMini(
@@ -44,7 +45,7 @@ public class RemotePlaylistItemHolder extends PlaylistItemHolder {
             itemUploaderView.setText(ServiceHelper.getNameOfServiceById(item.getServiceId()));
         }
 
-        CoilHelper.INSTANCE.loadPlaylistThumbnail(itemThumbnailView, item.getThumbnailUrl());
+        PicassoHelper.loadPlaylistThumbnail(item.getThumbnailUrl()).into(itemThumbnailView);
 
         super.updateFromItem(localItem, historyRecordManager, dateTimeFormatter);
     }

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

@@ -1,63 +1,41 @@
 package org.schabi.newpipe.local.subscription;
 
 import android.app.Dialog;
+import android.content.Intent;
 import android.os.Bundle;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.appcompat.app.AlertDialog;
-import androidx.core.os.BundleCompat;
 import androidx.fragment.app.DialogFragment;
 import androidx.fragment.app.Fragment;
-import androidx.work.Constraints;
-import androidx.work.ExistingWorkPolicy;
-import androidx.work.NetworkType;
-import androidx.work.OneTimeWorkRequest;
-import androidx.work.OutOfQuotaPolicy;
-import androidx.work.WorkManager;
 
 import com.livefront.bridge.Bridge;
 
 import org.schabi.newpipe.R;
-import org.schabi.newpipe.local.subscription.workers.SubscriptionImportInput;
-import org.schabi.newpipe.local.subscription.workers.SubscriptionImportWorker;
 
 public class ImportConfirmationDialog extends DialogFragment {
-    private static final String INPUT = "input";
+    protected Intent resultServiceIntent;
+    private static final String EXTRA_RESULT_SERVICE_INTENT = "extra_result_service_intent";
 
-    public static void show(@NonNull final Fragment fragment, final SubscriptionImportInput input) {
-        final var confirmationDialog = new ImportConfirmationDialog();
-        final var arguments = new Bundle();
-        arguments.putParcelable(INPUT, input);
-        confirmationDialog.setArguments(arguments);
+    public static void show(@NonNull final Fragment fragment,
+                            @NonNull final Intent resultServiceIntent) {
+        final ImportConfirmationDialog confirmationDialog = new ImportConfirmationDialog();
+        final Bundle args = new Bundle();
+        args.putParcelable(EXTRA_RESULT_SERVICE_INTENT, resultServiceIntent);
+        confirmationDialog.setArguments(args);
         confirmationDialog.show(fragment.getParentFragmentManager(), null);
     }
 
     @NonNull
     @Override
     public Dialog onCreateDialog(@Nullable final Bundle savedInstanceState) {
-        final var context = requireContext();
-        return new AlertDialog.Builder(context)
+        return new AlertDialog.Builder(requireContext())
                 .setMessage(R.string.import_network_expensive_warning)
                 .setCancelable(true)
                 .setNegativeButton(R.string.cancel, null)
                 .setPositiveButton(R.string.ok, (dialogInterface, i) -> {
-                    final var constraints = new Constraints.Builder()
-                            .setRequiredNetworkType(NetworkType.CONNECTED)
-                            .build();
-                    final var input = BundleCompat.getParcelable(requireArguments(), INPUT,
-                            SubscriptionImportInput.class);
-
-                    final var req = new OneTimeWorkRequest.Builder(SubscriptionImportWorker.class)
-                            .setInputData(input.toData())
-                            .setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)
-                            .setConstraints(constraints)
-                            .build();
-
-                    WorkManager.getInstance(context)
-                            .enqueueUniqueWork(SubscriptionImportWorker.WORK_NAME,
-                                    ExistingWorkPolicy.APPEND_OR_REPLACE, req);
-
+                    requireContext().startService(resultServiceIntent);
                     dismiss();
                 })
                 .create();
@@ -67,7 +45,7 @@ public class ImportConfirmationDialog extends DialogFragment {
     public void onCreate(@Nullable final Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 
-        Bridge.restoreInstanceState(this, savedInstanceState);
+        resultServiceIntent = requireArguments().getParcelable(EXTRA_RESULT_SERVICE_INTENT);
     }
 
     @Override

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

@@ -3,6 +3,7 @@ package org.schabi.newpipe.local.subscription
 import android.app.Activity
 import android.content.Context
 import android.content.DialogInterface
+import android.content.Intent
 import android.os.Bundle
 import android.os.Parcelable
 import android.view.LayoutInflater
@@ -52,11 +53,13 @@ import org.schabi.newpipe.local.subscription.item.FeedGroupCarouselItem
 import org.schabi.newpipe.local.subscription.item.GroupsHeader
 import org.schabi.newpipe.local.subscription.item.Header
 import org.schabi.newpipe.local.subscription.item.ImportSubscriptionsHintPlaceholderItem
-import org.schabi.newpipe.local.subscription.workers.SubscriptionExportWorker
-import org.schabi.newpipe.local.subscription.workers.SubscriptionImportInput
+import org.schabi.newpipe.local.subscription.services.SubscriptionsExportService
+import org.schabi.newpipe.local.subscription.services.SubscriptionsImportService
+import org.schabi.newpipe.local.subscription.services.SubscriptionsImportService.KEY_MODE
+import org.schabi.newpipe.local.subscription.services.SubscriptionsImportService.KEY_VALUE
+import org.schabi.newpipe.local.subscription.services.SubscriptionsImportService.PREVIOUS_EXPORT_MODE
 import org.schabi.newpipe.streams.io.NoFileManagerSafeGuard
 import org.schabi.newpipe.streams.io.StoredFileHelper
-import org.schabi.newpipe.ui.emptystate.setEmptyStateComposable
 import org.schabi.newpipe.util.NavigationHelper
 import org.schabi.newpipe.util.OnClickGesture
 import org.schabi.newpipe.util.ServiceHelper
@@ -127,7 +130,6 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
     // Menu
     // ////////////////////////////////////////////////////////////////////////
 
-    @Deprecated("Deprecated in Java")
     override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
         super.onCreateOptionsMenu(menu, inflater)
 
@@ -221,18 +223,21 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
     }
 
     private fun requestExportResult(result: ActivityResult) {
-        val data = result.data?.data
-        if (data != null && result.resultCode == Activity.RESULT_OK) {
-            SubscriptionExportWorker.schedule(activity, data)
+        if (result.data != null && result.resultCode == Activity.RESULT_OK) {
+            activity.startService(
+                Intent(activity, SubscriptionsExportService::class.java)
+                    .putExtra(SubscriptionsExportService.KEY_FILE_PATH, result.data?.data)
+            )
         }
     }
 
     private fun requestImportResult(result: ActivityResult) {
-        val data = result.data?.dataString
-        if (data != null && result.resultCode == Activity.RESULT_OK) {
+        if (result.data != null && result.resultCode == Activity.RESULT_OK) {
             ImportConfirmationDialog.show(
                 this,
-                SubscriptionImportInput.PreviousExportMode(data)
+                Intent(activity, SubscriptionsImportService::class.java)
+                    .putExtra(KEY_MODE, PREVIOUS_EXPORT_MODE)
+                    .putExtra(KEY_VALUE, result.data?.data)
             )
         }
     }
@@ -252,8 +257,6 @@ class SubscriptionFragment : BaseStateFragment<SubscriptionState>() {
         binding.itemsList.adapter = groupAdapter
         binding.itemsList.itemAnimator = null
 
-        binding.emptyStateView.setEmptyStateComposable()
-
         viewModel = ViewModelProvider(this)[SubscriptionViewModel::class.java]
         viewModel.stateLiveData.observe(viewLifecycleOwner) { it?.let(this::handleResult) }
         viewModel.feedGroupsLiveData.observe(viewLifecycleOwner) {

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

@@ -1,6 +1,7 @@
 package org.schabi.newpipe.local.subscription
 
 import android.content.Context
+import android.util.Pair
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
 import io.reactivex.rxjava3.core.Completable
 import io.reactivex.rxjava3.core.Flowable
@@ -50,16 +51,23 @@ class SubscriptionManager(context: Context) {
         }
     }
 
-    fun upsertAll(infoList: List<Pair<ChannelInfo, ChannelTabInfo>>) {
-        val listEntities = infoList.map { SubscriptionEntity.from(it.first) }
-        subscriptionTable.upsertAll(listEntities)
+    fun upsertAll(infoList: List<Pair<ChannelInfo, List<ChannelTabInfo>>>): List<SubscriptionEntity> {
+        val listEntities = subscriptionTable.upsertAll(
+            infoList.map { SubscriptionEntity.from(it.first) }
+        )
 
         database.runInTransaction {
             infoList.forEachIndexed { index, info ->
-                val streams = info.second.relatedItems.filterIsInstance<StreamInfoItem>()
-                feedDatabaseManager.upsertAll(listEntities[index].uid, streams)
+                info.second.forEach {
+                    feedDatabaseManager.upsertAll(
+                        listEntities[index].uid,
+                        it.relatedItems.filterIsInstance<StreamInfoItem>()
+                    )
+                }
             }
         }
+
+        return listEntities
     }
 
     fun updateChannelInfo(info: ChannelInfo): Completable = subscriptionTable.getSubscription(info.serviceId, info.url)

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

@@ -1,6 +1,10 @@
 package org.schabi.newpipe.local.subscription;
 
 import static org.schabi.newpipe.extractor.subscription.SubscriptionExtractor.ContentSource.CHANNEL_URL;
+import static org.schabi.newpipe.local.subscription.services.SubscriptionsImportService.CHANNEL_URL_MODE;
+import static org.schabi.newpipe.local.subscription.services.SubscriptionsImportService.INPUT_STREAM_MODE;
+import static org.schabi.newpipe.local.subscription.services.SubscriptionsImportService.KEY_MODE;
+import static org.schabi.newpipe.local.subscription.services.SubscriptionsImportService.KEY_VALUE;
 
 import android.app.Activity;
 import android.content.Intent;
@@ -33,7 +37,7 @@ import org.schabi.newpipe.error.UserAction;
 import org.schabi.newpipe.extractor.NewPipe;
 import org.schabi.newpipe.extractor.exceptions.ExtractionException;
 import org.schabi.newpipe.extractor.subscription.SubscriptionExtractor;
-import org.schabi.newpipe.local.subscription.workers.SubscriptionImportInput;
+import org.schabi.newpipe.local.subscription.services.SubscriptionsImportService;
 import org.schabi.newpipe.streams.io.NoFileManagerSafeGuard;
 import org.schabi.newpipe.streams.io.StoredFileHelper;
 import org.schabi.newpipe.util.Constants;
@@ -164,8 +168,10 @@ public class SubscriptionsImportFragment extends BaseFragment {
     }
 
     public void onImportUrl(final String value) {
-        ImportConfirmationDialog.show(this,
-                new SubscriptionImportInput.ChannelUrlMode(currentServiceId, value));
+        ImportConfirmationDialog.show(this, new Intent(activity, SubscriptionsImportService.class)
+                .putExtra(KEY_MODE, CHANNEL_URL_MODE)
+                .putExtra(KEY_VALUE, value)
+                .putExtra(Constants.KEY_SERVICE_ID, currentServiceId));
     }
 
     public void onImportFile() {
@@ -180,10 +186,16 @@ public class SubscriptionsImportFragment extends BaseFragment {
     }
 
     private void requestImportFileResult(final ActivityResult result) {
-        final String data = result.getData() != null ? result.getData().getDataString() : null;
-        if (result.getResultCode() == Activity.RESULT_OK && data != null) {
+        if (result.getData() == null) {
+            return;
+        }
+
+        if (result.getResultCode() == Activity.RESULT_OK && result.getData().getData() != null) {
             ImportConfirmationDialog.show(this,
-                    new SubscriptionImportInput.InputStreamMode(currentServiceId, data));
+                    new Intent(activity, SubscriptionsImportService.class)
+                            .putExtra(KEY_MODE, INPUT_STREAM_MODE)
+                            .putExtra(KEY_VALUE, result.getData().getData())
+                            .putExtra(Constants.KEY_SERVICE_ID, currentServiceId));
         }
     }
 

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

@@ -119,7 +119,6 @@ class FeedGroupDialog : DialogFragment(), BackPressable {
 
     override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
         return object : Dialog(requireActivity(), theme) {
-            @Deprecated("Deprecated in Java")
             override fun onBackPressed() {
                 if (!this@FeedGroupDialog.onBackPressed()) {
                     super.onBackPressed()
@@ -507,7 +506,7 @@ class FeedGroupDialog : DialogFragment(), BackPressable {
     private fun hideKeyboardSearch() {
         inputMethodManager.hideSoftInputFromWindow(
             searchLayoutBinding.toolbarSearchEditText.windowToken,
-            InputMethodManager.RESULT_UNCHANGED_SHOWN
+            InputMethodManager.HIDE_NOT_ALWAYS
         )
         searchLayoutBinding.toolbarSearchEditText.clearFocus()
     }
@@ -524,7 +523,7 @@ class FeedGroupDialog : DialogFragment(), BackPressable {
     private fun hideKeyboard() {
         inputMethodManager.hideSoftInputFromWindow(
             feedGroupCreateBinding.groupNameInput.windowToken,
-            InputMethodManager.RESULT_UNCHANGED_SHOWN
+            InputMethodManager.HIDE_NOT_ALWAYS
         )
         feedGroupCreateBinding.groupNameInput.clearFocus()
     }

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

@@ -9,7 +9,7 @@ import org.schabi.newpipe.R
 import org.schabi.newpipe.extractor.channel.ChannelInfoItem
 import org.schabi.newpipe.util.Localization
 import org.schabi.newpipe.util.OnClickGesture
-import org.schabi.newpipe.util.image.CoilHelper
+import org.schabi.newpipe.util.image.PicassoHelper
 
 class ChannelItem(
     private val infoItem: ChannelInfoItem,
@@ -39,7 +39,7 @@ class ChannelItem(
             itemChannelDescriptionView.text = infoItem.description
         }
 
-        CoilHelper.loadAvatar(itemThumbnailView, infoItem.thumbnails)
+        PicassoHelper.loadAvatar(infoItem.thumbnails).into(itemThumbnailView)
 
         gesturesListener?.run {
             viewHolder.root.setOnClickListener { selected(infoItem) }

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

@@ -3,18 +3,14 @@ package org.schabi.newpipe.local.subscription.item
 import android.view.View
 import com.xwray.groupie.viewbinding.BindableItem
 import org.schabi.newpipe.R
-import org.schabi.newpipe.databinding.ListEmptyViewSubscriptionsBinding
-import org.schabi.newpipe.ui.emptystate.EmptyStateSpec
-import org.schabi.newpipe.ui.emptystate.setEmptyStateComposable
+import org.schabi.newpipe.databinding.ListEmptyViewBinding
 
 /**
  * When there are no subscriptions, show a hint to the user about how to import subscriptions
  */
-class ImportSubscriptionsHintPlaceholderItem : BindableItem<ListEmptyViewSubscriptionsBinding>() {
+class ImportSubscriptionsHintPlaceholderItem : BindableItem<ListEmptyViewBinding>() {
     override fun getLayout(): Int = R.layout.list_empty_view_subscriptions
-    override fun bind(viewBinding: ListEmptyViewSubscriptionsBinding, position: Int) {
-        viewBinding.root.setEmptyStateComposable(EmptyStateSpec.NoSubscriptionsHint)
-    }
+    override fun bind(viewBinding: ListEmptyViewBinding, position: Int) {}
     override fun getSpanSize(spanCount: Int, position: Int): Int = spanCount
-    override fun initializeViewBinding(view: View) = ListEmptyViewSubscriptionsBinding.bind(view)
+    override fun initializeViewBinding(view: View) = ListEmptyViewBinding.bind(view)
 }

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

@@ -10,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.image.CoilHelper
+import org.schabi.newpipe.util.image.PicassoHelper
 
 data class PickerSubscriptionItem(
     val subscriptionEntity: SubscriptionEntity,
@@ -21,7 +21,7 @@ data class PickerSubscriptionItem(
     override fun getSpanSize(spanCount: Int, position: Int): Int = 1
 
     override fun bind(viewBinding: PickerSubscriptionItemBinding, position: Int) {
-        CoilHelper.loadAvatar(viewBinding.thumbnailView, subscriptionEntity.avatarUrl)
+        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/BaseImportExportService.java

@@ -0,0 +1,238 @@
+/*
+ * Copyright 2018 Mauricio Colli <mauriciocolli@outlook.com>
+ * BaseImportExportService.java is part of NewPipe
+ *
+ * License: GPL-3.0+
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.schabi.newpipe.local.subscription.services;
+
+import android.app.Service;
+import android.content.Intent;
+import android.os.Build;
+import android.os.IBinder;
+import android.text.TextUtils;
+import android.widget.Toast;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.StringRes;
+import androidx.core.app.NotificationCompat;
+import androidx.core.app.NotificationManagerCompat;
+import androidx.core.app.ServiceCompat;
+
+import org.reactivestreams.Publisher;
+import org.schabi.newpipe.R;
+import org.schabi.newpipe.error.ErrorInfo;
+import org.schabi.newpipe.error.ErrorUtil;
+import org.schabi.newpipe.error.UserAction;
+import org.schabi.newpipe.extractor.subscription.SubscriptionExtractor;
+import org.schabi.newpipe.ktx.ExceptionUtils;
+import org.schabi.newpipe.local.subscription.SubscriptionManager;
+
+import java.io.FileNotFoundException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
+import io.reactivex.rxjava3.core.Flowable;
+import io.reactivex.rxjava3.disposables.CompositeDisposable;
+import io.reactivex.rxjava3.functions.Function;
+import io.reactivex.rxjava3.processors.PublishProcessor;
+
+public abstract class BaseImportExportService extends Service {
+    protected final String TAG = this.getClass().getSimpleName();
+
+    protected final CompositeDisposable disposables = new CompositeDisposable();
+    protected final PublishProcessor<String> notificationUpdater = PublishProcessor.create();
+
+    protected NotificationManagerCompat notificationManager;
+    protected NotificationCompat.Builder notificationBuilder;
+    protected SubscriptionManager subscriptionManager;
+
+    private static final int NOTIFICATION_SAMPLING_PERIOD = 2500;
+
+    protected final AtomicInteger currentProgress = new AtomicInteger(-1);
+    protected final AtomicInteger maxProgress = new AtomicInteger(-1);
+    protected final ImportExportEventListener eventListener = new ImportExportEventListener() {
+        @Override
+        public void onSizeReceived(final int size) {
+            maxProgress.set(size);
+            currentProgress.set(0);
+        }
+
+        @Override
+        public void onItemCompleted(final String itemName) {
+            currentProgress.incrementAndGet();
+            notificationUpdater.onNext(itemName);
+        }
+    };
+
+    protected Toast toast;
+
+    @Nullable
+    @Override
+    public IBinder onBind(final Intent intent) {
+        return null;
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        subscriptionManager = new SubscriptionManager(this);
+        setupNotification();
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        disposeAll();
+    }
+
+    protected void disposeAll() {
+        disposables.clear();
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Notification Impl
+    //////////////////////////////////////////////////////////////////////////*/
+
+    protected abstract int getNotificationId();
+
+    @StringRes
+    public abstract int getTitle();
+
+    protected void setupNotification() {
+        notificationManager = NotificationManagerCompat.from(this);
+        notificationBuilder = createNotification();
+        startForeground(getNotificationId(), notificationBuilder.build());
+
+        final Function<Flowable<String>, Publisher<String>> throttleAfterFirstEmission = flow ->
+                flow.take(1).concatWith(flow.skip(1)
+                        .throttleLast(NOTIFICATION_SAMPLING_PERIOD, TimeUnit.MILLISECONDS));
+
+        disposables.add(notificationUpdater
+                .filter(s -> !s.isEmpty())
+                .publish(throttleAfterFirstEmission)
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe(this::updateNotification));
+    }
+
+    protected void updateNotification(final String text) {
+        notificationBuilder
+                .setProgress(maxProgress.get(), currentProgress.get(), maxProgress.get() == -1);
+
+        final String progressText = currentProgress + "/" + maxProgress;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            if (!TextUtils.isEmpty(text)) {
+                notificationBuilder.setContentText(text + "  (" + progressText + ")");
+            }
+        } else {
+            notificationBuilder.setContentInfo(progressText);
+            notificationBuilder.setContentText(text);
+        }
+
+        if (notificationManager.areNotificationsEnabled()) {
+            notificationManager.notify(getNotificationId(), notificationBuilder.build());
+        }
+    }
+
+    protected void stopService() {
+        postErrorResult(null, null);
+    }
+
+    protected void stopAndReportError(final Throwable throwable, final String request) {
+        stopService();
+        ErrorUtil.createNotification(this, new ErrorInfo(
+                throwable, UserAction.SUBSCRIPTION_IMPORT_EXPORT, request));
+    }
+
+    protected void postErrorResult(final String title, final String text) {
+        disposeAll();
+        ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE);
+        stopSelf();
+
+        if (title == null) {
+            return;
+        }
+
+        final String textOrEmpty = text == null ? "" : text;
+        notificationBuilder = new NotificationCompat
+                .Builder(this, getString(R.string.notification_channel_id))
+                .setSmallIcon(R.drawable.ic_newpipe_triangle_white)
+                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+                .setContentTitle(title)
+                .setStyle(new NotificationCompat.BigTextStyle().bigText(textOrEmpty))
+                .setContentText(textOrEmpty);
+
+        if (notificationManager.areNotificationsEnabled()) {
+            notificationManager.notify(getNotificationId(), notificationBuilder.build());
+        }
+    }
+
+    protected NotificationCompat.Builder createNotification() {
+        return new NotificationCompat.Builder(this, getString(R.string.notification_channel_id))
+                .setOngoing(true)
+                .setProgress(-1, -1, true)
+                .setSmallIcon(R.drawable.ic_newpipe_triangle_white)
+                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+                .setContentTitle(getString(getTitle()));
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Toast
+    //////////////////////////////////////////////////////////////////////////*/
+
+    protected void showToast(@StringRes final int message) {
+        showToast(getString(message));
+    }
+
+    protected void showToast(final String message) {
+        if (toast != null) {
+            toast.cancel();
+        }
+
+        toast = Toast.makeText(this, message, Toast.LENGTH_SHORT);
+        toast.show();
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Error handling
+    //////////////////////////////////////////////////////////////////////////*/
+
+    protected void handleError(@StringRes final int errorTitle, @NonNull final Throwable error) {
+        String message = getErrorMessage(error);
+
+        if (TextUtils.isEmpty(message)) {
+            final String errorClassName = error.getClass().getName();
+            message = getString(R.string.error_occurred_detail, errorClassName);
+        }
+
+        showToast(errorTitle);
+        postErrorResult(getString(errorTitle), message);
+    }
+
+    protected String getErrorMessage(final Throwable error) {
+        String message = null;
+        if (error instanceof SubscriptionExtractor.InvalidSourceException) {
+            message = getString(R.string.invalid_source);
+        } else if (error instanceof FileNotFoundException) {
+            message = getString(R.string.invalid_file);
+        } else if (ExceptionUtils.isNetworkRelated(error)) {
+            message = getString(R.string.network_error);
+        }
+        return message;
+    }
+}

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

@@ -0,0 +1,17 @@
+package org.schabi.newpipe.local.subscription.services;
+
+public interface ImportExportEventListener {
+    /**
+     * Called when the size has been resolved.
+     *
+     * @param size how many items there are to import/export
+     */
+    void onSizeReceived(int size);
+
+    /**
+     * Called every time an item has been parsed/resolved.
+     *
+     * @param itemName the name of the subscription item
+     */
+    void onItemCompleted(String itemName);
+}

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

@@ -0,0 +1,158 @@
+/*
+ * Copyright 2018 Mauricio Colli <mauriciocolli@outlook.com>
+ * ImportExportJsonHelper.java is part of NewPipe
+ *
+ * License: GPL-3.0+
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.schabi.newpipe.local.subscription.services;
+
+import androidx.annotation.Nullable;
+
+import com.grack.nanojson.JsonAppendableWriter;
+import com.grack.nanojson.JsonArray;
+import com.grack.nanojson.JsonObject;
+import com.grack.nanojson.JsonParser;
+import com.grack.nanojson.JsonWriter;
+
+import org.schabi.newpipe.BuildConfig;
+import org.schabi.newpipe.extractor.subscription.SubscriptionExtractor.InvalidSourceException;
+import org.schabi.newpipe.extractor.subscription.SubscriptionItem;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A JSON implementation capable of importing and exporting subscriptions, it has the advantage
+ * of being able to transfer subscriptions to any device.
+ */
+public final class ImportExportJsonHelper {
+    /*//////////////////////////////////////////////////////////////////////////
+    // Json implementation
+    //////////////////////////////////////////////////////////////////////////*/
+
+    private static final String JSON_APP_VERSION_KEY = "app_version";
+    private static final String JSON_APP_VERSION_INT_KEY = "app_version_int";
+
+    private static final String JSON_SUBSCRIPTIONS_ARRAY_KEY = "subscriptions";
+
+    private static final String JSON_SERVICE_ID_KEY = "service_id";
+    private static final String JSON_URL_KEY = "url";
+    private static final String JSON_NAME_KEY = "name";
+
+    private ImportExportJsonHelper() { }
+
+    /**
+     * Read a JSON source through the input stream.
+     *
+     * @param in            the input stream (e.g. a file)
+     * @param eventListener listener for the events generated
+     * @return the parsed subscription items
+     */
+    public static List<SubscriptionItem> readFrom(
+            final InputStream in, @Nullable final ImportExportEventListener eventListener)
+            throws InvalidSourceException {
+        if (in == null) {
+            throw new InvalidSourceException("input is null");
+        }
+
+        final List<SubscriptionItem> channels = new ArrayList<>();
+
+        try {
+            final JsonObject parentObject = JsonParser.object().from(in);
+
+            if (!parentObject.has(JSON_SUBSCRIPTIONS_ARRAY_KEY)) {
+                throw new InvalidSourceException("Channels array is null");
+            }
+
+            final JsonArray channelsArray = parentObject.getArray(JSON_SUBSCRIPTIONS_ARRAY_KEY);
+
+            if (eventListener != null) {
+                eventListener.onSizeReceived(channelsArray.size());
+            }
+
+            for (final Object o : channelsArray) {
+                if (o instanceof JsonObject) {
+                    final JsonObject itemObject = (JsonObject) o;
+                    final int serviceId = itemObject.getInt(JSON_SERVICE_ID_KEY, 0);
+                    final String url = itemObject.getString(JSON_URL_KEY);
+                    final String name = itemObject.getString(JSON_NAME_KEY);
+
+                    if (url != null && name != null && !url.isEmpty() && !name.isEmpty()) {
+                        channels.add(new SubscriptionItem(serviceId, url, name));
+                        if (eventListener != null) {
+                            eventListener.onItemCompleted(name);
+                        }
+                    }
+                }
+            }
+        } catch (final Throwable e) {
+            throw new InvalidSourceException("Couldn't parse json", e);
+        }
+
+        return channels;
+    }
+
+    /**
+     * Write the subscriptions items list as JSON to the output.
+     *
+     * @param items         the list of subscriptions items
+     * @param out           the output stream (e.g. a file)
+     * @param eventListener listener for the events generated
+     */
+    public static void writeTo(final List<SubscriptionItem> items, final OutputStream out,
+                               @Nullable final ImportExportEventListener eventListener) {
+        final JsonAppendableWriter writer = JsonWriter.on(out);
+        writeTo(items, writer, eventListener);
+        writer.done();
+    }
+
+    /**
+     * @see #writeTo(List, OutputStream, ImportExportEventListener)
+     * @param items         the list of subscriptions items
+     * @param writer        the output {@link JsonAppendableWriter}
+     * @param eventListener listener for the events generated
+     */
+    public static void writeTo(final List<SubscriptionItem> items,
+                               final JsonAppendableWriter writer,
+                               @Nullable final ImportExportEventListener eventListener) {
+        if (eventListener != null) {
+            eventListener.onSizeReceived(items.size());
+        }
+
+        writer.object();
+
+        writer.value(JSON_APP_VERSION_KEY, BuildConfig.VERSION_NAME);
+        writer.value(JSON_APP_VERSION_INT_KEY, BuildConfig.VERSION_CODE);
+
+        writer.array(JSON_SUBSCRIPTIONS_ARRAY_KEY);
+        for (final SubscriptionItem item : items) {
+            writer.object();
+            writer.value(JSON_SERVICE_ID_KEY, item.getServiceId());
+            writer.value(JSON_URL_KEY, item.getUrl());
+            writer.value(JSON_NAME_KEY, item.getName());
+            writer.end();
+
+            if (eventListener != null) {
+                eventListener.onItemCompleted(item.getName());
+            }
+        }
+        writer.end();
+
+        writer.end();
+    }
+}

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

@@ -0,0 +1,171 @@
+/*
+ * Copyright 2018 Mauricio Colli <mauriciocolli@outlook.com>
+ * SubscriptionsExportService.java is part of NewPipe
+ *
+ * License: GPL-3.0+
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.schabi.newpipe.local.subscription.services;
+
+import static org.schabi.newpipe.MainActivity.DEBUG;
+
+import android.content.Intent;
+import android.net.Uri;
+import android.util.Log;
+
+import androidx.core.content.IntentCompat;
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+import org.schabi.newpipe.App;
+import org.schabi.newpipe.R;
+import org.schabi.newpipe.database.subscription.SubscriptionEntity;
+import org.schabi.newpipe.extractor.subscription.SubscriptionItem;
+import org.schabi.newpipe.streams.io.SharpOutputStream;
+import org.schabi.newpipe.streams.io.StoredFileHelper;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
+import io.reactivex.rxjava3.functions.Function;
+import io.reactivex.rxjava3.schedulers.Schedulers;
+
+public class SubscriptionsExportService extends BaseImportExportService {
+    public static final String KEY_FILE_PATH = "key_file_path";
+
+    /**
+     * A {@link LocalBroadcastManager local broadcast} will be made with this action
+     * when the export is successfully completed.
+     */
+    public static final String EXPORT_COMPLETE_ACTION = App.PACKAGE_NAME + ".local.subscription"
+            + ".services.SubscriptionsExportService.EXPORT_COMPLETE";
+
+    private Subscription subscription;
+    private StoredFileHelper outFile;
+    private OutputStream outputStream;
+
+    @Override
+    public int onStartCommand(final Intent intent, final int flags, final int startId) {
+        if (intent == null || subscription != null) {
+            return START_NOT_STICKY;
+        }
+
+        final Uri path = IntentCompat.getParcelableExtra(intent, KEY_FILE_PATH, Uri.class);
+        if (path == null) {
+            stopAndReportError(new IllegalStateException(
+                    "Exporting to a file, but the path is null"),
+                    "Exporting subscriptions");
+            return START_NOT_STICKY;
+        }
+
+        try {
+            outFile = new StoredFileHelper(this, path, "application/json");
+            // truncate the file before writing to it, otherwise if the new content is smaller than
+            // the previous file size, the file will retain part of the previous content and be
+            // corrupted
+            outputStream = new SharpOutputStream(outFile.openAndTruncateStream());
+        } catch (final IOException e) {
+            handleError(e);
+            return START_NOT_STICKY;
+        }
+
+        startExport();
+
+        return START_NOT_STICKY;
+    }
+
+    @Override
+    protected int getNotificationId() {
+        return 4567;
+    }
+
+    @Override
+    public int getTitle() {
+        return R.string.export_ongoing;
+    }
+
+    @Override
+    protected void disposeAll() {
+        super.disposeAll();
+        if (subscription != null) {
+            subscription.cancel();
+        }
+    }
+
+    private void startExport() {
+        showToast(R.string.export_ongoing);
+
+        subscriptionManager.subscriptionTable().getAll().take(1)
+                .map(subscriptionEntities -> {
+                    final List<SubscriptionItem> result =
+                            new ArrayList<>(subscriptionEntities.size());
+                    for (final SubscriptionEntity entity : subscriptionEntities) {
+                        result.add(new SubscriptionItem(entity.getServiceId(), entity.getUrl(),
+                                entity.getName()));
+                    }
+                    return result;
+                })
+                .map(exportToFile())
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe(getSubscriber());
+    }
+
+    private Subscriber<StoredFileHelper> getSubscriber() {
+        return new Subscriber<StoredFileHelper>() {
+            @Override
+            public void onSubscribe(final Subscription s) {
+                subscription = s;
+                s.request(1);
+            }
+
+            @Override
+            public void onNext(final StoredFileHelper file) {
+                if (DEBUG) {
+                    Log.d(TAG, "startExport() success: file = " + file);
+                }
+            }
+
+            @Override
+            public void onError(final Throwable error) {
+                Log.e(TAG, "onError() called with: error = [" + error + "]", error);
+                handleError(error);
+            }
+
+            @Override
+            public void onComplete() {
+                LocalBroadcastManager.getInstance(SubscriptionsExportService.this)
+                        .sendBroadcast(new Intent(EXPORT_COMPLETE_ACTION));
+                showToast(R.string.export_complete_toast);
+                stopService();
+            }
+        };
+    }
+
+    private Function<List<SubscriptionItem>, StoredFileHelper> exportToFile() {
+        return subscriptionItems -> {
+            ImportExportJsonHelper.writeTo(subscriptionItems, outputStream, eventListener);
+            return outFile;
+        };
+    }
+
+    protected void handleError(final Throwable error) {
+        super.handleError(R.string.subscriptions_export_unsuccessful, error);
+    }
+}

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

@@ -0,0 +1,327 @@
+/*
+ * Copyright 2018 Mauricio Colli <mauriciocolli@outlook.com>
+ * SubscriptionsImportService.java is part of NewPipe
+ *
+ * License: GPL-3.0+
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+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;
+import android.util.Log;
+import android.util.Pair;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.content.IntentCompat;
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+import org.schabi.newpipe.App;
+import org.schabi.newpipe.R;
+import org.schabi.newpipe.database.subscription.SubscriptionEntity;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.channel.ChannelInfo;
+import org.schabi.newpipe.extractor.channel.tabs.ChannelTabInfo;
+import org.schabi.newpipe.extractor.subscription.SubscriptionItem;
+import org.schabi.newpipe.ktx.ExceptionUtils;
+import org.schabi.newpipe.streams.io.SharpInputStream;
+import org.schabi.newpipe.streams.io.StoredFileHelper;
+import org.schabi.newpipe.util.Constants;
+import org.schabi.newpipe.util.ExtractorHelper;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
+import io.reactivex.rxjava3.core.Flowable;
+import io.reactivex.rxjava3.core.Notification;
+import io.reactivex.rxjava3.functions.Consumer;
+import io.reactivex.rxjava3.functions.Function;
+import io.reactivex.rxjava3.schedulers.Schedulers;
+
+public class SubscriptionsImportService extends BaseImportExportService {
+    public static final int CHANNEL_URL_MODE = 0;
+    public static final int INPUT_STREAM_MODE = 1;
+    public static final int PREVIOUS_EXPORT_MODE = 2;
+    public static final String KEY_MODE = "key_mode";
+    public static final String KEY_VALUE = "key_value";
+
+    /**
+     * A {@link LocalBroadcastManager local broadcast} will be made with this action
+     * when the import is successfully completed.
+     */
+    public static final String IMPORT_COMPLETE_ACTION = App.PACKAGE_NAME + ".local.subscription"
+            + ".services.SubscriptionsImportService.IMPORT_COMPLETE";
+
+    /**
+     * How many extractions running in parallel.
+     */
+    public static final int PARALLEL_EXTRACTIONS = 8;
+
+    /**
+     * Number of items to buffer to mass-insert in the subscriptions table,
+     * this leads to a better performance as we can then use db transactions.
+     */
+    public static final int BUFFER_COUNT_BEFORE_INSERT = 50;
+
+    private Subscription subscription;
+    private int currentMode;
+    private int currentServiceId;
+    @Nullable
+    private String channelUrl;
+    @Nullable
+    private InputStream inputStream;
+    @Nullable
+    private String inputStreamType;
+
+    @Override
+    public int onStartCommand(final Intent intent, final int flags, final int startId) {
+        if (intent == null || subscription != null) {
+            return START_NOT_STICKY;
+        }
+
+        currentMode = intent.getIntExtra(KEY_MODE, -1);
+        currentServiceId = intent.getIntExtra(Constants.KEY_SERVICE_ID, Constants.NO_SERVICE_ID);
+
+        if (currentMode == CHANNEL_URL_MODE) {
+            channelUrl = intent.getStringExtra(KEY_VALUE);
+        } else {
+            final Uri uri = IntentCompat.getParcelableExtra(intent, KEY_VALUE, Uri.class);
+            if (uri == null) {
+                stopAndReportError(new IllegalStateException(
+                        "Importing from input stream, but file path is null"),
+                        "Importing subscriptions");
+                return START_NOT_STICKY;
+            }
+
+            try {
+                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;
+            }
+        }
+
+        if (currentMode == -1 || currentMode == CHANNEL_URL_MODE && channelUrl == null) {
+            final String errorDescription = "Some important field is null or in illegal state: "
+                    + "currentMode=[" + currentMode + "], "
+                    + "channelUrl=[" + channelUrl + "], "
+                    + "inputStream=[" + inputStream + "]";
+            stopAndReportError(new IllegalStateException(errorDescription),
+                    "Importing subscriptions");
+            return START_NOT_STICKY;
+        }
+
+        startImport();
+        return START_NOT_STICKY;
+    }
+
+    @Override
+    protected int getNotificationId() {
+        return 4568;
+    }
+
+    @Override
+    public int getTitle() {
+        return R.string.import_ongoing;
+    }
+
+    @Override
+    protected void disposeAll() {
+        super.disposeAll();
+        if (subscription != null) {
+            subscription.cancel();
+        }
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Imports
+    //////////////////////////////////////////////////////////////////////////*/
+
+    private void startImport() {
+        showToast(R.string.import_ongoing);
+
+        Flowable<List<SubscriptionItem>> flowable = null;
+        switch (currentMode) {
+            case CHANNEL_URL_MODE:
+                flowable = importFromChannelUrl();
+                break;
+            case INPUT_STREAM_MODE:
+                flowable = importFromInputStream();
+                break;
+            case PREVIOUS_EXPORT_MODE:
+                flowable = importFromPreviousExport();
+                break;
+        }
+
+        if (flowable == null) {
+            final String message = "Flowable given by \"importFrom\" is null "
+                    + "(current mode: " + currentMode + ")";
+            stopAndReportError(new IllegalStateException(message), "Importing subscriptions");
+            return;
+        }
+
+        flowable.doOnNext(subscriptionItems ->
+                eventListener.onSizeReceived(subscriptionItems.size()))
+                .flatMap(Flowable::fromIterable)
+
+                .parallel(PARALLEL_EXTRACTIONS)
+                .runOn(Schedulers.io())
+                .map((Function<SubscriptionItem, Notification<Pair<ChannelInfo,
+                        List<ChannelTabInfo>>>>) subscriptionItem -> {
+                    try {
+                        final ChannelInfo channelInfo = ExtractorHelper
+                                .getChannelInfo(subscriptionItem.getServiceId(),
+                                        subscriptionItem.getUrl(), true)
+                                .blockingGet();
+                        return Notification.createOnNext(new Pair<>(channelInfo,
+                                Collections.singletonList(
+                                        ExtractorHelper.getChannelTab(
+                                                subscriptionItem.getServiceId(),
+                                                channelInfo.getTabs().get(0), true).blockingGet()
+                                )));
+                    } catch (final Throwable e) {
+                        return Notification.createOnError(e);
+                    }
+                })
+                .sequential()
+
+                .observeOn(Schedulers.io())
+                .doOnNext(getNotificationsConsumer())
+
+                .buffer(BUFFER_COUNT_BEFORE_INSERT)
+                .map(upsertBatch())
+
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe(getSubscriber());
+    }
+
+    private Subscriber<List<SubscriptionEntity>> getSubscriber() {
+        return new Subscriber<>() {
+            @Override
+            public void onSubscribe(final Subscription s) {
+                subscription = s;
+                s.request(Long.MAX_VALUE);
+            }
+
+            @Override
+            public void onNext(final List<SubscriptionEntity> successfulInserted) {
+                if (DEBUG) {
+                    Log.d(TAG, "startImport() " + successfulInserted.size()
+                            + " items successfully inserted into the database");
+                }
+            }
+
+            @Override
+            public void onError(final Throwable error) {
+                Log.e(TAG, "Got an error!", error);
+                handleError(error);
+            }
+
+            @Override
+            public void onComplete() {
+                LocalBroadcastManager.getInstance(SubscriptionsImportService.this)
+                        .sendBroadcast(new Intent(IMPORT_COMPLETE_ACTION));
+                showToast(R.string.import_complete_toast);
+                stopService();
+            }
+        };
+    }
+
+    private Consumer<Notification<Pair<ChannelInfo,
+            List<ChannelTabInfo>>>> getNotificationsConsumer() {
+        return notification -> {
+            if (notification.isOnNext()) {
+                final String name = notification.getValue().first.getName();
+                eventListener.onItemCompleted(!TextUtils.isEmpty(name) ? name : "");
+            } else if (notification.isOnError()) {
+                final Throwable error = notification.getError();
+                final Throwable cause = error.getCause();
+                if (error instanceof IOException) {
+                    throw error;
+                } else if (cause instanceof IOException) {
+                    throw cause;
+                } else if (ExceptionUtils.isNetworkRelated(error)) {
+                    throw new IOException(error);
+                }
+
+                eventListener.onItemCompleted("");
+            }
+        };
+    }
+
+    private Function<List<Notification<Pair<ChannelInfo, List<ChannelTabInfo>>>>,
+            List<SubscriptionEntity>> upsertBatch() {
+        return notificationList -> {
+            final List<Pair<ChannelInfo, List<ChannelTabInfo>>> infoList =
+                    new ArrayList<>(notificationList.size());
+            for (final Notification<Pair<ChannelInfo, List<ChannelTabInfo>>> n : notificationList) {
+                if (n.isOnNext()) {
+                    infoList.add(n.getValue());
+                }
+            }
+
+            return subscriptionManager.upsertAll(infoList);
+        };
+    }
+
+    private Flowable<List<SubscriptionItem>> importFromChannelUrl() {
+        return Flowable.fromCallable(() -> NewPipe.getService(currentServiceId)
+                .getSubscriptionExtractor()
+                .fromChannelUrl(channelUrl));
+    }
+
+    private Flowable<List<SubscriptionItem>> importFromInputStream() {
+        Objects.requireNonNull(inputStream);
+        Objects.requireNonNull(inputStreamType);
+
+        return Flowable.fromCallable(() -> NewPipe.getService(currentServiceId)
+                .getSubscriptionExtractor()
+                .fromInputStream(inputStream, inputStreamType));
+    }
+
+    private Flowable<List<SubscriptionItem>> importFromPreviousExport() {
+        return Flowable.fromCallable(() -> ImportExportJsonHelper.readFrom(inputStream, null));
+    }
+
+    protected void handleError(@NonNull final Throwable error) {
+        super.handleError(R.string.subscriptions_import_unsuccessful, error);
+    }
+}

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

@@ -1,72 +0,0 @@
-/*
- * Copyright 2018 Mauricio Colli <mauriciocolli@outlook.com>
- * ImportExportJsonHelper.java is part of NewPipe
- *
- * License: GPL-3.0+
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package org.schabi.newpipe.local.subscription.workers
-
-import java.io.InputStream
-import java.io.OutputStream
-import kotlinx.serialization.ExperimentalSerializationApi
-import kotlinx.serialization.json.Json
-import kotlinx.serialization.json.decodeFromStream
-import kotlinx.serialization.json.encodeToStream
-import org.schabi.newpipe.extractor.subscription.SubscriptionExtractor.InvalidSourceException
-
-/**
- * A JSON implementation capable of importing and exporting subscriptions, it has the advantage
- * of being able to transfer subscriptions to any device.
- */
-object ImportExportJsonHelper {
-    private val json = Json { encodeDefaults = true }
-
-    /**
-     * Read a JSON source through the input stream.
-     *
-     * @param in            the input stream (e.g. a file)
-     * @return the parsed subscription items
-     */
-    @JvmStatic
-    @Throws(InvalidSourceException::class)
-    fun readFrom(`in`: InputStream?): List<SubscriptionItem> {
-        if (`in` == null) {
-            throw InvalidSourceException("input is null")
-        }
-
-        try {
-            @OptIn(ExperimentalSerializationApi::class)
-            return json.decodeFromStream<SubscriptionData>(`in`).subscriptions
-        } catch (e: Throwable) {
-            throw InvalidSourceException("Couldn't parse json", e)
-        }
-    }
-
-    /**
-     * Write the subscriptions items list as JSON to the output.
-     *
-     * @param items         the list of subscriptions items
-     * @param out           the output stream (e.g. a file)
-     */
-    @OptIn(ExperimentalSerializationApi::class)
-    @JvmStatic
-    fun writeTo(
-        items: List<SubscriptionItem>,
-        out: OutputStream
-    ) {
-        json.encodeToStream(SubscriptionData(items), out)
-    }
-}

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

@@ -1,24 +0,0 @@
-package org.schabi.newpipe.local.subscription.workers
-
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-import org.schabi.newpipe.BuildConfig
-
-@Serializable
-class SubscriptionData(
-    val subscriptions: List<SubscriptionItem>
-) {
-    @SerialName("app_version")
-    private val appVersion = BuildConfig.VERSION_NAME
-
-    @SerialName("app_version_int")
-    private val appVersionInt = BuildConfig.VERSION_CODE
-}
-
-@Serializable
-data class SubscriptionItem(
-    @SerialName("service_id")
-    val serviceId: Int,
-    val url: String,
-    val name: String
-)

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

@@ -1,119 +0,0 @@
-package org.schabi.newpipe.local.subscription.workers
-
-import android.content.Context
-import android.content.pm.ServiceInfo
-import android.net.Uri
-import android.os.Build
-import android.util.Log
-import android.widget.Toast
-import androidx.core.app.NotificationCompat
-import androidx.core.net.toUri
-import androidx.work.CoroutineWorker
-import androidx.work.ExistingWorkPolicy
-import androidx.work.ForegroundInfo
-import androidx.work.OneTimeWorkRequestBuilder
-import androidx.work.OutOfQuotaPolicy
-import androidx.work.WorkManager
-import androidx.work.WorkerParameters
-import androidx.work.workDataOf
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.reactive.awaitFirst
-import kotlinx.coroutines.withContext
-import org.schabi.newpipe.BuildConfig
-import org.schabi.newpipe.NewPipeDatabase
-import org.schabi.newpipe.R
-
-class SubscriptionExportWorker(
-    appContext: Context,
-    params: WorkerParameters
-) : CoroutineWorker(appContext, params) {
-    // This is needed for API levels < 31 (Android S).
-    override suspend fun getForegroundInfo(): ForegroundInfo {
-        return createForegroundInfo(applicationContext.getString(R.string.export_ongoing))
-    }
-
-    override suspend fun doWork(): Result {
-        return try {
-            val uri = inputData.getString(EXPORT_PATH)!!.toUri()
-            val table = NewPipeDatabase.getInstance(applicationContext).subscriptionDAO()
-            val subscriptions =
-                table.getAll()
-                    .awaitFirst()
-                    .map { SubscriptionItem(it.serviceId, it.url ?: "", it.name ?: "") }
-
-            val qty = subscriptions.size
-            val title = applicationContext.resources.getQuantityString(R.plurals.export_subscriptions, qty, qty)
-            setForeground(createForegroundInfo(title))
-
-            withContext(Dispatchers.IO) {
-                // Truncate file if it already exists
-                applicationContext.contentResolver.openOutputStream(uri, "wt")?.use {
-                    ImportExportJsonHelper.writeTo(subscriptions, it)
-                }
-            }
-
-            if (BuildConfig.DEBUG) {
-                Log.i(TAG, "Exported $qty subscriptions")
-            }
-
-            withContext(Dispatchers.Main) {
-                Toast
-                    .makeText(applicationContext, R.string.export_complete_toast, Toast.LENGTH_SHORT)
-                    .show()
-            }
-
-            Result.success()
-        } catch (e: Exception) {
-            if (BuildConfig.DEBUG) {
-                Log.e(TAG, "Error while exporting subscriptions", e)
-            }
-
-            withContext(Dispatchers.Main) {
-                Toast
-                    .makeText(applicationContext, R.string.subscriptions_export_unsuccessful, Toast.LENGTH_SHORT)
-                    .show()
-            }
-
-            return Result.failure()
-        }
-    }
-
-    private fun createForegroundInfo(title: String): ForegroundInfo {
-        val notification =
-            NotificationCompat
-                .Builder(applicationContext, NOTIFICATION_CHANNEL_ID)
-                .setSmallIcon(R.drawable.ic_newpipe_triangle_white)
-                .setOngoing(true)
-                .setProgress(-1, -1, true)
-                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-                .setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE)
-                .setContentTitle(title)
-                .build()
-        val serviceType = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC else 0
-        return ForegroundInfo(NOTIFICATION_ID, notification, serviceType)
-    }
-
-    companion object {
-        private const val TAG = "SubscriptionExportWork"
-        private const val NOTIFICATION_ID = 4567
-        private const val NOTIFICATION_CHANNEL_ID = "newpipe"
-        private const val WORK_NAME = "exportSubscriptions"
-        private const val EXPORT_PATH = "exportPath"
-
-        fun schedule(
-            context: Context,
-            uri: Uri
-        ) {
-            val data = workDataOf(EXPORT_PATH to uri.toString())
-            val workRequest =
-                OneTimeWorkRequestBuilder<SubscriptionExportWorker>()
-                    .setInputData(data)
-                    .setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)
-                    .build()
-
-            WorkManager
-                .getInstance(context)
-                .enqueueUniqueWork(WORK_NAME, ExistingWorkPolicy.APPEND_OR_REPLACE, workRequest)
-        }
-    }
-}

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

@@ -1,242 +0,0 @@
-package org.schabi.newpipe.local.subscription.workers
-
-import android.content.Context
-import android.content.pm.ServiceInfo
-import android.os.Build
-import android.os.Parcelable
-import android.util.Log
-import android.webkit.MimeTypeMap
-import android.widget.Toast
-import androidx.core.app.NotificationCompat
-import androidx.core.net.toUri
-import androidx.work.CoroutineWorker
-import androidx.work.Data
-import androidx.work.ForegroundInfo
-import androidx.work.WorkManager
-import androidx.work.WorkerParameters
-import androidx.work.workDataOf
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
-import kotlinx.coroutines.awaitAll
-import kotlinx.coroutines.rx3.await
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import kotlinx.coroutines.withContext
-import kotlinx.parcelize.Parcelize
-import org.schabi.newpipe.BuildConfig
-import org.schabi.newpipe.R
-import org.schabi.newpipe.extractor.NewPipe
-import org.schabi.newpipe.local.subscription.SubscriptionManager
-import org.schabi.newpipe.util.ExtractorHelper
-
-class SubscriptionImportWorker(
-    appContext: Context,
-    params: WorkerParameters
-) : CoroutineWorker(appContext, params) {
-    // This is needed for API levels < 31 (Android S).
-    override suspend fun getForegroundInfo(): ForegroundInfo {
-        return createForegroundInfo(applicationContext.getString(R.string.import_ongoing), null, 0, 0)
-    }
-
-    override suspend fun doWork(): Result {
-        val subscriptions =
-            try {
-                loadSubscriptionsFromInput(SubscriptionImportInput.fromData(inputData))
-            } catch (e: Exception) {
-                if (BuildConfig.DEBUG) {
-                    Log.e(TAG, "Error while loading subscriptions from path", e)
-                }
-                withContext(Dispatchers.Main) {
-                    Toast
-                        .makeText(applicationContext, R.string.subscriptions_import_unsuccessful, Toast.LENGTH_SHORT)
-                        .show()
-                }
-                return Result.failure()
-            }
-
-        val mutex = Mutex()
-        var index = 1
-        val qty = subscriptions.size
-        var title =
-            applicationContext.resources.getQuantityString(R.plurals.load_subscriptions, qty, qty)
-
-        val channelInfoList =
-            try {
-                withContext(Dispatchers.IO.limitedParallelism(PARALLEL_EXTRACTIONS)) {
-                    subscriptions
-                        .map {
-                            async {
-                                val channelInfo =
-                                    ExtractorHelper.getChannelInfo(it.serviceId, it.url, true).await()
-                                val channelTab =
-                                    ExtractorHelper.getChannelTab(it.serviceId, channelInfo.tabs[0], true).await()
-
-                                val currentIndex = mutex.withLock { index++ }
-                                setForeground(createForegroundInfo(title, channelInfo.name, currentIndex, qty))
-
-                                channelInfo to channelTab
-                            }
-                        }.awaitAll()
-                }
-            } catch (e: Exception) {
-                if (BuildConfig.DEBUG) {
-                    Log.e(TAG, "Error while loading subscription data", e)
-                }
-                withContext(Dispatchers.Main) {
-                    Toast.makeText(applicationContext, R.string.subscriptions_import_unsuccessful, Toast.LENGTH_SHORT)
-                        .show()
-                }
-                return Result.failure()
-            }
-
-        title = applicationContext.resources.getQuantityString(R.plurals.import_subscriptions, qty, qty)
-        setForeground(createForegroundInfo(title, null, 0, 0))
-        index = 0
-
-        val subscriptionManager = SubscriptionManager(applicationContext)
-        for (chunk in channelInfoList.chunked(BUFFER_COUNT_BEFORE_INSERT)) {
-            withContext(Dispatchers.IO) {
-                subscriptionManager.upsertAll(chunk)
-            }
-            index += chunk.size
-            setForeground(createForegroundInfo(title, null, index, qty))
-        }
-
-        withContext(Dispatchers.Main) {
-            Toast.makeText(applicationContext, R.string.import_complete_toast, Toast.LENGTH_SHORT)
-                .show()
-        }
-
-        return Result.success()
-    }
-
-    private suspend fun loadSubscriptionsFromInput(input: SubscriptionImportInput): List<SubscriptionItem> {
-        return withContext(Dispatchers.IO) {
-            when (input) {
-                is SubscriptionImportInput.ChannelUrlMode ->
-                    NewPipe.getService(input.serviceId).subscriptionExtractor
-                        .fromChannelUrl(input.url)
-                        .map { SubscriptionItem(it.serviceId, it.url, it.name) }
-
-                is SubscriptionImportInput.InputStreamMode ->
-                    applicationContext.contentResolver.openInputStream(input.url.toUri())?.use {
-                        val contentType =
-                            MimeTypeMap.getFileExtensionFromUrl(input.url).ifEmpty { DEFAULT_MIME }
-                        NewPipe.getService(input.serviceId).subscriptionExtractor
-                            .fromInputStream(it, contentType)
-                            .map { SubscriptionItem(it.serviceId, it.url, it.name) }
-                    }
-
-                is SubscriptionImportInput.PreviousExportMode ->
-                    applicationContext.contentResolver.openInputStream(input.url.toUri())?.use {
-                        ImportExportJsonHelper.readFrom(it)
-                    }
-            } ?: emptyList()
-        }
-    }
-
-    private fun createForegroundInfo(
-        title: String,
-        text: String?,
-        currentProgress: Int,
-        maxProgress: Int
-    ): ForegroundInfo {
-        val notification =
-            NotificationCompat
-                .Builder(applicationContext, NOTIFICATION_CHANNEL_ID)
-                .setSmallIcon(R.drawable.ic_newpipe_triangle_white)
-                .setOngoing(true)
-                .setProgress(maxProgress, currentProgress, currentProgress == 0)
-                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-                .setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE)
-                .setContentTitle(title)
-                .setContentText(text)
-                .addAction(
-                    R.drawable.ic_close,
-                    applicationContext.getString(R.string.cancel),
-                    WorkManager.getInstance(applicationContext).createCancelPendingIntent(id)
-                ).apply {
-                    if (currentProgress > 0 && maxProgress > 0) {
-                        val progressText = "$currentProgress/$maxProgress"
-                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
-                            setSubText(progressText)
-                        } else {
-                            setContentInfo(progressText)
-                        }
-                    }
-                }.build()
-        val serviceType = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC else 0
-
-        return ForegroundInfo(NOTIFICATION_ID, notification, serviceType)
-    }
-
-    companion object {
-        // Log tag length is limited to 23 characters on API levels < 24.
-        private const val TAG = "SubscriptionImport"
-
-        private const val NOTIFICATION_ID = 4568
-        private const val NOTIFICATION_CHANNEL_ID = "newpipe"
-        private const val DEFAULT_MIME = "application/octet-stream"
-        private const val PARALLEL_EXTRACTIONS = 8
-        private const val BUFFER_COUNT_BEFORE_INSERT = 50
-
-        const val WORK_NAME = "SubscriptionImportWorker"
-    }
-}
-
-sealed class SubscriptionImportInput : Parcelable {
-    @Parcelize
-    data class ChannelUrlMode(val serviceId: Int, val url: String) : SubscriptionImportInput()
-
-    @Parcelize
-    data class InputStreamMode(val serviceId: Int, val url: String) : SubscriptionImportInput()
-
-    @Parcelize
-    data class PreviousExportMode(val url: String) : SubscriptionImportInput()
-
-    fun toData(): Data {
-        val (mode, serviceId, url) = when (this) {
-            is ChannelUrlMode -> Triple(CHANNEL_URL_MODE, serviceId, url)
-            is InputStreamMode -> Triple(INPUT_STREAM_MODE, serviceId, url)
-            is PreviousExportMode -> Triple(PREVIOUS_EXPORT_MODE, null, url)
-        }
-        return workDataOf("mode" to mode, "service_id" to serviceId, "url" to url)
-    }
-
-    companion object {
-
-        private const val CHANNEL_URL_MODE = 0
-        private const val INPUT_STREAM_MODE = 1
-        private const val PREVIOUS_EXPORT_MODE = 2
-
-        fun fromData(data: Data): SubscriptionImportInput {
-            val mode = data.getInt("mode", PREVIOUS_EXPORT_MODE)
-            when (mode) {
-                CHANNEL_URL_MODE -> {
-                    val serviceId = data.getInt("service_id", -1)
-                    if (serviceId == -1) {
-                        throw IllegalArgumentException("No service id provided")
-                    }
-                    val url = data.getString("url")!!
-                    return ChannelUrlMode(serviceId, url)
-                }
-
-                INPUT_STREAM_MODE -> {
-                    val serviceId = data.getInt("service_id", -1)
-                    if (serviceId == -1) {
-                        throw IllegalArgumentException("No service id provided")
-                    }
-                    val url = data.getString("url")!!
-                    return InputStreamMode(serviceId, url)
-                }
-
-                PREVIOUS_EXPORT_MODE -> {
-                    val url = data.getString("url")!!
-                    return PreviousExportMode(url)
-                }
-
-                else -> throw IllegalArgumentException("Unknown mode: $mode")
-            }
-        }
-    }
-}

app/src/main/java/org/schabi/newpipe/paging/CommentRepliesSource.kt

@@ -1,27 +0,0 @@
-package org.schabi.newpipe.paging
-
-import androidx.paging.PagingSource
-import androidx.paging.PagingState
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-import org.schabi.newpipe.extractor.NewPipe
-import org.schabi.newpipe.extractor.Page
-import org.schabi.newpipe.extractor.comments.CommentsInfo
-import org.schabi.newpipe.extractor.comments.CommentsInfoItem
-
-class CommentRepliesSource(
-    private val commentInfo: CommentsInfoItem
-) : PagingSource<Page, CommentsInfoItem>() {
-    private val service = NewPipe.getService(commentInfo.serviceId)
-
-    override suspend fun load(params: LoadParams<Page>): LoadResult<Page, CommentsInfoItem> {
-        // params.key is null the first time load() is called, and we need to return the first page
-        val repliesPage = params.key ?: commentInfo.replies
-        val info = withContext(Dispatchers.IO) {
-            CommentsInfo.getMoreItems(service, commentInfo.url, repliesPage)
-        }
-        return LoadResult.Page(info.items, null, info.nextPage)
-    }
-
-    override fun getRefreshKey(state: PagingState<Page, CommentsInfoItem>) = null
-}

app/src/main/java/org/schabi/newpipe/paging/CommentsSource.kt

@@ -1,32 +0,0 @@
-package org.schabi.newpipe.paging
-
-import androidx.paging.PagingSource
-import androidx.paging.PagingState
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-import org.schabi.newpipe.extractor.NewPipe
-import org.schabi.newpipe.extractor.Page
-import org.schabi.newpipe.extractor.comments.CommentsInfo
-import org.schabi.newpipe.extractor.comments.CommentsInfoItem
-import org.schabi.newpipe.ui.components.video.comment.CommentInfo
-
-class CommentsSource(private val commentInfo: CommentInfo) : PagingSource<Page, CommentsInfoItem>() {
-    private val service = NewPipe.getService(commentInfo.serviceId)
-
-    override suspend fun load(params: LoadParams<Page>): LoadResult<Page, CommentsInfoItem> {
-        // params.key is null the first time the load() function is called, so we need to return the
-        // first batch of already-loaded comments
-
-        if (params.key == null) {
-            return LoadResult.Page(commentInfo.comments, null, commentInfo.nextPage)
-        } else {
-            val info = withContext(Dispatchers.IO) {
-                CommentsInfo.getMoreItems(service, commentInfo.url, params.key)
-            }
-
-            return LoadResult.Page(info.items, null, info.nextPage)
-        }
-    }
-
-    override fun getRefreshKey(state: PagingState<Page, CommentsInfoItem>) = null
-}

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

@@ -95,48 +95,8 @@ public final class PlayQueueActivity extends AppCompatActivity
             getSupportActionBar().setTitle(R.string.title_activity_play_queue);
         }
 
-        serviceConnection = new ServiceConnection() {
-            @Override
-            public void onServiceDisconnected(final ComponentName name) {
-                Log.d(TAG, "Player service is disconnected");
-            }
-
-            @Override
-            public void onServiceConnected(final ComponentName name, final IBinder binder) {
-                Log.d(TAG, "Player service is connected");
-
-                if (binder instanceof PlayerService.LocalBinder) {
-                    @Nullable final PlayerService s =
-                            ((PlayerService.LocalBinder) binder).getService();
-                    if (s == null) {
-                        throw new IllegalArgumentException(
-                                "PlayerService.LocalBinder.getService() must never be"
-                                        + "null after the service connects");
-                    }
-                    player = s.getPlayer();
-                }
-
-                if (player == null || player.getPlayQueue() == null || player.exoPlayerIsNull()) {
-                    unbind();
-                } else {
-                    onQueueUpdate(player.getPlayQueue());
-                    buildComponents();
-                    if (player != null) {
-                        player.setActivityListener(PlayQueueActivity.this);
-                    }
-                }
-            }
-        };
-
-        // Note: this code should not really exist, and PlayerHolder should be used instead, but
-        // it will be rewritten when NewPlayer will replace the current player.
-        final Intent bindIntent = new Intent(this, PlayerService.class);
-        bindIntent.setAction(PlayerService.BIND_PLAYER_HOLDER_ACTION);
-        final boolean success = bindService(bindIntent, serviceConnection, BIND_AUTO_CREATE);
-        if (!success) {
-            unbindService(serviceConnection);
-        }
-        serviceBound = success;
+        serviceConnection = getServiceConnection();
+        bind();
     }
 
     @Override
@@ -167,39 +127,39 @@ public final class PlayQueueActivity extends AppCompatActivity
 
     @Override
     public boolean onOptionsItemSelected(final MenuItem item) {
-        switch (item.getItemId()) {
-            case android.R.id.home:
-                finish();
-                return true;
-            case R.id.action_settings:
-                NavigationHelper.openSettings(this);
-                return true;
-            case R.id.action_append_playlist:
-                PlaylistDialog.showForPlayQueue(player, getSupportFragmentManager());
-                return true;
-            case R.id.action_playback_speed:
-                openPlaybackParameterDialog();
-                return true;
-            case R.id.action_mute:
-                player.toggleMute();
-                return true;
-            case R.id.action_system_audio:
-                startActivity(new Intent(Settings.ACTION_SOUND_SETTINGS));
-                return true;
-            case R.id.action_switch_main:
+        final int itemId = item.getItemId();
+        if (itemId == android.R.id.home) {
+            finish();
+            return true;
+        } else if (itemId == R.id.action_settings) {
+            NavigationHelper.openSettings(this);
+            return true;
+        } else if (itemId == R.id.action_append_playlist) {
+            PlaylistDialog.showForPlayQueue(player, getSupportFragmentManager());
+            return true;
+        } else if (itemId == R.id.action_playback_speed) {
+            openPlaybackParameterDialog();
+            return true;
+        } else if (itemId == R.id.action_mute) {
+            player.toggleMute();
+            return true;
+        } else if (itemId == R.id.action_system_audio) {
+            startActivity(new Intent(Settings.ACTION_SOUND_SETTINGS));
+            return true;
+        } else if (itemId == R.id.action_switch_main) {
+            this.player.setRecovery();
+            NavigationHelper.playOnMainPlayer(this, player.getPlayQueue(), true);
+            return true;
+        } else if (itemId == R.id.action_switch_popup) {
+            if (PermissionHelper.isPopupEnabledElseAsk(this)) {
                 this.player.setRecovery();
-                NavigationHelper.playOnMainPlayer(this, player.getPlayQueue(), true);
-                return true;
-            case R.id.action_switch_popup:
-                if (PermissionHelper.isPopupEnabledElseAsk(this)) {
-                    this.player.setRecovery();
-                    NavigationHelper.playOnPopupPlayer(this, player.getPlayQueue(), true);
-                }
-                return true;
-            case R.id.action_switch_background:
-                this.player.setRecovery();
-                NavigationHelper.playOnBackgroundPlayer(this, player.getPlayQueue(), true);
-                return true;
+                NavigationHelper.playOnPopupPlayer(this, player.getPlayQueue(), true);
+            }
+            return true;
+        } else if (itemId == R.id.action_switch_background) {
+            this.player.setRecovery();
+            NavigationHelper.playOnBackgroundPlayer(this, player.getPlayQueue(), true);
+            return true;
         }
 
         if (item.getGroupId() == MENU_ID_AUDIO_TRACK) {
@@ -218,6 +178,19 @@ public final class PlayQueueActivity extends AppCompatActivity
 
     ////////////////////////////////////////////////////////////////////////////
     // Service Connection
+    ////////////////////////////////////////////////////////////////////////////
+
+    private void bind() {
+        // Note: this code should not really exist, and PlayerHolder should be used instead, but
+        // it will be rewritten when NewPlayer will replace the current player.
+        final Intent bindIntent = new Intent(this, PlayerService.class);
+        bindIntent.setAction(PlayerService.BIND_PLAYER_HOLDER_ACTION);
+        final boolean success = bindService(bindIntent, serviceConnection, BIND_AUTO_CREATE);
+        if (!success) {
+            unbindService(serviceConnection);
+        }
+        serviceBound = success;
+    }
 
     private void unbind() {
         if (serviceBound) {
@@ -237,6 +210,34 @@ public final class PlayQueueActivity extends AppCompatActivity
         }
     }
 
+    private ServiceConnection getServiceConnection() {
+        return new ServiceConnection() {
+            @Override
+            public void onServiceDisconnected(final ComponentName name) {
+                Log.d(TAG, "Player service is disconnected");
+            }
+
+            @Override
+            public void onServiceConnected(final ComponentName name, final IBinder service) {
+                Log.d(TAG, "Player service is connected");
+
+                if (service instanceof PlayerService.LocalBinder) {
+                    player = ((PlayerService.LocalBinder) service).getService().getPlayer();
+                }
+
+                if (player == null || player.getPlayQueue() == null || player.exoPlayerIsNull()) {
+                    unbind();
+                } else {
+                    onQueueUpdate(player.getPlayQueue());
+                    buildComponents();
+                    if (player != null) {
+                        player.setActivityListener(PlayQueueActivity.this);
+                    }
+                }
+            }
+        };
+    }
+
     ////////////////////////////////////////////////////////////////////////////
     // Component Building
     ////////////////////////////////////////////////////////////////////////////

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

@@ -45,7 +45,6 @@ import static org.schabi.newpipe.player.notification.NotificationConstants.ACTIO
 import static org.schabi.newpipe.util.ListHelper.getPopupResolutionIndex;
 import static org.schabi.newpipe.util.ListHelper.getResolutionIndex;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import static coil3.Image_androidKt.toBitmap;
 
 import android.content.BroadcastReceiver;
 import android.content.Context;
@@ -53,6 +52,7 @@ import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.SharedPreferences;
 import android.graphics.Bitmap;
+import android.graphics.drawable.Drawable;
 import android.media.AudioManager;
 import android.support.v4.media.session.MediaSessionCompat;
 import android.util.Log;
@@ -80,6 +80,8 @@ import com.google.android.exoplayer2.trackselection.DefaultTrackSelector;
 import com.google.android.exoplayer2.trackselection.MappingTrackSelector;
 import com.google.android.exoplayer2.upstream.DefaultBandwidthMeter;
 import com.google.android.exoplayer2.video.VideoSize;
+import com.squareup.picasso.Picasso;
+import com.squareup.picasso.Target;
 
 import org.schabi.newpipe.MainActivity;
 import org.schabi.newpipe.R;
@@ -124,14 +126,13 @@ import org.schabi.newpipe.util.ListHelper;
 import org.schabi.newpipe.util.NavigationHelper;
 import org.schabi.newpipe.util.SerializedCache;
 import org.schabi.newpipe.util.StreamTypeUtil;
-import org.schabi.newpipe.util.image.CoilHelper;
+import org.schabi.newpipe.util.image.PicassoHelper;
 
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.stream.IntStream;
 
-import coil3.target.Target;
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
 import io.reactivex.rxjava3.core.Observable;
 import io.reactivex.rxjava3.core.Single;
@@ -140,10 +141,6 @@ import io.reactivex.rxjava3.disposables.Disposable;
 import io.reactivex.rxjava3.disposables.SerialDisposable;
 import io.reactivex.rxjava3.schedulers.Schedulers;
 
-/**
- * The ExoPlayer wrapper & Player business logic.
- * Only instantiated once, from {@link PlayerService}.
- */
 public final class Player implements PlaybackListener, Listener {
     public static final boolean DEBUG = MainActivity.DEBUG;
     public static final String TAG = Player.class.getSimpleName();
@@ -184,6 +181,7 @@ public final class Player implements PlaybackListener, Listener {
     //////////////////////////////////////////////////////////////////////////*/
 
     public static final int RENDERER_UNAVAILABLE = -1;
+    private static final String PICASSO_PLAYER_THUMBNAIL_TAG = "PICASSO_PLAYER_THUMBNAIL_TAG";
 
     /*//////////////////////////////////////////////////////////////////////////
     // Playback
@@ -202,8 +200,6 @@ public final class Player implements PlaybackListener, Listener {
     private MediaItemTag currentMetadata;
     @Nullable
     private Bitmap currentThumbnail;
-    @Nullable
-    private coil3.request.Disposable thumbnailDisposable;
 
     /*//////////////////////////////////////////////////////////////////////////
     // Player
@@ -259,6 +255,12 @@ public final class Player implements PlaybackListener, Listener {
     @NonNull
     private final CompositeDisposable streamItemDisposable = new CompositeDisposable();
 
+    // This is the only listener we need for thumbnail loading, since there is always at most only
+    // one thumbnail being loaded at a time. This field is also here to maintain a strong reference,
+    // which would otherwise be garbage collected since Picasso holds weak references to targets.
+    @NonNull
+    private final Target currentThumbnailTarget;
+
     /*//////////////////////////////////////////////////////////////////////////
     // Utils
     //////////////////////////////////////////////////////////////////////////*/
@@ -312,6 +314,8 @@ public final class Player implements PlaybackListener, Listener {
         videoResolver = new VideoPlaybackResolver(context, dataSource, getQualityResolver());
         audioResolver = new AudioPlaybackResolver(context, dataSource);
 
+        currentThumbnailTarget = getCurrentThumbnailTarget();
+
         // The UIs added here should always be present. They will be initialized when the player
         // reaches the initialization step. Make sure the media session ui is before the
         // notification ui in the UIs list, since the notification depends on the media session in
@@ -411,11 +415,12 @@ public final class Player implements PlaybackListener, Listener {
                         .subscribe(info -> {
                             final @Nullable PlayQueue oldPlayQueue = playQueue;
                             info.setStartPosition(data.getSeconds());
-                            final PlayQueueItem item = new PlayQueueItem(info);
+                            final PlayQueueItem playQueueItem = new PlayQueueItem(info);
 
                             // If the stream is already playing,
                             // we can just seek to the appropriate timestamp
-                            if (oldPlayQueue != null && item.equals(oldPlayQueue.getItem())) {
+                            if (oldPlayQueue != null
+                                    && playQueueItem.isSameItem(oldPlayQueue.getItem())) {
                                 // Player can have state = IDLE when playback is stopped or failed
                                 // and we should retry in this case
                                 if (simpleExoPlayer.getPlaybackState()
@@ -431,12 +436,12 @@ public final class Player implements PlaybackListener, Listener {
 
                                 // If there is no queue yet, just add our item
                                 if (oldPlayQueue == null) {
-                                    newPlayQueue = new SinglePlayQueue(item);
+                                    newPlayQueue = new SinglePlayQueue(playQueueItem);
 
                                 // else we add the timestamped stream behind the current video
                                 // and start playing it.
                                 } else {
-                                    oldPlayQueue.enqueueNext(item, true);
+                                    oldPlayQueue.enqueueNext(playQueueItem, true);
                                     oldPlayQueue.offsetIndex(1);
                                     newPlayQueue = oldPlayQueue;
                                 }
@@ -479,7 +484,7 @@ public final class Player implements PlaybackListener, Listener {
         if (!exoPlayerIsNull()
                 && newQueue.size() == 1 && newQueue.getItem() != null
                 && playQueue != null && playQueue.size() == 1 && playQueue.getItem() != null
-                && newQueue.getItem().equals(playQueue.getItem())
+                && newQueue.getItem().isSameItem(playQueue.getItem())
                 && newQueue.getItem().getRecoveryPosition() != PlayQueueItem.RECOVERY_UNSET) {
             // Player can have state = IDLE when playback is stopped or failed
             // and we should retry in this case
@@ -566,38 +571,36 @@ public final class Player implements PlaybackListener, Listener {
     }
 
     private void initUIsForCurrentPlayerType() {
-        if ((UIs.get(MainPlayerUi.class) != null && playerType == PlayerType.MAIN)
-                || (UIs.get(BackgroundPlayerUi.class) != null && playerType == PlayerType.AUDIO)
-                || (UIs.get(PopupPlayerUi.class) != null && playerType == PlayerType.POPUP)) {
+        if ((UIs.get(MainPlayerUi.class).isPresent() && playerType == PlayerType.MAIN)
+                || (UIs.get(BackgroundPlayerUi.class).isPresent() && playerType == PlayerType.AUDIO)
+                || (UIs.get(PopupPlayerUi.class).isPresent() && playerType == PlayerType.POPUP)) {
             // correct UI already in place
             return;
         }
 
         // try to reuse binding if possible
-        @Nullable final VideoPlayerUi ui = UIs.get(VideoPlayerUi.class);
-        final PlayerBinding binding;
-        if (ui != null) {
-            binding = ui.getBinding();
-        } else if (playerType == PlayerType.AUDIO) {
-            binding = null;
-        } else {
-            binding = PlayerBinding.inflate(LayoutInflater.from(context));
-        }
+        final PlayerBinding binding = UIs.get(VideoPlayerUi.class).map(VideoPlayerUi::getBinding)
+                .orElseGet(() -> {
+                    if (playerType == PlayerType.AUDIO) {
+                        return null;
+                    } else {
+                        return PlayerBinding.inflate(LayoutInflater.from(context));
+                    }
+                });
 
         switch (playerType) {
             case MAIN:
-                UIs.destroyAllOfType(PopupPlayerUi.class);
-                UIs.destroyAllOfType(BackgroundPlayerUi.class);
+                UIs.destroyAll(PopupPlayerUi.class);
+                UIs.destroyAll(BackgroundPlayerUi.class);
                 UIs.addAndPrepare(new MainPlayerUi(this, binding));
                 break;
             case POPUP:
-                UIs.destroyAllOfType(MainPlayerUi.class);
-                UIs.destroyAllOfType(BackgroundPlayerUi.class);
+                UIs.destroyAll(MainPlayerUi.class);
+                UIs.destroyAll(BackgroundPlayerUi.class);
                 UIs.addAndPrepare(new PopupPlayerUi(this, binding));
                 break;
             case AUDIO:
-                // destroys both MainPlayerUi and PopupPlayerUi
-                UIs.destroyAllOfType(VideoPlayerUi.class);
+                UIs.destroyAll(VideoPlayerUi.class); // destroys both MainPlayerUi and PopupPlayerUi
                 UIs.addAndPrepare(new BackgroundPlayerUi(this));
                 break;
         }
@@ -686,15 +689,9 @@ public final class Player implements PlaybackListener, Listener {
         }
     }
 
-
-    /**
-     * Shut down this player.
-     * Saves the stream progress, sets recovery.
-     * Then destroys the player in all UIs and destroys the UIs as well.
-     */
-    public void saveAndShutdown() {
+    public void destroy() {
         if (DEBUG) {
-            Log.d(TAG, "saveAndShutdown() called");
+            Log.d(TAG, "destroy() called");
         }
 
         saveStreamProgressState();
@@ -707,8 +704,9 @@ public final class Player implements PlaybackListener, Listener {
         databaseUpdateDisposable.clear();
         progressUpdateDisposable.set(null);
         streamItemDisposable.clear();
+        cancelLoadingCurrentThumbnail();
 
-        UIs.destroyAllOfType(null);
+        UIs.destroyAll(Object.class); // destroy every UI: obviously every UI extends Object
     }
 
     public void setRecovery() {
@@ -886,57 +884,67 @@ public final class Player implements PlaybackListener, Listener {
     //////////////////////////////////////////////////////////////////////////*/
     //region Thumbnail loading
 
+    private Target getCurrentThumbnailTarget() {
+        // a Picasso target is just a listener for thumbnail loading events
+        return new Target() {
+            @Override
+            public void onBitmapLoaded(final Bitmap bitmap, final Picasso.LoadedFrom from) {
+                if (DEBUG) {
+                    Log.d(TAG, "Thumbnail - onBitmapLoaded() called with: bitmap = [" + bitmap
+                            + " -> " + bitmap.getWidth() + "x" + bitmap.getHeight() + "], from = ["
+                            + from + "]");
+                }
+                // there is a new thumbnail, so e.g. the end screen thumbnail needs to change, too.
+                onThumbnailLoaded(bitmap);
+            }
+
+            @Override
+            public void onBitmapFailed(final Exception e, final Drawable errorDrawable) {
+                Log.e(TAG, "Thumbnail - onBitmapFailed() called", e);
+                // there is a new thumbnail, so e.g. the end screen thumbnail needs to change, too.
+                onThumbnailLoaded(null);
+            }
+
+            @Override
+            public void onPrepareLoad(final Drawable placeHolderDrawable) {
+                if (DEBUG) {
+                    Log.d(TAG, "Thumbnail - onPrepareLoad() called");
+                }
+            }
+        };
+    }
+
     private void loadCurrentThumbnail(final List<Image> thumbnails) {
         if (DEBUG) {
             Log.d(TAG, "Thumbnail - loadCurrentThumbnail() called with thumbnails = ["
                     + thumbnails.size() + "]");
         }
 
-        // Cancel any ongoing image loading
-        if (thumbnailDisposable != null) {
-            thumbnailDisposable.dispose();
-        }
+        // first cancel any previous loading
+        cancelLoadingCurrentThumbnail();
 
         // Unset currentThumbnail, since it is now outdated. This ensures it is not used in media
-        // session metadata while the new thumbnail is being loaded by Coil.
+        // session metadata while the new thumbnail is being loaded by Picasso.
         onThumbnailLoaded(null);
         if (thumbnails.isEmpty()) {
             return;
         }
 
         // scale down the notification thumbnail for performance
-        final var thumbnailTarget = new Target() {
-            @Override
-            public void onError(@Nullable final coil3.Image error) {
-                Log.e(TAG, "Thumbnail - onError() called");
-                // there is a new thumbnail, so e.g. the end screen thumbnail needs to change, too.
-                onThumbnailLoaded(null);
-            }
+        PicassoHelper.loadScaledDownThumbnail(context, thumbnails)
+                .tag(PICASSO_PLAYER_THUMBNAIL_TAG)
+                .into(currentThumbnailTarget);
+    }
 
-            @Override
-            public void onStart(@Nullable final coil3.Image placeholder) {
-                if (DEBUG) {
-                    Log.d(TAG, "Thumbnail - onStart() called");
-                }
-            }
-
-            @Override
-            public void onSuccess(@NonNull final coil3.Image result) {
-                if (DEBUG) {
-                    Log.d(TAG, "Thumbnail - onSuccess() called with: drawable = [" + result + "]");
-                }
-                // there is a new thumbnail, so e.g. the end screen thumbnail needs to change, too.
-                onThumbnailLoaded(toBitmap(result));
-            }
-        };
-        thumbnailDisposable = CoilHelper.INSTANCE
-                .loadScaledDownThumbnail(context, thumbnails, thumbnailTarget);
+    private void cancelLoadingCurrentThumbnail() {
+        // cancel the Picasso job associated with the player thumbnail, if any
+        PicassoHelper.cancelTag(PICASSO_PLAYER_THUMBNAIL_TAG);
     }
 
     private void onThumbnailLoaded(@Nullable final Bitmap bitmap) {
         // Avoid useless thumbnail updates, if the thumbnail has not actually changed. Based on the
         // thumbnail loading code, this if would be skipped only when both bitmaps are `null`, since
-        // onThumbnailLoaded won't be called twice with the same nonnull bitmap by Coil's target.
+        // onThumbnailLoaded won't be called twice with the same nonnull bitmap by Picasso's target.
         if (currentThumbnail != bitmap) {
             currentThumbnail = bitmap;
             UIs.call(playerUi -> playerUi.onThumbnailLoaded(bitmap));
@@ -2113,10 +2121,6 @@ public final class Player implements PlaybackListener, Listener {
         triggerProgressUpdate();
     }
 
-    /**
-     * Remove the listener, if it was set.
-     * @param listener listener to remove
-     * */
     public void removeFragmentListener(final PlayerServiceEventListener listener) {
         if (fragmentListener == listener) {
             fragmentListener = null;
@@ -2131,10 +2135,6 @@ public final class Player implements PlaybackListener, Listener {
         triggerProgressUpdate();
     }
 
-    /**
-     * Remove the listener, if it was set.
-     * @param listener listener to remove
-     * */
     void removeActivityListener(final PlayerEventListener listener) {
         if (activityListener == listener) {
             activityListener = null;

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

@@ -0,0 +1,348 @@
+/*
+ * Copyright 2017 Mauricio Colli <mauriciocolli@outlook.com>
+ * Part of NewPipe
+ *
+ * License: GPL-3.0+
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.schabi.newpipe.player;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Binder;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.support.v4.media.MediaBrowserCompat;
+import android.support.v4.media.session.MediaSessionCompat;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.app.ServiceCompat;
+import androidx.media.MediaBrowserServiceCompat;
+
+import com.google.android.exoplayer2.ext.mediasession.MediaSessionConnector;
+
+import org.schabi.newpipe.ktx.BundleKt;
+import org.schabi.newpipe.player.mediabrowser.MediaBrowserImpl;
+import org.schabi.newpipe.player.mediabrowser.MediaBrowserPlaybackPreparer;
+import org.schabi.newpipe.player.mediasession.MediaSessionPlayerUi;
+import org.schabi.newpipe.player.notification.NotificationPlayerUi;
+import org.schabi.newpipe.player.notification.NotificationUtil;
+import org.schabi.newpipe.util.ThemeHelper;
+
+import java.lang.ref.WeakReference;
+import java.util.List;
+import java.util.function.Consumer;
+
+
+/**
+ * One service for all players.
+ */
+public final class PlayerService extends MediaBrowserServiceCompat {
+    private static final String TAG = PlayerService.class.getSimpleName();
+    private static final boolean DEBUG = Player.DEBUG;
+
+    public static final String SHOULD_START_FOREGROUND_EXTRA = "should_start_foreground_extra";
+    public static final String BIND_PLAYER_HOLDER_ACTION = "bind_player_holder_action";
+
+    // These objects are used to cleanly separate the Service implementation (in this file) and the
+    // media browser and playback preparer implementations. At the moment the playback preparer is
+    // only used in conjunction with the media browser.
+    private MediaBrowserImpl mediaBrowserImpl;
+    private MediaBrowserPlaybackPreparer mediaBrowserPlaybackPreparer;
+
+    // these are instantiated in onCreate() as per
+    // https://developer.android.com/training/cars/media#browser_workflow
+    private MediaSessionCompat mediaSession;
+    private MediaSessionConnector sessionConnector;
+
+    @Nullable
+    private Player player;
+
+    private final IBinder mBinder = new PlayerService.LocalBinder(this);
+
+    /**
+     * The parameter taken by this {@link Consumer} can be null to indicate the player is being
+     * stopped.
+     */
+    @Nullable
+    private Consumer<Player> onPlayerStartedOrStopped = null;
+
+
+    //region Service lifecycle
+    @Override
+    public void onCreate() {
+        super.onCreate();
+
+        if (DEBUG) {
+            Log.d(TAG, "onCreate() called");
+        }
+        ThemeHelper.setTheme(this);
+
+        mediaBrowserImpl = new MediaBrowserImpl(this, this::notifyChildrenChanged);
+
+        // see https://developer.android.com/training/cars/media#browser_workflow
+        mediaSession = new MediaSessionCompat(this, "MediaSessionPlayerServ");
+        setSessionToken(mediaSession.getSessionToken());
+        sessionConnector = new MediaSessionConnector(mediaSession);
+        sessionConnector.setMetadataDeduplicationEnabled(true);
+
+        mediaBrowserPlaybackPreparer = new MediaBrowserPlaybackPreparer(
+                this,
+                sessionConnector::setCustomErrorMessage,
+                () -> sessionConnector.setCustomErrorMessage(null),
+                (playWhenReady) -> {
+                    if (player != null) {
+                        player.onPrepare();
+                    }
+                }
+        );
+        sessionConnector.setPlaybackPreparer(mediaBrowserPlaybackPreparer);
+
+        // Note: you might be tempted to create the player instance and call startForeground here,
+        // but be aware that the Android system might start the service just to perform media
+        // queries. In those cases creating a player instance is a waste of resources, and calling
+        // startForeground means creating a useless empty notification. In case it's really needed
+        // the player instance can be created here, but startForeground() should definitely not be
+        // called here unless the service is actually starting in the foreground, to avoid the
+        // useless notification.
+    }
+
+    @Override
+    public int onStartCommand(final Intent intent, final int flags, final int startId) {
+        if (DEBUG) {
+            Log.d(TAG, "onStartCommand() called with: intent = [" + intent
+                    + "], extras = [" + BundleKt.toDebugString(intent.getExtras())
+                    + "], flags = [" + flags + "], startId = [" + startId + "]");
+        }
+
+        // All internal NewPipe intents used to interact with the player, that are sent to the
+        // PlayerService using startForegroundService(), will have SHOULD_START_FOREGROUND_EXTRA,
+        // to ensure startForeground() is called (otherwise Android will force-crash the app).
+        if (intent.getBooleanExtra(SHOULD_START_FOREGROUND_EXTRA, false)) {
+            final boolean playerWasNull = (player == null);
+            if (playerWasNull) {
+                // make sure the player exists, in case the service was resumed
+                player = new Player(this, mediaSession, sessionConnector);
+            }
+
+            // Be sure that the player notification is set and the service is started in foreground,
+            // otherwise, the app may crash on Android 8+ as the service would never be put in the
+            // foreground while we said to the system we would do so. The service is always
+            // requested to be started in foreground, so always creating a notification if there is
+            // no one already and starting the service in foreground should not create any issues.
+            // If the service is already started in foreground, requesting it to be started
+            // shouldn't do anything.
+            player.UIs().get(NotificationPlayerUi.class)
+                    .ifPresent(NotificationPlayerUi::createNotificationAndStartForeground);
+
+            if (playerWasNull && onPlayerStartedOrStopped != null) {
+                // notify that a new player was created (but do it after creating the foreground
+                // notification just to make sure we don't incur, due to slowness, in
+                // "Context.startForegroundService() did not then call Service.startForeground()")
+                onPlayerStartedOrStopped.accept(player);
+            }
+        }
+
+        if (player == null) {
+            // No need to process media button's actions or other system intents if the player is
+            // not running. However, since the current intent might have been issued by the system
+            // with `startForegroundService()` (for unknown reasons), we need to ensure that we post
+            // a (dummy) foreground notification, otherwise we'd incur in
+            // "Context.startForegroundService() did not then call Service.startForeground()". Then
+            // we stop the service again.
+            Log.d(TAG, "onStartCommand() got a useless intent, closing the service");
+            NotificationUtil.startForegroundWithDummyNotification(this);
+            destroyPlayerAndStopService();
+            return START_NOT_STICKY;
+        }
+
+        final PlayerType oldPlayerType = player.getPlayerType();
+        player.handleIntent(intent);
+        player.handleIntentPost(oldPlayerType);
+        player.UIs().get(MediaSessionPlayerUi.class)
+                .ifPresent(ui -> ui.handleMediaButtonIntent(intent));
+
+        return START_NOT_STICKY;
+    }
+
+    public void stopForImmediateReusing() {
+        if (DEBUG) {
+            Log.d(TAG, "stopForImmediateReusing() called");
+        }
+
+        if (player != null && !player.exoPlayerIsNull()) {
+            // Releases wifi & cpu, disables keepScreenOn, etc.
+            // We can't just pause the player here because it will make transition
+            // from one stream to a new stream not smooth
+            player.smoothStopForImmediateReusing();
+        }
+    }
+
+    @Override
+    public void onTaskRemoved(final Intent rootIntent) {
+        super.onTaskRemoved(rootIntent);
+        if (player != null && !player.videoPlayerSelected()) {
+            return;
+        }
+        onDestroy();
+        // Unload from memory completely
+        Runtime.getRuntime().halt(0);
+    }
+
+    @Override
+    public void onDestroy() {
+        if (DEBUG) {
+            Log.d(TAG, "destroy() called");
+        }
+        super.onDestroy();
+
+        cleanup();
+
+        mediaBrowserPlaybackPreparer.dispose();
+        mediaSession.release();
+        mediaBrowserImpl.dispose();
+    }
+
+    private void cleanup() {
+        if (player != null) {
+            if (onPlayerStartedOrStopped != null) {
+                // notify that the player is being destroyed
+                onPlayerStartedOrStopped.accept(null);
+            }
+            player.destroy();
+            player = null;
+        }
+
+        // Should already be handled by MediaSessionPlayerUi, but just to be sure.
+        mediaSession.setActive(false);
+
+        // Should already be handled by NotificationUtil.cancelNotificationAndStopForeground() in
+        // NotificationPlayerUi, but let's make sure that the foreground service is stopped.
+        ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE);
+    }
+
+    /**
+     * Destroys the player and allows the player instance to be garbage collected. Sets the media
+     * session to inactive. Stops the foreground service and removes the player notification
+     * associated with it. Tries to stop the {@link PlayerService} completely, but this step will
+     * have no effect in case some service connection still uses the service (e.g. the Android Auto
+     * system accesses the media browser even when no player is running).
+     */
+    public void destroyPlayerAndStopService() {
+        if (DEBUG) {
+            Log.d(TAG, "destroyPlayerAndStopService() called");
+        }
+
+        cleanup();
+
+        // This only really stops the service if there are no other service connections (see docs):
+        // for example the (Android Auto) media browser binder will block stopService().
+        // This is why we also stopForeground() above, to make sure the notification is removed.
+        // If we were to call stopSelf(), then the service would be surely stopped (regardless of
+        // other service connections), but this would be a waste of resources since the service
+        // would be immediately restarted by those same connections to perform the queries.
+        stopService(new Intent(this, PlayerService.class));
+    }
+
+    @Override
+    protected void attachBaseContext(final Context base) {
+        super.attachBaseContext(AudioServiceLeakFix.preventLeakOf(base));
+    }
+    //endregion
+
+    //region Bind
+    @Override
+    public IBinder onBind(final Intent intent) {
+        if (DEBUG) {
+            Log.d(TAG, "onBind() called with: intent = [" + intent
+                    + "], extras = [" + BundleKt.toDebugString(intent.getExtras()) + "]");
+        }
+
+        if (BIND_PLAYER_HOLDER_ACTION.equals(intent.getAction())) {
+            // Note that this binder might be reused multiple times while the service is alive, even
+            // after unbind() has been called: https://stackoverflow.com/a/8794930 .
+            return mBinder;
+
+        } else if (MediaBrowserServiceCompat.SERVICE_INTERFACE.equals(intent.getAction())) {
+            // MediaBrowserService also uses its own binder, so for actions related to the media
+            // browser service, pass the onBind to the superclass.
+            return super.onBind(intent);
+
+        } else {
+            // This is an unknown request, avoid returning any binder to not leak objects.
+            return null;
+        }
+    }
+
+    public static class LocalBinder extends Binder {
+        private final WeakReference<PlayerService> playerService;
+
+        LocalBinder(final PlayerService playerService) {
+            this.playerService = new WeakReference<>(playerService);
+        }
+
+        public PlayerService getService() {
+            return playerService.get();
+        }
+    }
+
+    /**
+     * @return the current active player instance. May be null, since the player service can outlive
+     * the player e.g. to respond to Android Auto media browser queries.
+     */
+    @Nullable
+    public Player getPlayer() {
+        return player;
+    }
+
+    /**
+     * Sets the listener that will be called when the player is started or stopped. If a
+     * {@code null} listener is passed, then the current listener will be unset. The parameter taken
+     * by the {@link Consumer} can be null to indicate that the player is stopping.
+     * @param listener the listener to set or unset
+     */
+    public void setPlayerListener(@Nullable final Consumer<Player> listener) {
+        this.onPlayerStartedOrStopped = listener;
+        if (listener != null) {
+            // if there is no player, then `null` will be sent here, to ensure the state is synced
+            listener.accept(player);
+        }
+    }
+    //endregion
+
+    //region Media browser
+    @Override
+    public BrowserRoot onGetRoot(@NonNull final String clientPackageName,
+                                 final int clientUid,
+                                 @Nullable final Bundle rootHints) {
+        return mediaBrowserImpl.onGetRoot(clientPackageName, clientUid, rootHints);
+    }
+
+    @Override
+    public void onLoadChildren(@NonNull final String parentId,
+                               @NonNull final Result<List<MediaBrowserCompat.MediaItem>> result) {
+        mediaBrowserImpl.onLoadChildren(parentId, result);
+    }
+
+    @Override
+    public void onSearch(@NonNull final String query,
+                         final Bundle extras,
+                         @NonNull final Result<List<MediaBrowserCompat.MediaItem>> result) {
+        mediaBrowserImpl.onSearch(query, result);
+    }
+    //endregion
+}

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

@@ -1,323 +0,0 @@
-/*
- * Copyright 2017 Mauricio Colli <mauriciocolli@outlook.com>
- * Part of NewPipe
- *
- * License: GPL-3.0+
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package org.schabi.newpipe.player
-
-import android.content.Context
-import android.content.Intent
-import android.os.Binder
-import android.os.Bundle
-import android.os.IBinder
-import android.support.v4.media.MediaBrowserCompat
-import android.support.v4.media.session.MediaSessionCompat
-import android.util.Log
-import androidx.core.app.ServiceCompat
-import androidx.media.MediaBrowserServiceCompat
-import com.google.android.exoplayer2.ext.mediasession.MediaSessionConnector
-import java.lang.ref.WeakReference
-import java.util.function.Consumer
-import org.schabi.newpipe.ktx.toDebugString
-import org.schabi.newpipe.player.mediabrowser.MediaBrowserImpl
-import org.schabi.newpipe.player.mediabrowser.MediaBrowserPlaybackPreparer
-import org.schabi.newpipe.player.mediasession.MediaSessionPlayerUi
-import org.schabi.newpipe.player.notification.NotificationPlayerUi
-import org.schabi.newpipe.player.notification.NotificationUtil
-import org.schabi.newpipe.util.ThemeHelper
-
-/**
- * One service for all players.
- */
-class PlayerService : MediaBrowserServiceCompat() {
-    // These objects are used to cleanly separate the Service implementation (in this file) and the
-    // media browser and playback preparer implementations. At the moment the playback preparer is
-    // only used in conjunction with the media browser.
-    private lateinit var mediaBrowserImpl: MediaBrowserImpl
-    private lateinit var mediaBrowserPlaybackPreparer: MediaBrowserPlaybackPreparer
-
-    // these are instantiated in onCreate() as per
-    // https://developer.android.com/training/cars/media#browser_workflow
-    private lateinit var mediaSession: MediaSessionCompat
-    private lateinit var sessionConnector: MediaSessionConnector
-
-    /**
-     * @return the current active player instance. May be null, since the player service can outlive
-     * the player e.g. to respond to Android Auto media browser queries.
-     */
-    var player: Player? = null
-        private set
-
-    private val mBinder: IBinder = LocalBinder(this)
-
-    /**
-     * The parameter taken by this [Consumer] can be null to indicate the player is being
-     * stopped.
-     */
-    private var onPlayerStartedOrStopped: ((player: Player?) -> Unit)? = null
-
-    //region Service lifecycle
-    override fun onCreate() {
-        super.onCreate()
-
-        if (DEBUG) {
-            Log.d(TAG, "onCreate() called")
-        }
-        ThemeHelper.setTheme(this)
-
-        mediaBrowserImpl = MediaBrowserImpl(this, this::notifyChildrenChanged)
-
-        // see https://developer.android.com/training/cars/media#browser_workflow
-        val session = MediaSessionCompat(this, "MediaSessionPlayerServ")
-        mediaSession = session
-        setSessionToken(session.sessionToken)
-        val connector = MediaSessionConnector(session)
-        sessionConnector = connector
-        connector.setMetadataDeduplicationEnabled(true)
-
-        mediaBrowserPlaybackPreparer = MediaBrowserPlaybackPreparer(
-            context = this,
-            setMediaSessionError = connector::setCustomErrorMessage,
-            clearMediaSessionError = { connector.setCustomErrorMessage(null) },
-            onPrepare = { player?.onPrepare() }
-        )
-        connector.setPlaybackPreparer(mediaBrowserPlaybackPreparer)
-
-        // Note: you might be tempted to create the player instance and call startForeground here,
-        // but be aware that the Android system might start the service just to perform media
-        // queries. In those cases creating a player instance is a waste of resources, and calling
-        // startForeground means creating a useless empty notification. In case it's really needed
-        // the player instance can be created here, but startForeground() should definitely not be
-        // called here unless the service is actually starting in the foreground, to avoid the
-        // useless notification.
-    }
-
-    override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int {
-        if (DEBUG) {
-            Log.d(
-                TAG,
-                "onStartCommand() called with: intent = [$intent], extras = [${
-                    intent.extras.toDebugString()}], flags = [$flags], startId = [$startId]"
-            )
-        }
-
-        // All internal NewPipe intents used to interact with the player, that are sent to the
-        // PlayerService using startForegroundService(), will have SHOULD_START_FOREGROUND_EXTRA,
-        // to ensure startForeground() is called (otherwise Android will force-crash the app).
-        if (intent.getBooleanExtra(SHOULD_START_FOREGROUND_EXTRA, false)) {
-            val playerWasNull = (player == null)
-            if (playerWasNull) {
-                // make sure the player exists, in case the service was resumed
-                player = Player(this, mediaSession, sessionConnector)
-            }
-
-            // Be sure that the player notification is set and the service is started in foreground,
-            // otherwise, the app may crash on Android 8+ as the service would never be put in the
-            // foreground while we said to the system we would do so. The service is always
-            // requested to be started in foreground, so always creating a notification if there is
-            // no one already and starting the service in foreground should not create any issues.
-            // If the service is already started in foreground, requesting it to be started
-            // shouldn't do anything.
-            player?.UIs()?.get(NotificationPlayerUi::class)?.createNotificationAndStartForeground()
-
-            if (playerWasNull) {
-                // notify that a new player was created (but do it after creating the foreground
-                // notification just to make sure we don't incur, due to slowness, in
-                // "Context.startForegroundService() did not then call Service.startForeground()")
-                onPlayerStartedOrStopped?.invoke(player)
-            }
-        }
-
-        if (player == null) {
-            // No need to process media button's actions or other system intents if the player is
-            // not running. However, since the current intent might have been issued by the system
-            // with `startForegroundService()` (for unknown reasons), we need to ensure that we post
-            // a (dummy) foreground notification, otherwise we'd incur in
-            // "Context.startForegroundService() did not then call Service.startForeground()". Then
-            // we stop the service again.
-            Log.d(TAG, "onStartCommand() got a useless intent, closing the service")
-            NotificationUtil.startForegroundWithDummyNotification(this)
-            return START_NOT_STICKY
-        }
-
-        val oldPlayerType = player?.playerType
-        player?.handleIntent(intent)
-        player?.handleIntentPost(oldPlayerType)
-        player?.UIs()?.get(MediaSessionPlayerUi::class.java)
-            ?.handleMediaButtonIntent(intent)
-
-        return START_NOT_STICKY
-    }
-
-    fun stopForImmediateReusing() {
-        if (DEBUG) {
-            Log.d(TAG, "stopForImmediateReusing() called")
-        }
-
-        val p = player
-        if (p != null && !p.exoPlayerIsNull()) {
-            // Releases wifi & cpu, disables keepScreenOn, etc.
-            // We can't just pause the player here because it will make transition
-            // from one stream to a new stream not smooth
-            p.smoothStopForImmediateReusing()
-        }
-    }
-
-    override fun onTaskRemoved(rootIntent: Intent?) {
-        super.onTaskRemoved(rootIntent)
-        val p = player
-        if (p != null && !p.videoPlayerSelected()) {
-            return
-        }
-        onDestroy()
-        // Unload from memory completely
-        Runtime.getRuntime().halt(0)
-    }
-
-    override fun onDestroy() {
-        if (DEBUG) {
-            Log.d(TAG, "destroy() called")
-        }
-        super.onDestroy()
-
-        cleanup()
-
-        mediaBrowserPlaybackPreparer.dispose()
-        mediaSession.release()
-        mediaBrowserImpl.dispose()
-    }
-
-    private fun cleanup() {
-        val p = player
-        if (p != null) {
-            // notify that the player is being destroyed
-            onPlayerStartedOrStopped?.invoke(null)
-            p.saveAndShutdown()
-            player = null
-        }
-
-        // Should already be handled by MediaSessionPlayerUi, but just to be sure.
-        mediaSession.setActive(false)
-
-        // Should already be handled by NotificationUtil.cancelNotificationAndStopForeground() in
-        // NotificationPlayerUi, but let's make sure that the foreground service is stopped.
-        ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
-    }
-
-    /**
-     * Destroys the player and allows the player instance to be garbage collected. Sets the media
-     * session to inactive. Stops the foreground service and removes the player notification
-     * associated with it. Tries to stop the [PlayerService] completely, but this step will
-     * have no effect in case some service connection still uses the service (e.g. the Android Auto
-     * system accesses the media browser even when no player is running).
-     */
-    fun destroyPlayerAndStopService() {
-        if (DEBUG) {
-            Log.d(TAG, "destroyPlayerAndStopService() called")
-        }
-
-        cleanup()
-
-        // This only really stops the service if there are no other service connections (see docs):
-        // for example the (Android Auto) media browser binder will block stopService().
-        // This is why we also stopForeground() above, to make sure the notification is removed.
-        // If we were to call stopSelf(), then the service would be surely stopped (regardless of
-        // other service connections), but this would be a waste of resources since the service
-        // would be immediately restarted by those same connections to perform the queries.
-        stopService(Intent(this, PlayerService::class.java))
-    }
-
-    override fun attachBaseContext(base: Context?) {
-        super.attachBaseContext(AudioServiceLeakFix.preventLeakOf(base))
-    }
-
-    //endregion
-    //region Bind
-    override fun onBind(intent: Intent): IBinder? {
-        if (DEBUG) {
-            Log.d(
-                TAG,
-                "onBind() called with: intent = [$intent], extras = [${
-                    intent.extras.toDebugString()}]"
-            )
-        }
-
-        return if (BIND_PLAYER_HOLDER_ACTION == intent.action) {
-            // Note that this binder might be reused multiple times while the service is alive, even
-            // after unbind() has been called: https://stackoverflow.com/a/8794930 .
-            mBinder
-        } else if (SERVICE_INTERFACE == intent.action) {
-            // MediaBrowserService also uses its own binder, so for actions related to the media
-            // browser service, pass the onBind to the superclass.
-            super.onBind(intent)
-        } else {
-            // This is an unknown request, avoid returning any binder to not leak objects.
-            null
-        }
-    }
-
-    class LocalBinder internal constructor(playerService: PlayerService) : Binder() {
-        private val playerService = WeakReference(playerService)
-
-        val service: PlayerService?
-            get() = playerService.get()
-    }
-
-    /**
-     * Sets the listener that will be called when the player is started or stopped. If a
-     * `null` listener is passed, then the current listener will be unset. The parameter taken
-     * by the [Consumer] can be null to indicate that the player is stopping.
-     * @param listener the listener to set or unset
-     */
-    fun setPlayerListener(listener: ((player: Player?) -> Unit)?) {
-        this.onPlayerStartedOrStopped = listener
-        listener?.invoke(player)
-    }
-
-    //endregion
-    //region Media browser
-    override fun onGetRoot(
-        clientPackageName: String,
-        clientUid: Int,
-        rootHints: Bundle?
-    ): BrowserRoot? {
-        // TODO check if the accessing package has permission to view data
-        return mediaBrowserImpl.onGetRoot(clientPackageName, clientUid, rootHints)
-    }
-
-    override fun onLoadChildren(
-        parentId: String,
-        result: Result<List<MediaBrowserCompat.MediaItem>>
-    ) {
-        mediaBrowserImpl.onLoadChildren(parentId, result)
-    }
-
-    override fun onSearch(
-        query: String,
-        extras: Bundle?,
-        result: Result<List<MediaBrowserCompat.MediaItem>>
-    ) {
-        mediaBrowserImpl.onSearch(query, result)
-    } //endregion
-
-    companion object {
-        private val TAG: String = PlayerService::class.java.getSimpleName()
-        private val DEBUG = Player.DEBUG
-
-        const val SHOULD_START_FOREGROUND_EXTRA: String = "should_start_foreground_extra"
-        const val BIND_PLAYER_HOLDER_ACTION: String = "bind_player_holder_action"
-    }
-}

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

@@ -5,7 +5,6 @@ import com.google.android.exoplayer2.PlaybackParameters;
 import org.schabi.newpipe.extractor.stream.StreamInfo;
 import org.schabi.newpipe.player.playqueue.PlayQueue;
 
-/** Player-specific events like queue or progress updates. */
 public interface PlayerEventListener {
     void onQueueUpdate(PlayQueue queue);
     void onPlaybackUpdate(int state, int repeatMode, boolean shuffled,

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

@@ -2,15 +2,12 @@ package org.schabi.newpipe.player.event;
 
 import com.google.android.exoplayer2.PlaybackException;
 
-/** {@link org.schabi.newpipe.player.event.PlayerEventListener} that also gets called for
- * application-specific events like screen rotation or UI changes.
- */
 public interface PlayerServiceEventListener extends PlayerEventListener {
     void onViewCreated();
 
     void onFullscreenStateChanged(boolean fullscreen);
 
-    void onFullscreenToggleButtonClicked();
+    void onScreenRotationButtonClicked();
 
     void onMoreOptionsLongClicked();
 

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

@@ -0,0 +1,372 @@
+package org.schabi.newpipe.player.helper;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.IBinder;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+import androidx.core.content.ContextCompat;
+
+import com.google.android.exoplayer2.PlaybackException;
+import com.google.android.exoplayer2.PlaybackParameters;
+
+import org.schabi.newpipe.App;
+import org.schabi.newpipe.MainActivity;
+import org.schabi.newpipe.extractor.stream.StreamInfo;
+import org.schabi.newpipe.player.PlayerService;
+import org.schabi.newpipe.player.Player;
+import org.schabi.newpipe.player.PlayerType;
+import org.schabi.newpipe.player.event.PlayerServiceEventListener;
+import org.schabi.newpipe.player.event.PlayerServiceExtendedEventListener;
+import org.schabi.newpipe.player.playqueue.PlayQueue;
+import org.schabi.newpipe.util.NavigationHelper;
+
+import java.util.Optional;
+import java.util.function.Consumer;
+
+public final class PlayerHolder {
+
+    private PlayerHolder() {
+    }
+
+    private static PlayerHolder instance;
+    public static synchronized PlayerHolder getInstance() {
+        if (PlayerHolder.instance == null) {
+            PlayerHolder.instance = new PlayerHolder();
+        }
+        return PlayerHolder.instance;
+    }
+
+    private static final boolean DEBUG = MainActivity.DEBUG;
+    private static final String TAG = PlayerHolder.class.getSimpleName();
+
+    @Nullable private PlayerServiceExtendedEventListener listener;
+
+    private final PlayerServiceConnection serviceConnection = new PlayerServiceConnection();
+    private boolean bound;
+    @Nullable private PlayerService playerService;
+
+    private Optional<Player> getPlayer() {
+        return Optional.ofNullable(playerService)
+                .flatMap(s -> Optional.ofNullable(s.getPlayer()));
+    }
+
+    private Optional<PlayQueue> getPlayQueue() {
+        // player play queue might be null e.g. while player is starting
+        return getPlayer().flatMap(p -> Optional.ofNullable(p.getPlayQueue()));
+    }
+
+    /**
+     * Returns the current {@link PlayerType} of the {@link PlayerService} service,
+     * otherwise `null` if no service is running.
+     *
+     * @return Current PlayerType
+     */
+    @Nullable
+    public PlayerType getType() {
+        return getPlayer().map(Player::getPlayerType).orElse(null);
+    }
+
+    public boolean isPlaying() {
+        return getPlayer().map(Player::isPlaying).orElse(false);
+    }
+
+    public boolean isPlayerOpen() {
+        return getPlayer().isPresent();
+    }
+
+    /**
+     * Use this method to only allow the user to manipulate the play queue (e.g. by enqueueing via
+     * the stream long press menu) when there actually is a play queue to manipulate.
+     * @return true only if the player is open and its play queue is ready (i.e. it is not null)
+     */
+    public boolean isPlayQueueReady() {
+        return getPlayQueue().isPresent();
+    }
+
+    public boolean isBound() {
+        return bound;
+    }
+
+    public int getQueueSize() {
+        return getPlayQueue().map(PlayQueue::size).orElse(0);
+    }
+
+    public int getQueuePosition() {
+        return getPlayQueue().map(PlayQueue::getIndex).orElse(0);
+    }
+
+    public void setListener(@Nullable final PlayerServiceExtendedEventListener newListener) {
+        listener = newListener;
+
+        if (listener == null) {
+            return;
+        }
+
+        // Force reload data from service
+        if (playerService != null) {
+            listener.onServiceConnected(playerService);
+            startPlayerListener();
+            // ^ will call listener.onPlayerConnected() down the line if there is an active player
+        }
+    }
+
+    // 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 void startService(final boolean playAfterConnect,
+                             final PlayerServiceExtendedEventListener newListener) {
+        if (DEBUG) {
+            Log.d(TAG, "startService() called with playAfterConnect=" + playAfterConnect);
+        }
+        final Context context = getCommonContext();
+        setListener(newListener);
+        if (bound) {
+            return;
+        }
+        // startService() can be called concurrently and it will give a random crashes
+        // and NullPointerExceptions inside the service because the service will be
+        // bound twice. Prevent it with unbinding first
+        unbind(context);
+        final Intent intent = new Intent(context, PlayerService.class);
+        intent.putExtra(PlayerService.SHOULD_START_FOREGROUND_EXTRA, true);
+        ContextCompat.startForegroundService(context, intent);
+        serviceConnection.doPlayAfterConnect(playAfterConnect);
+        bind(context);
+    }
+
+    public void stopService() {
+        if (DEBUG) {
+            Log.d(TAG, "stopService() called");
+        }
+        if (playerService != null) {
+            playerService.destroyPlayerAndStopService();
+        }
+        final Context context = getCommonContext();
+        unbind(context);
+        // destroyPlayerAndStopService() already runs the next line of code, but run it again just
+        // to make sure to stop the service even if playerService is null by any chance.
+        context.stopService(new Intent(context, PlayerService.class));
+    }
+
+    class PlayerServiceConnection implements ServiceConnection {
+
+        private boolean playAfterConnect = false;
+
+        /**
+         * @param playAfterConnection Sets the value of `playAfterConnect` to pass to the {@link
+         * PlayerServiceExtendedEventListener#onPlayerConnected(Player, boolean)} the next time it
+         * is called. The value of `playAfterConnect` will be reset to false after that.
+         */
+        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");
+            }
+
+            final Context context = getCommonContext();
+            unbind(context);
+        }
+
+        @Override
+        public void onServiceConnected(final ComponentName compName, final IBinder service) {
+            if (DEBUG) {
+                Log.d(TAG, "Player service is connected");
+            }
+            final PlayerService.LocalBinder localBinder = (PlayerService.LocalBinder) service;
+
+            playerService = localBinder.getService();
+            if (listener != null) {
+                listener.onServiceConnected(playerService);
+            }
+            startPlayerListener();
+            // ^ will call listener.onPlayerConnected() down the line if there is an active player
+
+            if (playerService != null && playerService.getPlayer() != null) {
+                // notify the main activity that binding the service has completed and that there is
+                // a player, so that it can open the bottom mini-player
+                NavigationHelper.sendPlayerStartedEvent(localBinder.getService());
+            }
+        }
+    }
+
+    private void bind(final Context context) {
+        if (DEBUG) {
+            Log.d(TAG, "bind() called");
+        }
+        // BIND_AUTO_CREATE starts the service if it's not already running
+        bound = bind(context, Context.BIND_AUTO_CREATE);
+        if (!bound) {
+            context.unbindService(serviceConnection);
+        }
+    }
+
+    public void tryBindIfNeeded(final Context context) {
+        if (!bound) {
+            // flags=0 means the service will not be started if it does not already exist. In this
+            // case the return value is not useful, as a value of "true" does not really indicate
+            // that the service is going to be bound.
+            bind(context, 0);
+        }
+    }
+
+    private boolean bind(final Context context, final int flags) {
+        final Intent serviceIntent = new Intent(context, PlayerService.class);
+        serviceIntent.setAction(PlayerService.BIND_PLAYER_HOLDER_ACTION);
+        return context.bindService(serviceIntent, serviceConnection, flags);
+    }
+
+    private void unbind(final Context context) {
+        if (DEBUG) {
+            Log.d(TAG, "unbind() called");
+        }
+
+        if (bound) {
+            context.unbindService(serviceConnection);
+            bound = false;
+            stopPlayerListener();
+            playerService = null;
+            if (listener != null) {
+                listener.onPlayerDisconnected();
+                listener.onServiceDisconnected();
+            }
+        }
+    }
+
+    private void startPlayerListener() {
+        if (playerService != null) {
+            // setting the player listener will take care of calling relevant callbacks if the
+            // player in the service is (not) already active, also see playerStateListener below
+            playerService.setPlayerListener(playerStateListener);
+        }
+        getPlayer().ifPresent(p -> p.setFragmentListener(internalListener));
+    }
+
+    private void stopPlayerListener() {
+        if (playerService != null) {
+            playerService.setPlayerListener(null);
+        }
+        getPlayer().ifPresent(p -> p.removeFragmentListener(internalListener));
+    }
+
+    /**
+     * This listener will be held by the players created by {@link PlayerService}.
+     */
+    private final PlayerServiceEventListener internalListener =
+            new PlayerServiceEventListener() {
+                @Override
+                public void onViewCreated() {
+                    if (listener != null) {
+                        listener.onViewCreated();
+                    }
+                }
+
+                @Override
+                public void onFullscreenStateChanged(final boolean fullscreen) {
+                    if (listener != null) {
+                        listener.onFullscreenStateChanged(fullscreen);
+                    }
+                }
+
+                @Override
+                public void onScreenRotationButtonClicked() {
+                    if (listener != null) {
+                        listener.onScreenRotationButtonClicked();
+                    }
+                }
+
+                @Override
+                public void onMoreOptionsLongClicked() {
+                    if (listener != null) {
+                        listener.onMoreOptionsLongClicked();
+                    }
+                }
+
+                @Override
+                public void onPlayerError(final PlaybackException error,
+                                          final boolean isCatchableException) {
+                    if (listener != null) {
+                        listener.onPlayerError(error, isCatchableException);
+                    }
+                }
+
+                @Override
+                public void hideSystemUiIfNeeded() {
+                    if (listener != null) {
+                        listener.hideSystemUiIfNeeded();
+                    }
+                }
+
+                @Override
+                public void onQueueUpdate(final PlayQueue queue) {
+                    if (listener != null) {
+                        listener.onQueueUpdate(queue);
+                    }
+                }
+
+                @Override
+                public void onPlaybackUpdate(final int state,
+                                             final int repeatMode,
+                                             final boolean shuffled,
+                                             final PlaybackParameters parameters) {
+                    if (listener != null) {
+                        listener.onPlaybackUpdate(state, repeatMode, shuffled, parameters);
+                    }
+                }
+
+                @Override
+                public void onProgressUpdate(final int currentProgress,
+                                             final int duration,
+                                             final int bufferPercent) {
+                    if (listener != null) {
+                        listener.onProgressUpdate(currentProgress, duration, bufferPercent);
+                    }
+                }
+
+                @Override
+                public void onMetadataUpdate(final StreamInfo info, final PlayQueue queue) {
+                    if (listener != null) {
+                        listener.onMetadataUpdate(info, queue);
+                    }
+                }
+
+                @Override
+                public void onServiceStopped() {
+                    if (listener != null) {
+                        listener.onServiceStopped();
+                    }
+                    unbind(getCommonContext());
+                }
+            };
+
+    /**
+     * This listener will be held by bound {@link PlayerService}s to notify of the player starting
+     * or stopping. This is necessary since the service outlives the player e.g. to answer Android
+     * Auto media browser queries.
+     */
+    private final Consumer<Player> playerStateListener = (@Nullable final Player player) -> {
+        if (listener != null) {
+            if (player == null) {
+                // player.fragmentListener=null is already done by player.stopActivityBinding(),
+                // which is called by player.destroy(), which is in turn called by PlayerService
+                // before setting its player to null
+                listener.onPlayerDisconnected();
+            } else {
+                listener.onPlayerConnected(player, serviceConnection.playAfterConnect);
+                // reset the value of playAfterConnect: if it was true before, it is now "consumed"
+                serviceConnection.playAfterConnect = false;
+                player.setFragmentListener(internalListener);
+            }
+        }
+    };
+}

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

@@ -1,318 +0,0 @@
-package org.schabi.newpipe.player.helper
-
-import android.content.ComponentName
-import android.content.Context
-import android.content.Intent
-import android.content.ServiceConnection
-import android.os.IBinder
-import android.util.Log
-import androidx.core.content.ContextCompat
-import com.google.android.exoplayer2.PlaybackException
-import com.google.android.exoplayer2.PlaybackParameters
-import org.schabi.newpipe.App
-import org.schabi.newpipe.MainActivity
-import org.schabi.newpipe.extractor.stream.StreamInfo
-import org.schabi.newpipe.player.Player
-import org.schabi.newpipe.player.PlayerService
-import org.schabi.newpipe.player.PlayerService.LocalBinder
-import org.schabi.newpipe.player.PlayerType
-import org.schabi.newpipe.player.event.PlayerServiceEventListener
-import org.schabi.newpipe.player.event.PlayerServiceExtendedEventListener
-import org.schabi.newpipe.player.playqueue.PlayQueue
-import org.schabi.newpipe.util.NavigationHelper
-
-private val DEBUG = MainActivity.DEBUG
-private val TAG: String = PlayerHolder::class.java.getSimpleName()
-
-/**
- * Singleton that manages a `PlayerService`
- * and can be used to control the player instance through the service.
- */
-object PlayerHolder {
-    private var listener: PlayerServiceExtendedEventListener? = null
-
-    var isBound: Boolean = false
-        private set
-
-    private var playerService: PlayerService? = null
-
-    private val player: Player?
-        get() = playerService?.player
-
-    // player play queue might be null e.g. while player is starting
-    private val playQueue: PlayQueue?
-        get() = this.player?.playQueue
-
-    /**
-     * Returns the current [PlayerType] of the [PlayerService] service,
-     * otherwise `null` if no service is running.
-     *
-     * @return Current PlayerType
-     */
-    val type: PlayerType?
-        get() = this.player?.playerType
-
-    val isPlaying: Boolean
-        get() = this.player?.isPlaying == true
-
-    val isPlayerOpen: Boolean
-        get() = this.player != null
-
-    /**
-     * Use this method to only allow the user to manipulate the play queue (e.g. by enqueueing via
-     * the stream long press menu) when there actually is a play queue to manipulate.
-     * @return true only if the player is open and its play queue is ready (i.e. it is not null)
-     */
-    val isPlayQueueReady: Boolean
-        get() = this.playQueue != null
-
-    val queueSize: Int
-        get() = this.playQueue?.size() ?: 0
-
-    val queuePosition: Int
-        get() = this.playQueue?.index ?: 0
-
-    fun setListener(newListener: PlayerServiceExtendedEventListener?) {
-        listener = newListener
-
-        // Force reload data from service
-        newListener?.let { listener ->
-            playerService?.let { service ->
-                listener.onServiceConnected(service)
-                startPlayerListener()
-                // ^ will call listener.onPlayerConnected() down the line if there is an active player
-            }
-        }
-    }
-
-    private val commonContext: Context
-        // helper to handle context in common place as using the same
-        get() = App.instance
-
-    /**
-     * Connect to (and if needed start) the [PlayerService]
-     * and bind [PlayerServiceConnection] to it.
-     * If the service is already started, only set the listener.
-     * @param playAfterConnect If this holder’s service was already started,
-     * start playing immediately
-     * @param newListener set this listener
-     */
-    fun startService(
-        playAfterConnect: Boolean,
-        newListener: PlayerServiceExtendedEventListener?
-    ) {
-        if (DEBUG) {
-            Log.d(TAG, "startService() called with playAfterConnect=$playAfterConnect")
-        }
-        val context = this.commonContext
-        setListener(newListener)
-        if (this.isBound) {
-            return
-        }
-        // startService() can be called concurrently and it will give a random crashes
-        // and NullPointerExceptions inside the service because the service will be
-        // bound twice. Prevent it with unbinding first
-        unbind(context)
-        val intent = Intent(context, PlayerService::class.java)
-        intent.putExtra(PlayerService.SHOULD_START_FOREGROUND_EXTRA, true)
-        ContextCompat.startForegroundService(context, intent)
-        PlayerServiceConnection.doPlayAfterConnect(playAfterConnect)
-        bind(context)
-    }
-
-    fun stopService() {
-        if (DEBUG) {
-            Log.d(TAG, "stopService() called")
-        }
-        playerService?.destroyPlayerAndStopService()
-        val context = this.commonContext
-        unbind(context)
-        // destroyPlayerAndStopService() already runs the next line of code, but run it again just
-        // to make sure to stop the service even if playerService is null by any chance.
-        context.stopService(Intent(context, PlayerService::class.java))
-    }
-
-    internal object PlayerServiceConnection : ServiceConnection {
-        internal var playAfterConnect = false
-
-        /**
-         * @param playAfterConnection Sets the value of [playAfterConnect] to pass to the
-         * [PlayerServiceExtendedEventListener.onPlayerConnected] the next time it
-         * is called. The value of [playAfterConnect] will be reset to false after that.
-         */
-        fun doPlayAfterConnect(playAfterConnection: Boolean) {
-            this.playAfterConnect = playAfterConnection
-        }
-
-        override fun onServiceDisconnected(compName: ComponentName?) {
-            if (DEBUG) {
-                Log.d(TAG, "Player service is disconnected")
-            }
-
-            val context: Context = this@PlayerHolder.commonContext
-            unbind(context)
-        }
-
-        override fun onServiceConnected(compName: ComponentName?, service: IBinder?) {
-            if (DEBUG) {
-                Log.d(TAG, "Player service is connected")
-            }
-            val localBinder = service as LocalBinder
-
-            val s = localBinder.service
-            requireNotNull(s) {
-                "PlayerService.LocalBinder.getService() must never be" +
-                    "null after the service connects"
-            }
-            playerService = s
-            listener?.let { l ->
-                l.onServiceConnected(s)
-                player?.let { l.onPlayerConnected(it, playAfterConnect) }
-            }
-            startPlayerListener()
-            // ^ will call listener.onPlayerConnected() down the line if there is an active player
-
-            if (playerService != null && playerService?.player != null) {
-                // notify the main activity that binding the service has completed and that there is
-                // a player, so that it can open the bottom mini-player
-                NavigationHelper.sendPlayerStartedEvent(localBinder.service)
-            }
-        }
-    }
-
-    private fun bind(context: Context) {
-        if (DEBUG) {
-            Log.d(TAG, "bind() called")
-        }
-        // BIND_AUTO_CREATE starts the service if it's not already running
-        this.isBound = bind(context, Context.BIND_AUTO_CREATE)
-        if (!this.isBound) {
-            context.unbindService(PlayerServiceConnection)
-        }
-    }
-
-    fun tryBindIfNeeded(context: Context) {
-        if (!this.isBound) {
-            // flags=0 means the service will not be started if it does not already exist. In this
-            // case the return value is not useful, as a value of "true" does not really indicate
-            // that the service is going to be bound.
-            bind(context, 0)
-        }
-    }
-
-    private fun bind(context: Context, flags: Int): Boolean {
-        val serviceIntent = Intent(context, PlayerService::class.java)
-        serviceIntent.setAction(PlayerService.BIND_PLAYER_HOLDER_ACTION)
-        return context.bindService(serviceIntent, PlayerServiceConnection, flags)
-    }
-
-    private fun unbind(context: Context) {
-        if (DEBUG) {
-            Log.d(TAG, "unbind() called")
-        }
-
-        if (this.isBound) {
-            context.unbindService(PlayerServiceConnection)
-            this.isBound = false
-            stopPlayerListener()
-            playerService = null
-            listener?.onPlayerDisconnected()
-            listener?.onServiceDisconnected()
-        }
-    }
-
-    private fun startPlayerListener() {
-        // setting the player listener will take care of calling relevant callbacks if the
-        // player in the service is (not) already active, also see playerStateListener below
-        playerService?.setPlayerListener(playerStateListener)
-        this.player?.setFragmentListener(HolderPlayerServiceEventListener)
-    }
-
-    private fun stopPlayerListener() {
-        playerService?.setPlayerListener(null)
-        this.player?.removeFragmentListener(HolderPlayerServiceEventListener)
-    }
-
-    /**
-     * This listener will be held by the players created by [PlayerService].
-     */
-    private object HolderPlayerServiceEventListener : PlayerServiceEventListener {
-        override fun onViewCreated() {
-            listener?.onViewCreated()
-        }
-
-        override fun onFullscreenStateChanged(fullscreen: Boolean) {
-            listener?.onFullscreenStateChanged(fullscreen)
-        }
-
-        override fun onFullscreenToggleButtonClicked() {
-            listener?.onFullscreenToggleButtonClicked()
-        }
-
-        override fun onMoreOptionsLongClicked() {
-            listener?.onMoreOptionsLongClicked()
-        }
-
-        override fun onPlayerError(
-            error: PlaybackException?,
-            isCatchableException: Boolean
-        ) {
-            listener?.onPlayerError(error, isCatchableException)
-        }
-
-        override fun hideSystemUiIfNeeded() {
-            listener?.hideSystemUiIfNeeded()
-        }
-
-        override fun onQueueUpdate(queue: PlayQueue?) {
-            listener?.onQueueUpdate(queue)
-        }
-
-        override fun onPlaybackUpdate(
-            state: Int,
-            repeatMode: Int,
-            shuffled: Boolean,
-            parameters: PlaybackParameters?
-        ) {
-            listener?.onPlaybackUpdate(state, repeatMode, shuffled, parameters)
-        }
-
-        override fun onProgressUpdate(
-            currentProgress: Int,
-            duration: Int,
-            bufferPercent: Int
-        ) {
-            listener?.onProgressUpdate(currentProgress, duration, bufferPercent)
-        }
-
-        override fun onMetadataUpdate(info: StreamInfo?, queue: PlayQueue?) {
-            listener?.onMetadataUpdate(info, queue)
-        }
-
-        override fun onServiceStopped() {
-            listener?.onServiceStopped()
-            unbind(this@PlayerHolder.commonContext)
-        }
-    }
-
-    /**
-     * This listener will be held by bound [PlayerService]s to notify of the player starting
-     * or stopping. This is necessary since the service outlives the player e.g. to answer Android
-     * Auto media browser queries.
-     */
-    private val playerStateListener: (Player?) -> Unit = { player: Player? ->
-        listener?.let { l ->
-            if (player == null) {
-                // player.fragmentListener=null is already done by player.stopActivityBinding(),
-                // which is called by player.destroy(), which is in turn called by PlayerService
-                // before setting its player to null
-                l.onPlayerDisconnected()
-            } else {
-                l.onPlayerConnected(player, PlayerServiceConnection.playAfterConnect)
-                // reset the value of playAfterConnect: if it was true before, it is now "consumed"
-                PlayerServiceConnection.playAfterConnect = false
-                player.setFragmentListener(HolderPlayerServiceEventListener)
-            }
-        }
-    }
-}

app/src/main/java/org/schabi/newpipe/player/mediabrowser/MediaBrowserImpl.kt

@@ -9,7 +9,6 @@ import android.support.v4.media.MediaDescriptionCompat
 import android.util.Log
 import androidx.annotation.DrawableRes
 import androidx.core.net.toUri
-import androidx.core.os.bundleOf
 import androidx.media.MediaBrowserServiceCompat
 import androidx.media.MediaBrowserServiceCompat.BrowserRoot.EXTRA_RECENT
 import androidx.media.MediaBrowserServiceCompat.Result
@@ -18,6 +17,7 @@ import io.reactivex.rxjava3.core.Flowable
 import io.reactivex.rxjava3.core.Single
 import io.reactivex.rxjava3.disposables.CompositeDisposable
 import io.reactivex.rxjava3.schedulers.Schedulers
+import java.util.function.Consumer
 import org.schabi.newpipe.MainActivity.DEBUG
 import org.schabi.newpipe.NewPipeDatabase
 import org.schabi.newpipe.R
@@ -47,7 +47,8 @@ import org.schabi.newpipe.util.image.ImageStrategy
  */
 class MediaBrowserImpl(
     private val context: Context,
-    notifyChildrenChanged: (parentId: String) -> Unit
+    // parentId
+    notifyChildrenChanged: Consumer<String>
 ) {
     private val packageValidator = PackageValidator(context)
     private val database = NewPipeDatabase.getInstance(context)
@@ -55,7 +56,9 @@ class MediaBrowserImpl(
 
     init {
         // this will listen to changes in the bookmarks until this MediaBrowserImpl is dispose()d
-        disposables.add(getMergedPlaylists().subscribe { notifyChildrenChanged(ID_BOOKMARKS) })
+        disposables.add(
+            getMergedPlaylists().subscribe { notifyChildrenChanged.accept(ID_BOOKMARKS) }
+        )
     }
 
     //region Cleanup
@@ -195,16 +198,17 @@ class MediaBrowserImpl(
 
     private fun createPlaylistMediaItem(playlist: PlaylistLocalItem): MediaBrowserCompat.MediaItem {
         val builder = MediaDescriptionCompat.Builder()
+        builder
             .setMediaId(createMediaIdForInfoItem(playlist is PlaylistRemoteEntity, playlist.uid))
             .setTitle(playlist.orderingName)
             .setIconUri(imageUriOrNullIfDisabled(playlist.thumbnailUrl))
-            .setExtras(
-                bundleOf(
-                    MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_GROUP_TITLE
-                        to context.resources.getString(R.string.tab_bookmarks)
-                )
-            )
 
+        val extras = Bundle()
+        extras.putString(
+            MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_GROUP_TITLE,
+            context.resources.getString(R.string.tab_bookmarks)
+        )
+        builder.setExtras(extras)
         return MediaBrowserCompat.MediaItem(
             builder.build(),
             MediaBrowserCompat.MediaItem.FLAG_BROWSABLE
@@ -213,9 +217,8 @@ class MediaBrowserImpl(
 
     private fun createInfoItemMediaItem(item: InfoItem): MediaBrowserCompat.MediaItem? {
         val builder = MediaDescriptionCompat.Builder()
-            .setMediaId(createMediaIdForInfoItem(item))
+        builder.setMediaId(createMediaIdForInfoItem(item))
             .setTitle(item.name)
-            .setIconUri(ImageStrategy.choosePreferredImage(item.thumbnails)?.toUri())
 
         when (item.infoType) {
             InfoType.STREAM -> builder.setSubtitle((item as StreamInfoItem).uploaderName)
@@ -224,6 +227,10 @@ class MediaBrowserImpl(
             else -> return null
         }
 
+        ImageStrategy.choosePreferredImage(item.thumbnails)?.let {
+            builder.setIconUri(imageUriOrNullIfDisabled(it))
+        }
+
         return MediaBrowserCompat.MediaItem(
             builder.build(),
             MediaBrowserCompat.MediaItem.FLAG_PLAYABLE
@@ -264,7 +271,7 @@ class MediaBrowserImpl(
         index: Int
     ): MediaBrowserCompat.MediaItem {
         val builder = MediaDescriptionCompat.Builder()
-            .setMediaId(createMediaIdForPlaylistIndex(false, playlistId, index))
+        builder.setMediaId(createMediaIdForPlaylistIndex(false, playlistId, index))
             .setTitle(item.streamEntity.title)
             .setSubtitle(item.streamEntity.uploader)
             .setIconUri(imageUriOrNullIfDisabled(item.streamEntity.thumbnailUrl))
@@ -284,7 +291,10 @@ class MediaBrowserImpl(
         builder.setMediaId(createMediaIdForPlaylistIndex(true, playlistId, index))
             .setTitle(item.name)
             .setSubtitle(item.uploaderName)
-            .setIconUri(ImageStrategy.choosePreferredImage(item.thumbnails)?.toUri())
+
+        ImageStrategy.choosePreferredImage(item.thumbnails)?.let {
+            builder.setIconUri(imageUriOrNullIfDisabled(it))
+        }
 
         return MediaBrowserCompat.MediaItem(
             builder.build(),

app/src/main/java/org/schabi/newpipe/player/mediabrowser/MediaBrowserPlaybackPreparer.kt

@@ -6,6 +6,7 @@ import android.os.Bundle
 import android.os.ResultReceiver
 import android.support.v4.media.session.PlaybackStateCompat
 import android.util.Log
+import androidx.core.content.ContextCompat
 import androidx.core.net.toUri
 import com.google.android.exoplayer2.Player
 import com.google.android.exoplayer2.ext.mediasession.MediaSessionConnector.PlaybackPreparer
@@ -30,7 +31,6 @@ import org.schabi.newpipe.player.playqueue.PlaylistPlayQueue
 import org.schabi.newpipe.player.playqueue.SinglePlayQueue
 import org.schabi.newpipe.util.ChannelTabHelper
 import org.schabi.newpipe.util.ExtractorHelper
-import org.schabi.newpipe.util.Localization
 import org.schabi.newpipe.util.NavigationHelper
 
 /**
@@ -111,7 +111,7 @@ class MediaBrowserPlaybackPreparer(
     //region Errors
     private fun onUnsupportedError() {
         setMediaSessionError.accept(
-            Localization.compatGetString(context, R.string.content_not_supported),
+            ContextCompat.getString(context, R.string.content_not_supported),
             PlaybackStateCompat.ERROR_CODE_NOT_SUPPORTED
         )
     }