@oxymoron.13/tizentube-s95b 0.2.2 → 0.2.3

package/mods/ui/chapters.js

@@ -0,0 +1,137 @@
+function parseTimestamps(input) {
+    var lines = input.trim().split('\n');
+    var result = [];
+    var timestampRegex = /^\d+:\d{2}/;
+
+    for (var i = 0; i < lines.length; i++) {
+        var line = lines[i];
+        var match = line.match(timestampRegex);
+        if (match) {
+            var timePart = match[0];
+            var parts = line.split(' ');
+            parts.shift();
+            var timeParts = timePart.split(':');
+            var minutes = parseInt(timeParts[0], 10);
+            var seconds = parseInt(timeParts[1], 10);
+            var milliseconds = (minutes * 60 + seconds) * 1000;
+            var name = parts.join(' ');
+            result.push({ time: milliseconds, name: name });
+        }
+    }
+    return result;
+}
+
+function marker(title, start, duration, videoID, i) {
+    return {
+        title: {
+            simpleText: title
+        },
+        startMillis: start,
+        durationMillis: duration,
+        thumbnailDetails: {
+            thumbnails: [
+                {
+                    url: `https://i.ytimg.com/vi/${videoID}/hqdefault.jpg`,
+                    width: 320,
+                    height: 180
+                }
+            ]
+        },
+        onActive: {
+            innertubeCommand: {
+                clickTrackingParams: null,
+                entityUpdateCommand: {
+                    entityBatchUpdate: {
+                        mutations: [
+                            {
+                                entityKey: `${videoID}${start}${duration}`,
+                                type: 'ENTITY_MUTATION_TYPE_REPLACE',
+                                payload: {
+                                    markersEngagementPanelSyncEntity: {
+                                        key: `${videoID}${start}${duration}`,
+                                        panelId: 'engagement-panel-macro-markers-description-chapters',
+                                        activeItemIndex: i,
+                                        syncEnabled: true
+                                    }
+                                }
+                            }
+                        ]
+                    }
+                }
+            }
+        }
+    }
+}
+
+function markerEntity(videoID, markers) {
+    return {
+        entityKey: `${videoID}-key`,
+        type: 'ENTITY_MUTATION_TYPE_REPLACE',
+        payload: {
+            macroMarkersListEntity: {
+                key: `${videoID}-key`,
+                externalVideoId: videoID,
+                markersList: {
+                    markerType: 'MARKER_TYPE_CHAPTERS',
+                    markers: markers,
+                    headerTitle: {
+                        runs: [
+                            {
+                                text: 'Chapters'
+                            }
+                        ]
+                    },
+                    onTap: {
+                        innertubeCommand: {
+                            clickTrackingParams: null,
+                            changeEngagementPanelVisibilityAction: {
+                                targetId: 'engagement-panel-macro-markers-description-chapters',
+                                visibility: 'ENGAGEMENT_PANEL_VISIBILITY_EXPANDED'
+                            }
+                        }
+                    },
+                    markersEdu: {
+                        enterNudgeText: {
+                            runs: [
+                                {
+                                    text: 'To view chapters, press the up arrow button'
+                                }
+                            ]
+                        },
+                        enterNudgeA11yText: 'To view chapters, press the up arrow button',
+                        navNudgeText: {
+                            runs: [
+                                {
+                                    text: 'Navigate between chapters'
+                                }
+                            ]
+                        },
+                        navNudgeA11yText: 'Press the left or right arrow button to navigate between chapters'
+                    },
+                    loggingDirectives: {
+                        trackingParams: null,
+                        enableDisplayloggerExperiment: true
+                    }
+                }
+            }
+        }
+    }
+}
+
+export default function Chapters(video) {
+    const videoID = video.contents.singleColumnWatchNextResults.results.results.contents[0].itemSectionRenderer.contents[0].videoMetadataRenderer.videoId;
+    const videoDescription = video.contents.singleColumnWatchNextResults.results.results.contents[0].itemSectionRenderer.contents[0].videoMetadataRenderer.description.runs[0].text;
+    const chapters = parseTimestamps(videoDescription);
+    const videoDuration = document.getElementsByTagName('video')[0].duration * 1000;
+    let markers = [];
+
+    for (let i = 0; i < chapters.length; i++) {
+        const chapter = chapters[i];
+        const nextChapter = chapters[i + 1];
+        const duration = nextChapter ? nextChapter.time - chapter.time : videoDuration - chapter.time;
+        markers.push(marker(chapter.name, String(chapter.time), String(duration), videoID, i));
+    }
+
+    const markerEntityData = markerEntity(videoID, markers);
+    return markerEntityData;
+}

package/mods/ui/clock.js

@@ -0,0 +1,71 @@
+import { configChangeEmitter, configRead } from '../config.js';
+
+configChangeEmitter.addEventListener('configChange', (e) => {
+    if (e.detail.key === 'enableClock') {
+        toggleClock(e.detail.value);
+    }
+});
+
+let actualClock;
+
+function toggleClock(value) {
+    const existingClock = document.getElementById('tizentube-clock');
+    if (value && existingClock) return;
+    if (!value && existingClock) {
+        existingClock.remove();
+        return;
+    }
+    if (!value && !existingClock) {
+        return;
+    } else {
+        const clock = document.createElement('div');
+ 
+        clock.id = 'tizentube-clock';
+        clock.style.height = '45rem';
+        clock.style.width = '80rem';
+        clock.style.position = 'absolute';
+        clock.style.top = '50%';
+        clock.style.left = '50%';
+        clock.style.marginTop = '-22.5rem';
+        clock.style.marginLeft = '-40rem';
+
+        actualClock = document.createElement('div');
+
+        actualClock.style.position = 'absolute';
+        actualClock.style.zIndex = '9999';
+        actualClock.style.right = '5%';
+        actualClock.style.top = '2%';
+        actualClock.style.fontSize = '1.5em';
+        clock.appendChild(actualClock);
+        document.body.appendChild(clock);
+
+        function updateClock() {
+            const now = new Date();
+            const is12HourFormat = configRead('isClock12HourFormat');
+            const secondsEnabled = configRead('clockShowSeconds');
+            const shouldHideWhenVideoPlaying = configRead('clockHideWhenVideoPlaying');
+            const ytlrWatchDefault = document.querySelector('ytlr-watch-default');
+            
+            if (shouldHideWhenVideoPlaying) {
+                if (ytlrWatchDefault && ytlrWatchDefault.getAttribute('hybridnavfocusable') === 'true')
+                    actualClock.style.display = 'none';
+                else actualClock.style.display = 'block';
+            }
+
+            let hours = now.getHours();
+            if (is12HourFormat) {
+                hours = hours % 12 || 12;
+            }
+
+            hours = hours.toString().padStart(2, '0');
+            const minutes = now.getMinutes().toString().padStart(2, '0');
+            const seconds = now.getSeconds().toString().padStart(2, '0');
+            actualClock.textContent = `${hours}:${minutes}${secondsEnabled ? `:${seconds}` : ''}${is12HourFormat ? (now.getHours() >= 12 ? ' PM' : ' AM') : ''}`;
+        }
+
+        updateClock();
+        setInterval(updateClock, 1000);
+    }
+}
+
+toggleClock(configRead('enableClock'));

package/mods/ui/customCommandExecution.js

@@ -0,0 +1,49 @@
+function getCommandExecutor() {
+    let instance;
+    let executeFunction;
+
+    for (const key in window._yttv) {
+        if (window._yttv[key] && window._yttv[key].getInstance) {
+            if (window._yttv[key].toString().includes('ytlrActionRouter')) instance = window._yttv[key].getInstance();
+            else {
+                let isInstance = false;
+                const tempInstance = window._yttv[key].getInstance();
+                const keys = Object.getOwnPropertyNames(Object.getPrototypeOf(tempInstance));
+                for (const key of keys) {
+                    if (typeof tempInstance[key] === 'function' && tempInstance[key].toString().includes('ytlrActionRouter')) {
+                        executeFunction = tempInstance[key];
+                        isInstance = true;
+                    }
+                }
+
+                if (isInstance) instance = window._yttv[key].getInstance();
+            }
+        }
+    }
+
+    if (!instance) return;
+
+    if (!executeFunction) {
+        const keys = Object.getOwnPropertyNames(Object.getPrototypeOf(instance));
+        for (const key of keys) {
+            if (typeof instance[key] === 'function' && instance[key].toString().includes('ytlrActionRouter')) {
+                executeFunction = instance[key];
+            }
+        }
+    }
+
+    if (!executeFunction) return;
+
+    let commandFunction;
+    for (const key in window._yttv) {
+        if (window._yttv[key] && typeof window._yttv[key] === 'function' && window._yttv[key].toString().includes('this.actionName')) {
+            commandFunction = window._yttv[key];
+        }
+    }
+    return {
+        executeFunction: executeFunction.bind(instance),
+        commandFunction
+    }
+}
+
+export default getCommandExecutor;

package/mods/ui/customGuideAction.js

@@ -0,0 +1,119 @@
+import { configChangeEmitter, configRead, configWrite } from "../config.js";
+import getCommandExecutor from "./customCommandExecution.js";
+import { GuideEntryRenderer } from "./ytUI.js";
+
+const origParse = JSON.parse;
+JSON.parse = function () {
+    const r = origParse.apply(this, arguments);
+    const guideSection = r.items?.[0]?.guideSectionRenderer;
+    const order = configRead('sidebarContentsOrder');
+    if (guideSection && Array.isArray(order)) {
+        let orderChanged = false;
+        for (const item of guideSection.items) {
+            // Not every guide item is a guideEntryRenderer: a throw here would fail
+            // the caller's JSON.parse and lose the whole guide response.
+            const itemOrder = item.guideEntryRenderer?.navigationEndpoint?.browseEndpoint?.browseId
+                || (item.guideEntryRenderer?.navigationEndpoint?.searchEndpoint && 'search');
+            if (itemOrder && !order.some(orderItem =>
+                (typeof orderItem === 'object' ? orderItem.browseId : orderItem) === itemOrder)) {
+                order.push(itemOrder);
+                orderChanged = true;
+            }
+        }
+        if (orderChanged) configWrite('sidebarContentsOrder', order);
+    }
+    if (configRead('sidebarContentsOrder')?.length === 0) {
+       // Add all of the items in the sidebar to the sidebarContentsOrder
+        if (r.items && Array.isArray(r.items) && r.items[0].guideSectionRenderer) {
+            const order = [];
+            for (const item of r.items[0].guideSectionRenderer.items) {
+                const browseId = item.guideEntryRenderer?.navigationEndpoint?.browseEndpoint?.browseId;
+                if (browseId) {
+                    order.push(browseId);
+                } else if (item.guideEntryRenderer?.navigationEndpoint?.searchEndpoint) {
+                    order.push('search');
+                }
+            }
+            configWrite('sidebarContentsOrder', order);
+        }
+    } else {
+        // Reorder the items based on the sidebarContentsOrder config key
+
+        if (r.items && Array.isArray(r.items) && r.items[0].guideSectionRenderer) {
+            const order = configRead('sidebarContentsOrder');
+            const items = r.items[0].guideSectionRenderer.items;
+            const copiedItems = JSON.parse(JSON.stringify(items));
+
+            for (const orderItem of order) {
+                if (typeof orderItem === 'object' && orderItem !== null) {
+                    const customItem = GuideEntryRenderer(
+                        orderItem.title,
+                        {
+                            browseEndpoint: {
+                                browseId: orderItem.browseId
+                            }
+                        },
+                        'PERSON'
+                    );
+                    copiedItems.push(customItem);
+                }
+            }
+
+            const orderedItems = [];
+            const placed = new Set();
+            for (const orderItem of order) {
+                const browseId = typeof orderItem === 'object' ? orderItem.browseId : orderItem;
+                const index = copiedItems.findIndex(item => {
+                    const itemBrowseId = item.guideEntryRenderer?.navigationEndpoint?.browseEndpoint?.browseId;
+                    return itemBrowseId === browseId || (browseId === 'search' && item.guideEntryRenderer?.navigationEndpoint?.searchEndpoint);
+                });
+                if (index !== -1) {
+                    orderedItems.push(copiedItems[index]);
+                    placed.add(index);
+                }
+            }
+            // Entries the stored order knows nothing about must survive, after the
+            // ordered ones. The order is not scoped to a profile: it is learned from
+            // whichever profile loads first, and only from entries exposing a
+            // browseEndpoint.browseId. A YouTube Kids profile's guide entries don't,
+            // so they were neither learned above nor matched here — dropping them
+            // emptied the whole left menu on that profile (#643, #648).
+            copiedItems.forEach((item, index) => {
+                if (!placed.has(index)) orderedItems.push(item);
+            });
+            r.items[0].guideSectionRenderer.items = orderedItems;
+        }
+    }
+
+    const disabledSidebarContents = configRead('disabledSidebarContents');
+    const disableChannelsOnSidebar = configRead('disableChannelsOnSidebar');
+    if (r.items && Array.isArray(r.items) && r.items[0].guideSectionRenderer) {
+        for (let i = 0; i < r.items.length; i++) {
+            const section = r.items[i].guideSectionRenderer;
+            section.originalItems = section.items.slice();
+            for (let j = 0; j < section.items.length; j++) {
+                const item = section.items[j].guideEntryRenderer;
+                if (!item) continue;
+                if ((disabledSidebarContents?.length &&
+                    disabledSidebarContents.includes(item.navigationEndpoint?.browseEndpoint ?
+                        item.navigationEndpoint.browseEndpoint.browseId :
+                        'search'))
+                    || (disableChannelsOnSidebar && item?.thumbnail)) {
+                    section.items.splice(j, 1);
+                    j--;
+                }
+            }
+        }
+    }
+
+    return r;
+}
+
+configChangeEmitter.addEventListener('configChange', (e) => {
+    if (e.detail.key === 'disabledSidebarContents' || e.detail.key === 'disableChannelsOnSidebar' || e.detail.key === 'sidebarContentsOrder') {
+        const commandExecutor = getCommandExecutor();
+        if (commandExecutor) {
+            commandExecutor.executeFunction(new commandExecutor.commandFunction('reloadGuideAction'));
+        }
+    }
+});

package/mods/ui/customUI.js

@@ -0,0 +1,192 @@
+// Custom UI for video player
+
+import { extractAssignedFunctions } from "../utils/ASTParser.js";
+import { configRead } from "../config.js";
+import { ButtonRenderer } from "./ytUI.js";
+import { t } from 'i18next';
+
+// S95B: result of the AST scan is constant for a given player class, so compute it once.
+let s95bFunctions = null;
+function applyPatches() {
+    if (!window._yttv) return setTimeout(applyPatches, 250);
+    if (!document.querySelector('video')) return setTimeout(applyPatches, 250);
+    const methods = Object.keys(window._yttv).filter(key => {
+        return typeof window._yttv[key] === 'function' && window._yttv[key].toString().includes('TRANSPORT_CONTROLS_BUTTON_TYPE_FEATURED_ACTION');
+    });
+
+    if (methods.length === 0) {
+        setTimeout(applyPatches, 250);
+        return;
+    }
+
+    const origMethod = window._yttv[methods[0]];
+
+    function YtlrPlayerActionsContainer() {
+        const args = Array.prototype.slice.call(arguments);
+        const isClass = /^class\s/.test(origMethod.toString());
+
+        function constructAsNew(ctor, argsList) {
+            if (typeof Reflect !== 'undefined' && typeof Reflect.construct === 'function') {
+                return Reflect.construct(ctor, argsList, YtlrPlayerActionsContainer);
+            }
+            return new origMethod(...argsList);
+        }
+
+        if (!(this instanceof YtlrPlayerActionsContainer)) {
+            if (isClass) return constructAsNew(origMethod, args);
+            return origMethod.apply(this, args);
+        }
+
+        let inst;
+        if (isClass) {
+            inst = constructAsNew(origMethod, args);
+        } else {
+            origMethod.apply(this, args);
+            inst = this;
+        }
+
+        const functions = s95bFunctions || (s95bFunctions = extractAssignedFunctions(origMethod.toString()));
+
+        const pipCommand = {
+            "type": "TRANSPORT_CONTROLS_BUTTON_TYPE_PIP",
+            "button": {
+                "buttonRenderer": ButtonRenderer(
+                    false,
+                    configRead('enableSwapMPWithPIP') ? t('player.pictureInPicture') : t('player.miniPlayer'),
+                    'CLEAR_COOKIES',
+                    {
+                        customAction: {
+                            action: configRead('enableSwapMPWithPIP') ? 'ENTER_PIP' : 'ENTER_MP',
+                        }
+                    }
+                )
+            }
+        }
+
+        const settingActionGroup = functions.find(func => {
+            return func.rhs.includes('TRANSPORT_CONTROLS_BUTTON_TYPE_PLAYBACK_SETTINGS');
+        }).left.split('.')[1];
+
+        if (!settingActionGroup) return inst;
+
+        const origSettingActionGroup = inst[settingActionGroup];
+        if (configRead('enableMPButton')) {
+            inst[settingActionGroup] = function () {
+                const res = origSettingActionGroup.apply(this, arguments);
+                const idx = res.findIndex(item => item.type === 'TRANSPORT_CONTROLS_BUTTON_TYPE_PLAYBACK_SETTINGS');
+                res.find(item => item.type === 'TRANSPORT_CONTROLS_BUTTON_TYPE_PIP') || res.splice(idx, 0, pipCommand);
+                return res;
+            };
+        }
+
+        const previousButtonName = functions.find(func => {
+            if (func.rhs.includes('skipNextButton')) {
+                const skipNextButtonIndex = func.rhs.indexOf('skipNextButton');
+                const skipPreviousButtonIndex = func.rhs.indexOf('skipPreviousButton');
+                if (skipPreviousButtonIndex > skipNextButtonIndex) {
+                    return true;
+                }
+            }
+        }).left.split('.')[1];
+
+        const nextButtonName = functions.find(func => {
+            if (func.rhs.includes('skipPreviousButton')) {
+                const skipNextButtonIndex = func.rhs.indexOf('skipNextButton');
+                const skipPreviousButtonIndex = func.rhs.indexOf('skipPreviousButton');
+                if (skipNextButtonIndex > skipPreviousButtonIndex) {
+                    return true;
+                }
+            }
+        }).left.split('.')[1];
+
+        const engagementActionButton = functions.find(func => func.rhs.includes('props.data.engagementActions')).left.split('.')[1];
+
+        if (engagementActionButton && configRead('enableSpeedControlsButton')) {
+            const origEngagementActionButton = inst[engagementActionButton];
+            inst[engagementActionButton] = function () {
+                const res = origEngagementActionButton.apply(this, arguments);
+                res.find(item => item.type === 'TRANSPORT_CONTROLS_BUTTON_TYPE_SPEED') || res.push({
+                    type: 'TRANSPORT_CONTROLS_BUTTON_TYPE_SPEED',
+                    button: {
+                        buttonRenderer: ButtonRenderer(
+                            false,
+                            t('player.playbackSpeed.button'),
+                            'SLOW_MOTION_VIDEO',
+                            {
+                                customAction:
+                                {
+                                    action: 'TT_SPEED_SETTINGS_SHOW',
+                                }
+                            }
+                        )
+                    }
+                });
+                return res;
+            }
+        }
+
+        if (!configRead('enableSuperThanksButton')) {
+            const origEngagementActionButton = inst[engagementActionButton];
+            inst[engagementActionButton] = function () {
+                const res = origEngagementActionButton.apply(this, arguments);
+                const superThanksFiltered = res.filter(item => item.type !== 'TRANSPORT_CONTROLS_BUTTON_TYPE_SUPER_THANKS');
+                const shoppingFiltered = superThanksFiltered.filter(item => item.type !== 'TRANSPORT_CONTROLS_BUTTON_TYPE_SHOPPING');
+                return shoppingFiltered;
+            }
+        }
+        
+        if (!configRead('enableAIAskButton')) {
+            const origEngagementActionButton = inst[engagementActionButton];
+            inst[engagementActionButton] = function () {
+                const res = origEngagementActionButton.apply(this, arguments);
+                const superThanksFiltered = res.filter(item => item.type !== 'TRANSPORT_CONTROLS_BUTTON_TYPE_YOUCHAT_BUTTON');
+                const shoppingFiltered = superThanksFiltered.filter(item => item.type !== 'TRANSPORT_CONTROLS_BUTTON_TYPE_YOUCHAT_BUTTON');
+                return shoppingFiltered;
+            }
+        }
+
+        if (configRead('enablePreviousNextButtons')) {
+            if (!previousButtonName || !nextButtonName) return inst;
+            inst[previousButtonName] = function () {
+                return ButtonRenderer(
+                    false,
+                    t('player.previous'),
+                    'SKIP_PREVIOUS',
+                    {
+                        signalAction: {
+                            signal: 'PLAYER_PLAY_PREVIOUS'
+                        }
+                    }
+                )
+            }
+
+            inst[nextButtonName] = function () {
+                return ButtonRenderer(
+                    false,
+                    t('player.next'),
+                    'SKIP_NEXT',
+                    {
+                        signalAction: {
+                            signal: 'PLAYER_PLAY_NEXT'
+                        }
+                    }
+                )
+            }
+
+        }
+
+        return inst;
+    }
+
+    if (configRead('enablePatchingVideoPlayer')) {
+        YtlrPlayerActionsContainer.prototype = origMethod.prototype;
+        window._yttv[methods[0]] = YtlrPlayerActionsContainer;
+    }
+}
+
+
+if (document.readyState === 'complete' || document.readyState === 'interactive') {
+    applyPatches();
+} else {
+    window.addEventListener('DOMContentLoaded', applyPatches);
+}

package/mods/ui/customYTSettings.js

@@ -0,0 +1,29 @@
+import { SettingActionRenderer, SettingsCategory } from './ytUI.js';
+import { t } from 'i18next';
+
+function PatchSettings(settingsObject) {
+    const tizentubeOpenAction = SettingActionRenderer(
+        t('settings.ttSettings.title'),
+        'tizentube_open_action',
+        {
+            customAction: {
+                action: 'TT_SETTINGS_SHOW',
+                parameters: []
+            }
+        },
+        t('settings.ttSettings.summary'),
+        'https://www.gstatic.com/ytlr/img/parent_code.png'
+    )
+
+    const tizenTubeCategory = SettingsCategory(
+        'tizentube_category',
+        [tizentubeOpenAction]
+    );
+    // Add it as the first item in the settings object
+    settingsObject.items.unshift(tizenTubeCategory);
+
+}
+
+export {
+    PatchSettings
+}

package/mods/ui/disableWhosWatching.js

@@ -0,0 +1,48 @@
+import { configChangeEmitter, configRead } from '../config.js';
+
+configChangeEmitter.addEventListener('configChange', (event) => {
+    const { key, value } = event.detail;
+    if (key === 'enableWhoIsWatchingMenu') {
+        disableWhosWatching(value);
+    }
+});
+
+let interval;
+
+function disableWhosWatching(value) {
+    const LeanbackRecurringActions = JSON.parse(localStorage['yt.leanback.default::recurring_actions']);
+    const shouldPermanentlyEnable = configRead('permanentlyEnableWhoIsWatchingMenu');
+    const date = new Date();
+    if (!value) {
+        // Setting it after 7 days should be enough, as it'll get executed every time the app launches.
+        date.setDate(date.getDate() + 7);
+        LeanbackRecurringActions.data.data["startup-screen-account-selector-with-guest"] && 
+            (LeanbackRecurringActions.data.data["startup-screen-account-selector-with-guest"].lastFired = date.getTime());
+        LeanbackRecurringActions.data.data.whos_watching_fullscreen_zero_accounts.lastFired = date.getTime();
+        LeanbackRecurringActions.data.data["startup-screen-signed-out-welcome-back"] && 
+            (LeanbackRecurringActions.data.data["startup-screen-signed-out-welcome-back"].lastFired = date.getTime());
+        localStorage['yt.leanback.default::recurring_actions'] = JSON.stringify(LeanbackRecurringActions);
+    } else {
+        // Do nothing if the last fired action is less than 2 hours ago.
+        if (date.getTime() - LeanbackRecurringActions.data.data["startup-screen-account-selector-with-guest"]?.lastFired > 0 && date.getTime() - LeanbackRecurringActions.data.data["startup-screen-account-selector-with-guest"]?.lastFired < 2 * 60 * 60 * 1000
+        && !shouldPermanentlyEnable) {
+            return;
+        }
+        function setActions() {
+            LeanbackRecurringActions.data.data["startup-screen-account-selector-with-guest"] && 
+                (LeanbackRecurringActions.data.data["startup-screen-account-selector-with-guest"].lastFired = date.getTime());
+            LeanbackRecurringActions.data.data.whos_watching_fullscreen_zero_accounts.lastFired = date.getTime();
+            LeanbackRecurringActions.data.data["startup-screen-signed-out-welcome-back"] &&
+                (LeanbackRecurringActions.data.data["startup-screen-signed-out-welcome-back"].lastFired = date.getTime());
+            localStorage['yt.leanback.default::recurring_actions'] = JSON.stringify(LeanbackRecurringActions);
+        }
+        setActions();
+        if (shouldPermanentlyEnable) {
+            date.setDate(date.getDate() - 7);
+            setActions();
+            interval = setInterval(setActions, 60 * 1000);
+        } else if (interval) clearInterval(interval);
+    }
+}
+
+disableWhosWatching(configRead('enableWhoIsWatchingMenu'));