@oxymoron.13/tizentube-s95b 0.2.2 → 0.2.3

package/mods/features/standaloneUserscript.js

@@ -0,0 +1,107 @@
+function redirectUrl(originalUrl) {
+    if (!originalUrl) return originalUrl;
+
+    try {
+        if (typeof originalUrl === 'string' && originalUrl.startsWith('//')) originalUrl = originalUrl.replace('//', 'https://')
+        const url = new URL(originalUrl, window.location.origin);
+        const hostname = url.hostname;
+
+        if (hostname === 'youtube.com' || hostname === 'www.youtube.com') {
+            url.protocol = 'http:';
+            url.host = 'localhost:8099';
+            return url.toString();
+        }
+
+        if (hostname.endsWith('googlevideo.com') || hostname.endsWith('youtube.com')
+            || hostname.endsWith('gstatic.com') || hostname.endsWith('.google.com')
+            || hostname.endsWith('.googleapis.com') || hostname.endsWith('googleusercontent.com')
+            || hostname.endsWith('.ggpht.com')) {
+            return 'http://localhost:8099/cors-bypass/' + url.toString();
+        }
+    } catch (e) {
+        console.error('Failed to parse URL during interception:', e);
+    }
+
+    return originalUrl;
+}
+
+export default function () {
+    const originalFetch = window.fetch;
+    if (originalFetch) {
+        window.fetch = function (input, init) {
+            let targetUrl = '';
+            let isRequestObject = false;
+
+            if (typeof input === 'string') {
+                targetUrl = redirectUrl(input);
+            } else if (input instanceof URL) {
+                targetUrl = redirectUrl(input.toString());
+                input = new URL(targetUrl);
+            } else if (input instanceof Request) {
+                isRequestObject = true;
+                targetUrl = redirectUrl(input.url);
+            }
+
+            if (isRequestObject) {
+                if (input.method === 'POST' && targetUrl.indexOf('localhost') !== -1) {
+                    const modifiedOptions = {
+                        method: input.method,
+                        headers: new Headers(input.headers),
+                        mode: input.mode,
+                        credentials: input.credentials,
+                    };
+
+                    if (input.body && !input.bodyUsed) {
+                        const requestClone = input.clone();
+                        return input.clone().arrayBuffer().then(function (buffer) {
+                            modifiedOptions.body = buffer;
+
+                            return originalFetch(targetUrl, modifiedOptions);
+                        });
+                    }
+
+                    return originalFetch(targetUrl, modifiedOptions);
+                }
+
+                input = new Request(targetUrl, input);
+            }
+
+            return originalFetch.apply(this, [targetUrl, init]);
+        };
+    }
+
+    const originalOpen = XMLHttpRequest.prototype.open;
+    XMLHttpRequest.prototype.open = function (method, url, async, user, password) {
+        const redirectedUrl = redirectUrl(url);
+        if (redirectedUrl !== url) {
+            async = true;
+        }
+
+        if (async === undefined) {
+            async = true;
+        }
+
+        return originalOpen.apply(this, [method, redirectedUrl, async, user, password]);
+    };
+
+    if (navigator.sendBeacon) {
+        const originalSendBeacon = navigator.sendBeacon;
+        navigator.sendBeacon = function (url, data) {
+            console.log("Beacon data:", data);
+            return originalSendBeacon.apply(this, [redirectUrl(url), data]);
+        };
+    }
+
+    Object.defineProperty(HTMLImageElement.prototype, 'src', {
+        set: function(value) {
+            const descriptor = Object.getOwnPropertyDescriptor(Element.prototype, 'setAttribute');
+            descriptor.value.call(this, 'src', redirectUrl(value));
+        }
+    });
+    Object.defineProperty(HTMLScriptElement.prototype, 'src', {
+        set: function(value) {
+            const descriptor = Object.getOwnPropertyDescriptor(Element.prototype, 'setAttribute');
+            descriptor.value.call(this, 'src', redirectUrl(value));
+        }
+    });
+}

package/mods/features/updater.js

@@ -0,0 +1,119 @@
+// TizenTube Cobalt Update Checker
+
+import { buttonItem, showModal, showToast, overlayPanelItemListRenderer, scrollPaneRenderer, overlayMessageRenderer } from '../ui/ytUI.js';
+import { configRead } from '../config.js';
+import { t } from 'i18next';
+
+// If TizenTube is not running on Cobalt, do nothing
+// Add a timeout since reloading the home page while the updater pop up is shown causes the pop up to instantly disappear.
+setTimeout(() => {
+    if (window.h5vcc && window.h5vcc.tizentube && configRead('enableUpdater')) {
+        const currentEpoch = Math.floor(Date.now() / 1000);
+        if (configRead('dontCheckUpdateUntil') > currentEpoch) {
+            console.info('Skipping update check until', new Date(configRead('dontCheckUpdateUntil') * 1000).toLocaleString());
+        } else checkForUpdates();
+    }
+}, 2500);
+
+function getLatestRelease() {
+    return fetch('https://api.github.com/repos/reisxd/TizenTubeCobalt/releases/latest')
+        .then(response => {
+            if (!response.ok) {
+                throw new Error('Network response was not ok');
+            }
+            return response.json();
+        });
+}
+
+function checkForUpdates(showNoUpdateToast) {
+    const currentAppVersion = window.h5vcc.tizentube.GetVersion();
+    const currentEpoch = Math.floor(Date.now() / 1000);
+
+    getLatestRelease()
+        .then(release => {
+            const latestVersion = release.tag_name.replace('v', '');
+            const releaseDate = new Date(release.published_at).getTime() / 1000;
+
+            let architecture;
+            let downloadUrl;
+
+            if (window.h5vcc.tizentube.GetArchitecture) {
+                architecture = window.h5vcc.tizentube.GetArchitecture();
+            }
+
+            if (architecture) {
+                if (architecture === 'arm64-v8a') {
+                    downloadUrl = release.assets.find(asset => asset.name.includes('arm64.apk')).browser_download_url;
+                } else {
+                    downloadUrl = release.assets.find(asset => asset.name.includes('arm.apk')).browser_download_url;
+                }
+            } else downloadUrl = release.assets[0].browser_download_url;
+
+            if (latestVersion !== currentAppVersion) {
+                console.info(`New version available: ${latestVersion} (current: ${currentAppVersion})`);
+                const msg = `${t('settings.options.updater.releaseDate', { date: new Date(releaseDate * 1000).toLocaleString() })}\n${release.body}`.replace(/#/g, '').replace(/\*/g, '').trim();
+
+                const buttons = [
+                    buttonItem(
+                        { title: t('settings.options.updater.updateNow.title'), subtitle: t('settings.options.updater.updateNow.subtitle') },
+                        { icon: 'DOWN_ARROW' },
+                        [
+                            {
+                                customAction: {
+                                    action: 'UPDATE_DOWNLOAD',
+                                    parameters: downloadUrl
+                                }
+                            },
+                            {
+                                signalAction: {
+                                    signal: 'POPUP_BACK'
+                                }
+                            }
+                        ]
+                    ),
+                    buttonItem(
+                        { title: t('settings.options.updater.remindLater.title'), subtitle: t('settings.options.updater.remindLater.subtitle') },
+                        { icon: 'SEARCH_HISTORY' },
+                        [
+                            {
+                                customAction: {
+                                    action: 'UPDATE_REMIND_LATER',
+                                    parameters: currentEpoch + 86400
+                                }
+                            },
+                            {
+                                signalAction: {
+                                    signal: 'POPUP_BACK'
+                                }
+                            }
+                        ]
+                    )
+                ];
+
+                // Add an empty message so the CSS doesn't get screwed after user input
+                buttons.push(overlayMessageRenderer(' '));
+                buttons.push(overlayMessageRenderer(msg));
+
+                showModal(
+                    {
+                        title: t('settings.options.updater.updateAvailable.title'),
+                        subtitle: t('settings.options.updater.updateAvailable.subtitle', { latestVersion, currentVersion: currentAppVersion })
+                    },
+                    overlayPanelItemListRenderer(buttons),
+                    'tt-update-modal',
+                    false
+                )
+            } else {
+                console.info('You are using the latest version of TizenTube.');
+                if (showNoUpdateToast) {
+                    showToast(t('settings.options.updater.upToDate.title'), t('settings.options.updater.upToDate.subtitle', { version: currentAppVersion }), null);
+                }
+            }
+        })
+        .catch(error => {
+            console.error('Error fetching the latest release:', error);
+            showToast(t('settings.options.updater.checkFailed.title'), t('settings.options.updater.checkFailed.subtitle'), null);
+        });
+}
+
+export default checkForUpdates;

package/mods/features/userAgentSpoofing.js

@@ -0,0 +1,73 @@
+const deviceProfiles = [
+    {
+        architecture: 'Linux arm64-v8a',
+        os: 'Android 10',
+        rasterizer: 'gles',
+        manufacturer: 'Sony',
+        deviceType: 'ATV',
+        chipsetModel: 'sdm845',
+        modelYear: 13140765,
+        firmwareVersion: '52.1.C.0.268',
+        brand: 'KDDI',
+        model: 'SOV38'
+    },
+    {
+        architecture: 'Linux armeabi-v7a',
+        os: 'Android 14',
+        rasterizer: 'gles',
+        manufacturer: 'Google',
+        deviceType: 'ATV',
+        chipsetModel: 'sabrina',
+        modelYear: 2020,
+        firmwareVersion: 'UTTC.250917.004',
+        brand: 'google',
+        model: 'Chromecast'
+    },
+    {
+        architecture: 'Linux armeabi-v7a',
+        os: 'Android 12',
+        rasterizer: 'gles',
+        manufacturer: 'TCL',
+        deviceType: 'ATV',
+        chipsetModel: 'merak',
+        modelYear: 2023,
+        firmwareVersion: 'STT2.221228.001',
+        brand: 'TCL',
+        model: 'Smart TV Pro'
+    },
+    {
+        architecture: 'Linux armeabi-v7a',
+        os: 'Android 7.1.2',
+        rasterizer: 'gles',
+        manufacturer: 'Amazon',
+        deviceType: 'ATV',
+        chipsetModel: 'mt8695',
+        modelYear: 0,
+        firmwareVersion: 'NS6294',
+        brand: 'Amazon',
+        model: 'AFTMM'
+    }
+]
+
+const cobaltVersion = '25.lts.30.1034958-gold';
+const v8Version = 'v8/8.8.278.17-jit';
+const starboardVersion = '15';
+const auxField = 'com.google.android.youtube.tv/5.30.301';
+
+function generateUserAgent(profile) {
+    return `Mozilla/5.0 (${profile.architecture}; ${profile.os}) Cobalt/${cobaltVersion} (unlike Gecko) ${v8Version} ${profile.rasterizer} Starboard/${starboardVersion}, ${profile.manufacturer}_${profile.deviceType}_${profile.chipsetModel}_${profile.modelYear}/${profile.firmwareVersion} (${profile.brand}, ${profile.model}) ${auxField}`;
+}
+
+if (document.querySelector('.content-container') && window.h5vcc && window.h5vcc.tizentube && window.h5vcc.tizentube.SetUserAgent) {
+    const ua = localStorage.getItem('userAgent');
+    if (ua) {
+        window.h5vcc.tizentube.SetUserAgent(ua);
+        location.reload();
+    }
+
+    const randomProfile = deviceProfiles[Math.floor(Math.random() * deviceProfiles.length)];
+    const spoofedUserAgent = generateUserAgent(randomProfile);
+    localStorage.setItem('userAgent', spoofedUserAgent);
+    window.h5vcc.tizentube.SetUserAgent(spoofedUserAgent);
+    location.reload();
+}

package/mods/features/videoQueuing.js

@@ -0,0 +1,64 @@
+window.queuedVideos = {
+    videos: [],
+    lastVideoId: null
+};
+
+import resolveCommand from '../resolveCommand.js';
+
+function addListener() {
+    const videoPlayer = document.querySelector('.html5-video-player');
+    if (!videoPlayer) return setTimeout(addListener, 250);
+
+    videoPlayer.addEventListener('onStateChange', () => {
+        const playerStateObject = videoPlayer.getPlayerStateObject();
+        const videoData = videoPlayer.getVideoData();
+        if (window.queuedVideos.videos.length === 0) return;
+        if (playerStateObject.isEnded) {
+            const index = window.queuedVideos.videos.findIndex(v =>
+                (v.tileRenderer && v.tileRenderer.contentId === videoData.video_id) ||
+                (v.lockupViewModel && v.lockupViewModel.contentId === videoData.video_id)
+            );
+            if (index !== -1) {
+                if (index + 1 >= window.queuedVideos.videos.length) {
+                    resolveCommand({
+                        customAction: {
+                            action: 'CLEAR_QUEUE'
+                        }
+                    });
+                    return;
+                }
+                const element = window.queuedVideos.videos[index + 1];
+                const videoWatchEndpoint = element.tileRenderer ? element.tileRenderer.onSelectCommand : element.lockupViewModel.rendererContext.commandContext.onTap.innertubeCommand;
+                setTimeout(() => resolveCommand(videoWatchEndpoint), 500);
+            } else if (window.queuedVideos.lastVideoId) {
+                const lastIndex = window.queuedVideos.videos.findIndex(v =>
+                    v.tileRenderer?.contentId === window.queuedVideos.lastVideoId ||
+                    v.lockupViewModel?.contentId === window.queuedVideos.lastVideoId
+                );
+                if (lastIndex !== -1 && lastIndex + 1 < window.queuedVideos.videos.length) {
+                    const element = window.queuedVideos.videos[lastIndex + 1];
+                    const videoWatchEndpoint = element.tileRenderer ? element.tileRenderer.onSelectCommand : element.lockupViewModel.rendererContext.commandContext.onTap.innertubeCommand;
+                    setTimeout(() => resolveCommand(videoWatchEndpoint), 500);
+                } else {
+                    resolveCommand({
+                        customAction: {
+                            action: 'CLEAR_QUEUE'
+                        }
+                    });
+                    return;
+                }
+            } else {
+                const element = window.queuedVideos.videos[0];
+                const videoWatchEndpoint = element.tileRenderer ? element.tileRenderer.onSelectCommand : element.lockupViewModel.rendererContext.commandContext.onTap.innertubeCommand;
+                setTimeout(() => resolveCommand(videoWatchEndpoint), 500);
+            }
+        } else if (playerStateObject.isPlaying) {
+            document.getElementById('container').style.setProperty('opacity', '1', 'important');
+            if (window.queuedVideos.videos.find(v => v.contentId === videoData.video_id)) {
+                window.queuedVideos.lastVideoId = videoData.video_id;
+            }
+        }
+    });
+}
+
+addListener();