nuvio-tizen 1.8.13 → 1.9.1

package/README.md

@@ -47,6 +47,26 @@ core behaviour, targeting 2017 Samsung TVs (Tizen 3.0, ~Chromium 47).
 - Settings: add addons on a **dedicated page** (field kept above the on-screen keyboard;
   nothing is saved unless you press Confirm), remove with a confirmation prompt, and
   **Reset to default addons**.
+- **Live TV (IPTV)**: point Settings → *Live TV (IPTV)* at an **M3U/M3U8 playlist URL**.
+  Channels are grouped by `group-title` into `tv`-type **Live TV** rows on Home (searchable,
+  orderable like any feed). **Direct HTTP(S) HLS** channels play natively via AVPlay
+  (per-channel `http-user-agent` / `http-referrer` from the playlist are applied best-effort).
+  **YouTube** channels (`youtube.com/...`) play via YouTube's own **leanback TV app** behind a
+  bundled localhost proxy — see below.
+
+### YouTube (leanback) channels
+
+M3U entries that point at `youtube.com`/`youtu.be` can't be turned into a direct stream URL
+on-device (YouTube blocks that) and `youtube.com/tv` can't be framed directly
+(`X-Frame-Options`). Nuvio bundles a small **localhost proxy service** (`service/index.js`,
+a `<tizen:service>` on `127.0.0.1:8099`) that serves `youtube.com/tv` with `X-Frame-Options`
+and CSP stripped, rewrites media/asset URLs, and injects an ad-block userscript — then Nuvio
+plays it in a fullscreen leanback overlay. Press **RETURN/Back** to return to Nuvio.
+
+> Credit: the proxy design, URL-rewrite rules and the injected ad-block userscript are from
+> **[TizenTube](https://github.com/KrX3D/TizenTube)** (`@krx3d/tizentube2`, MIT). Nuvio ports a
+> trimmed, dependency-free (Node-core only) version of its standalone proxy and additionally
+> strips `X-Frame-Options` so it can run inside an in-app overlay.
 
 > **Note on WatchHub:** it's a "where to watch" addon — its results are Rent/Buy/Subscription
 > *links to external services*, not direct video URLs, so they show as non-playable. Add your
@@ -64,6 +84,10 @@ come from whatever **stream addons you add yourself** in Settings. Streams that
 a torrent `infoHash` (no HTTP URL) are listed but not playable — AVPlay needs a direct
 HTTP(S)/HLS/DASH URL, and this app embeds no torrent/debrid engine.
 
+The **IPTV** feature likewise hosts no content: you supply your own M3U playlist URL. The
+bundled leanback proxy only relays requests to YouTube's own servers on the TV's behalf (to
+strip framing headers); it stores nothing and adds no content.
+
 ---
 
 ## Install path A — TizenBrew (recommended, no cert signing)

package/config.xml

@@ -1,17 +1,28 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <widget xmlns="http://www.w3.org/ns/widgets" xmlns:tizen="http://tizen.org/ns/widgets"
-        id="http://nuvio.tizen/NuvioTizen" version="1.8.13" viewmodes="maximized">
-    <tizen:application id="Nuvio00001.Nuvio" package="Nuvio00001" required_version="2.4"/>
+        id="http://nuvio.tizen/NuvioTizen" version="1.9.0" viewmodes="maximized">
+    <tizen:application id="Nuvio00001.Nuvio" package="Nuvio00001" required_version="3.0"/>
     <content src="index.html"/>
     <feature name="http://tizen.org/feature/screen.size.all"/>
+    <!-- Node service (leanback proxy) -->
+    <feature name="http://tizen.org/feature/web.service"/>
     <icon src="icon.png"/>
     <name>Nuvio</name>
     <tizen:privilege name="http://tizen.org/privilege/internet"/>
     <tizen:privilege name="http://tizen.org/privilege/tv.inputdevice"/>
     <tizen:privilege name="http://tizen.org/privilege/application.launch"/>
-    <!-- Cross-origin XHR to any addon host -->
+    <tizen:privilege name="http://developer.samsung.com/privilege/network.public"/>
+    <!-- Cross-origin XHR to any addon host; framing the localhost leanback proxy -->
     <access origin="*" subdomains="true"/>
+    <tizen:allow-navigation href="*"/>
     <tizen:profile name="tv"/>
+    <!-- Bundled leanback proxy service (see service/index.js). Launched on demand
+         by js/ytplay.js to serve youtube.com/tv with X-Frame-Options/CSP stripped. -->
+    <tizen:service id="Nuvio00001.NuvioProxy">
+        <tizen:content src="service/index.js"/>
+        <tizen:name>NuvioProxy</tizen:name>
+        <tizen:description>Nuvio leanback proxy</tizen:description>
+    </tizen:service>
     <tizen:setting screen-orientation="landscape" context-menu="disable"
                    background-support="disable" encryption="disable"
                    install-location="auto" hwkey-event="enable"/>

package/css/style.css

@@ -209,3 +209,7 @@ html, body {
 .spin { width: 70px; height: 70px; border: 7px solid rgba(255,255,255,0.2); border-top-color: #818cf8; border-radius: 50%; -webkit-animation: sp 0.9s linear infinite; animation: sp 0.9s linear infinite; }
 @-webkit-keyframes sp { to { -webkit-transform: rotate(360deg); } }
 @keyframes sp { to { transform: rotate(360deg); } }
+
+/* YouTube leanback overlay (IPTV YouTube channels via the localhost proxy) */
+#yt-leanback { position: absolute; top: 0; left: 0; width: 1920px; height: 1080px; z-index: 46; background: #000; }
+#yt-leanback iframe { width: 1920px; height: 1080px; border: 0; display: block; background: #000; }

package/index.html

@@ -4,7 +4,7 @@
     <meta charset="utf-8">
     <meta name="viewport" content="width=1920, height=1080, user-scalable=no">
     <title>Nuvio</title>
-    <link rel="stylesheet" href="css/style.css?v=1.8.13">
+    <link rel="stylesheet" href="css/style.css?v=1.9.0">
 </head>
 <body>
     <!-- CSS-applied sentinel (kept off-screen); app.js waits for its width before rendering -->
@@ -42,18 +42,23 @@
     <!-- Skip intro/recap/credits prompt (TheIntroDB) -->
     <div id="skip-prompt" class="hidden"></div>
 
+    <!-- YouTube leanback overlay (IPTV YouTube channels, via the localhost proxy) -->
+    <div id="yt-leanback" class="hidden"></div>
+
     <div id="toast" class="hidden"></div>
     <div id="spinner" class="hidden"><div class="spin"></div></div>
 
-    <!-- Load order matters: polyfills -> util -> data -> input -> player -> views -> app -->
+    <!-- Load order matters: polyfills -> util -> iptv -> data -> input -> player -> ytplay -> views -> app -->
     <!-- ?v= busts the TV webview cache on every release (keep in sync with package.json) -->
-    <script src="js/polyfills.js?v=1.8.13"></script>
-    <script src="js/util.js?v=1.8.13"></script>
-    <script src="js/stremio.js?v=1.8.13"></script>
-    <script src="js/keys.js?v=1.8.13"></script>
-    <script src="js/focus.js?v=1.8.13"></script>
-    <script src="js/player.js?v=1.8.13"></script>
-    <script src="js/views.js?v=1.8.13"></script>
-    <script src="js/app.js?v=1.8.13"></script>
+    <script src="js/polyfills.js?v=1.9.0"></script>
+    <script src="js/util.js?v=1.9.0"></script>
+    <script src="js/iptv.js?v=1.9.0"></script>
+    <script src="js/stremio.js?v=1.9.0"></script>
+    <script src="js/keys.js?v=1.9.0"></script>
+    <script src="js/focus.js?v=1.9.0"></script>
+    <script src="js/player.js?v=1.9.0"></script>
+    <script src="js/ytplay.js?v=1.9.0"></script>
+    <script src="js/views.js?v=1.9.0"></script>
+    <script src="js/app.js?v=1.9.0"></script>
 </body>
 </html>

package/js/iptv.js

@@ -0,0 +1,172 @@
+/* IPTV / M3U support. Global namespace: IPTV
+   Parses a user-supplied M3U playlist into Stremio-shaped `tv` catalogs, so the
+   rest of the app (home rows, search, detail, player) treats live channels exactly
+   like any other addon's content. Exposed to Stremio as a local synthetic addon
+   (see synthAddon()); Stremio.loadAddons / getCatalog / getMeta / getStreams route
+   `iptv:` ids here instead of over HTTP.
+
+   Direct HTTP(S) streams play through AVPlay. YouTube channels are tagged `_yt` and
+   handed to YTPlay (leanback proxy) at playback time. */
+var IPTV = (function () {
+    'use strict';
+
+    var URL_KEY = 'nuvio.iptv.url';
+    var CACHE_MS = 10 * 60 * 1000;
+    var _cache = null;   // { ts, channels, groups, byId, catalogs }
+    var _status = { url: '', count: 0, groups: 0, error: '' };   // last load result, for Settings
+
+    function getUrl() { return U.store.get(URL_KEY, '') || ''; }
+    function isEnabled() { return !!getUrl(); }
+    function reset() { _cache = null; }
+    function setUrl(u) {
+        u = ('' + (u || '')).trim();
+        if (u) { U.store.set(URL_KEY, u); } else { U.store.remove(URL_KEY); }
+        reset();
+    }
+
+    function slug(s) {
+        var v = ('' + s).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+        return v.slice(0, 40) || 'x';
+    }
+
+    function attr(line, re) { var m = line.match(re); return m ? m[1] : ''; }
+
+    // Returns [{ id, name, logo, group, tvgId, ua, ref, url, _yt }]
+    function parseM3U(text) {
+        var lines = ('' + text).split(/\r?\n/);
+        var channels = [];
+        var cur = null;
+        var seen = {};
+        for (var i = 0; i < lines.length; i++) {
+            var s = lines[i].replace(/^\s+/, '');
+            if (s.indexOf('#EXTINF') === 0) {
+                cur = {
+                    name: (s.slice(s.lastIndexOf(',') + 1).trim()) || 'Channel',
+                    logo: attr(s, /tvg-logo="([^"]*)"/),
+                    group: attr(s, /group-title="([^"]*)"/) || 'Live TV',
+                    tvgId: attr(s, /tvg-id="([^"]*)"/),
+                    ua: attr(s, /http-user-agent="([^"]*)"/),
+                    ref: attr(s, /http-referrer="([^"]*)"/),
+                    url: ''
+                };
+            } else if (s.indexOf('#EXTVLCOPT:http-user-agent=') === 0) {
+                if (cur) { cur.ua = s.slice('#EXTVLCOPT:http-user-agent='.length).trim(); }
+            } else if (s.indexOf('#EXTVLCOPT:http-referrer=') === 0) {
+                if (cur) { cur.ref = s.slice('#EXTVLCOPT:http-referrer='.length).trim(); }
+            } else if (s && s.charAt(0) !== '#') {
+                if (cur) {
+                    var u = s.trim();
+                    if (/^https?:\/\//i.test(u)) {
+                        cur.url = u;
+                        cur._yt = /(^|\.)youtube\.com\//i.test(u) || /(^|\.)youtu\.be\//i.test(u);
+                        var base = 'iptv:' + slug(cur.tvgId || cur.name);
+                        var id = base, n = 2;
+                        while (seen[id]) { id = base + '-' + n; n++; }
+                        seen[id] = 1; cur.id = id;
+                        channels.push(cur);
+                    }
+                    cur = null;
+                }
+            }
+        }
+        return channels;
+    }
+
+    function build(channels) {
+        var groups = [], gseen = {}, byId = {};
+        channels.forEach(function (c) {
+            byId[c.id] = c;
+            if (!gseen[c.group]) { gseen[c.group] = 1; groups.push(c.group); }
+        });
+        var catalogs = groups.map(function (g) {
+            return { type: 'tv', id: 'iptv_' + slug(g), name: g, extra: [{ name: 'search' }], _group: g };
+        });
+        return { ts: Date.now(), channels: channels, groups: groups, byId: byId, catalogs: catalogs };
+    }
+
+    function load() {
+        if (_cache && (Date.now() - _cache.ts) < CACHE_MS) { return Promise.resolve(_cache); }
+        var url = getUrl();
+        _status = { url: url, count: 0, groups: 0, error: '' };
+        if (!url) { _cache = build([]); return Promise.resolve(_cache); }
+        return U.getText(url, 15000).then(function (text) {
+            _cache = build(parseM3U(text));
+            _status.count = _cache.channels.length;
+            _status.groups = _cache.groups.length;
+            if (!_cache.channels.length) {
+                // Fetched, but nothing parsed — usually the URL returned an error/HTML page
+                // (e.g. a "not found" body) rather than an M3U.
+                _status.error = 'Fetched, but no channels parsed (is the URL returning the .m3u file?)';
+            }
+            return _cache;
+        }, function (e) {
+            _status.error = (e && e.message) ? e.message : 'Could not fetch the playlist URL';
+            _cache = build([]);   // keep the app usable if the playlist is unreachable
+            return _cache;
+        });
+    }
+
+    function status() { return _status; }
+
+    function toMeta(c) {
+        return {
+            id: c.id, type: 'tv', name: c.name,
+            poster: c.logo || '', background: c.logo || '', logo: c.logo || '',
+            posterShape: 'landscape', description: c.group
+        };
+    }
+
+    function catalog(catId, extra) {
+        return load().then(function (d) {
+            var cat = null;
+            for (var i = 0; i < d.catalogs.length; i++) {
+                if (d.catalogs[i].id === catId) { cat = d.catalogs[i]; break; }
+            }
+            if (!cat) { return []; }
+            var q = (extra && extra.search) ? ('' + extra.search).toLowerCase() : '';
+            var out = [];
+            d.channels.forEach(function (c) {
+                if (c.group !== cat._group) { return; }
+                if (q && c.name.toLowerCase().indexOf(q) === -1) { return; }
+                out.push(toMeta(c));
+            });
+            return out;
+        });
+    }
+
+    function meta(id) {
+        return load().then(function (d) { var c = d.byId[id]; return c ? toMeta(c) : null; });
+    }
+
+    function streams(id) {
+        return load().then(function (d) {
+            var c = d.byId[id];
+            if (!c) { return []; }
+            if (c._yt) {
+                return [{ url: c.url, _yt: true, ytPage: c.url, name: c.name, title: 'YouTube · ' + c.group }];
+            }
+            var st = { url: c.url, name: c.name, title: 'IPTV · ' + c.group };
+            if (c.ua || c.ref) { st._headers = { ua: c.ua || '', ref: c.ref || '' }; }
+            return [st];
+        });
+    }
+
+    // A local addon object shaped like the HTTP addons in Stremio.loadAddons().
+    // `__local` tells Stremio to route resource calls here instead of over HTTP.
+    function synthAddon() {
+        var d = _cache || build([]);
+        return {
+            __local: true, url: 'local:iptv', base: 'local:iptv',
+            manifest: {
+                id: 'org.nuvio.iptv', name: 'IPTV', version: '1.0.0',
+                types: ['tv'], resources: ['catalog', 'meta', 'stream'],
+                idPrefixes: ['iptv:'], catalogs: d.catalogs
+            }
+        };
+    }
+
+    return {
+        getUrl: getUrl, setUrl: setUrl, isEnabled: isEnabled, reset: reset, status: status,
+        load: load, catalog: catalog, meta: meta, streams: streams, synthAddon: synthAddon
+    };
+})();

package/js/player.js

@@ -228,6 +228,13 @@ var Player = (function () {
         } catch (e) {}
         try {
             avplay.open(url);
+            // Best-effort per-stream HTTP headers (some IPTV channels need a UA / Referer).
+            // Guarded: unsupported properties simply throw and are ignored.
+            try {
+                var h = _ctx && _ctx._headers;
+                if (h && h.ua) { avplay.setStreamingProperty('USER_AGENT', h.ua); }
+                if (h && h.ref) { avplay.setStreamingProperty('CUSTOM_MESSAGE', 'Referer:' + h.ref); }
+            } catch (eh) {}
             avplay.setListener({
                 onbufferingstart: function () { _buffering = true; U.spinner(true); },
                 onbufferingcomplete: function () {

package/js/stremio.js

@@ -84,6 +84,8 @@ var Stremio = (function () {
     // ---- Manifest loading (cached in-memory per session) ----
     var _loaded = null;
 
+    var _hasIptv = (typeof IPTV !== 'undefined');
+
     function loadAddons() {
         if (_loaded) { return Promise.resolve(_loaded); }
         var urls = getAddonUrls();
@@ -94,14 +96,31 @@ var Stremio = (function () {
                 });
             };
         });
-        return U.settleAll(tasks, 4).then(function (results) {
+        // Load the IPTV playlist first (if configured) so its synthetic addon's
+        // catalogs reflect the parsed channel groups.
+        var pre = (_hasIptv && IPTV.isEnabled()) ? IPTV.load() : Promise.resolve(null);
+        return pre.then(function () {
+            return U.settleAll(tasks, 4);
+        }).then(function (results) {
             var addons = [];
             results.forEach(function (r) { if (r.ok && r.value.manifest) { addons.push(r.value); } });
+            // Prepend so the Live TV rows sort first on Home and are never cut by the
+            // home-page row cap (the user can still reorder them in Home Feeds).
+            if (_hasIptv && IPTV.isEnabled()) { addons.unshift(IPTV.synthAddon()); }
             _loaded = addons;
             return addons;
         });
     }
 
+    // Point Nuvio's IPTV playlist at a new M3U URL and force a reload.
+    function iptvSetUrl(url) {
+        if (_hasIptv) { IPTV.setUrl(url); }
+        _loaded = null;
+    }
+    function iptvGetUrl() { return _hasIptv ? IPTV.getUrl() : ''; }
+    function iptvLoad() { return _hasIptv ? IPTV.load() : Promise.resolve(null); }
+    function iptvStatus() { return _hasIptv ? IPTV.status() : { error: 'IPTV unavailable' }; }
+
     // ---- Resource matching ----
     function resourceEntries(addon) {
         var res = (addon.manifest.resources) || [];
@@ -174,6 +193,7 @@ var Stremio = (function () {
     }
 
     function getCatalog(cat, extra) {
+        if (cat.addon && cat.addon.__local) { return IPTV.catalog(cat.id, extra); }
         return U.getJSON(buildCatalogUrl(cat.addon, cat.type, cat.id, extra), 12000)
             .then(function (res) { return (res && res.metas) ? res.metas : []; });
     }
@@ -243,6 +263,12 @@ var Stremio = (function () {
 
     // ---- Meta ----
     function getMeta(type, id) {
+        if (/^iptv:/.test(id)) {
+            return IPTV.meta(id).then(function (m) {
+                if (!m) { throw new Error('IPTV channel not found'); }
+                return m;
+            });
+        }
         return loadAddons().then(function (addons) {
             var providers = addons.filter(function (a) { return supports(a, 'meta', type, id); });
             if (!providers.length) { return Promise.reject(new Error('No meta addon for ' + type)); }
@@ -263,6 +289,7 @@ var Stremio = (function () {
     // ---- Streams ----
     // Aggregates stream lists from every addon that supports the (type,id).
     function getStreams(type, id) {
+        if (/^iptv:/.test(id)) { return IPTV.streams(id); }
         return loadAddons().then(function (addons) {
             var providers = addons.filter(function (a) { return supports(a, 'stream', type, id); });
             var tasks = providers.map(function (a) {
@@ -518,6 +545,8 @@ var Stremio = (function () {
         getMeta: getMeta, getStreams: getStreams, getSubtitles: getSubtitles,
         getSearchCatalogs: getSearchCatalogs, search: search,
         isPlayable: isPlayable, streamLabel: streamLabel, streamName: streamName,
-        streamSize: streamSize, streamDescription: streamDescription
+        streamSize: streamSize, streamDescription: streamDescription,
+        iptvSetUrl: iptvSetUrl, iptvGetUrl: iptvGetUrl,
+        iptvLoad: iptvLoad, iptvStatus: iptvStatus
     };
 })();

package/js/views.js

@@ -517,8 +517,10 @@ var Views = (function () {
 
     function startPlayback(stream, videoId, label) {
         markHomeDirty();   // progress/watched will change → refresh Continue Watching on return
+        // YouTube-live IPTV channels play through the leanback proxy overlay, not AVPlay.
+        if (stream._yt) { YTPlay.open(stream, function () { drawDetail(); }); return; }
         var ctx = { url: stream.url, type: _d.type, id: videoId, name: label,
-            poster: _d.meta.poster, streams: playableSources() };
+            poster: _d.meta.poster, streams: playableSources(), _headers: stream._headers };
         if (_d.type === 'series' && _d.meta.videos) {
             var ord = orderedEpisodes(_d.meta);
             var idx = ord.findIndex(function (v) { return v.id === videoId; });
@@ -756,6 +758,7 @@ var Views = (function () {
         var wrap = U.el('div', 'settings-wrap');
         s.appendChild(wrap);
         if (_settingsSection === 'addons') { settingsAddons(wrap); }
+        else if (_settingsSection === 'iptv') { settingsIptv(wrap); }
         else if (_settingsSection === 'integrations') { settingsIntegrations(wrap); }
         else if (_settingsSection === 'subtitles') { settingsSubtitles(wrap); }
         else if (_settingsSection === 'feeds') { settingsFeeds(wrap); }
@@ -780,6 +783,7 @@ var Views = (function () {
     function settingsMenu(wrap) {
         wrap.appendChild(U.el('h2', null, 'Settings'));
         wrap.appendChild(sectionRow('Addons', 'Catalog, stream & subtitle addons', 'addons'));
+        wrap.appendChild(sectionRow('Live TV (IPTV)', 'Load channels from an M3U playlist URL', 'iptv'));
         wrap.appendChild(sectionRow('Integrations', 'API keys (OMDb, TMDB, MDBList)', 'integrations'));
         wrap.appendChild(sectionRow('Subtitle Options', 'Default language, size, style', 'subtitles'));
         wrap.appendChild(sectionRow('Home Feeds', 'Order & show/hide the home rows', 'feeds'));
@@ -843,6 +847,68 @@ var Views = (function () {
         });
     }
 
+    function settingsIptv(wrap) {
+        wrap.appendChild(U.el('h2', null, 'Live TV (IPTV)'));
+        var url = Stremio.iptvGetUrl ? Stremio.iptvGetUrl() : '';
+
+        // Live load status — turns a silent fetch failure into a visible message.
+        if (url && Stremio.iptvLoad) {
+            var statusEl = U.el('div', 'hint', 'Checking playlist…');
+            wrap.appendChild(statusEl);
+            Stremio.iptvLoad().then(function () {
+                var st = Stremio.iptvStatus();
+                if (st.error) { statusEl.textContent = '⚠ ' + st.error; }
+                else { statusEl.textContent = '✓ Loaded ' + st.count + ' channels in ' + st.groups + ' group(s).'; }
+            });
+        }
+
+        var set = U.el('div', 'addon-item focusable');
+        set.appendChild(U.el('div', 'a-name', url ? 'M3U playlist' : '+  Set M3U playlist URL'));
+        set.appendChild(U.el('div', 'a-url', url || 'Not set — press OK to enter an M3U URL'));
+        set.__onselect = function () {
+            App.openEntry({
+                title: 'IPTV playlist URL',
+                hint: 'Type an M3U/M3U8 playlist URL, then Confirm. RETURN cancels — nothing is saved unless you confirm.',
+                value: url || 'https://', placeholder: 'https://example.com/playlist.m3u',
+                validate: function (v) { return (!v || v === 'https://' || v.indexOf('://') === -1 || v.length < 12) ? 'Enter a full M3U URL' : null; },
+                onConfirm: function (v) { Stremio.iptvSetUrl(v); clearCatalogCache(); U.toast('Playlist saved'); App.back(); renderSettings(); }
+            });
+        };
+        wrap.appendChild(set);
+
+        if (url) {
+            var reload = U.el('div', 'addon-item focusable');
+            reload.appendChild(U.el('div', 'a-name', '↻  Reload playlist'));
+            reload.appendChild(U.el('div', 'a-url', 'Re-fetch channels from the M3U URL now'));
+            reload.__onselect = function () {
+                Stremio.iptvSetUrl(url);   // re-sets same URL, clears cache
+                clearCatalogCache();
+                U.toast('Reloading channels…');
+                setTimeout(renderSettings, 300);
+            };
+            wrap.appendChild(reload);
+
+            var rm = U.el('div', 'addon-item focusable reset-item');
+            rm.appendChild(U.el('div', 'a-name', '✕  Remove playlist'));
+            rm.appendChild(U.el('div', 'a-url', 'Clears the IPTV channels from Nuvio'));
+            rm.__onselect = function () {
+                confirm('Remove the IPTV playlist?', 'Remove', function () {
+                    Stremio.iptvSetUrl('');
+                    clearCatalogCache();
+                    U.toast('Playlist removed');
+                    setTimeout(renderSettings, 300);
+                });
+            };
+            wrap.appendChild(rm);
+        }
+
+        wrap.appendChild(U.el('div', 'hint',
+            'Channels are grouped by the playlist\'s group-title into Live TV rows on Home. ' +
+            'Direct HLS streams play via AVPlay; YouTube channels play via the built-in leanback proxy.'));
+        wrap.appendChild(backRow());
+        Focus.setScope(scr('settings'));
+    }
+
     function maskKey(v) { v = '' + v; return v.length <= 4 ? '••••' : ('••••' + v.slice(-4)); }
 
     function keyRow(title, key, placeholder, validator) {

package/js/ytplay.js

@@ -0,0 +1,115 @@
+/* YouTube leanback playback. Global namespace: YTPlay
+   YouTube-live IPTV channels can't be extracted to a direct URL on-device and
+   youtube.com/tv can't be framed (X-Frame-Options). So we launch a bundled
+   localhost proxy (service/index.js) that serves youtube.com/tv with those
+   headers stripped, and load it in a fullscreen overlay iframe — the same
+   leanback approach TizenTube uses. See service/index.js for the proxy. */
+var YTPlay = (function () {
+    'use strict';
+
+    var PROXY = 'http://localhost:8099';
+    var _open = false;
+    var _onExit = null;
+    var _idCache = {};              // ytPage -> { id, ts }
+    var ID_TTL = 5 * 60 * 1000;     // live video ids rotate; keep short
+
+    function overlay() { return U.byId('yt-leanback'); }
+
+    // Launch the proxy service (idempotent) and resolve once it answers /health.
+    function ensureService() {
+        return new Promise(function (resolve, reject) {
+            if (!(window.tizen && tizen.application)) { reject(new Error('no-service')); return; }
+            function poll(left) {
+                U.getText(PROXY + '/health', 2500).then(function () { resolve(); }, function () {
+                    if (left <= 0) { reject(new Error('proxy-timeout')); return; }
+                    setTimeout(function () { poll(left - 1); }, 500);
+                });
+            }
+            try {
+                var pkgId = tizen.application.getCurrentApplication().appInfo.packageId;
+                tizen.application.launchAppControl(
+                    new tizen.ApplicationControl('http://tizen.org/appcontrol/operation/service'),
+                    pkgId + '.NuvioProxy',
+                    function () { poll(40); },   // launched → wait for it to listen (~20s)
+                    function () { poll(40); }    // may already be running
+                );
+            } catch (e) { poll(40); }
+        });
+    }
+
+    // A youtube.com/<channel>/live (or /watch?v=) URL -> the current live video id.
+    function resolveVideoId(page) {
+        var direct = ('' + page).match(/[?&]v=([A-Za-z0-9_-]{11})/);
+        if (direct) { return Promise.resolve(direct[1]); }
+        var hit = _idCache[page];
+        if (hit && (Date.now() - hit.ts) < ID_TTL) { return Promise.resolve(hit.id); }
+        return U.getText(page, 12000).then(function (html) {
+            var m = html.match(/"videoId":"([A-Za-z0-9_-]{11})"/);
+            var id = m ? m[1] : '';
+            if (id) { _idCache[page] = { id: id, ts: Date.now() }; }
+            return id;
+        }, function () { return ''; });
+    }
+
+    function onHwKey(e) {
+        if (e && e.keyName === 'back') { if (e.preventDefault) { e.preventDefault(); } close(); }
+    }
+    function onKeyDown(e) {
+        if (e && (e.keyCode === 10009 || e.keyCode === 461)) {
+            if (e.preventDefault) { e.preventDefault(); }
+            if (e.stopPropagation) { e.stopPropagation(); }
+            close();
+        }
+    }
+
+    function show(id) {
+        var o = overlay();
+        if (!o) { return; }
+        U.clear(o);
+        var iframe = document.createElement('iframe');
+        iframe.setAttribute('allow', 'autoplay; encrypted-media');
+        iframe.src = PROXY + '/tv#/watch?v=' + encodeURIComponent(id);
+        iframe.onload = function () { try { iframe.focus(); } catch (e) {} };
+        o.appendChild(iframe);
+        o.className = '';
+        U.byId('app').className = 'hidden';
+        _open = true;
+        // Hardware Back is delivered app-wide (tizenhwkey) even when the iframe has
+        // focus; the keydown capture covers the moment before the iframe grabs focus.
+        document.addEventListener('tizenhwkey', onHwKey, true);
+        document.addEventListener('keydown', onKeyDown, true);
+    }
+
+    function close() {
+        if (!_open) { return; }
+        _open = false;
+        document.removeEventListener('tizenhwkey', onHwKey, true);
+        document.removeEventListener('keydown', onKeyDown, true);
+        var o = overlay();
+        if (o) { o.className = 'hidden'; U.clear(o); }
+        U.byId('app').className = '';
+        var cb = _onExit; _onExit = null;
+        if (cb) { try { cb(); } catch (e) {} }   // redraw detail -> restores focus scope
+    }
+
+    function open(stream, onExit) {
+        _onExit = onExit || null;
+        var page = stream.ytPage || stream.url;
+        U.spinner(true);
+        ensureService().then(function () {
+            return resolveVideoId(page);
+        }).then(function (id) {
+            U.spinner(false);
+            if (!id) { U.toast('Could not find the live stream for this channel', 3500); return; }
+            show(id);
+        }, function (err) {
+            U.spinner(false);
+            var msg = (err && err.message === 'no-service')
+                ? 'YouTube channels need the on-TV proxy (not available in this browser).'
+                : 'Could not start the YouTube proxy service.';
+            U.toast(msg, 4500);
+        });
+    }
+
+    return { open: open, close: close, isOpen: function () { return _open; } };
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuvio-tizen",
-  "version": "1.8.13",
+  "version": "1.9.1",
   "description": "Nuvio-style Stremio-addon streaming client for Tizen 3.0+ Samsung TVs (TizenBrew app module).",
   "packageType": "app",
   "appName": "Nuvio",
@@ -9,6 +9,7 @@
     "index.html",
     "css",
     "js",
+    "service",
     "icon.png",
     "config.xml",
     "README.md"

package/service/index.js

@@ -0,0 +1,225 @@
+"use strict";
+/*
+ * Nuvio leanback proxy — Tizen <tizen:service> (Node ~4.x engine).
+ *
+ * Lets Nuvio play YouTube-live IPTV channels through YouTube's own leanback TV
+ * app (youtube.com/tv) inside an in-app overlay. youtube.com/tv sends
+ * X-Frame-Options: SAMEORIGIN and CSP, so it can't be framed directly; this
+ * localhost proxy strips those, rewrites media/asset URLs through /cors-bypass/,
+ * and injects TizenTube's ad-block userscript.
+ *
+ * Adapted from TizenTube (@krx3d/tizentube2, MIT — https://github.com/KrX3D/TizenTube):
+ * the /tv + /cors-bypass proxy design, the URL-rewrite rules, and the userscript
+ * injection are ported from its standalone/service/index.js. Reduced to Node core
+ * modules only (no express/node-fetch) so it needs no bundling, and additionally
+ * strips X-Frame-Options so Nuvio can frame it in an overlay.
+ *
+ * ES5 only — the Tizen service engine is an old Node (no let/const/arrow/templates).
+ */
+
+var http = require('http');
+var https = require('https');
+var zlib = require('zlib');
+var urllib = require('url');
+
+var PORT = 8099;
+var USERSCRIPT_CDN = 'https://cdn.jsdelivr.net/npm/@krx3d/tizentube2/dist/userScript.js';
+var USERSCRIPT_FALLBACK = 'https://unpkg.com/@krx3d/tizentube2/dist/userScript.js';
+var ALLOWED = ['googlevideo.com', 'youtube.com', 'gstatic.com', 'google.com',
+    'googleapis.com', 'googleusercontent.com', 'ggpht.com'];
+
+function hostAllowed(h) {
+    if (!h) { return false; }
+    for (var i = 0; i < ALLOWED.length; i++) {
+        var a = ALLOWED[i];
+        if (h === a || h.slice(-(a.length + 1)) === '.' + a) { return true; }
+    }
+    return false;
+}
+
+function proxyPrefix() { return 'http://localhost:' + PORT + '/cors-bypass/'; }
+
+function rewriteText(text, isTvHtml) {
+    var p = proxyPrefix();
+    if (isTvHtml) {
+        var inject = '<script>window.__tizenTubeStandaloneVersion="nuvio";</script>' +
+            '<script src="' + USERSCRIPT_CDN + '?ver=' + Date.now() +
+            '" onerror="this.onerror=null;this.src=\'' + USERSCRIPT_FALLBACK + '\'"></script>';
+        if (/<body[^>]*>/i.test(text)) {
+            text = text.replace(/<body[^>]*>/i, function (b) { return b + inject; });
+        } else {
+            text = inject + text;
+        }
+    }
+    text = text.replace(/https:\/\/([a-zA-Z0-9-.]+)\.googlevideo\.com/g, p + 'https://$1.googlevideo.com');
+    text = text.replace(/https:\\\/\\\/([a-zA-Z0-9-.]+)\.googlevideo\.com/g,
+        'http:\\/\\/localhost:' + PORT + '\\/cors-bypass\\/https:\\/\\/$1.googlevideo.com');
+    text = text.replace(/"\/\/([a-zA-Z0-9-.]+)\.googlevideo\.com/g, '"' + p + 'https://$1.googlevideo.com');
+    text = text.replace(/https:\/\/www\.gstatic\.com/g, p + 'https://www.gstatic.com');
+    text = text.replace(/http:\/\/www\.gstatic\.com/g, p + 'https://www.gstatic.com');
+    text = text.replace(/"\/\/www\.gstatic\.com/g, '"' + p + 'https://www.gstatic.com');
+    text = text.replace(/\(\/\/www\.gstatic\.com/g, '(' + p + 'https://www.gstatic.com');
+    text = text.replace(/https:\/\/yt3\.ggpht\.com/g, p + 'https://yt3.ggpht.com');
+    text = text.replace(/https:\/\/clients1\.google\.com/g, p + 'https://clients1.google.com');
+    text = text.replace(/http:\/\/clients1\.google\.com/g, p + 'https://clients1.google.com');
+    text = text.replace(/"\/\/clients1\.google\.com/g, '"' + p + 'https://clients1.google.com');
+    text = text.replace('Set(["www.youtube.com","accounts.google.com"]);',
+        'Set(["www.youtube.com", "accounts.google.com", "localhost"]);');
+    text = text.replace(/:document\.location\.toString\(\)/g,
+        ':document.location.toString().replace("http://localhost:' + PORT + '", "https://www.youtube.com")');
+    text = text.replace(/euri:[^,]+,/g,
+        'euri:document.location.toString().replace("http://localhost:' + PORT + '", "https://www.youtube.com"),');
+    text = text.replace(/https:\/\/s\.youtube\.com/g, p + 'https://s.youtube.com');
+    text = text.replace(/redirector\.googlevideo\.com/g, p + 'https://redirector.googlevideo.com');
+    text = text.replace(/this.scheme="https"/, 'this.scheme="http"');
+    text = text.replace(/https:\/\/jnn-pa\.googleapis\.com/g, p + 'https://jnn-pa.googleapis.com');
+    text = text.replace(/https:\/\/yt3\.googleusercontent\.com/g, p + 'https://yt3.googleusercontent.com');
+    text = text.replace(/"\/\/yt3\.googleusercontent\.com/g, '"' + p + 'https://yt3.googleusercontent.com');
+    text = text.replace(/=window\.location\.href;/,
+        '=window.location.href.replace("http://localhost:' + PORT + '", "https://www.youtube.com");');
+    text = text.replace(/=document\.location\.href/,
+        '=document.location.href.replace("http://localhost:' + PORT + '", "https://www.youtube.com")');
+    return text;
+}
+
+function rewriteCookies(arr) {
+    if (!arr) { return arr; }
+    if (!(arr instanceof Array)) { arr = [arr]; }
+    var out = [];
+    for (var i = 0; i < arr.length; i++) {
+        out.push(String(arr[i])
+            .replace(/^__Secure-/i, '__LocalSecure-')
+            .replace(/^__Host-/i, '__LocalHost-')
+            .replace(/Domain=[^;]+/i, 'Domain=localhost')
+            .replace(/;\s*Secure/i, '')
+            .replace(/;\s*SameSite=None/i, ''));
+    }
+    return out;
+}
+
+function isTextType(ct) {
+    ct = ct || '';
+    return ct.indexOf('text/html') !== -1 || ct.indexOf('application/json') !== -1 ||
+        ct.indexOf('javascript') !== -1 || ct.indexOf('text/css') !== -1;
+}
+
+function decompress(buf, enc, cb) {
+    enc = (enc || '').toLowerCase();
+    if (enc === 'gzip') { zlib.gunzip(buf, cb); return; }
+    if (enc === 'deflate') {
+        zlib.inflate(buf, function (e, r) { if (e) { zlib.inflateRaw(buf, cb); } else { cb(null, r); } });
+        return;
+    }
+    cb(null, buf);
+}
+
+var SKIP_HEADERS = ['content-encoding', 'content-length', 'transfer-encoding',
+    'content-security-policy', 'x-frame-options', 'alt-svc'];
+
+function handle(req, res) {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, PUT, PATCH, DELETE');
+    res.setHeader('Access-Control-Allow-Headers', '*');
+    if (req.method === 'OPTIONS') { res.writeHead(200); res.end(); return; }
+
+    var pathOnly = req.url.split('?')[0];
+    if (pathOnly === '/health') { res.writeHead(200, { 'Content-Type': 'text/plain' }); res.end('ok'); return; }
+
+    var isCors = req.url.indexOf('/cors-bypass/') === 0;
+    var target;
+    if (isCors) {
+        var raw = req.url.substring('/cors-bypass/'.length);
+        target = raw.indexOf('http') === 0 ? raw : ('https://' + raw);
+    } else {
+        target = 'https://www.youtube.com' + req.url;
+    }
+
+    var pu;
+    try { pu = urllib.parse(target); } catch (e) { res.writeHead(403); res.end('bad url'); return; }
+    if (pu.protocol !== 'https:' && pu.protocol !== 'http:') { res.writeHead(403); res.end('bad protocol'); return; }
+    if (!hostAllowed(pu.hostname)) { res.writeHead(403); res.end('host not allowed'); return; }
+
+    var isTvHtml = (!isCors && pathOnly === '/tv');
+
+    var headers = {};
+    for (var k in req.headers) {
+        if (!Object.prototype.hasOwnProperty.call(req.headers, k)) { continue; }
+        if (k === 'cookie') {
+            headers[k] = String(req.headers[k])
+                .replace(/__LocalSecure-/g, '__Secure-')
+                .replace(/__LocalHost-/g, '__Host-');
+        } else if (k !== 'host' && k !== 'accept-encoding') {
+            headers[k] = req.headers[k];
+        }
+    }
+    headers.host = pu.host;
+    headers.origin = 'https://www.youtube.com';
+    if (headers.referer) { headers.referer = 'https://www.youtube.com/tv'; }
+    headers['accept-encoding'] = 'gzip, deflate';
+
+    var mod = pu.protocol === 'http:' ? http : https;
+    var options = {
+        hostname: pu.hostname,
+        port: pu.port || (pu.protocol === 'http:' ? 80 : 443),
+        path: pu.path,
+        method: req.method,
+        headers: headers,
+        maxHeaderSize: 5 * 1024 * 1024   // ignored on old Node; helps where supported (YT sends big headers)
+    };
+
+    var preq = mod.request(options, function (pres) {
+        var outHeaders = {};
+        for (var hk in pres.headers) {
+            if (!Object.prototype.hasOwnProperty.call(pres.headers, hk)) { continue; }
+            var lk = hk.toLowerCase();
+            if (SKIP_HEADERS.indexOf(lk) !== -1) { continue; }
+            if (lk === 'set-cookie') { outHeaders[hk] = rewriteCookies(pres.headers[hk]); continue; }
+            if (lk === 'location') {
+                outHeaders[hk] = String(pres.headers[hk])
+                    .replace(/https?:\/\/(www\.)?youtube\.com/gi, 'http://localhost:' + PORT);
+                continue;
+            }
+            outHeaders[hk] = pres.headers[hk];
+        }
+        outHeaders['Access-Control-Allow-Origin'] = '*';
+
+        var enc = pres.headers['content-encoding'];
+        var ct = pres.headers['content-type'] || '';
+
+        if (isTextType(ct)) {
+            var chunks = [];
+            pres.on('data', function (c) { chunks.push(c); });
+            pres.on('end', function () {
+                decompress(Buffer.concat(chunks), enc, function (err, buf) {
+                    if (err) { res.writeHead(502); res.end('decompress error'); return; }
+                    var text = rewriteText(buf.toString('utf8'), isTvHtml);
+                    // new Buffer(): Buffer.from() doesn't exist on the TV's old Node (< 4.5).
+                    var body = new Buffer(text, 'utf8');
+                    outHeaders['Content-Length'] = body.length;
+                    res.writeHead(pres.statusCode, outHeaders);
+                    res.end(body);
+                });
+            });
+            pres.on('error', function () { if (!res.headersSent) { res.writeHead(502); } res.end(); });
+        } else {
+            res.writeHead(pres.statusCode, outHeaders);
+            var e2 = (enc || '').toLowerCase();
+            if (e2 === 'gzip') { pres.pipe(zlib.createGunzip()).pipe(res); }
+            else if (e2 === 'deflate') { pres.pipe(zlib.createInflate()).pipe(res); }
+            else { pres.pipe(res); }
+        }
+    });
+
+    preq.on('error', function (e) {
+        if (!res.headersSent) { res.writeHead(502); }
+        try { res.end('proxy error'); } catch (e3) {}
+    });
+
+    req.pipe(preq);
+}
+
+var server = http.createServer(handle);
+server.on('error', function (err) { try { console.error('proxy listen error', err); } catch (e) {} });
+server.listen(PORT, '127.0.0.1', function () {
+    try { console.log('Nuvio leanback proxy on 127.0.0.1:' + PORT); } catch (e) {}
+});