@oxymoron.13/tizentube-s95b 0.2.2 → 0.2.3

package/mods/features/moreSubtitles.js

@@ -0,0 +1,378 @@
+// TizenTube Subtitle Localization Mod
+// Automatically adds user's local language to subtitle auto-translate menu if not present
+
+import { configRead } from "../config.js";
+import languages from "../translations/language-names.js";
+
+const LANGUAGE_CODES = [
+    "af", "sq", "am", "ar", "hy", "as", "az", "eu", "be", "bn", "bs", "bg",
+    "my", "ca", "zh-CN", "zh-TW", "zh-HK", "hr", "cs", "da", "nl", "en", "et",
+    "fil", "fi", "fr", "gl", "ka", "de", "el", "gu", "he", "hi", "hu", "is",
+    "id", "ga", "it", "ja", "kn", "kk", "km", "ko", "ky", "lo", "lv", "lt",
+    "mk", "ms", "ml", "mt", "mr", "mn", "ne", "no", "or", "fa", "pl", "pt",
+    "pa", "ro", "ru", "sr", "si", "sk", "sl", "es", "sw", "sv", "ta", "te",
+    "th", "tr", "uk", "ur", "uz", "vi", "cy", "yi", "yo", "zu"
+];
+
+// Return an object mapping language code -> localized language name.
+export function getComprehensiveLanguageList() {
+    try {
+        const map = {};
+        LANGUAGE_CODES.forEach((code) => {
+            if (code.includes("-")) {
+                const [lang, region] = code.split("-");
+                const languageName = languages.language.standard.long[lang] || code;
+                const regionName = languages.region.long[region] || region;
+                map[code] = `${languageName} (${regionName})`;
+            } else {
+                const name = languages.language.standard.long[code] || code;
+                map[code] = name;
+            }
+        });
+        return map;
+    } catch (e) {
+        const fallback = {};
+        LANGUAGE_CODES.forEach((c) => (fallback[c] = c));
+        return fallback;
+    }
+}
+
+// Infer the most likely language for a given ISO 3166-1 alpha-2 country code using Intl.Locale.
+// Returns { code, name } or null if unknown.
+export function getCountryLanguage(countryCode) {
+    if (!countryCode) return null;
+    try {
+        const region = String(countryCode).toUpperCase();
+
+        const zhRegionMap = { CN: "zh-CN", TW: "zh-TW", HK: "zh-HK", SG: "zh-CN" };
+        if (zhRegionMap[region]) {
+            const code = zhRegionMap[region];
+            const name = languages.language.standard.long[code] || code;
+            return { code, name };
+        }
+
+        const base = new Intl.Locale("und", { region });
+        const maximized = base.maximize ? base.maximize() : base;
+        const lang = maximized.language || "en";
+
+        const name = languages.language.standard.long[lang] || lang;
+
+        return { code: lang, name };
+    } catch (e) {
+        console.warn("TizenTube Subtitle Localization: Could not infer language for country", countryCode, e);
+        return null;
+    }
+}
+
+let isPatched = false;
+
+// Function to get user's country code
+function getUserCountryCode() {
+    try {
+        // Always use window.yt.config_.GL as primary source
+        if (window.yt && window.yt.config_ && window.yt.config_.GL) {
+            return window.yt.config_.GL;
+        }
+
+        console.warn(
+            "TizenTube Subtitle Localization: Could not determine user country code"
+        );
+        return null;
+    } catch (error) {
+        console.error(
+            "TizenTube Subtitle Localization: Error getting country code:",
+            error
+        );
+        return null;
+    }
+}
+
+// Function to check if language already exists in the menu
+function languageExistsInMenu(items, languageCode, languageName) {
+    return items.some((item) => {
+        if (
+            item.compactLinkRenderer &&
+            item.compactLinkRenderer.serviceEndpoint
+        ) {
+            const commands =
+                item.compactLinkRenderer.serviceEndpoint.commandExecutorCommand
+                    ?.commands;
+            if (
+                commands &&
+                commands[0] &&
+                commands[0].selectSubtitlesTrackCommand
+            ) {
+                const translationLang =
+                    commands[0].selectSubtitlesTrackCommand.translationLanguage;
+                return (
+                    translationLang &&
+                    (translationLang.languageCode === languageCode ||
+                        translationLang.languageName === languageName)
+                );
+            }
+        }
+        return false;
+    });
+}
+
+// Function to create a language option
+function createLanguageOption(languageCode, languageName) {
+    return {
+        compactLinkRenderer: {
+            title: { simpleText: languageName },
+            serviceEndpoint: {
+                commandExecutorCommand: {
+                    commands: [
+                        {
+                            selectSubtitlesTrackCommand: {
+                                translationLanguage: {
+                                    languageCode,
+                                    languageName,
+                                },
+                            },
+                        },
+                        {
+                            openClientOverlayAction: {
+                                type: "CLIENT_OVERLAY_TYPE_CAPTIONS_LANGUAGE",
+                                updateAction: true,
+                            },
+                        },
+                        {
+                            signalAction: { signal: "POPUP_BACK" },
+                        },
+                    ],
+                },
+            },
+            secondaryIcon: { iconType: "RADIO_BUTTON_UNCHECKED" },
+        },
+    };
+}
+
+// Function to get languages already present in menu
+function getExistingLanguages(items) {
+    const existingLanguages = new Set();
+
+    items.forEach((item) => {
+        if (
+            item.compactLinkRenderer &&
+            item.compactLinkRenderer.serviceEndpoint
+        ) {
+            const commands =
+                item.compactLinkRenderer.serviceEndpoint.commandExecutorCommand
+                    ?.commands;
+            if (
+                commands &&
+                commands[0] &&
+                commands[0].selectSubtitlesTrackCommand
+            ) {
+                const translationLang =
+                    commands[0].selectSubtitlesTrackCommand.translationLanguage;
+                if (translationLang) {
+                    existingLanguages.add(translationLang.languageCode);
+                    existingLanguages.add(translationLang.languageName);
+                }
+            }
+        }
+    });
+
+    return existingLanguages;
+}
+
+// Function to create section title
+function createSectionTitle(title) {
+    return {
+        overlayMessageRenderer: {
+            title: { simpleText: "" },
+            subtitle: { simpleText: title },
+            style: "OVERLAY_MESSAGE_STYLE_SUBSECTION_TITLE",
+        },
+    };
+}
+
+// Main function to patch the subtitle menu
+function patchSubtitleMenu() {
+    if (isPatched) return;
+
+    const player = document.querySelector('.html5-video-player');
+    if (!player) return setTimeout(patchSubtitleMenu, 250);
+
+    // Always patch if possible - settings will be checked dynamically
+    if (!window._yttv) return setTimeout(patchSubtitleMenu, 250);
+    const yttvInstance = Object.values(window._yttv).find(
+        (obj) =>
+            obj &&
+            obj.instance &&
+            typeof obj.instance.resolveCommand === "function"
+    );
+
+    if (
+        !yttvInstance ||
+        yttvInstance.instance.resolveCommand.isPatchedBySubtitleLocalization
+    ) {
+        if (!yttvInstance) {
+            console.error(
+                "TizenTube Subtitle Localization: Could not find resolveCommand instance."
+            );
+        } else {
+            console.log("TizenTube Subtitle Localization: Already patched.");
+        }
+        return;
+    }
+
+    const originalResolveCommand = yttvInstance.instance.resolveCommand;
+
+    yttvInstance.instance.resolveCommand = function (cmd, _) {
+        // Identify the correct command using its uniqueId
+        if (
+            cmd?.openPopupAction?.uniqueId ===
+            "CLIENT_OVERLAY_TYPE_CAPTIONS_AUTO_TRANSLATE"
+        ) {
+            // Check current settings dynamically each time menu opens
+            const showUserLanguage = configRead("enableShowUserLanguage");
+            const showOtherLanguages = configRead("enableShowOtherLanguages");
+
+            // If neither feature is enabled, don't modify the menu
+            if (!showUserLanguage && !showOtherLanguages) {
+                return originalResolveCommand.apply(this, arguments);
+            }
+
+            const items =
+                cmd.openPopupAction.popup.overlaySectionRenderer.overlay
+                    .overlayTwoPanelRenderer.actionPanel.overlayPanelRenderer
+                    .content.overlayPanelItemListRenderer.items;
+
+            // Get existing languages
+            const existingLanguages = getExistingLanguages(items);
+
+            // Add user's local language if enabled
+            if (showUserLanguage) {
+                const userCountryCode = getUserCountryCode();
+                const userLanguage = getCountryLanguage(userCountryCode);
+
+                if (userLanguage) {
+                    // Check if the user's language already exists
+                    if (
+                        !languageExistsInMenu(items, userLanguage.code, userLanguage.name)
+                    ) {
+                        console.log(
+                            `%c[TizenTube Subtitle Localization] Adding user's local language: ${userLanguage.name} (${userLanguage.code})`,
+                            "background: #2196F3; color: #ffffff; font-size: 14px; font-weight: bold;"
+                        );
+
+                        const userLanguageOption = createLanguageOption(
+                            userLanguage.code,
+                            userLanguage.name
+                        );
+
+                        // Find the "Recommended languages" section and insert after it
+                        const recommendedIndex = items.findIndex(
+                            (item) =>
+                                item.overlayMessageRenderer?.subtitle
+                                    ?.simpleText === "Recommended languages"
+                        );
+
+                        if (recommendedIndex > -1) {
+                            // Insert user's language as the first recommendation
+                            items.splice(
+                                recommendedIndex + 1,
+                                0,
+                                userLanguageOption
+                            );
+                            // Update existing languages set
+                            existingLanguages.add(userLanguage.code);
+                            existingLanguages.add(userLanguage.name);
+                        } else {
+                            // Find "Other languages" section and insert before it
+                            const otherLanguagesIndex = items.findIndex(
+                                (item) =>
+                                    item.overlayMessageRenderer?.subtitle
+                                        ?.simpleText === "Other languages"
+                            );
+
+                            if (otherLanguagesIndex > -1) {
+                                items.splice(
+                                    otherLanguagesIndex,
+                                    0,
+                                    userLanguageOption
+                                );
+                            } else {
+                                // As a fallback, add it at the beginning
+                                items.unshift(userLanguageOption);
+                            }
+                            // Update existing languages set
+                            existingLanguages.add(userLanguage.code);
+                            existingLanguages.add(userLanguage.name);
+                        }
+                    } else {
+                        console.log(
+                            `%c[TizenTube Subtitle Localization] User's language ${userLanguage.name} already exists in menu`,
+                            "background: #4CAF50; color: #ffffff; font-size: 12px;"
+                        );
+                    }
+                } else {
+                    console.warn(
+                        `TizenTube Subtitle Localization: No language mapping found for country code: ${userCountryCode}`
+                    );
+                }
+            }
+
+            // Create "Tizen Languages" section with all missing languages if enabled
+            if (showOtherLanguages) {
+                const missingLanguages = Object.entries(getComprehensiveLanguageList())
+                    .filter(([code, name]) => !existingLanguages.has(code) && !existingLanguages.has(name))
+                    .sort(([, a], [, b]) => a.localeCompare(b));
+
+                if (missingLanguages.length > 0) {
+                    console.log(
+                        `%c[TizenTube Subtitle Localization] Adding "Tizen Languages" section with ${missingLanguages.length} additional languages`,
+                        "background: #FF9800; color: #ffffff; font-size: 12px;"
+                    );
+
+                    // Add section title
+                    items.push(createSectionTitle("Other Languages"));
+
+                    // Add all missing languages
+                    missingLanguages.forEach(([code, name]) => {
+                        items.push(createLanguageOption(code, name));
+                    });
+
+                    console.log(
+                        `%c[TizenTube Subtitle Localization] Added "Tizen Languages" section`,
+                        "background: #FF9800; color: #ffffff; font-size: 12px;"
+                    );
+                } else {
+                    console.log(
+                        `%c[TizenTube Subtitle Localization] All languages already present in menu`,
+                        "background: #4CAF50; color: #ffffff; font-size: 12px;"
+                    );
+                }
+            }
+        }
+
+        // Let the original function run with our modified 'cmd' object
+        return originalResolveCommand.apply(this, arguments);
+    };
+
+    yttvInstance.instance.resolveCommand.isPatchedBySubtitleLocalization = true;
+    console.log("TizenTube Subtitle Localization: Patch successful!");
+    isPatched = true;
+}
+
+// Wait for the YouTube TV app to be ready
+const interval = setInterval(() => {
+    if (window._yttv && Object.keys(window._yttv).length > 0) {
+        patchSubtitleMenu();
+        clearInterval(interval);
+    }
+}, 1000);
+
+// Also try to patch when DOM is loaded
+if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", patchSubtitleMenu);
+} else {
+    patchSubtitleMenu();
+}
+
+console.log(
+    "TizenTube Subtitle Localization: Module loaded, waiting for YouTube TV..."
+);

package/mods/features/pictureInPicture.js

@@ -0,0 +1,198 @@
+// Picture in Picture Mode for TizenTube
+
+import resolveCommand from "../resolveCommand.js";
+
+window.isPipPlaying = false;
+let PlayerService = null;
+
+function pipLoad() {
+    const mappings = Object.values(window._yttv).find(a => a && a.mappings);
+    PlayerService = mappings.get('PlayerService');
+    const PlaybackPreviewService = mappings.get('PlaybackPreviewService');
+    const PlaybackPreviewServiceStart = PlaybackPreviewService.start;
+    const PlaybackPreviewServiceStop = PlaybackPreviewService.stop;
+
+
+    PlaybackPreviewService.start = function (...args) {
+        if (window.isPipPlaying) return;
+        return PlaybackPreviewServiceStart.apply(this, args);
+    }
+
+    PlaybackPreviewService.stop = function (...args) {
+        if (window.isPipPlaying) return;
+        return PlaybackPreviewServiceStop.apply(this, args);
+    }
+}
+
+if (document.readyState === 'complete') {
+    pipLoad();
+} else window.addEventListener('load', pipLoad);
+
+function enablePip() {
+    if (!PlayerService) return;
+    const timestamp = Math.floor(document.querySelector('video').currentTime);
+    const videoElement = document.querySelector('video');
+
+    const ytlrPlayer = document.querySelector('ytlr-player');
+    const ytlrPlayerContainer = document.querySelector('ytlr-player-container');
+
+    const observer = new MutationObserver((mutations) => {
+        mutations.forEach((mutation) => {
+            if (mutation.attributeName === 'class') {
+                if (!ytlrPlayer.classList.contains('ytLrPlayerEnabled')) {
+                    function setStyles() {
+                        ytlrPlayerContainer.style.zIndex = '10';
+                        ytlrPlayer.style.display = 'block';
+                        ytlrPlayer.style.backgroundColor = 'rgba(0,0,0,0)';
+                    }
+
+                    setStyles();
+                    setTimeout(setStyles, 500);
+
+                    function onPipEnter() {
+                        videoElement.style.removeProperty('inset');
+                        const pipWidth = window.innerWidth / 3.5;
+                        const pipHeight = window.innerHeight / 3.5;
+                        videoElement.style.width = `${pipWidth}px`;
+                        videoElement.style.height = `${pipHeight}px`;
+                        videoElement.style.top = '68vh';
+                        videoElement.style.left = '68vw';
+
+                        window.isPipPlaying = true;
+                        videoElement.removeEventListener('play', onPipEnter);
+                    }
+
+                    videoElement.addEventListener('play', onPipEnter);
+                    observer.disconnect();
+
+                    setTimeout(() => {
+                        PlayerService.loadedPlaybackConfig.watchEndpoint.startTimeSeconds = timestamp;
+                        PlayerService.loadVideo(PlayerService.loadedPlaybackConfig);
+                    }, 1000);
+                }
+            }
+        });
+    });
+
+    observer.observe(ytlrPlayer, { attributes: true });
+
+    // Exit from the current video player
+    resolveCommand({
+        signalAction: {
+            signal: "HISTORY_BACK"
+        }
+    });
+}
+
+function pipToFullscreen() {
+    const { clickTrackingParams, commandMetadata, watchEndpoint } = PlayerService.loadedPlaybackConfig;
+    watchEndpoint.startTimeSeconds = Math.floor(document.querySelector('video').currentTime);
+    const command = {
+        clickTrackingParams,
+        commandMetadata,
+        watchEndpoint
+    };
+    resolveCommand(command);
+    window.isPipPlaying = false;
+};
+
+const originalClasses = {
+    ytlrSearchVoice: {
+        length: 0,
+        classes: []
+    },
+    ytlrSearchVoiceMicButton: {
+        length: 0,
+        classes: []
+    }
+}
+
+const observerPipEnter = new MutationObserver(() => {
+    if (!window.isPipPlaying) return;
+    const searchBar = document.querySelector('ytlr-search-bar');
+    if (searchBar) {
+        const pipButtonExists = document.querySelector('#tt-pip-button');
+        if (!pipButtonExists) {
+            const voiceButton = searchBar.querySelector('ytlr-search-voice');
+            if (voiceButton) {
+                const iconClassNames = Object.values(window._yttv).find(a => a instanceof Map && a.has("CLEAR_COOKIES"));
+                const iconClassToBeRemoved = iconClassNames.get('MICROPHONE_ON');
+                const iconClearCookiesClass = iconClassNames.get('CLEAR_COOKIES');
+                const pipButton = document.createElement('ytlr-search-voice');
+                for (let i = 0; i < voiceButton.classList.length; i++) {
+                    if (originalClasses.ytlrSearchVoice.length === 0) {
+                        originalClasses.ytlrSearchVoice.length = voiceButton.classList.length;
+                    }
+
+                    if (originalClasses.ytlrSearchVoice.length !== voiceButton.classList.length) {
+                        for (const className of originalClasses.ytlrSearchVoice.classes) {
+                            pipButton.classList.add(className);
+                        }
+                        break;
+                    }
+
+                    if (!originalClasses.ytlrSearchVoice.classes.includes(voiceButton.classList[i]))
+                        originalClasses.ytlrSearchVoice.classes.push(voiceButton.classList[i]);
+
+                    pipButton.classList.add(voiceButton.classList[i]);
+
+                }
+                pipButton.style.left = '10.25em';
+                pipButton.id = 'tt-pip-button';
+                const pipButtonMicButton = document.createElement('ytlr-search-voice-mic-button');
+                for (let i = 0; i < voiceButton.children[0].classList.length; i++) {
+                    if (originalClasses.ytlrSearchVoiceMicButton.length === 0) {
+                        originalClasses.ytlrSearchVoiceMicButton.length = voiceButton.children[0].classList.length;
+                    }
+                    
+                    if (originalClasses.ytlrSearchVoiceMicButton.length !== voiceButton.children[0].classList.length) {
+                        for (const className of originalClasses.ytlrSearchVoiceMicButton.classes) {
+                            pipButtonMicButton.classList.add(className);
+                        }
+                        break;
+                    }
+
+                    if (!originalClasses.ytlrSearchVoiceMicButton.classes.includes(voiceButton.children[0].classList[i]))
+                        originalClasses.ytlrSearchVoiceMicButton.classes.push(voiceButton.children[0].classList[i]);
+
+                    pipButtonMicButton.classList.add(voiceButton.children[0].classList[i]);
+                }
+                const pipIcon = document.createElement('yt-icon');
+                for (let i = 0; i < voiceButton.children[0].children[0].classList.length; i++) {
+                    pipIcon.classList.add(voiceButton.children[0].children[0].classList[i]);
+                }
+                pipIcon.classList.remove(iconClassToBeRemoved);
+                pipIcon.classList.add(iconClearCookiesClass);
+
+                pipButtonMicButton.appendChild(pipIcon);
+                pipButton.appendChild(pipButtonMicButton);
+                searchBar.appendChild(pipButton);
+            } else {
+                const pipButton = document.createElement('ytlr-search-voice');
+                pipButton.style.left = '10.25em';
+                pipButton.id = 'tt-pip-button';
+                pipButton.setAttribute('idomkey', 'ytLrSearchBarSearchVoice');
+                pipButton.setAttribute('tabindex', '0');
+                pipButton.classList.add('ytLrSearchVoiceHost', 'ytLrSearchBarSearchVoice');
+                const pipButtonMicButton = document.createElement('ytlr-search-voice-mic-button');
+                pipButtonMicButton.setAttribute('hybridnavfocusable', 'true');
+                pipButtonMicButton.setAttribute('tabindex', '-1');
+                pipButtonMicButton.classList.add('ytLrSearchVoiceMicButtonHost', 'zylon-ve');
+                const pipIcon = document.createElement('yt-icon');
+                pipIcon.setAttribute('tabindex', '-1');
+                pipIcon.classList.add('ytContribIconTvArrowLeft', 'ytContribIconHost', 'ytLrSearchVoiceMicButtonIcon');
+
+                pipButtonMicButton.appendChild(pipIcon);
+                pipButton.appendChild(pipButtonMicButton);
+                searchBar.appendChild(pipButton);
+            }
+        }
+    }
+});
+
+observerPipEnter.observe(document.body, { childList: true, subtree: true });
+
+export {
+    enablePip,
+    pipToFullscreen
+}

package/mods/features/preferredVideoQuality.js

@@ -0,0 +1,101 @@
+import { configRead, configChangeEmitter } from "../config.js";
+
+const SELECTORS = {
+    PLAYER: '.html5-video-player',
+};
+
+const EVENTS = {
+    YT_STATE_CHANGE: 'onStateChange',
+    CONFIG_CHANGE: 'configChange',
+};
+
+const CONFIG_KEYS = {
+    QUALITY: 'preferredVideoQuality',
+};
+
+class PreferredQualityHandler {
+    #player = null;
+    #attachTimeout = null;
+    #lastVideoId = null;
+    #hasAppliedQuality = false;
+
+    constructor() {
+        this.init();
+    }
+
+    init() {
+        this.#pollForPlayer();
+        this.#setupConfigListener();
+    }
+
+    #pollForPlayer() {
+        clearTimeout(this.#attachTimeout);
+
+        const playerElement = document.querySelector(SELECTORS.PLAYER);
+
+        if (!playerElement) {
+            this.#attachTimeout = setTimeout(() => this.#pollForPlayer(), 100);
+            return;
+        }
+
+        this.#player = playerElement;
+
+        this.#player.addEventListener(EVENTS.YT_STATE_CHANGE, this.#handleStateChange);
+
+        this.#handleStateChange();
+    }
+
+    #setupConfigListener() {
+        configChangeEmitter.addEventListener(EVENTS.CONFIG_CHANGE, (ev) => {
+            if (ev.detail?.key === CONFIG_KEYS.QUALITY) {
+                this.#applyQuality();
+            }
+        });
+    }
+
+    #handleStateChange = () => {
+        const state = this.#player?.getPlayerStateObject?.();
+        const videoData = this.#player?.getVideoData?.();
+        const videoId = videoData?.video_id;
+
+        if (videoId !== this.#lastVideoId) {
+            this.#lastVideoId = videoId;
+            this.#hasAppliedQuality = false;
+        }
+
+        const isShorts = Object.values(this.#player.getVideoStats()).find(a => a && a === 'shortspage');
+        if (state?.isPlaying && !this.#hasAppliedQuality && !isShorts) {
+            this.#applyQuality();
+            this.#hasAppliedQuality = true;
+        }
+    };
+
+    #applyQuality() {
+        const preferredQuality = configRead(CONFIG_KEYS.QUALITY);
+        if (!preferredQuality || preferredQuality === 'auto' || !this.#player) return;
+
+        try {
+            const quality = this.#determineQuality(preferredQuality);
+
+            if (quality) {
+              this.#player.setPlaybackQualityRange(quality, quality)
+            }
+        } catch (e) {
+            console.warn('[PreferredQuality] Failed to apply quality:', e);
+        }
+    }
+
+    #determineQuality(preference) {
+        const availableQualities = this.#player.getAvailableQualityData();
+        if (!availableQualities?.length) return 'highres';
+
+        const getQualityValue = (label) => parseInt(label, 10) || 0;
+        const targetValue = getQualityValue(preference);
+
+        const match = availableQualities.find(q => getQualityValue(q.qualityLabel) === targetValue);
+
+        return match ? match.quality : 'highres';
+    }
+}
+
+window.preferredVideoQualityHandler = new PreferredQualityHandler();