Submods

Clearer name setting
Merge branch 'plugin-fixes' into 'master'
2026-05-16 04:52:39 +02:00 · 2025-06-16 18:34:37 +02:00 · 2025-06-16 17:56:04 +02:00 · 2025-06-16 15:48:01 +00:00 · 2025-06-16 17:46:00 +02:00 · 2025-06-16 14:23:34 +02:00
43 changed files with 720 additions and 298 deletions
@@ -179,7 +179,8 @@ dependencies {
    implementation 'com.google.code.gson:gson:2.10.1' //Used for complex/anonymous cases like during development conversions (eg. V8RemoteObject)

    //JS
-    implementation("com.caoccao.javet:javet-android:3.0.2")
+    //implementation("com.caoccao.javet:javet-android:3.0.2")
+    implementation 'com.caoccao.javet:javet-v8-android:4.1.4'

    //Exoplayer
    implementation 'androidx.media3:media3-exoplayer:1.2.1'
@@ -11,7 +11,7 @@ import java.nio.ByteBuffer
 import kotlin.random.Random
 import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.Duration.Companion.seconds
-
+/*
 class SyncServerTests {

    //private val relayHost = "relay.grayjay.app"
@@ -335,4 +335,4 @@ class SyncServerTests {

 class AlwaysAuthorized : IAuthorizable {
    override val isAuthorized: Boolean get() = true
-}
+}*/
@@ -13,7 +13,7 @@ import kotlin.random.Random
 import java.io.InputStream
 import java.io.OutputStream
 import kotlin.time.Duration.Companion.seconds
-
+/*
 data class PipeStreams(
    val initiatorInput: LittleEndianDataInputStream,
    val initiatorOutput: LittleEndianDataOutputStream,
@@ -509,4 +509,4 @@ class Authorized : IAuthorizable {

 class Unauthorized : IAuthorizable {
    override val isAuthorized: Boolean = false
-}
+}*/
@@ -103,6 +103,12 @@ class UnavailableException extends ScriptException {
        super("UnavailableException", msg);
    }
 }
+class ReloadRequiredException extends ScriptException {
+    constructor(msg, reloadData) {
+        super("ReloadRequiredException", msg);
+        this.reloadData = reloadData;
+    }
+}
 class AgeException extends ScriptException {
    constructor(msg) {
        super("AgeException", msg);
@@ -584,6 +584,24 @@ class Settings : FragmentedStorageFileJson() {
            playbackSpeeds.sort();
            return playbackSpeeds;
        }
+
+        @FormField(R.string.hold_playback_speed, FieldForm.DROPDOWN, R.string.hold_playback_speed_description, 27)
+        @DropdownFieldOptionsId(R.array.hold_playback_speeds)
+        var holdPlaybackSpeed: Int = 3;
+
+        fun getHoldPlaybackSpeed(): Double {
+            return when(holdPlaybackSpeed) {
+                0 -> 1.25
+                1 -> 1.5
+                2 -> 1.75
+                3 -> 2.0
+                4 -> 2.25
+                5 -> 2.5
+                6 -> 2.75
+                7 -> 3.0
+                else -> 2.0
+            }
+        }
    }

    @FormField(R.string.comments, "group", R.string.comments_description, 6)
@@ -999,10 +1017,13 @@ class Settings : FragmentedStorageFileJson() {
        @FormField(R.string.playlist_allow_dups, FieldForm.TOGGLE, R.string.playlist_allow_dups_description, 3)
        var playlistAllowDups: Boolean = true;

-        @FormField(R.string.enable_polycentric, FieldForm.TOGGLE, R.string.can_be_disabled_when_you_are_experiencing_issues, 4)
+        @FormField(R.string.watch_later_add_start, FieldForm.TOGGLE, R.string.watch_later_add_start_description, 4)
+        var watchLaterAddStart: Boolean = true;
+
+        @FormField(R.string.enable_polycentric, FieldForm.TOGGLE, R.string.can_be_disabled_when_you_are_experiencing_issues, 5)
        var polycentricEnabled: Boolean = true;

-        @FormField(R.string.polycentric_local_cache, FieldForm.TOGGLE, R.string.polycentric_local_cache_description, 5)
+        @FormField(R.string.polycentric_local_cache, FieldForm.TOGGLE, R.string.polycentric_local_cache_description, 7)
        var polycentricLocalCache: Boolean = true;
    }

@@ -1151,6 +1151,8 @@ class UISlideOverlays {
                        call = {
                            if(StatePlaylists.instance.addToWatchLater(SerializedPlatformVideo.fromVideo(video), true))
                                UIDialogs.appToast("Added to watch later", false);
+                            else
+                                UIDialogs.toast(container.context.getString(R.string.already_in_watch_later))
                        }),
                )
            );
@@ -56,6 +56,7 @@ class DevJSClient : JSClient {

    override fun getCopy(privateCopy: Boolean, noSaveState: Boolean): JSClient {
        val client = DevJSClient(_context, descriptor, _script, if(!privateCopy) _auth else null, _captcha, if (noSaveState) null else saveState(), devID);
+        client.setReloadData(getReloadData(true));
        if (noSaveState)
            client.initialize()
        return client
@@ -62,6 +62,7 @@ import com.futo.platformplayer.states.StatePlugins
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import java.time.OffsetDateTime
+import java.util.Random
 import kotlin.Exception
 import kotlin.reflect.full.findAnnotations
 import kotlin.reflect.jvm.kotlinFunction
@@ -83,6 +84,8 @@ open class JSClient : IPlatformClient {
    private var _channelCapabilities: ResultCapabilities? = null;
    private var _peekChannelTypes: List<String>? = null;

+    private var _usedReloadData: String? = null;
+
    protected val _script: String;

    private var _initialized: Boolean = false;
@@ -98,14 +101,14 @@ open class JSClient : IPlatformClient {
    override val icon: ImageVariable;
    override var capabilities: PlatformClientCapabilities = PlatformClientCapabilities();

-    private val _busyLock = Object();
-    private var _busyCounter = 0;
    private var _busyAction = "";
-    val isBusy: Boolean get() = _busyCounter > 0;
+    val isBusy: Boolean get() = _plugin.isBusy;
    val isBusyAction: String get() {
        return _busyAction;
    }

+    val declareOnEnable = HashMap<String, String>();
+
    val settings: HashMap<String, String?> get() = descriptor.settings;

    val flags: Array<String>;
@@ -197,6 +200,7 @@ open class JSClient : IPlatformClient {

    open fun getCopy(withoutCredentials: Boolean = false, noSaveState: Boolean = false): JSClient {
        val client = JSClient(_context, descriptor, if (noSaveState) null else saveState(), _script, withoutCredentials);
+        client.setReloadData(getReloadData(true));
        if (noSaveState)
            client.initialize()
        return client
@@ -213,14 +217,31 @@ open class JSClient : IPlatformClient {
        return plugin.httpClientOthers[id];
    }

+    fun setReloadData(data: String?) {
+        if(data == null) {
+            if(declareOnEnable.containsKey("__reloadData"))
+                declareOnEnable.remove("__reloadData");
+        }
+        else
+            declareOnEnable.put("__reloadData", data ?: "");
+    }
+    fun getReloadData(orLast: Boolean): String? {
+        if(declareOnEnable.containsKey("__reloadData"))
+            return declareOnEnable["__reloadData"];
+        else if(orLast)
+            return _usedReloadData;
+        return null;
+    }
+
    override fun initialize() {
        if (_initialized) return

-        Logger.i(TAG, "Plugin [${config.name}] initializing");
        plugin.start();
+
        plugin.execute("plugin.config = ${Json.encodeToString(config)}");
        plugin.execute("plugin.settings = parseSettings(${Json.encodeToString(descriptor.getSettingsWithDefaults())})");

+
        descriptor.appSettings.loadDefaults(descriptor.config);

        _initialized = true;
@@ -263,7 +284,16 @@ open class JSClient : IPlatformClient {
    fun enable() {
        if(!_initialized)
            initialize();
+        for(toDeclare in declareOnEnable) {
+            plugin.execute("var ${toDeclare.key} = " + Json.encodeToString(toDeclare.value));
+        }
        plugin.execute("source.enable(${Json.encodeToString(config)}, parseSettings(${Json.encodeToString(descriptor.getSettingsWithDefaults())}), ${Json.encodeToString(_injectedSaveState)})");
+
+        if(declareOnEnable.containsKey("__reloadData")) {
+            Logger.i(TAG, "Plugin [${config.name}] enabled with reload data: ${declareOnEnable["__reloadData"]}");
+            _usedReloadData = declareOnEnable["__reloadData"];
+            declareOnEnable.remove("__reloadData");
+        }
        _enabled = true;
    }
    @JSDocs(1, "source.saveState()", "Provide a string that is passed to enable for quicker startup of multiple instances")
@@ -552,7 +582,7 @@ open class JSClient : IPlatformClient {
        Logger.i(TAG, "JSClient.getPlaybackTracker(${url})");
        val tracker = plugin.executeTyped<V8Value>("source.getPlaybackTracker(${Json.encodeToString(url)})");
        if(tracker is V8ValueObject)
-            return@isBusyWith JSPlaybackTracker(config, tracker);
+            return@isBusyWith JSPlaybackTracker(this, tracker);
        else
            return@isBusyWith null;
    }
@@ -734,19 +764,22 @@ open class JSClient : IPlatformClient {
        return urls;
    }

-
-    private fun <T> isBusyWith(actionName: String, handle: ()->T): T {
-        try {
-            synchronized(_busyLock) {
-                _busyCounter++;
-            }
-            _busyAction = actionName;
-            return handle();
+    fun <T> busy(handle: ()->T): T {
+        return _plugin.busy {
+            return@busy handle();
        }
-        finally {
-            _busyAction = "";
-            synchronized(_busyLock) {
-                _busyCounter--;
+    }
+
+    fun <T> isBusyWith(actionName: String, handle: ()->T): T {
+        //val busyId = kotlin.random.Random.nextInt(9999);
+        return busy {
+            try {
+                _busyAction = actionName;
+                return@busy handle();
+
+            }
+            finally {
+                _busyAction = "";
            }
        }
    }
@@ -4,6 +4,7 @@ import android.net.Uri
 import com.futo.platformplayer.SignatureProvider
 import com.futo.platformplayer.api.media.Serializer
 import com.futo.platformplayer.engine.IV8PluginConfig
+import com.futo.platformplayer.logging.Logger
 import com.futo.platformplayer.matchesDomain
 import com.futo.platformplayer.states.StatePlugins
 import kotlinx.serialization.Contextual
@@ -168,12 +169,17 @@ class SourcePluginConfig(
    }

    fun validate(text: String): Boolean {
-        if(scriptPublicKey.isNullOrEmpty())
-            throw IllegalStateException("No public key present");
-        if(scriptSignature.isNullOrEmpty())
-            throw IllegalStateException("No signature present");
+        try {
+            if (scriptPublicKey.isNullOrEmpty())
+                throw IllegalStateException("No public key present");
+            if (scriptSignature.isNullOrEmpty())
+                throw IllegalStateException("No signature present");

-        return SignatureProvider.verify(text, scriptSignature, scriptPublicKey);
+            return SignatureProvider.verify(text, scriptSignature, scriptPublicKey);
+        } catch (e: Throwable) {
+            Logger.e(TAG, "Failed to verify due to an unhandled exception", e)
+            return false
+        }
    }

    fun isUrlAllowed(url: String): Boolean {
@@ -204,6 +210,8 @@ class SourcePluginConfig(
                obj.sourceUrl = sourceUrl;
            return obj;
        }
+
+        private val TAG = "SourcePluginConfig"
    }

    @kotlinx.serialization.Serializable
@@ -67,6 +67,25 @@ class JSHttpClient : ManagedHttpClient {

    }

+    fun resetAuthCookies() {
+        _currentCookieMap.clear();
+        if(!_auth?.cookieMap.isNullOrEmpty()) {
+            for(domainCookies in _auth!!.cookieMap!!)
+                _currentCookieMap.put(domainCookies.key, HashMap(domainCookies.value));
+        }
+        if(!_captcha?.cookieMap.isNullOrEmpty()) {
+            for(domainCookies in _captcha!!.cookieMap!!) {
+                if(_currentCookieMap.containsKey(domainCookies.key))
+                    _currentCookieMap[domainCookies.key]?.putAll(domainCookies.value);
+                else
+                    _currentCookieMap.put(domainCookies.key, HashMap(domainCookies.value));
+            }
+        }
+    }
+    fun clearOtherCookies() {
+        _otherCookieMap.clear();
+    }
+
    override fun clone(): ManagedHttpClient {
        val newClient = JSHttpClient(_jsClient, _auth);
        newClient._currentCookieMap = HashMap(_currentCookieMap.toList().associate { Pair(it.first, HashMap(it.second)) })
@@ -29,7 +29,9 @@ abstract class JSPager<T> : IPager<T> {
        this.pager = pager;
        this.config = config;

-        _hasMorePages = pager.getOrDefault(config, "hasMore", "Pager", false) ?: false;
+        plugin.busy {
+            _hasMorePages = pager.getOrDefault(config, "hasMore", "Pager", false) ?: false;
+        }
        getResults();
    }

@@ -44,11 +46,14 @@ abstract class JSPager<T> : IPager<T> {
    override fun nextPage() {
        warnIfMainThread("JSPager.nextPage");

-        pager = plugin.getUnderlyingPlugin().catchScriptErrors("[${plugin.config.name}] JSPager", "pager.nextPage()") {
-            pager.invoke("nextPage", arrayOf<Any>());
-        };
-        _hasMorePages = pager.getOrDefault(config, "hasMore", "Pager", false) ?: false;
-        _resultChanged = true;
+        val pluginV8 = plugin.getUnderlyingPlugin();
+        pluginV8.busy {
+            pager = pluginV8.catchScriptErrors("[${plugin.config.name}] JSPager", "pager.nextPage()") {
+                pager.invoke("nextPage", arrayOf<Any>());
+            };
+            _hasMorePages = pager.getOrDefault(config, "hasMore", "Pager", false) ?: false;
+            _resultChanged = true;
+        }
        /*
        try {
        }
@@ -70,15 +75,18 @@ abstract class JSPager<T> : IPager<T> {
            return previousResults;

        warnIfMainThread("JSPager.getResults");
-        val items = pager.getOrThrow<V8ValueArray>(config, "results", "JSPager");
-        if(items.v8Runtime.isDead || items.v8Runtime.isClosed)
-            throw IllegalStateException("Runtime closed");
-        val newResults = items.toArray()
-            .map { convertResult(it as V8ValueObject) }
-            .toList();
-        _lastResults = newResults;
-        _resultChanged = false;
-        return newResults;
+
+        return plugin.getUnderlyingPlugin().busy {
+            val items = pager.getOrThrow<V8ValueArray>(config, "results", "JSPager");
+            if (items.v8Runtime.isDead || items.v8Runtime.isClosed)
+                throw IllegalStateException("Runtime closed");
+            val newResults = items.toArray()
+                .map { convertResult(it as V8ValueObject) }
+                .toList();
+            _lastResults = newResults;
+            _resultChanged = false;
+            return@busy newResults;
+        }
    }

    abstract fun convertResult(obj: V8ValueObject): T;
@@ -2,37 +2,50 @@ package com.futo.platformplayer.api.media.platforms.js.models

 import com.caoccao.javet.values.reference.V8ValueObject
 import com.futo.platformplayer.api.media.models.playback.IPlaybackTracker
+import com.futo.platformplayer.api.media.platforms.js.JSClient
 import com.futo.platformplayer.engine.IV8PluginConfig
 import com.futo.platformplayer.engine.exceptions.ScriptImplementationException
 import com.futo.platformplayer.getOrThrow
 import com.futo.platformplayer.logging.Logger
+import com.futo.platformplayer.states.StatePlatform
 import com.futo.platformplayer.warnIfMainThread

 class JSPlaybackTracker: IPlaybackTracker {
-    private val _config: IV8PluginConfig;
-    private val _obj: V8ValueObject;
+    private lateinit var _client: JSClient;
+    private lateinit var _config: IV8PluginConfig;
+    private lateinit var _obj: V8ValueObject;

    private var _hasCalledInit: Boolean = false;
-    private val _hasInit: Boolean;
+    private var _hasInit: Boolean = false;

    private var _lastRequest: Long = Long.MIN_VALUE;

-    private val _hasOnConcluded: Boolean;
+    private var _hasOnConcluded: Boolean = false;

    override var nextRequest: Int = 1000
        private set;

-    constructor(config: IV8PluginConfig, obj: V8ValueObject) {
+    constructor(client: JSClient, obj: V8ValueObject) {
        warnIfMainThread("JSPlaybackTracker.constructor");
-        if(!obj.has("onProgress"))
-            throw ScriptImplementationException(config, "Missing onProgress on PlaybackTracker");
-        if(!obj.has("nextRequest"))
-            throw ScriptImplementationException(config, "Missing nextRequest on PlaybackTracker");
-        _hasOnConcluded = obj.has("onConcluded");

-        this._config = config;
-        this._obj = obj;
-        this._hasInit = obj.has("onInit");
+        client.busy {
+            if (!obj.has("onProgress"))
+                throw ScriptImplementationException(
+                    client.config,
+                    "Missing onProgress on PlaybackTracker"
+                );
+            if (!obj.has("nextRequest"))
+                throw ScriptImplementationException(
+                    client.config,
+                    "Missing nextRequest on PlaybackTracker"
+                );
+            _hasOnConcluded = obj.has("onConcluded");
+
+            this._client = client;
+            this._config = client.config;
+            this._obj = obj;
+            this._hasInit = obj.has("onInit");
+        }
    }

    override fun onInit(seconds: Double) {
@@ -40,12 +53,15 @@ class JSPlaybackTracker: IPlaybackTracker {
        synchronized(_obj) {
            if(_hasCalledInit)
                return;
-            if (_hasInit) {
-                Logger.i("JSPlaybackTracker", "onInit (${seconds})");
-                _obj.invokeVoid("onInit", seconds);
+
+            _client.busy {
+                if (_hasInit) {
+                    Logger.i("JSPlaybackTracker", "onInit (${seconds})");
+                    _obj.invokeVoid("onInit", seconds);
+                }
+                nextRequest = Math.max(100, _obj.getOrThrow(_config, "nextRequest", "PlaybackTracker", false));
+                _hasCalledInit = true;
            }
-            nextRequest = Math.max(100, _obj.getOrThrow(_config, "nextRequest", "PlaybackTracker", false));
-            _hasCalledInit = true;
        }
    }

@@ -55,10 +71,12 @@ class JSPlaybackTracker: IPlaybackTracker {
            if(!_hasCalledInit && _hasInit)
                onInit(seconds);
            else {
-                Logger.i("JSPlaybackTracker", "onProgress (${seconds}, ${isPlaying})");
-                _obj.invokeVoid("onProgress", Math.floor(seconds), isPlaying);
-                nextRequest = Math.max(100, _obj.getOrThrow(_config, "nextRequest", "PlaybackTracker", false));
-                _lastRequest = System.currentTimeMillis();
+                _client.busy {
+                    Logger.i("JSPlaybackTracker", "onProgress (${seconds}, ${isPlaying})");
+                    _obj.invokeVoid("onProgress", Math.floor(seconds), isPlaying);
+                    nextRequest = Math.max(100, _obj.getOrThrow(_config, "nextRequest", "PlaybackTracker", false));
+                    _lastRequest = System.currentTimeMillis();
+                }
            }
        }
    }
@@ -67,7 +85,9 @@ class JSPlaybackTracker: IPlaybackTracker {
        if(_hasOnConcluded) {
            synchronized(_obj) {
                Logger.i("JSPlaybackTracker", "onConcluded");
-                _obj.invokeVoid("onConcluded", -1);
+                _client.busy {
+                    _obj.invokeVoid("onConcluded", -1);
+                }
            }
        }
    }
@@ -46,16 +46,18 @@ class JSRequestExecutor {
        if (_executor.isClosed)
            throw IllegalStateException("Executor object is closed");

-        val result = if(_plugin is DevJSClient)
-            StateDeveloper.instance.handleDevCall(_plugin.devID, "requestExecutor.executeRequest()") {
-                V8Plugin.catchScriptErrors<Any>(
-                    _config,
-                    "[${_config.name}] JSRequestExecutor",
-                    "builder.modifyRequest()"
-                ) {
-                    _executor.invoke("executeRequest", url, headers, method, body);
-                } as V8Value;
-            }
+        return _plugin.getUnderlyingPlugin().busy {
+
+            val result = if(_plugin is DevJSClient)
+                StateDeveloper.instance.handleDevCall(_plugin.devID, "requestExecutor.executeRequest()") {
+                    V8Plugin.catchScriptErrors<Any>(
+                        _config,
+                        "[${_config.name}] JSRequestExecutor",
+                        "builder.modifyRequest()"
+                    ) {
+                        _executor.invoke("executeRequest", url, headers, method, body);
+                    } as V8Value;
+                }
            else V8Plugin.catchScriptErrors<Any>(
                _config,
                "[${_config.name}] JSRequestExecutor",
@@ -64,34 +66,35 @@ class JSRequestExecutor {
                _executor.invoke("executeRequest", url, headers, method, body);
            } as V8Value;

-        try {
-            if(result is V8ValueString) {
-                val base64Result = Base64.getDecoder().decode(result.value);
-                return base64Result;
-            }
-            if(result is V8ValueTypedArray) {
-                val buffer = result.buffer;
-                val byteBuffer = buffer.byteBuffer;
-                val bytesResult = ByteArray(result.byteLength);
-                byteBuffer.get(bytesResult, 0, result.byteLength);
-                buffer.close();
-                return bytesResult;
-            }
-            if(result is V8ValueObject && result.has("type")) {
-                val type = result.getOrThrow<Int>(_config, "type", "JSRequestModifier");
-                when(type) {
-                    //TODO: Buffer type?
+            try {
+                if(result is V8ValueString) {
+                    val base64Result = Base64.getDecoder().decode(result.value);
+                    return@busy base64Result;
                }
+                if(result is V8ValueTypedArray) {
+                    val buffer = result.buffer;
+                    val byteBuffer = buffer.byteBuffer;
+                    val bytesResult = ByteArray(result.byteLength);
+                    byteBuffer.get(bytesResult, 0, result.byteLength);
+                    buffer.close();
+                    return@busy bytesResult;
+                }
+                if(result is V8ValueObject && result.has("type")) {
+                    val type = result.getOrThrow<Int>(_config, "type", "JSRequestModifier");
+                    when(type) {
+                        //TODO: Buffer type?
+                    }
+                }
+                if(result is V8ValueUndefined) {
+                    if(_plugin is DevJSClient)
+                        StateDeveloper.instance.logDevException(_plugin.devID, "JSRequestExecutor.executeRequest returned illegal undefined");
+                    throw ScriptImplementationException(_config, "JSRequestExecutor.executeRequest returned illegal undefined", null);
+                }
+                throw NotImplementedError("Executor result type not implemented? " + result.javaClass.name);
            }
-            if(result is V8ValueUndefined) {
-                if(_plugin is DevJSClient)
-                    StateDeveloper.instance.logDevException(_plugin.devID, "JSRequestExecutor.executeRequest returned illegal undefined");
-                throw ScriptImplementationException(_config, "JSRequestExecutor.executeRequest returned illegal undefined", null);
+            finally {
+                result.close();
            }
-            throw NotImplementedError("Executor result type not implemented? " + result.javaClass.name);
-        }
-        finally {
-            result.close();
        }
    }

@@ -99,24 +102,25 @@ class JSRequestExecutor {
    open fun cleanup() {
        if (!hasCleanup || _executor.isClosed)
            return;
-
-       if(_plugin is DevJSClient)
-            StateDeveloper.instance.handleDevCall(_plugin.devID, "requestExecutor.executeRequest()") {
-                V8Plugin.catchScriptErrors<Any>(
-                    _config,
-                    "[${_config.name}] JSRequestExecutor",
-                    "builder.modifyRequest()"
-                ) {
-                    _executor.invokeVoid("cleanup", null);
-                };
-            }
-        else V8Plugin.catchScriptErrors<Any>(
-            _config,
-            "[${_config.name}] JSRequestExecutor",
-            "builder.modifyRequest()"
-        ) {
-           _executor.invokeVoid("cleanup", null);
-        };
+        _plugin.busy {
+            if(_plugin is DevJSClient)
+                StateDeveloper.instance.handleDevCall(_plugin.devID, "requestExecutor.executeRequest()") {
+                    V8Plugin.catchScriptErrors<Any>(
+                        _config,
+                        "[${_config.name}] JSRequestExecutor",
+                        "builder.modifyRequest()"
+                    ) {
+                        _executor.invokeVoid("cleanup", null);
+                    };
+                }
+            else V8Plugin.catchScriptErrors<Any>(
+                _config,
+                "[${_config.name}] JSRequestExecutor",
+                "builder.modifyRequest()"
+            ) {
+                _executor.invokeVoid("cleanup", null);
+            };
+        }
    }

    protected fun finalize() {
@@ -16,7 +16,7 @@ class JSRequestModifier: IRequestModifier {
    private val _plugin: JSClient;
    private val _config: IV8PluginConfig;
    private var _modifier: V8ValueObject;
-    override var allowByteSkip: Boolean;
+    override var allowByteSkip: Boolean = false;

    constructor(plugin: JSClient, modifier: V8ValueObject) {
        this._plugin = plugin;
@@ -24,10 +24,13 @@ class JSRequestModifier: IRequestModifier {
        this._config = plugin.config;
        val config = plugin.config;

-        allowByteSkip = modifier.getOrNull(config, "allowByteSkip", "JSRequestModifier") ?: true;
+        plugin.busy {
+            allowByteSkip = modifier.getOrNull(config, "allowByteSkip", "JSRequestModifier") ?: true;
+
+            if(!modifier.has("modifyRequest"))
+                throw ScriptImplementationException(config, "RequestModifier is missing modifyRequest", null);
+        }

-        if(!modifier.has("modifyRequest"))
-            throw ScriptImplementationException(config, "RequestModifier is missing modifyRequest", null);
    }

    override fun modifyRequest(url: String, headers: Map<String, String>): IRequest {
@@ -35,13 +38,15 @@ class JSRequestModifier: IRequestModifier {
            return Request(url, headers);
        }

-        val result = V8Plugin.catchScriptErrors<Any>(_config, "[${_config.name}] JSRequestModifier", "builder.modifyRequest()") {
-            _modifier.invoke("modifyRequest", url, headers);
-        } as V8ValueObject;
+        return _plugin.busy {
+            val result = V8Plugin.catchScriptErrors<Any>(_config, "[${_config.name}] JSRequestModifier", "builder.modifyRequest()") {
+                _modifier.invoke("modifyRequest", url, headers);
+            } as V8ValueObject;

-        val req = JSRequest(_plugin, result, url, headers);
-        result.close();
-        return req;
+            val req = JSRequest(_plugin, result, url, headers);
+            result.close();
+            return@busy req;
+        }
    }


@@ -27,6 +27,7 @@ import com.futo.platformplayer.getOrThrowNullable
 import com.futo.platformplayer.states.StateDeveloper

 class JSVideoDetails : JSVideo, IPlatformVideoDetails {
+    private val _plugin: JSClient;
    private val _hasGetComments: Boolean;
    private val _hasGetContentRecommendations: Boolean;
    private val _hasGetPlaybackTracker: Boolean;
@@ -48,6 +49,7 @@ class JSVideoDetails : JSVideo, IPlatformVideoDetails {

    constructor(plugin: JSClient, obj: V8ValueObject) : super(plugin.config, obj) {
        val contextName = "VideoDetails";
+        _plugin = plugin;
        val config = plugin.config;
        description = _content.getOrThrow(config, "description", contextName);
        video = JSVideoSourceDescriptor.fromV8(plugin, _content.getOrThrow(config, "video", contextName));
@@ -86,7 +88,7 @@ class JSVideoDetails : JSVideo, IPlatformVideoDetails {
            val tracker = _content.invoke<V8Value>("getPlaybackTracker", arrayOf<Any>())
                ?: return@catchScriptErrors null;
            if(tracker is V8ValueObject)
-                return@catchScriptErrors JSPlaybackTracker(_pluginConfig, tracker);
+                return@catchScriptErrors JSPlaybackTracker(_plugin, tracker);
            else
                return@catchScriptErrors null;
        };
@@ -62,12 +62,16 @@ class JSDashManifestRawAudioSource : JSSource, IAudioSource, IJSDashManifestRawS
        if(_plugin is DevJSClient)
            result = StateDeveloper.instance.handleDevCall(_plugin.devID, "DashManifestRaw", false) {
                _plugin.getUnderlyingPlugin().catchScriptErrors("DashManifestRaw", "dashManifestRaw.generate()") {
-                    _obj.invokeString("generate");
+                    _plugin.isBusyWith("dashAudio.generate") {
+                        _obj.invokeString("generate");
+                    }
                }
            }
        else
            result = _plugin.getUnderlyingPlugin().catchScriptErrors("DashManifestRaw", "dashManifestRaw.generate()") {
-                _obj.invokeString("generate");
+                _plugin.isBusyWith("dashAudio.generate") {
+                    _obj.invokeString("generate");
+                }
            }

        if(result != null){
@@ -67,13 +67,17 @@ open class JSDashManifestRawSource: JSSource, IVideoSource, IJSDashManifestRawSo
        if(_plugin is DevJSClient) {
            result = StateDeveloper.instance.handleDevCall(_plugin.devID, "DashManifestRawSource.generate()") {
                _plugin.getUnderlyingPlugin().catchScriptErrors("DashManifestRaw.generate", "generate()", {
-                    _obj.invokeString("generate");
+                    _plugin.isBusyWith("dashVideo.generate") {
+                        _obj.invokeString("generate");
+                    }
                });
            }
        }
        else
            result = _plugin.getUnderlyingPlugin().catchScriptErrors("DashManifestRaw.generate", "generate()", {
-                _obj.invokeString("generate");
+                _plugin.isBusyWith("dashVideo.generate") {
+                    _obj.invokeString("generate");
+                }
            });

        if(result != null){
@@ -62,9 +62,11 @@ abstract class JSSource {
        if (!hasRequestModifier || _obj.isClosed)
            return null;

-        val result = V8Plugin.catchScriptErrors<Any>(_config, "[${_config.name}] JSVideoUrlSource", "obj.getRequestModifier()") {
-            _obj.invoke("getRequestModifier", arrayOf<Any>());
-        };
+        val result = _plugin.isBusyWith("getRequestModifier") {
+            V8Plugin.catchScriptErrors<Any>(_config, "[${_config.name}] JSVideoUrlSource", "obj.getRequestModifier()") {
+                _obj.invoke("getRequestModifier", arrayOf<Any>());
+            };
+        }

        if (result !is V8ValueObject)
            return null;
@@ -75,9 +77,14 @@ abstract class JSSource {
        if (!hasRequestExecutor || _obj.isClosed)
            return null;

-        val result = V8Plugin.catchScriptErrors<Any>(_config, "[${_config.name}] JSSource", "obj.getRequestExecutor()") {
-            _obj.invoke("getRequestExecutor", arrayOf<Any>());
-        };
+        Logger.v("JSSource", "Request executor for [${type}] requesting");
+        val result =_plugin.isBusyWith("getRequestExecutor") {
+            V8Plugin.catchScriptErrors<Any>(_config, "[${_config.name}] JSSource", "obj.getRequestExecutor()") {
+                _obj.invoke("getRequestExecutor", arrayOf<Any>());
+            };
+        }
+
+        Logger.v("JSSource", "Request executor for [${type}] received");

        if (result !is V8ValueObject)
            return null;
@@ -35,7 +35,7 @@ class ChromecastCastingDevice : CastingDevice {
    override var usedRemoteAddress: InetAddress? = null;
    override var localAddress: InetAddress? = null;
    override val canSetVolume: Boolean get() = true;
-    override val canSetSpeed: Boolean get() = false; //TODO: Implement
+    override val canSetSpeed: Boolean get() = true;

    var addresses: Array<InetAddress>? = null;
    var port: Int = 0;
@@ -144,6 +144,23 @@ class ChromecastCastingDevice : CastingDevice {
        sendChannelMessage("sender-0", transportId, "urn:x-cast:com.google.cast.media", json);
    }

+    override fun changeSpeed(speed: Double) {
+        if (invokeInIOScopeIfRequired { changeSpeed(speed) }) return
+
+        val speedClamped = speed.coerceAtLeast(1.0).coerceAtLeast(1.0).coerceAtMost(2.0)
+        setSpeed(speedClamped)
+        val mediaSessionId = _mediaSessionId ?: return
+        val transportId = _transportId ?: return
+        val setSpeedObject = JSONObject().apply {
+            put("type", "SET_PLAYBACK_RATE")
+            put("mediaSessionId", mediaSessionId)
+            put("playbackRate", speedClamped)
+            put("requestId", _requestId++)
+        }
+
+        sendChannelMessage(sourceId = "sender-0", destinationId = transportId, namespace = "urn:x-cast:com.google.cast.media", json = setSpeedObject.toString())
+    }
+
    override fun changeVolume(volume: Double) {
        if (invokeInIOScopeIfRequired({ changeVolume(volume) })) {
            return;
@@ -4,10 +4,9 @@ import android.content.Context
 import com.caoccao.javet.exceptions.JavetCompilationException
 import com.caoccao.javet.exceptions.JavetException
 import com.caoccao.javet.exceptions.JavetExecutionException
+import com.caoccao.javet.interfaces.IJavetEntityError
 import com.caoccao.javet.interop.V8Host
 import com.caoccao.javet.interop.V8Runtime
-import com.caoccao.javet.interop.options.V8Flags
-import com.caoccao.javet.interop.options.V8RuntimeOptions
 import com.caoccao.javet.values.V8Value
 import com.caoccao.javet.values.primitive.V8ValueBoolean
 import com.caoccao.javet.values.primitive.V8ValueInteger
@@ -26,6 +25,7 @@ import com.futo.platformplayer.engine.exceptions.ScriptException
 import com.futo.platformplayer.engine.exceptions.ScriptExecutionException
 import com.futo.platformplayer.engine.exceptions.ScriptImplementationException
 import com.futo.platformplayer.engine.exceptions.ScriptLoginRequiredException
+import com.futo.platformplayer.engine.exceptions.ScriptReloadRequiredException
 import com.futo.platformplayer.engine.exceptions.ScriptTimeoutException
 import com.futo.platformplayer.engine.exceptions.ScriptUnavailableException
 import com.futo.platformplayer.engine.internal.V8Converter
@@ -40,6 +40,8 @@ import com.futo.platformplayer.logging.Logger
 import com.futo.platformplayer.states.StateAssets
 import com.futo.platformplayer.warnIfMainThread
 import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock

 class V8Plugin {
    val config: IV8PluginConfig;
@@ -51,6 +53,8 @@ class V8Plugin {
    val httpClientAuth: ManagedHttpClient get() = _clientAuth;
    val httpClientOthers: Map<String, JSHttpClient> get() = _clientOthers;

+    var runtimeId: Int = 0;
+
    fun registerHttpClient(client: JSHttpClient) {
        synchronized(_clientOthers) {
            _clientOthers.put(client.clientId, client);
@@ -67,10 +71,8 @@ class V8Plugin {
    var isStopped = true;
    val onStopped = Event1<V8Plugin>();

-    //TODO: Implement a more universal isBusy system for plugins + JSClient + pooling? TBD if propagation would be beneficial
-    private val _busyCounterLock = Object();
-    private var _busyCounter = 0;
-    val isBusy get() = synchronized(_busyCounterLock) { _busyCounter > 0 };
+    private val _busyLock = ReentrantLock()
+    val isBusy get() = _busyLock.isLocked;

    var allowDevSubmit: Boolean = false
        private set(value) {
@@ -140,6 +142,7 @@ class V8Plugin {
        synchronized(_runtimeLock) {
            if (_runtime != null)
                return;
+            runtimeId = runtimeId + 1;
            //V8RuntimeOptions.V8_FLAGS.setUseStrict(true);
            val host = V8Host.getV8Instance();
            val options = host.jsRuntimeType.getRuntimeOptions();
@@ -184,10 +187,13 @@ class V8Plugin {
    }
    fun stop(){
        Logger.i(TAG, "Stopping plugin [${config.name}]");
-        isStopped = true;
-        whenNotBusy {
+        busy {
+            Logger.i(TAG, "Plugin stopping");
            synchronized(_runtimeLock) {
+                if(isStopped)
+                    return@busy;
                isStopped = true;
+                runtimeId = runtimeId + 1;

                //Cleanup http
                for(pack in _depsPackages) {
@@ -211,10 +217,17 @@ class V8Plugin {
                    Logger.i(TAG, "Stopped plugin [${config.name}]");
                };
            }
+            Logger.i(TAG, "Plugin stopped");
            onStopped.emit(this);
        }
    }

+    fun <T> busy(handle: ()->T): T {
+        _busyLock.withLock {
+            //Logger.i(TAG, "Entered busy: " + Thread.currentThread().stackTrace.drop(3)?.firstOrNull()?.toString() + ", " + Thread.currentThread().stackTrace.drop(4)?.firstOrNull()?.toString());
+            return handle();
+        }
+    }
    fun execute(js: String) : V8Value {
        return executeTyped<V8Value>(js);
    }
@@ -223,49 +236,17 @@ class V8Plugin {
        if(isStopped)
            throw PluginEngineStoppedException(config, "Instance is stopped", js);

-        synchronized(_busyCounterLock) {
-            _busyCounter++;
-        }
+        return busy {

-        val runtime = _runtime ?: throw IllegalStateException("JSPlugin not started yet");
-        try {
-            return catchScriptErrors("Plugin[${config.name}]", js) {
+            val runtime = _runtime ?: throw IllegalStateException("JSPlugin not started yet");
+            return@busy catchScriptErrors("Plugin[${config.name}]", js) {
                runtime.getExecutor(js).execute()
            };
        }
-        finally {
-            synchronized(_busyCounterLock) {
-                //Free busy *after* afterBusy calls are done to prevent calls on dead runtimes
-                try {
-                    afterBusy.emit(_busyCounter - 1);
-                }
-                catch(ex: Throwable) {
-                    Logger.e(TAG, "Unhandled V8Plugin.afterBusy", ex);
-                }
-                _busyCounter--;
-            }
-        }
-    }
-    fun executeBoolean(js: String) : Boolean? = catchScriptErrors("Plugin[${config.name}]") { executeTyped<V8ValueBoolean>(js).value };
-    fun executeString(js: String) : String? = catchScriptErrors("Plugin[${config.name}]") { executeTyped<V8ValueString>(js).value };
-    fun executeInteger(js: String) : Int? = catchScriptErrors("Plugin[${config.name}]") { executeTyped<V8ValueInteger>(js).value };
-
-    fun whenNotBusy(handler: (V8Plugin)->Unit) {
-        synchronized(_busyCounterLock) {
-            if(_busyCounter == 0)
-                handler(this);
-            else {
-                val tag = Object();
-                afterBusy.subscribe(tag) {
-                    if(it == 0) {
-                        Logger.w(TAG, "V8Plugin afterBusy handled");
-                        afterBusy.remove(tag);
-                        handler(this);
-                    }
-                }
-            }
-        }
    }
+    fun executeBoolean(js: String) : Boolean? = busy { catchScriptErrors("Plugin[${config.name}]") { executeTyped<V8ValueBoolean>(js).value } }
+    fun executeString(js: String) : String? = busy { catchScriptErrors("Plugin[${config.name}]") { executeTyped<V8ValueString>(js).value } }
+    fun executeInteger(js: String) : Int? = busy { catchScriptErrors("Plugin[${config.name}]") { executeTyped<V8ValueInteger>(js).value } }

    private fun getPackage(packageName: String, allowNull: Boolean = false): V8Package? {
        //TODO: Auto get all package types?
@@ -327,26 +308,38 @@ class V8Plugin {
                throw ScriptCompilationException(config, "Compilation: [${context}]: ${scriptEx.message}\n(${scriptEx.scriptingError.lineNumber})[${scriptEx.scriptingError.startColumn}-${scriptEx.scriptingError.endColumn}]: ${scriptEx.scriptingError.sourceLine}", null, codeStripped);
            }
            catch(executeEx: JavetExecutionException) {
-                if(executeEx.scriptingError?.context?.containsKey("plugin_type") == true) {
-                    val pluginType = executeEx.scriptingError.context["plugin_type"].toString();
+                if(executeEx.scriptingError?.context is IJavetEntityError) {
+                    val obj = executeEx.scriptingError?.context as IJavetEntityError
+                    if(obj.context.containsKey("plugin_type") == true) {
+                        val pluginType = obj.context["plugin_type"].toString();

-                    //Captcha
-                    if (pluginType == "CaptchaRequiredException") {
-                        throw ScriptCaptchaRequiredException(config,
-                            executeEx.scriptingError.context["url"]?.toString(),
-                            executeEx.scriptingError.context["body"]?.toString(),
-                            executeEx, executeEx.scriptingError?.stack, codeStripped);
+                        //Captcha
+                        if (pluginType == "CaptchaRequiredException") {
+                            throw ScriptCaptchaRequiredException(config,
+                                obj.context["url"]?.toString(),
+                                obj.context["body"]?.toString(),
+                                executeEx, executeEx.scriptingError?.stack, codeStripped);
+                        }
+
+                        //Reload Required
+                        if (pluginType == "ReloadRequiredException") {
+                            throw ScriptReloadRequiredException(config,
+                                obj.context["msg"]?.toString(),
+                                obj.context["reloadData"]?.toString(),
+                                executeEx, executeEx.scriptingError?.stack, codeStripped);
+                        }
+
+                        //Others
+                        throwExceptionFromV8(
+                            config,
+                            pluginType,
+                            (extractJSExceptionMessage(executeEx) ?: ""),
+                            executeEx,
+                            executeEx.scriptingError?.stack,
+                            codeStripped
+                        );
                    }

-                    //Others
-                    throwExceptionFromV8(
-                        config,
-                        pluginType,
-                        (extractJSExceptionMessage(executeEx) ?: ""),
-                        executeEx,
-                        executeEx.scriptingError?.stack,
-                        codeStripped
-                    );
                }
                throw ScriptExecutionException(config, extractJSExceptionMessage(executeEx) ?: "", null, executeEx.scriptingError?.stack, codeStripped);
            }
@@ -398,9 +391,4 @@ class V8Plugin {
            return StateAssets.readAsset(context, path) ?: throw java.lang.IllegalStateException("script ${path} not found");
        }
    }
-
-
-    /**
-     * Methods available for scripts (bridge object)
-     */
 }
@@ -0,0 +1,20 @@
+package com.futo.platformplayer.engine.exceptions
+
+import com.caoccao.javet.values.reference.V8ValueObject
+import com.futo.platformplayer.api.media.platforms.js.SourcePluginConfig
+import com.futo.platformplayer.engine.IV8PluginConfig
+import com.futo.platformplayer.engine.V8PluginConfig
+import com.futo.platformplayer.getOrDefault
+import com.futo.platformplayer.getOrThrow
+
+class ScriptReloadRequiredException(config: IV8PluginConfig, val msg: String?, val reloadData: String?, ex: Exception? = null, stack: String? = null, code: String? = null) : ScriptException(config, msg ?: "ReloadRequired", ex, stack, code) {
+
+    companion object {
+        fun fromV8(config: IV8PluginConfig, obj: V8ValueObject) : ScriptException {
+            val contextName = "ScriptReloadRequiredException";
+            return ScriptReloadRequiredException(config,
+                obj.getOrThrow(config, "message", contextName),
+                obj.getOrDefault<String>(config, "reloadData", contextName, null));
+        }
+    }
+}
@@ -13,8 +13,8 @@ open class V8BindObject : IV8Convertable {

    override fun toV8(runtime: V8Runtime): V8Value? {
        synchronized(this) {
-            if(_runtimeObj != null)
-                return _runtimeObj;
+            //if(_runtimeObj != null)
+            //    return _runtimeObj;

            val v8Obj = runtime.createV8ValueObject();
            v8Obj.bind(this);
@@ -4,6 +4,7 @@ import android.media.MediaCodec
 import android.media.MediaCodecList
 import com.caoccao.javet.annotations.V8Function
 import com.caoccao.javet.annotations.V8Property
+import com.caoccao.javet.interop.callback.JavetCallbackContext
 import com.caoccao.javet.utils.JavetResourceUtils
 import com.caoccao.javet.values.V8Value
 import com.caoccao.javet.values.reference.V8ValueFunction
@@ -78,6 +79,14 @@ class PackageBridge : V8Package {
        return "android";
    }

+    @V8Property
+    fun supportedFeatures(): Array<String> {
+        return arrayOf(
+            "ReloadRequiredException",
+            "HttpBatchClient"
+        );
+    }
+
    @V8Property
    fun supportedContent(): Array<Int> {
        return arrayOf(
@@ -105,28 +114,38 @@ class PackageBridge : V8Package {
    @V8Function
    fun setTimeout(func: V8ValueFunction, timeout: Long): Int {
        val id = timeoutCounter++;
-
        val funcClone = func.toClone<V8ValueFunction>()

        StateApp.instance.scopeOrNull?.launch(Dispatchers.IO) {
            delay(timeout);
+            if(_plugin.isStopped)
+                return@launch;
            synchronized(timeoutMap) {
                if(!timeoutMap.contains(id)) {
-                    JavetResourceUtils.safeClose(funcClone);
+                    _plugin.busy {
+                        if(!_plugin.isStopped)
+                            JavetResourceUtils.safeClose(funcClone);
+                    }
                    return@launch;
                }
                timeoutMap.remove(id);
            }
            try {
-                _plugin.whenNotBusy {
-                    funcClone.callVoid(null, arrayOf<Any>());
+                _plugin.busy {
+                    if(!_plugin.isStopped)
+                        funcClone.callVoid(null, arrayOf<Any>());
                }
            }
            catch(ex: Throwable) {
                Logger.e(TAG, "Failed timeout callback", ex);
            }
            finally {
-                JavetResourceUtils.safeClose(funcClone);
+                _plugin.busy {
+                    if(!_plugin.isStopped)
+                        JavetResourceUtils.safeClose(funcClone);
+                }
+                //_plugin.whenNotBusy {
+                //}
            }
        };
        synchronized(timeoutMap) {
@@ -141,13 +160,17 @@ class PackageBridge : V8Package {
                timeoutMap.remove(id);
        }
    }
+    @V8Function
+    fun sleep(length: Int) {
+        Thread.sleep(length.toLong());
+    }

    @V8Function
    fun toast(str: String) {
        Logger.i(TAG, "Plugin toast [${_config.name}]: ${str}");
        StateApp.instance.scopeOrNull?.launch(Dispatchers.Main) {
            try {
-                UIDialogs.toast(str);
+                UIDialogs.appToast(str);
            } catch (e: Throwable) {
                Logger.e(TAG, "Failed to show toast.", e);
            }
@@ -44,6 +44,17 @@ class PackageHttp: V8Package {
    private val aliveSockets = mutableListOf<SocketResult>();
    private var _cleanedUp = false;

+    private val _clients = mutableMapOf<String, PackageHttpClient>()
+
+    fun getClient(id: String?): PackageHttpClient {
+        if(id == null)
+            throw IllegalArgumentException("Http client ${id} doesn't exist");
+        if(_packageClient.clientId() == id)
+            return _packageClient;
+        if(_packageClientAuth.clientId() == id)
+            return _packageClientAuth;
+        return _clients.getOrDefault(id, null) ?: throw IllegalArgumentException("Http client ${id} doesn't exist");
+    }

    constructor(plugin: V8Plugin, config: IV8PluginConfig): super(plugin) {
        _config = config;
@@ -112,6 +123,8 @@ class PackageHttp: V8Package {
            _plugin.registerHttpClient(httpClient);
        val client = PackageHttpClient(this, httpClient);

+        _clients.put(client.clientId() ?: "", client);
+
        return client;
    }
    @V8Function
@@ -246,18 +259,18 @@ class PackageHttp: V8Package {

        @V8Function
        fun request(method: String, url: String, headers: MutableMap<String, String> = HashMap(), useAuth: Boolean = false) : BatchBuilder {
-            return clientRequest(_package.getDefaultClient(useAuth), method, url, headers);
+            return clientRequest(_package.getDefaultClient(useAuth).clientId(), method, url, headers);
        }
        @V8Function
        fun requestWithBody(method: String, url: String, body:String, headers: MutableMap<String, String> = HashMap(), useAuth: Boolean = false) : BatchBuilder {
-            return clientRequestWithBody(_package.getDefaultClient(useAuth), method, url, body, headers);
+            return clientRequestWithBody(_package.getDefaultClient(useAuth).clientId(), method, url, body, headers);
        }
        @V8Function
        fun GET(url: String, headers: MutableMap<String, String> = HashMap(), useAuth: Boolean = false) : BatchBuilder
-            = clientGET(_package.getDefaultClient(useAuth), url, headers);
+            = clientGET(_package.getDefaultClient(useAuth).clientId(), url, headers);
        @V8Function
        fun POST(url: String, body: String, headers: MutableMap<String, String> = HashMap(), useAuth: Boolean = false) : BatchBuilder
-            = clientPOST(_package.getDefaultClient(useAuth), url, body, headers);
+            = clientPOST(_package.getDefaultClient(useAuth).clientId(), url, body, headers);

        @V8Function
        fun DUMMY(): BatchBuilder {
@@ -268,21 +281,21 @@ class PackageHttp: V8Package {
        //Client-specific

        @V8Function
-        fun clientRequest(client: PackageHttpClient, method: String, url: String, headers: MutableMap<String, String> = HashMap()) : BatchBuilder {
-            _reqs.add(Pair(client, RequestDescriptor(method, url, headers)));
+        fun clientRequest(clientId: String?, method: String, url: String, headers: MutableMap<String, String> = HashMap()) : BatchBuilder {
+            _reqs.add(Pair(_package.getClient(clientId), RequestDescriptor(method, url, headers)));
            return BatchBuilder(_package, _reqs);
        }
        @V8Function
-        fun clientRequestWithBody(client: PackageHttpClient, method: String, url: String, body:String, headers: MutableMap<String, String> = HashMap()) : BatchBuilder {
-            _reqs.add(Pair(client, RequestDescriptor(method, url, headers, body)));
+        fun clientRequestWithBody(clientId: String?, method: String, url: String, body:String, headers: MutableMap<String, String> = HashMap()) : BatchBuilder {
+            _reqs.add(Pair(_package.getClient(clientId), RequestDescriptor(method, url, headers, body)));
            return BatchBuilder(_package, _reqs);
        }
        @V8Function
-        fun clientGET(client: PackageHttpClient, url: String, headers: MutableMap<String, String> = HashMap()) : BatchBuilder
-                = clientRequest(client, "GET", url, headers);
+        fun clientGET(clientId: String?, url: String, headers: MutableMap<String, String> = HashMap()) : BatchBuilder
+                = clientRequest(clientId, "GET", url, headers);
        @V8Function
-        fun clientPOST(client: PackageHttpClient, url: String, body: String, headers: MutableMap<String, String> = HashMap()) : BatchBuilder
-                = clientRequestWithBody(client, "POST", url, body, headers);
+        fun clientPOST(clientId: String?, url: String, body: String, headers: MutableMap<String, String> = HashMap()) : BatchBuilder
+                = clientRequestWithBody(clientId, "POST", url, body, headers);


        //Finalizer
@@ -321,6 +334,7 @@ class PackageHttp: V8Package {
        @Transient
        private val _clientId: String?;

+
        @V8Property
        fun clientId(): String? {
            return _clientId;
@@ -333,6 +347,17 @@ class PackageHttp: V8Package {
            _clientId = if(_client is JSHttpClient) _client.clientId else null;
        }

+        @V8Function
+        fun resetAuthCookies(){
+            if(_client is JSHttpClient)
+                _client.resetAuthCookies();
+        }
+        @V8Function
+        fun clearOtherCookies(){
+            if(_client is JSHttpClient)
+                _client.clearOtherCookies();
+        }
+
        @V8Function
        fun setDefaultHeaders(defaultHeaders: Map<String, String>) {
            for(pair in defaultHeaders)
@@ -429,8 +454,23 @@ class PackageHttp: V8Package {
            };
        }
        @V8Function
-        fun POST(url: String, body: String, headers: MutableMap<String, String> = HashMap(), useBytes: Boolean = false) : IBridgeHttpResponse
-            = POSTInternal(url, body, headers, if(useBytes) ReturnType.BYTES else ReturnType.STRING)
+        fun POST(url: String, body: Any, headers: MutableMap<String, String> = HashMap(), useBytes: Boolean = false) : IBridgeHttpResponse {
+            if(body is V8ValueString)
+                return POSTInternal(url, body.value, headers, if(useBytes) ReturnType.BYTES else ReturnType.STRING);
+            else if(body is String)
+                return POSTInternal(url, body, headers, if(useBytes) ReturnType.BYTES else ReturnType.STRING);
+            else if(body is V8ValueTypedArray)
+                return POSTInternal(url, body.toBytes(), headers, if(useBytes) ReturnType.BYTES else ReturnType.STRING);
+            else if(body is ByteArray)
+                return POSTInternal(url, body, headers, if(useBytes) ReturnType.BYTES else ReturnType.STRING);
+            else if(body is ArrayList<*>) //Avoid this case, used purely for testing
+                return POSTInternal(url, body.map { (it as Double).toInt().toByte() }.toByteArray(), headers, if(useBytes) ReturnType.BYTES else ReturnType.STRING);
+            else
+                throw NotImplementedError("Body type " + body?.javaClass?.name?.toString() + " not implemented for POST");
+        }
+
+
+        //    = POSTInternal(url, body, headers, if(useBytes) ReturnType.BYTES else ReturnType.STRING)
        fun POSTInternal(url: String, body: String, headers: MutableMap<String, String> = HashMap(), returnType: ReturnType = ReturnType.STRING) : IBridgeHttpResponse {
            applyDefaultHeaders(headers);
            return logExceptions {
@@ -452,9 +492,6 @@ class PackageHttp: V8Package {
                }
            };
        }
-        @V8Function
-        fun POST(url: String, body: ByteArray, headers: MutableMap<String, String> = HashMap(), useBytes: Boolean = false) : IBridgeHttpResponse
-                = POSTInternal(url, body, headers, if(useBytes) ReturnType.BYTES else ReturnType.STRING)
        fun POSTInternal(url: String, body: ByteArray, headers: MutableMap<String, String> = HashMap(), returnType: ReturnType = ReturnType.STRING) : IBridgeHttpResponse {
            applyDefaultHeaders(headers);
            return logExceptions {
@@ -630,7 +667,9 @@ class PackageHttp: V8Package {
                        _isOpen = true;
                        if(hasOpen && _listeners?.isClosed != true) {
                            try {
-                                _listeners?.invokeVoid("open", arrayOf<Any>());
+                                _package._plugin.busy {
+                                    _listeners?.invokeVoid("open", arrayOf<Any>());
+                                }
                            }
                            catch(ex: Throwable){
                                Logger.e(TAG, "Socket for [${_packageClient.parentConfig.name}] open failed: " + ex.message, ex);
@@ -640,7 +679,9 @@ class PackageHttp: V8Package {
                    override fun message(msg: String) {
                        if(hasMessage && _listeners?.isClosed != true) {
                            try {
-                                _listeners?.invokeVoid("message", msg);
+                                _package._plugin.busy {
+                                    _listeners?.invokeVoid("message", msg);
+                                }
                            }
                            catch(ex: Throwable) {}
                        }
@@ -649,7 +690,9 @@ class PackageHttp: V8Package {
                        if(hasClosing && _listeners?.isClosed != true)
                        {
                            try {
-                                _listeners?.invokeVoid("closing", code, reason);
+                                _package._plugin.busy {
+                                    _listeners?.invokeVoid("closing", code, reason);
+                                }
                            }
                            catch(ex: Throwable){
                                Logger.e(TAG, "Socket for [${_packageClient.parentConfig.name}] closing failed: " + ex.message, ex);
@@ -660,7 +703,9 @@ class PackageHttp: V8Package {
                        _isOpen = false;
                        if(hasClosed && _listeners?.isClosed != true) {
                            try {
-                                _listeners?.invokeVoid("closed", code, reason);
+                                _package._plugin.busy {
+                                    _listeners?.invokeVoid("closed", code, reason);
+                                }
                            }
                            catch(ex: Throwable){
                                Logger.e(TAG, "Socket for [${_packageClient.parentConfig.name}] closed failed: " + ex.message, ex);
@@ -676,7 +721,9 @@ class PackageHttp: V8Package {
                        Logger.e(TAG, "Websocket failure: ${exception.message} (${_url})", exception);
                        if(hasFailure &&  _listeners?.isClosed != true) {
                            try {
-                                _listeners?.invokeVoid("failure", exception.message);
+                                _package._plugin.busy {
+                                    _listeners?.invokeVoid("failure", exception.message);
+                                }
                            }
                            catch(ex: Throwable){
                                Logger.e(TAG, "Socket for [${_packageClient.parentConfig.name}] closed failed: " + ex.message, ex);
@@ -778,6 +778,8 @@ class ArticleDetailFragment : MainFragment {
                        view.onAddToWatchLaterClicked.subscribe { a ->
                            if(StatePlaylists.instance.addToWatchLater(SerializedPlatformVideo.fromVideo(content), true))
                                UIDialogs.toast("Added to watch later\n[${content.name}]")
+                            else
+                                UIDialogs.toast(context.getString(R.string.already_in_watch_later))
                        }
                    }
                    else if(content is IPlatformPost) {
@@ -226,6 +226,8 @@ class ChannelFragment : MainFragment() {
                if (content is IPlatformVideo) {
                    if(StatePlaylists.instance.addToWatchLater(SerializedPlatformVideo.fromVideo(content), true))
                        UIDialogs.toast("Added to watch later\n[${content.name}]")
+                    else
+                        UIDialogs.toast(context.getString(R.string.already_in_watch_later))
                }
            }
            adapter.onUrlClicked.subscribe { url ->
@@ -86,6 +86,8 @@ abstract class ContentFeedView<TFragment> : FeedView<TFragment, IPlatformContent
            if(it is IPlatformVideo) {
                if(StatePlaylists.instance.addToWatchLater(SerializedPlatformVideo.fromVideo(it), true))
                    UIDialogs.toast("Added to watch later\n[${it.name}]");
+                else
+                    UIDialogs.toast(context.getString(R.string.already_in_watch_later))
            }
        };
        adapter.onLongPress.subscribe(this) {
@@ -101,7 +101,7 @@ class VideoDetailFragment() : MainFragment() {
    }

    private fun isSmallWindow(): Boolean {
-        return resources.configuration.smallestScreenWidthDp < resources.getInteger(R.integer.column_width_dp) * 2
+        return resources.configuration.smallestScreenWidthDp < resources.getInteger(R.integer.smallest_width_dp)
    }

    private fun isAutoRotateEnabled(): Boolean {
@@ -627,11 +627,6 @@ class VideoDetailFragment() : MainFragment() {
            showSystemUI()
        }

-        // temporarily force the device to portrait if auto-rotate is disabled to prevent landscape when exiting full screen on a small device
-//        @SuppressLint("SourceLockedOrientationActivity")
-//        if (!isFullscreen && isSmallWindow() && !isAutoRotateEnabled() && !isMinimizingFromFullScreen) {
-//            activity?.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT
-//        }
        updateOrientation();
        _view?.allowMotion = !fullscreen;
    }
@@ -93,6 +93,7 @@ import com.futo.platformplayer.engine.exceptions.ScriptAgeException
 import com.futo.platformplayer.engine.exceptions.ScriptException
 import com.futo.platformplayer.engine.exceptions.ScriptImplementationException
 import com.futo.platformplayer.engine.exceptions.ScriptLoginRequiredException
+import com.futo.platformplayer.engine.exceptions.ScriptReloadRequiredException
 import com.futo.platformplayer.engine.exceptions.ScriptUnavailableException
 import com.futo.platformplayer.exceptions.UnsupportedCastException
 import com.futo.platformplayer.fixHtmlLinks
@@ -608,6 +609,10 @@ class VideoDetailView : ConstraintLayout {
            }
        }

+        _player.onReloadRequired.subscribe {
+            fetchVideo();
+        }
+
        _player.onPlayChanged.subscribe {
            if (StateCasting.instance.activeDevice == null) {
                handlePlayChanged(it);
@@ -1934,8 +1939,8 @@ class VideoDetailView : ConstraintLayout {
            }

            updateQualityFormatsOverlay(
-                videoTrackFormats.distinctBy { it.height }.sortedBy { it.height },
-                audioTrackFormats.distinctBy { it.bitrate }.sortedBy { it.bitrate });
+                videoTrackFormats.distinctBy { it.height }.sortedByDescending { it.height },
+                audioTrackFormats.distinctBy { it.bitrate }.sortedByDescending { it.bitrate });
        }
    }

@@ -2492,7 +2497,9 @@ class VideoDetailView : ConstraintLayout {

        val url = _url;
        if (!url.isNullOrBlank()) {
-            setLoading(true);
+            fragment.lifecycleScope.launch(Dispatchers.Main) {
+                setLoading(true);
+            }
            _taskLoadVideo.run(url);
        }
    }
@@ -2758,6 +2765,8 @@ class VideoDetailView : ConstraintLayout {
                        if(it is IPlatformVideo) {
                            if(StatePlaylists.instance.addToWatchLater(SerializedPlatformVideo.fromVideo(it), true))
                                UIDialogs.toast("Added to watch later\n[${it.name}]");
+                            else
+                                UIDialogs.toast(context.getString(R.string.already_in_watch_later))
                        }
                    }
                    onAddToQueueClicked.subscribe(this) {
@@ -3025,6 +3034,11 @@ class VideoDetailView : ConstraintLayout {
            return@TaskHandler result;
        })
        .success { setVideoDetails(it, true) }
+        .exception<ScriptReloadRequiredException> {
+            StatePlatform.instance.handleReloadRequired(it, {
+                fetchVideo();
+            });
+        }
        .exception<NoPlatformClientException> {
            Logger.w(TAG, "exception<NoPlatformClientException>", it)

@@ -2,6 +2,7 @@ package com.futo.platformplayer.states

 import android.content.Context
 import androidx.collection.LruCache
+import androidx.lifecycle.lifecycleScope
 import com.futo.platformplayer.R
 import com.futo.platformplayer.Settings
 import com.futo.platformplayer.UIDialogs
@@ -38,6 +39,7 @@ import com.futo.platformplayer.awaitFirstNotNullDeferred
 import com.futo.platformplayer.constructs.BatchedTaskHandler
 import com.futo.platformplayer.constructs.Event0
 import com.futo.platformplayer.constructs.Event1
+import com.futo.platformplayer.engine.exceptions.ScriptReloadRequiredException
 import com.futo.platformplayer.fromPool
 import com.futo.platformplayer.getNowDiffDays
 import com.futo.platformplayer.getNowDiffSeconds
@@ -316,7 +318,18 @@ class StatePlatform {
        _platformOrderPersistent.save();
    }

-    suspend fun reloadClient(context: Context, id: String) : JSClient? {
+    fun handleReloadRequired(reloadRequiredException: ScriptReloadRequiredException, afterReload: (() -> Unit)? = null) {
+        val id = if(reloadRequiredException.config is SourcePluginConfig) reloadRequiredException.config.id else "";
+        UIDialogs.appToast("Reloading [${reloadRequiredException.config.name}] by plugin request");
+        StateApp.instance.scopeOrNull?.launch(Dispatchers.IO) {
+            if(!reloadRequiredException.reloadData.isNullOrEmpty())
+                reEnableClientWithData(id, reloadRequiredException.reloadData, afterReload);
+            else
+                reEnableClient(id, afterReload);
+        }
+    }
+
+    suspend fun reloadClient(context: Context, id: String, afterReload: (()->Unit)? = null) : JSClient? {
        return withContext(Dispatchers.IO) {
            val client = getClient(id);
            if (client !is JSClient)
@@ -347,10 +360,27 @@ class StatePlatform {
                _availableClients.removeIf { it.id == id };
                _availableClients.add(newClient);
            }
+            afterReload?.invoke();
            return@withContext newClient;
        };
    }

+    suspend fun reEnableClientWithData(id: String, data: String? = null, afterReload: (()->Unit)? = null) {
+        val enabledBefore = getEnabledClients().map { it.id };
+        if(data != null) {
+            val client = getClientOrNull(id);
+            if(client != null && client is JSClient)
+                client.setReloadData(data);
+        }
+        selectClients({
+            _scope.launch(Dispatchers.IO) {
+                selectClients({
+                    afterReload?.invoke();
+                }, *(enabledBefore).distinct().toTypedArray());
+            }
+        }, *(enabledBefore.filter { it != id }).distinct().toTypedArray())
+    }
+    suspend fun reEnableClient(id: String, afterReload: (()->Unit)? = null) = reEnableClientWithData(id, null, afterReload);

    suspend fun enableClient(ids: List<String>) {
        val currentClients = getEnabledClients().map { it.id };
@@ -361,6 +391,9 @@ class StatePlatform {
     * If a client is disabled, NO requests are made to said client
     */
    suspend fun selectClients(vararg ids: String) {
+        selectClients(null, *ids);
+    }
+    suspend fun selectClients(afterLoad: (() -> Unit)?, vararg ids: String) {
        withContext(Dispatchers.IO) {
            synchronized(_clientsLock) {
                val removed = _enabledClients.toMutableList();
@@ -385,6 +418,7 @@ class StatePlatform {
                    onSourceDisabled.emit(oldClient);
                }
            }
+            afterLoad?.invoke();
        };
    }

@@ -3,7 +3,6 @@ package com.futo.platformplayer.states
 import android.content.Context
 import android.net.Uri
 import androidx.core.content.FileProvider
-import androidx.fragment.app.Fragment
 import com.futo.platformplayer.R
 import com.futo.platformplayer.Settings
 import com.futo.platformplayer.api.media.exceptions.NoPlatformClientException
@@ -21,7 +20,6 @@ import com.futo.platformplayer.models.ImportCache
 import com.futo.platformplayer.models.Playlist
 import com.futo.platformplayer.sToOffsetDateTimeUTC
 import com.futo.platformplayer.smartMerge
-import com.futo.platformplayer.states.StateSubscriptionGroups.Companion
 import com.futo.platformplayer.stores.FragmentedStorage
 import com.futo.platformplayer.stores.StringArrayStorage
 import com.futo.platformplayer.stores.StringDateMapStorage
@@ -30,15 +28,12 @@ import com.futo.platformplayer.stores.v2.ManagedStore
 import com.futo.platformplayer.stores.v2.ReconstructStore
 import com.futo.platformplayer.sync.internal.GJSyncOpcodes
 import com.futo.platformplayer.sync.models.SyncPlaylistsPackage
-import com.futo.platformplayer.sync.models.SyncSubscriptionGroupsPackage
-import com.futo.platformplayer.sync.models.SyncSubscriptionsPackage
 import com.futo.platformplayer.sync.models.SyncWatchLaterPackage
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import java.io.File
-import java.time.Instant
 import java.time.OffsetDateTime
 import java.time.ZoneOffset

@@ -178,31 +173,30 @@ class StatePlaylists {
            StateDownloads.instance.checkForOutdatedPlaylistVideos(VideoDownload.GROUP_WATCHLATER);
        }
    }
-    fun addToWatchLater(video: SerializedPlatformVideo, isUserInteraction: Boolean = false, orderPosition: Int = -1): Boolean {
-        var wasNew = false;
+    fun addToWatchLater(video: SerializedPlatformVideo, isUserInteraction: Boolean = false): Boolean {
        synchronized(_watchlistStore) {
-            if(!_watchlistStore.hasItem { it.url == video.url })
-                wasNew = true;
-            _watchlistStore.saveAsync(video);
-            if(orderPosition == -1)
-                _watchlistOrderStore.set(*(listOf(video.url) + _watchlistOrderStore.values).toTypedArray());
-            else {
-                val existing = _watchlistOrderStore.getAllValues().toMutableList();
-                existing.add(orderPosition, video.url);
-                _watchlistOrderStore.set(*existing.toTypedArray());
+            if (_watchlistStore.hasItem { it.url == video.url }) {
+                return false
            }
-            _watchlistOrderStore.save();
+
+            _watchlistStore.saveAsync(video)
+            if (Settings.instance.other.watchLaterAddStart) {
+                _watchlistOrderStore.set(*(listOf(video.url) + _watchlistOrderStore.values).toTypedArray())
+            } else {
+                _watchlistOrderStore.set(*(_watchlistOrderStore.values + listOf(video.url)).toTypedArray())
+            }
+            _watchlistOrderStore.save()
        }
        onWatchLaterChanged.emit();

-        if(isUserInteraction) {
+        if (isUserInteraction) {
            val now = OffsetDateTime.now();
            _watchLaterAdds.setAndSave(video.url, now);
            broadcastWatchLaterAddition(video, now);
        }

        StateDownloads.instance.checkForOutdatedPlaylists();
-        return wasNew;
+        return true;
    }

    fun getLastPlayedPlaylist() : Playlist? {
@@ -174,7 +174,7 @@ abstract class SubscriptionsTaskFetchAlgorithm(

                            if (resolve != null) {
                                resolveCount = resolves.size;
-                                UIDialogs.appToast("SubsExchange (Res: ${resolves.size}, Prov: ${resolve.size}")
+                                UIDialogs.appToast("SubsExchange (Res: ${resolves.size}, Prov: ${resolve.size})")
                                for(result in resolve){
                                    val task = providedTasks?.find { it.url == result.channelUrl };
                                    if(task != null) {
@@ -39,6 +39,9 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
+import java.text.DecimalFormat
+import java.text.DecimalFormatSymbols
+import java.util.Locale


 class GestureControlView : LinearLayout {
@@ -79,6 +82,9 @@ class GestureControlView : LinearLayout {
    private var _adjustingFullscreenDown: Boolean = false;
    private var _fullScreenFactorUp = 1.0f;
    private var _fullScreenFactorDown = 1.0f;
+    private val _layoutHoldSpeed: LinearLayout
+    private val _textHoldFastForward: TextView
+    private val _imageHoldFastForward: ImageView

    private var _scaleGestureDetector: ScaleGestureDetector
    private var _scaleFactor = 1.0f
@@ -94,6 +100,10 @@ class GestureControlView : LinearLayout {
    private var _layoutIndicatorFit: FrameLayout;
    private var _speedHolding = false

+    private val _speedFormatter = DecimalFormat("#.##", DecimalFormatSymbols(Locale.US)).apply {
+        roundingMode = java.math.RoundingMode.HALF_UP
+    }
+
    private val _gestureController: GestureDetectorCompat;

    val isUserGesturing get() = _rewinding || _skipping || _adjustingBrightness || _adjustingSound || _adjustingFullscreenUp || _adjustingFullscreenDown || _isPanning || _isZooming;
@@ -127,6 +137,9 @@ class GestureControlView : LinearLayout {
        _layoutControlsFullscreen = findViewById(R.id.layout_controls_fullscreen);
        _layoutIndicatorFill = findViewById(R.id.layout_indicator_fill);
        _layoutIndicatorFit = findViewById(R.id.layout_indicator_fit);
+        _layoutHoldSpeed = findViewById(R.id.layout_controls_increased_speed)
+        _textHoldFastForward = findViewById(R.id.text_holdFastForward)
+        _imageHoldFastForward = findViewById(R.id.image_holdFastForward)

        _scaleGestureDetector = ScaleGestureDetector(context, object : ScaleGestureDetector.SimpleOnScaleGestureListener() {
            override fun onScale(detector: ScaleGestureDetector): Boolean {
@@ -229,6 +242,7 @@ class GestureControlView : LinearLayout {
                    && !_isPanning
                    && !_isZooming) {
                    _speedHolding = true
+                    showHoldSpeedControls()
                    onSpeedHoldStart.emit()
                }
            }
@@ -316,6 +330,17 @@ class GestureControlView : LinearLayout {
        onPan.emit(_translationX, _translationY)
    }

+    private fun showHoldSpeedControls() {
+        _layoutHoldSpeed.visibility = View.VISIBLE
+        _textHoldFastForward.text = _speedFormatter.format(Settings.instance.playback.getHoldPlaybackSpeed()) + "x"
+        (_imageHoldFastForward.drawable as? Animatable)?.start()
+    }
+
+    private fun hideHoldSpeedControls() {
+        _layoutHoldSpeed.visibility = View.GONE
+        (_imageHoldFastForward.drawable as? Animatable)?.stop()
+    }
+
    fun setupTouchArea(layoutControls: ViewGroup? = null, background: View? = null) {
        _layoutControls = layoutControls;
        _background = background;
@@ -326,6 +351,7 @@ class GestureControlView : LinearLayout {

        if (ev.action == MotionEvent.ACTION_UP && _speedHolding) {
            _speedHolding = false
+            hideHoldSpeedControls()
            onSpeedHoldEnd.emit()
        }

@@ -18,6 +18,7 @@ import androidx.media3.ui.DefaultTimeBar
 import androidx.media3.ui.TimeBar
 import com.bumptech.glide.Glide
 import com.futo.platformplayer.R
+import com.futo.platformplayer.Settings
 import com.futo.platformplayer.api.media.models.chapters.IChapter
 import com.futo.platformplayer.api.media.models.video.IPlatformVideoDetails
 import com.futo.platformplayer.casting.AirPlayCastingDevice
@@ -58,6 +59,8 @@ class CastView : ConstraintLayout {
    private var _inPictureInPicture: Boolean = false;
    private var _chapters: List<IChapter>? = null;
    private var _currentChapter: IChapter? = null;
+    private var _speedHoldPrevRate = 1.0
+    private var _speedHoldWasPlaying = false

    val onChapterChanged = Event2<IChapter?, Boolean>();
    val onMinimizeClick = Event0();
@@ -87,6 +90,20 @@ class CastView : ConstraintLayout {
        _gestureControlView = findViewById(R.id.gesture_control);
        _gestureControlView.fullScreenGestureEnabled = false
        _gestureControlView.setupTouchArea();
+        _gestureControlView.onSpeedHoldStart.subscribe {
+            val d = StateCasting.instance.activeDevice ?: return@subscribe;
+            _speedHoldWasPlaying = d.isPlaying
+            _speedHoldPrevRate = d.speed
+            if (d.canSetSpeed)
+                d.changeSpeed(Settings.instance.playback.getHoldPlaybackSpeed())
+            d.resumeVideo()
+        }
+        _gestureControlView.onSpeedHoldEnd.subscribe {
+            val d = StateCasting.instance.activeDevice ?: return@subscribe;
+            if (!_speedHoldWasPlaying) d.pauseVideo()
+            d.changeSpeed(_speedHoldPrevRate)
+        }
+
        _gestureControlView.onSeek.subscribe {
            val d = StateCasting.instance.activeDevice ?: return@subscribe;
            StateCasting.instance.videoSeekTo(d.expectedCurrentTime + it / 1000);
@@ -13,6 +13,7 @@ import android.widget.RelativeLayout
 import android.widget.TextView
 import androidx.core.animation.doOnEnd
 import androidx.core.view.children
+import androidx.core.view.isVisible
 import com.futo.platformplayer.R
 import com.futo.platformplayer.constructs.Event0

@@ -42,10 +43,14 @@ class SlideUpMenuOverlay : RelativeLayout {
    constructor(context: Context, parent: ViewGroup, titleText: String, okText: String?, animated: Boolean, items: List<View>, hideButtons: Boolean = false): super(context){
        init(animated, okText);
        _container = parent;
-        if(!_container!!.children.contains(this)) {
-            _container!!.removeAllViews();
-            _container!!.addView(this);
+        _container!!.removeAllViews();
+        _container!!.addView(this);
+        if (_container!!.isVisible) {
+            isVisible = true
+            _viewBackground.alpha = 1.0f;
+            _viewOverlayContainer.translationY = 0.0f;
        }
+
        _textTitle.text = titleText;
        groupItems = items;

@@ -56,6 +61,12 @@ class SlideUpMenuOverlay : RelativeLayout {
        }

        setItems(items);
+
+        if (!isVisible) {
+            _viewOverlayContainer.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED);
+            _viewOverlayContainer.translationY = _viewOverlayContainer.measuredHeight.toFloat()
+            _viewBackground.alpha = 0f;
+        }
    }


@@ -146,16 +157,9 @@ class SlideUpMenuOverlay : RelativeLayout {
        }

        isVisible = true;
-        _container?.post {
-            _container?.visibility = View.VISIBLE;
-            _container?.bringToFront();
-        }
+        _container?.visibility = View.VISIBLE;

        if (_animated) {
-            _viewOverlayContainer.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED);
-            _viewOverlayContainer.translationY = _viewOverlayContainer.measuredHeight.toFloat()
-            _viewBackground.alpha = 0f;
-
            val animations = arrayListOf<Animator>();
            animations.add(ObjectAnimator.ofFloat(_viewBackground, "alpha", 0.0f, 1.0f).setDuration(ANIMATION_DURATION_MS));
            animations.add(ObjectAnimator.ofFloat(_viewOverlayContainer, "translationY", _viewOverlayContainer.measuredHeight.toFloat(), 0.0f).setDuration(ANIMATION_DURATION_MS));
@@ -261,7 +261,7 @@ class FutoVideoPlayer : FutoVideoPlayerBase {
            exoPlayer?.player?.let { player ->
                _speedHoldWasPlaying = player.isPlaying
                _speedHoldPrevRate = getPlaybackRate()
-                setPlaybackRate(2f)
+                setPlaybackRate(Settings.instance.playback.getHoldPlaybackSpeed().toFloat())
                player.play()
            }
        }
@@ -52,10 +52,13 @@ import com.futo.platformplayer.api.media.platforms.js.models.sources.JSDashManif
 import com.futo.platformplayer.api.media.platforms.js.models.sources.JSHLSManifestAudioSource
 import com.futo.platformplayer.api.media.platforms.js.models.sources.JSSource
 import com.futo.platformplayer.api.media.platforms.js.models.sources.JSVideoUrlRangeSource
+import com.futo.platformplayer.constructs.Event0
 import com.futo.platformplayer.constructs.Event1
+import com.futo.platformplayer.engine.exceptions.ScriptReloadRequiredException
 import com.futo.platformplayer.helpers.VideoHelper
 import com.futo.platformplayer.logging.Logger
 import com.futo.platformplayer.states.StateApp
+import com.futo.platformplayer.states.StatePlatform
 import com.futo.platformplayer.video.PlayerManager
 import com.futo.platformplayer.views.video.datasources.PluginMediaDrmCallback
 import com.futo.platformplayer.views.video.datasources.JSHttpDataSource
@@ -108,6 +111,8 @@ abstract class FutoVideoPlayerBase : RelativeLayout {
    val onPositionDiscontinuity = Event1<Long>();
    val onDatasourceError = Event1<Throwable>();

+    val onReloadRequired = Event0();
+
    private var _didCallSourceChange = false;
    private var _lastState: Int = -1;

@@ -560,12 +565,14 @@ abstract class FutoVideoPlayerBase : RelativeLayout {

        if(videoSource.hasGenerate) {
            findViewTreeLifecycleOwner()?.lifecycle?.coroutineScope?.launch(Dispatchers.IO) {
+                var startId = -1;
                try {
+                    startId = videoSource?.getUnderlyingPlugin()?.getUnderlyingPlugin()?.runtimeId ?: -1;
                    val generated = videoSource.generate();
                    if (generated != null) {
                        withContext(Dispatchers.Main) {
                            val dataSource = if(videoSource is JSSource && (videoSource.requiresCustomDatasource))
-                                videoSource.getHttpDataSourceFactory()
+                                withContext(Dispatchers.IO) { videoSource.getHttpDataSourceFactory() }
                            else
                                DefaultHttpDataSource.Factory().setUserAgent(DEFAULT_USER_AGENT);

@@ -585,6 +592,17 @@ abstract class FutoVideoPlayerBase : RelativeLayout {
                        }
                    }
                }
+                catch(reloadRequired: ScriptReloadRequiredException) {
+                    Logger.i(TAG, "Reload required detected");
+                    val plugin = videoSource.getUnderlyingPlugin();
+                    if(plugin == null)
+                        return@launch;
+                    if(startId != -1 && plugin.getUnderlyingPlugin()?.runtimeId != startId)
+                        return@launch;
+                    StatePlatform.instance.handleReloadRequired(reloadRequired, {
+                        onReloadRequired.emit();
+                    });
+                }
                catch(ex: Throwable) {
                    Logger.e(TAG, "DashRaw generator failed", ex);
                }
@@ -671,25 +689,47 @@ abstract class FutoVideoPlayerBase : RelativeLayout {
    @OptIn(UnstableApi::class)
    private fun swapAudioSourceDashRaw(audioSource: JSDashManifestRawAudioSource, play: Boolean, resume: Boolean): Boolean {
        Logger.i(TAG, "Loading AudioSource [DashRaw]");
-        val dataSource = if(audioSource is JSSource && (audioSource.requiresCustomDatasource))
-            audioSource.getHttpDataSourceFactory()
-        else
-            DefaultHttpDataSource.Factory().setUserAgent(DEFAULT_USER_AGENT);
        if(audioSource.hasGenerate) {
            findViewTreeLifecycleOwner()?.lifecycle?.coroutineScope?.launch(Dispatchers.IO) {
-                val generated = audioSource.generate();
-                if(generated != null) {
-                    withContext(Dispatchers.Main) {
-                        _lastVideoMediaSource = DashMediaSource.Factory(dataSource)
-                            .createMediaSource(DashManifestParser().parse(Uri.parse(audioSource.url),
-                                ByteArrayInputStream(generated?.toByteArray() ?: ByteArray(0))));
-                        loadSelectedSources(play, resume);
+                var startId = -1;
+                try {
+                    startId = audioSource.getUnderlyingPlugin()?.getUnderlyingPlugin()?.runtimeId ?: -1;
+                    val generated = audioSource.generate();
+                    if(generated != null) {
+                        val dataSource = if(audioSource is JSSource && (audioSource.requiresCustomDatasource))
+                            audioSource.getHttpDataSourceFactory()
+                        else
+                            DefaultHttpDataSource.Factory().setUserAgent(DEFAULT_USER_AGENT);
+                        withContext(Dispatchers.Main) {
+                            _lastVideoMediaSource = DashMediaSource.Factory(dataSource)
+                                .createMediaSource(DashManifestParser().parse(Uri.parse(audioSource.url),
+                                    ByteArrayInputStream(generated?.toByteArray() ?: ByteArray(0))));
+                            loadSelectedSources(play, resume);
+                        }
                    }
                }
+                catch(reloadRequired: ScriptReloadRequiredException) {
+                    Logger.i(TAG, "Reload required detected");
+                    val plugin = audioSource.getUnderlyingPlugin();
+                    if(plugin == null)
+                        return@launch;
+                    if(startId != -1 && plugin.getUnderlyingPlugin()?.runtimeId != startId)
+                        return@launch;
+                    StatePlatform.instance.reEnableClient(plugin.id, {
+                        onReloadRequired.emit();
+                    });
+                }
+                catch(ex: Throwable) {
+
+                }
            }
            return false;
        }
        else {
+            val dataSource = if(audioSource is JSSource && (audioSource.requiresCustomDatasource))
+                audioSource.getHttpDataSourceFactory()
+            else
+                DefaultHttpDataSource.Factory().setUserAgent(DEFAULT_USER_AGENT);
            _lastVideoMediaSource = DashMediaSource.Factory(dataSource)
                .createMediaSource(
                    DashManifestParser().parse(
@@ -8,7 +8,7 @@
    android:orientation="vertical"
    android:paddingTop="10dp"
    android:animateLayoutChanges="true">
-    <ScrollView
+    <androidx.core.widget.NestedScrollView
        android:layout_width="match_parent"
        android:layout_height="match_parent">
        <LinearLayout
@@ -152,13 +152,14 @@
                android:id="@+id/button_add_sources"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
+                android:layout_marginBottom="10dp"
                app:buttonIcon="@drawable/ic_explore"
                app:buttonText="Add Sources"
                app:buttonSubText="Install new sources to see more content."
                />

        </LinearLayout>
-    </ScrollView>
+    </androidx.core.widget.NestedScrollView>


 </LinearLayout>
@@ -195,4 +195,39 @@
        app:layout_constraintEnd_toEndOf="parent"
        android:visibility="gone"/>

+    <LinearLayout
+        android:id="@+id/layout_controls_increased_speed"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        app:layout_constraintTop_toTopOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        android:orientation="horizontal"
+        android:gravity="center_vertical"
+        android:background="@drawable/background_pill_black"
+        android:paddingStart="8dp"
+        android:paddingEnd="8dp"
+        android:paddingTop="4dp"
+        android:paddingBottom="4dp"
+        android:layout_marginTop="20dp"
+        android:visibility="gone">
+
+        <TextView
+            android:id="@+id/text_holdFastForward"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            tools:text="2x"
+            android:textSize="14dp"
+            android:textColor="@color/white"
+            android:fontFamily="@font/inter_regular" />
+
+        <ImageView
+            android:id="@+id/image_holdFastForward"
+            android:layout_width="wrap_content"
+            android:layout_height="8dp"
+            android:adjustViewBounds="true"
+            app:srcCompat="@drawable/ic_fastforward_animated"
+            android:layout_marginStart="4dp"/>
+    </LinearLayout>
+
 </androidx.constraintlayout.widget.ConstraintLayout>
@@ -3,4 +3,5 @@
    <dimen name="minimized_player_max_width">500dp</dimen>
    <dimen name="app_bar_height">200dp</dimen>
    <integer name="column_width_dp">400</integer>
+    <integer name="smallest_width_dp">600</integer>
 </resources>
@@ -433,6 +433,8 @@
    <string name="min_playback_speed_description">Minimum Available Speed</string>
    <string name="max_playback_speed">Maximum Playback Speed</string>
    <string name="max_playback_speed_description">Maximum Available Speed</string>
+    <string name="hold_playback_speed">Hold playback speed</string>
+    <string name="hold_playback_speed_description">Playback speed when pressing down on the video</string>
    <string name="step_playback_speed">Playback Speed Step Size</string>
    <string name="step_playback_speed_description">The step size of playback speeds, may not affect higher playback speeds.</string>
    <string name="seek_offset_description">Fast-Forward / Fast-Rewind duration</string>
@@ -466,6 +468,9 @@
    <string name="playlist_delete_confirmation_description">Show confirmation dialog when deleting media from a playlist</string>
    <string name="playlist_allow_dups">Allow duplicate playlist videos</string>
    <string name="playlist_allow_dups_description">Allow adding duplicate videos to playlists</string>
+    <string name="watch_later_add_start">Add new videos to the beginning of Watch Later</string>
+    <string name="watch_later_add_start_description">When adding videos to Watch Later add them to the beginning of the list instead of the end</string>
+    <string name="already_in_watch_later">Already in watch later</string>
    <string name="enable_polycentric">Enable Polycentric</string>
    <string name="polycentric_local_cache">Enable Polycentric Local Caching</string>
    <string name="polycentric_local_cache_description">Caches polycentric results on-device to reduce load times, changing requires app reboot</string>
@@ -1106,6 +1111,16 @@
        <item>4.0</item>
        <item>5.0</item>
    </string-array>
+    <string-array name="hold_playback_speeds">
+        <item>1.25</item>
+        <item>1.5</item>
+        <item>1.75</item>
+        <item>2.0</item>
+        <item>2.25</item>
+        <item>2.5</item>
+        <item>2.75</item>
+        <item>3.0</item>
+    </string-array>
    <string-array name="min_playback_speed">
        <item>0.25</item>
        <item>0.5</item>
Author	SHA1	Message	Date
Kelvin K	7e83793586	Submods	2025-06-16 18:34:37 +02:00
Kelvin K	6ba9ec8bc2	Clearer name setting	2025-06-16 17:56:04 +02:00
Kelvin	0b02ab0e2d	Merge branch 'plugin-fixes' into 'master' V8 Update, V8 interaction locking, Package fixes, ReloadRequiredException support See merge request videostreaming/grayjay!125	2025-06-16 15:48:01 +00:00
Kelvin K	ff531b5e77	Cleanup, fixes, clearCookies support on httpClients	2025-06-16 17:46:00 +02:00
Kelvin K	b3f9de3b83	edgecase fix	2025-06-16 14:23:34 +02:00
Kelvin K	86bd71b89c	Fix edgecase	2025-06-16 14:19:23 +02:00
Kelvin K	2fca7e9a01	Locking of most known v8 interactions, fix returning previously returned jvm objects, Related fixes	2025-06-16 14:13:47 +02:00
Koen	2cc873ef60	Merge branch 'quality-selector-fix' into 'master' fix graphical glitches with quality selector See merge request videostreaming/grayjay!109	2025-06-16 10:07:16 +00:00
Koen	7a66ce6bcd	Merge branch 'sources-tab-scrolling-fix' into 'master' Sources Scrolling Fix See merge request videostreaming/grayjay!114	2025-06-16 10:01:45 +00:00
Koen	2730569b6b	Merge branch 'tablet-landscape-fix' into 'master' Tablet Landscape Fix See merge request videostreaming/grayjay!115	2025-06-16 09:57:57 +00:00
Koen	ede5c4409c	Merge branch 'watch-later-add-feature' into 'master' Water Later Add Feature See merge request videostreaming/grayjay!117	2025-06-16 09:54:43 +00:00
Koen	0dbe398435	Merge branch 'hls-quality-sort' into 'master' Adaptive Quality Sort See merge request videostreaming/grayjay!118	2025-06-16 09:41:22 +00:00
Koen J	bcab3bccbc	Fixed crash when signature fields are wrongly populated.	2025-06-16 10:43:57 +02:00
Kelvin K	58c9aeb1a2	WIP: V8 update, package http fixes, ReloadRequiredException support, other fixes. Currently broken in situations where setTimeout is used	2025-06-14 15:51:31 +02:00
Kelvin K	4702787784	WIP	2025-06-13 17:47:22 +02:00
Koen J	13100dc38d	Minor fix in playback speed setting.	2025-06-12 11:21:00 +02:00
Koen J	5227041398	Added setting for hold playback speed increase. Implemented chromecast playback rate adjustment in range [1, 2]. Implemented hold playback speed increase pill.	2025-06-12 10:33:05 +02:00
Kai	9944842a2f	Change adaptive streaming (HLS and Dash) quality to sort in descending quality to align with YouTube and the rest of Grayjay Changelog: changed	2025-06-09 17:02:55 -05:00
Kai	99dc50894c	update text Changelog: changed	2025-06-09 16:54:24 -05:00
Kai	6598dff6df	add add to watch later setting add https://github.com/futo-org/grayjay-android/issues/2173 Changelog: added	2025-06-06 23:35:59 -05:00
Kai	623c47fa2e	fix https://github.com/futo-org/grayjay-android/issues/2210 Changelog: changed	2025-06-06 15:25:46 -05:00
Kai	19861fe812	fix https://github.com/futo-org/grayjay-android/issues/2316 Changelog: changed	2025-06-06 13:40:20 -05:00
Kai	c333300906	fix graphical glitches with quality selector Changelog: changed	2025-06-05 11:08:19 -05:00