Rewrite PoToken functionality using coroutines

Author: Isira-Seneviratne

app/src/main/java/org/schabi/newpipe/util/potoken/PoTokenGenerator.kt

@@ -1,7 +1,6 @@
 package org.schabi.newpipe.util.potoken
 
 import android.content.Context
-import io.reactivex.rxjava3.core.Single
 import java.io.Closeable
 
 /**
@@ -14,13 +13,13 @@ interface PoTokenGenerator : Closeable {
      * `webPoSignalOutput` previously obtained in the initialization of [PoTokenWebView]. Can be
      * called multiple times.
      */
-    fun generatePoToken(identifier: String): Single<String>
+    suspend fun generatePoToken(identifier: String): String
 
     /**
      * @return whether the `integrityToken` is expired, in which case all tokens generated by
      * [generatePoToken] will be invalid
      */
-    fun isExpired(): Boolean
+    val isExpired: Boolean
 
     interface Factory {
         /**
@@ -30,6 +29,6 @@ interface PoTokenGenerator : Closeable {
          *
          * @param context used e.g. to load the HTML asset or to instantiate a WebView
          */
-        fun newPoTokenGenerator(context: Context): Single<PoTokenGenerator>
+        suspend fun getNewPoTokenGenerator(context: Context): PoTokenGenerator
     }
 }

app/src/main/java/org/schabi/newpipe/util/potoken/PoTokenProviderImpl.kt

@@ -1,8 +1,11 @@
 package org.schabi.newpipe.util.potoken
 
-import android.os.Handler
-import android.os.Looper
 import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
 import org.schabi.newpipe.App
 import org.schabi.newpipe.BuildConfig
 import org.schabi.newpipe.extractor.NewPipe
@@ -17,7 +20,7 @@ object PoTokenProviderImpl : PoTokenProvider {
     private val webViewSupported by lazy { DeviceUtils.supportsWebView() }
     private var webViewBadImpl = false // whether the system has a bad WebView implementation
 
-    private object WebPoTokenGenLock
+    private val webPoTokenGenLock = Mutex()
     private var webPoTokenVisitorData: String? = null
     private var webPoTokenStreamingPot: String? = null
     private var webPoTokenGenerator: PoTokenGenerator? = null
@@ -27,18 +30,16 @@ object PoTokenProviderImpl : PoTokenProvider {
             return null
         }
 
-        try {
-            return getWebClientPoToken(videoId = videoId, forceRecreate = false)
-        } catch (e: RuntimeException) {
-            // RxJava's Single wraps exceptions into RuntimeErrors, so we need to unwrap them here
-            when (val cause = e.cause) {
+        return try {
+            runBlocking { getWebClientPoToken(videoId, forceRecreate = false) }
+        } catch (e: Exception) {
+            when (e) {
                 is BadWebViewException -> {
                     Log.e(TAG, "Could not obtain poToken because WebView is broken", e)
                     webViewBadImpl = true
-                    return null
+                    null
                 }
-                null -> throw e
-                else -> throw cause // includes PoTokenException
+                else -> throw e // includes PoTokenException
             }
         }
     }
@@ -48,56 +49,52 @@ object PoTokenProviderImpl : PoTokenProvider {
      * case the current [webPoTokenGenerator] threw an error last time
      * [PoTokenGenerator.generatePoToken] was called
      */
-    private fun getWebClientPoToken(videoId: String, forceRecreate: Boolean): PoTokenResult {
+    private suspend fun getWebClientPoToken(videoId: String, forceRecreate: Boolean): PoTokenResult {
         // just a helper class since Kotlin does not have builtin support for 4-tuples
         data class Quadruple<T1, T2, T3, T4>(val t1: T1, val t2: T2, val t3: T3, val t4: T4)
 
         val (poTokenGenerator, visitorData, streamingPot, hasBeenRecreated) =
-            synchronized(WebPoTokenGenLock) {
-                val shouldRecreate = webPoTokenGenerator == null || forceRecreate ||
-                    webPoTokenGenerator!!.isExpired()
+            webPoTokenGenLock.withLock {
+                val gen = webPoTokenGenerator
+                val shouldRecreate = forceRecreate || gen == null || gen.isExpired
 
                 if (shouldRecreate) {
-
-                    val innertubeClientRequestInfo = InnertubeClientRequestInfo.ofWebClient()
-                    innertubeClientRequestInfo.clientInfo.clientVersion =
-                        YoutubeParsingHelper.getClientVersion()
-
-                    webPoTokenVisitorData = YoutubeParsingHelper.getVisitorDataFromInnertube(
-                        innertubeClientRequestInfo,
-                        NewPipe.getPreferredLocalization(),
-                        NewPipe.getPreferredContentCountry(),
-                        YoutubeParsingHelper.getYouTubeHeaders(),
-                        YoutubeParsingHelper.YOUTUBEI_V1_URL,
-                        null,
-                        false
-                    )
-                    // close the current webPoTokenGenerator on the main thread
-                    webPoTokenGenerator?.let { Handler(Looper.getMainLooper()).post { it.close() } }
+                    webPoTokenVisitorData = withContext(Dispatchers.IO) {
+                        val innertubeClientRequestInfo = InnertubeClientRequestInfo.ofWebClient()
+                        innertubeClientRequestInfo.clientInfo.clientVersion =
+                            YoutubeParsingHelper.getClientVersion()
+
+                        YoutubeParsingHelper.getVisitorDataFromInnertube(
+                            innertubeClientRequestInfo,
+                            NewPipe.getPreferredLocalization(),
+                            NewPipe.getPreferredContentCountry(),
+                            YoutubeParsingHelper.getYouTubeHeaders(),
+                            YoutubeParsingHelper.YOUTUBEI_V1_URL,
+                            null,
+                            false
+                        )
+                    }
+
+                    withContext(Dispatchers.Main) {
+                        webPoTokenGenerator?.close()
+                    }
 
                     // create a new webPoTokenGenerator
-                    webPoTokenGenerator = PoTokenWebView
-                        .newPoTokenGenerator(App.instance).blockingGet()
+                    webPoTokenGenerator = PoTokenWebView.getNewPoTokenGenerator(App.instance)
 
                     // The streaming poToken needs to be generated exactly once before generating
                     // any other (player) tokens.
-                    webPoTokenStreamingPot = webPoTokenGenerator!!
-                        .generatePoToken(webPoTokenVisitorData!!).blockingGet()
+                    webPoTokenStreamingPot = webPoTokenGenerator!!.generatePoToken(webPoTokenVisitorData!!)
                 }
 
-                return@synchronized Quadruple(
-                    webPoTokenGenerator!!,
-                    webPoTokenVisitorData!!,
-                    webPoTokenStreamingPot!!,
-                    shouldRecreate
-                )
+                Quadruple(webPoTokenGenerator!!, webPoTokenVisitorData!!, webPoTokenStreamingPot!!, shouldRecreate)
             }
 
         val playerPot = try {
             // Not using synchronized here, since poTokenGenerator would be able to generate
             // multiple poTokens in parallel if needed. The only important thing is for exactly one
             // visitorData/streaming poToken to be generated before anything else.
-            poTokenGenerator.generatePoToken(videoId).blockingGet()
+            poTokenGenerator.generatePoToken(videoId)
         } catch (throwable: Throwable) {
             if (hasBeenRecreated) {
                 // the poTokenGenerator has just been recreated (and possibly this is already the
@@ -108,7 +105,7 @@ object PoTokenProviderImpl : PoTokenProvider {
                 // this might happen for example if NewPipe goes in the background and the WebView
                 // content is lost
                 Log.e(TAG, "Failed to obtain poToken, retrying", throwable)
-                return getWebClientPoToken(videoId = videoId, forceRecreate = true)
+                return getWebClientPoToken(videoId, forceRecreate = true)
             }
         }