fix

Author: 0xrxL

extensions/shared/src/main/java/app/revanced/extension/shared/patches/spoof/requests/StreamingDataRequest.kt

@@ -84,7 +84,7 @@ class StreamingDataRequest private constructor(
 
     companion object {
         private const val AUTHORIZATION_HEADER = "Authorization"
-        private const val MAX_MILLISECONDS_TO_WAIT_FOR_FETCH = 20 * 1000
+        private const val MAX_MILLISECONDS_TO_WAIT_FOR_FETCH = 10 * 1000
 
         private val SPOOF_STREAMING_DATA_TYPE: YouTubeAppClient.ClientType =
             BaseSettings.SPOOF_STREAMING_DATA_TYPE.get()
@@ -97,11 +97,11 @@ class StreamingDataRequest private constructor(
 
         @GuardedBy("itself")
         val cache: MutableMap<String, StreamingDataRequest> = Collections.synchronizedMap(
-            object : LinkedHashMap<String, StreamingDataRequest>(100) {
-                private val CACHE_LIMIT = 50
+            object : LinkedHashMap<String, StreamingDataRequest>(1) {
+                private val CACHE_LIMIT = 10
 
                 override fun removeEldestEntry(eldest: Map.Entry<String, StreamingDataRequest>): Boolean {
-                    return size > CACHE_LIMIT // Evict the oldest entry if over the cache limit.
+                    return size >= CACHE_LIMIT // Evict the oldest entry if over the cache limit.
                 }
             })
 

extensions/shared/src/main/java/app/revanced/extension/shared/utils/Utils.java

@@ -129,23 +129,28 @@ public static void hideViewByRemovingFromParentUnderCondition(boolean condition,
      */
     private static final ThreadPoolExecutor backgroundThreadPool = new ThreadPoolExecutor(
             3, // 3 threads always ready to go
-            Integer.MAX_VALUE,
+            10,
             10, // For any threads over the minimum, keep them alive 10 seconds after they go idle
             TimeUnit.SECONDS,
             new SynchronousQueue<>(),
             r -> { // ThreadFactory
                 Thread t = new Thread(r);
-                t.setPriority(Thread.MAX_PRIORITY); // run at max priority
+                t.setPriority(Thread.NORM_PRIORITY); // run at norm priority
                 return t;
-            });
+            },
+            ThreadPoolExecutor.DiscardPolicy()
+    );
 
     public static void runOnBackgroundThread(@NonNull Runnable task) {
         backgroundThreadPool.execute(task);
     }
 
     @NonNull
     public static <T> Future<T> submitOnBackgroundThread(@NonNull Callable<T> call) {
-        return backgroundThreadPool.submit(call);
+        ThreadPoolExecutor submitThreadPool = backgroundThreadPool;
+        submitThreadPool.allowCoreThreadTimeOut(true);
+
+        return submitThreadPool.submit(call);
     }
 
     /**