nuvio-tizen 1.0.0

package/js/player.js

@@ -0,0 +1,218 @@
+/* Playback via Tizen AVPlay, with an HTML5 <video> fallback for desktop dev.
+   Global namespace: Player */
+var Player = (function () {
+    'use strict';
+
+    var PROGRESS_KEY = 'nuvio.progress';
+
+    var avplay = (window.webapis && webapis.avplay) ? webapis.avplay : null;
+    var useAV = !!avplay;
+
+    var videoEl = null;      // html5 fallback
+    var objEl = null;
+
+    var _active = false;
+    var _onExit = null;
+    var _ctx = null;         // { id, type, name, poster, resumeSec }
+    var _dur = 0;            // seconds
+    var _cur = 0;            // seconds
+    var _ticker = null;
+    var _osdTimer = null;
+    var _seekPending = 0;
+
+    function init() {
+        objEl = U.byId('av-player');
+        videoEl = U.byId('html5-player');
+    }
+
+    function isActive() { return _active; }
+
+    // ---------- progress store ----------
+    function progressAll() { return U.store.get(PROGRESS_KEY, {}); }
+    function progressKey(ctx) { return ctx.type + ':' + ctx.id; }
+
+    function saveProgress() {
+        if (!_ctx || !_dur) { return; }
+        var all = progressAll();
+        var k = progressKey(_ctx);
+        if (_cur / _dur > 0.95 || _cur < 5) {
+            delete all[k];
+        } else {
+            all[k] = { id: _ctx.id, type: _ctx.type, name: _ctx.name, poster: _ctx.poster,
+                       position: Math.floor(_cur), duration: Math.floor(_dur), updated: Date.now() };
+        }
+        U.store.set(PROGRESS_KEY, all);
+    }
+
+    function getResume(type, id) {
+        var e = progressAll()[type + ':' + id];
+        return e ? e.position : 0;
+    }
+
+    function continueList() {
+        var all = progressAll();
+        var arr = [];
+        for (var k in all) { if (Object.prototype.hasOwnProperty.call(all, k)) { arr.push(all[k]); } }
+        arr.sort(function (a, b) { return b.updated - a.updated; });
+        return arr;
+    }
+
+    // ---------- OSD ----------
+    function showOSD(sticky) {
+        U.byId('player-osd').className = '';
+        if (_osdTimer) { clearTimeout(_osdTimer); _osdTimer = null; }
+        if (!sticky) { _osdTimer = setTimeout(hideOSD, 4000); }
+    }
+    function hideOSD() { U.byId('player-osd').className = 'hidden'; }
+
+    function renderOSD() {
+        U.byId('osd-title').textContent = _ctx ? _ctx.name : '';
+        var pct = _dur > 0 ? (_cur / _dur * 100) : 0;
+        U.byId('osd-progress').style.width = pct + '%';
+        U.byId('osd-cur').textContent = U.fmtTime(_cur);
+        U.byId('osd-dur').textContent = U.fmtTime(_dur);
+    }
+
+    // ---------- lifecycle ----------
+    function play(ctx, onExit) {
+        _ctx = ctx; _onExit = onExit;
+        _active = true; _cur = 0; _dur = 0;
+        _ctx.resumeSec = ctx.resumeSec || getResume(ctx.type, ctx.id);
+
+        U.byId('app').className = 'hidden';
+        document.body.style.background = 'transparent';
+        showOSD(true);
+        U.spinner(true);
+
+        if (useAV) { startAV(ctx.url); } else { startHTML5(ctx.url); }
+    }
+
+    function startAV(url) {
+        objEl.className = 'active';
+        try {
+            avplay.close();
+        } catch (e) {}
+        try {
+            avplay.open(url);
+            avplay.setListener({
+                onbufferingstart: function () { U.spinner(true); },
+                onbufferingcomplete: function () { U.spinner(false); },
+                onstreamcompleted: function () { _cur = _dur; onEnded(); },
+                oncurrentplaytime: function (ms) { _cur = ms / 1000; renderOSD(); },
+                onerror: function (err) { U.spinner(false); U.toast('Playback error: ' + err); setTimeout(exit, 1500); }
+            });
+            try { avplay.setStreamingProperty('ADAPTIVE_INFO', 'BITRATES=1'); } catch (e0) {}
+            avplay.prepareAsync(function () {
+                U.spinner(false);
+                try { avplay.setDisplayRect(0, 0, 1920, 1080); } catch (e1) {}
+                try { avplay.setDisplayMethod('PLAYER_DISPLAY_MODE_LETTER_BOX'); } catch (e2) {}
+                try { _dur = avplay.getDuration() / 1000; } catch (e3) { _dur = 0; }
+                if (_ctx.resumeSec > 5) { try { avplay.seekTo(_ctx.resumeSec * 1000); } catch (e4) {} }
+                avplay.play();
+                renderOSD();
+                startTicker();
+                showOSD(false);
+            }, function (err) {
+                U.spinner(false); U.toast('Could not open stream'); setTimeout(exit, 1500);
+            });
+        } catch (e) {
+            U.spinner(false); U.toast('AVPlay failed: ' + e.message); setTimeout(exit, 1500);
+        }
+    }
+
+    function startHTML5(url) {
+        videoEl.className = 'active';
+        videoEl.src = url;
+        videoEl.onloadedmetadata = function () {
+            _dur = videoEl.duration || 0;
+            if (_ctx.resumeSec > 5) { try { videoEl.currentTime = _ctx.resumeSec; } catch (e) {} }
+            U.spinner(false); showOSD(false);
+        };
+        videoEl.ontimeupdate = function () { _cur = videoEl.currentTime; renderOSD(); };
+        videoEl.onended = onEnded;
+        videoEl.onerror = function () { U.toast('Playback error'); setTimeout(exit, 1500); };
+        var p = videoEl.play();
+        if (p && p['catch']) { p['catch'](function () {}); }
+        startTicker();
+    }
+
+    function startTicker() {
+        if (_ticker) { clearInterval(_ticker); }
+        _ticker = setInterval(function () {
+            if (useAV) { try { _cur = avplay.getCurrentTime() / 1000; } catch (e) {} renderOSD(); }
+            saveProgress();
+        }, 5000);
+    }
+
+    function onEnded() { saveProgress(); exit(); }
+
+    // ---------- controls ----------
+    function state() {
+        if (useAV) { try { return avplay.getState(); } catch (e) { return ''; } }
+        return videoEl.paused ? 'PAUSED' : 'PLAYING';
+    }
+
+    function togglePlay() {
+        if (useAV) {
+            var s = state();
+            if (s === 'PLAYING') { avplay.pause(); } else { avplay.play(); }
+        } else {
+            if (videoEl.paused) { videoEl.play(); } else { videoEl.pause(); }
+        }
+        showOSD(false);
+    }
+
+    function seekBy(delta) {
+        var target = Math.max(0, Math.min((_dur || 1e9), _cur + delta));
+        _cur = target;
+        renderOSD();
+        showOSD(false);
+        if (useAV) {
+            try { avplay.seekTo(Math.floor(target * 1000)); } catch (e) {}
+        } else {
+            try { videoEl.currentTime = target; } catch (e2) {}
+        }
+    }
+
+    function handleKey(action) {
+        showOSD(false);
+        switch (action) {
+            case 'OK': case 'PLAYPAUSE': togglePlay(); return true;
+            case 'PLAY': if (useAV) { try { avplay.play(); } catch (e) {} } else { videoEl.play(); } return true;
+            case 'PAUSE': if (useAV) { try { avplay.pause(); } catch (e) {} } else { videoEl.pause(); } return true;
+            case 'RIGHT': case 'FF': seekBy(action === 'FF' ? 30 : 10); return true;
+            case 'LEFT': case 'REW': seekBy(action === 'REW' ? -30 : -10); return true;
+            case 'UP': case 'DOWN': showOSD(false); return true;
+            case 'STOP': case 'BACK': exit(); return true;
+        }
+        return true;
+    }
+
+    function exit() {
+        if (!_active) { return; }
+        saveProgress();
+        _active = false;
+        if (_ticker) { clearInterval(_ticker); _ticker = null; }
+        if (_osdTimer) { clearTimeout(_osdTimer); _osdTimer = null; }
+        hideOSD();
+        if (useAV) {
+            try { avplay.stop(); } catch (e) {}
+            try { avplay.close(); } catch (e2) {}
+            objEl.className = '';
+        } else {
+            try { videoEl.pause(); } catch (e3) {}
+            videoEl.removeAttribute('src');
+            videoEl.className = '';
+        }
+        document.body.style.background = '';
+        U.byId('app').className = '';
+        U.spinner(false);
+        var cb = _onExit; _onExit = null; _ctx = null;
+        if (cb) { cb(); }
+    }
+
+    return {
+        init: init, play: play, handleKey: handleKey, isActive: isActive,
+        exit: exit, continueList: continueList, getResume: getResume
+    };
+})();

package/js/polyfills.js

@@ -0,0 +1,47 @@
+/* Minimal polyfills for Tizen 3.0 (Chromium ~47). Each is feature-guarded. */
+(function () {
+    'use strict';
+
+    if (typeof Object.assign !== 'function') {
+        Object.assign = function (target) {
+            for (var i = 1; i < arguments.length; i++) {
+                var src = arguments[i];
+                if (src) { for (var k in src) { if (Object.prototype.hasOwnProperty.call(src, k)) { target[k] = src[k]; } } }
+            }
+            return target;
+        };
+    }
+
+    if (!Array.prototype.find) {
+        Array.prototype.find = function (fn) {
+            for (var i = 0; i < this.length; i++) { if (fn(this[i], i, this)) { return this[i]; } }
+            return undefined;
+        };
+    }
+
+    if (!Array.prototype.findIndex) {
+        Array.prototype.findIndex = function (fn) {
+            for (var i = 0; i < this.length; i++) { if (fn(this[i], i, this)) { return i; } }
+            return -1;
+        };
+    }
+
+    if (!Array.prototype.includes) {
+        Array.prototype.includes = function (v) { return this.indexOf(v) !== -1; };
+    }
+
+    if (!String.prototype.includes) {
+        String.prototype.includes = function (v) { return this.indexOf(v) !== -1; };
+    }
+
+    if (!Array.from) {
+        Array.from = function (arrLike) {
+            var out = []; for (var i = 0; i < arrLike.length; i++) { out.push(arrLike[i]); } return out;
+        };
+    }
+
+    // requestAnimationFrame fallback (usually present, but be safe)
+    if (!window.requestAnimationFrame) {
+        window.requestAnimationFrame = function (cb) { return window.setTimeout(function () { cb(Date.now()); }, 16); };
+    }
+})();

package/js/stremio.js

@@ -0,0 +1,198 @@
+/* Stremio addon protocol client. Global namespace: Stremio
+   Mirrors how Nuvio sources data: user-configured addons expose
+   catalog / meta / stream resources over HTTP JSON. */
+var Stremio = (function () {
+    'use strict';
+
+    var ADDONS_KEY = 'nuvio.addons';
+
+    // Default: Cinemeta (official catalog + metadata addon). Stream addons are
+    // added by the user in Settings — this app hosts no content itself.
+    var DEFAULT_ADDONS = ['https://v3-cinemeta.strem.io/manifest.json'];
+
+    function normalizeManifestUrl(input) {
+        var u = ('' + input).trim();
+        if (!u) { return null; }
+        if (u.indexOf('://') === -1) { u = 'https://' + u; }
+        if (u.slice(-13) === 'manifest.json') { return u; }
+        if (u.slice(-1) === '/') { u = u.slice(0, -1); }
+        return u + '/manifest.json';
+    }
+
+    function baseOf(manifestUrl) {
+        return manifestUrl.replace(/\/manifest\.json.*$/, '');
+    }
+
+    function getAddonUrls() {
+        var list = U.store.get(ADDONS_KEY, null);
+        if (!list || !list.length) { list = DEFAULT_ADDONS.slice(); }
+        return list;
+    }
+
+    function saveAddonUrls(list) { U.store.set(ADDONS_KEY, list); }
+
+    function addAddon(input) {
+        var url = normalizeManifestUrl(input);
+        if (!url) { return false; }
+        var list = getAddonUrls();
+        if (list.indexOf(url) === -1) { list.push(url); saveAddonUrls(list); }
+        _loaded = null; // force reload
+        return url;
+    }
+
+    function removeAddon(url) {
+        var list = getAddonUrls().filter(function (u) { return u !== url; });
+        saveAddonUrls(list);
+        _loaded = null;
+    }
+
+    // ---- Manifest loading (cached in-memory per session) ----
+    var _loaded = null;
+
+    function loadAddons() {
+        if (_loaded) { return Promise.resolve(_loaded); }
+        var urls = getAddonUrls();
+        var tasks = urls.map(function (url) {
+            return function () {
+                return U.getJSON(url, 12000).then(function (manifest) {
+                    return { url: url, base: baseOf(url), manifest: manifest };
+                });
+            };
+        });
+        return U.settleAll(tasks, 4).then(function (results) {
+            var addons = [];
+            results.forEach(function (r) { if (r.ok && r.value.manifest) { addons.push(r.value); } });
+            _loaded = addons;
+            return addons;
+        });
+    }
+
+    // ---- Resource matching ----
+    function resourceEntries(addon) {
+        var res = (addon.manifest.resources) || [];
+        var out = [];
+        res.forEach(function (r) {
+            if (typeof r === 'string') {
+                out.push({ name: r, types: addon.manifest.types || [], idPrefixes: addon.manifest.idPrefixes || null });
+            } else if (r && r.name) {
+                out.push({ name: r.name, types: r.types || addon.manifest.types || [], idPrefixes: r.idPrefixes || addon.manifest.idPrefixes || null });
+            }
+        });
+        return out;
+    }
+
+    function supports(addon, resourceName, type, id) {
+        var entries = resourceEntries(addon);
+        for (var i = 0; i < entries.length; i++) {
+            var e = entries[i];
+            if (e.name !== resourceName) { continue; }
+            if (type && e.types && e.types.length && e.types.indexOf(type) === -1) { continue; }
+            if (id && e.idPrefixes && e.idPrefixes.length) {
+                var ok = false;
+                for (var j = 0; j < e.idPrefixes.length; j++) {
+                    if (id.indexOf(e.idPrefixes[j]) === 0) { ok = true; break; }
+                }
+                if (!ok) { continue; }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    // ---- Catalogs ----
+    // Returns list of {addon, type, id, name} across all addons.
+    function listCatalogs() {
+        return loadAddons().then(function (addons) {
+            var cats = [];
+            addons.forEach(function (addon) {
+                var cs = addon.manifest.catalogs || [];
+                cs.forEach(function (c) {
+                    if (!c.type || !c.id) { return; }
+                    var label = c.name || c.id;
+                    cats.push({ addon: addon, type: c.type, id: c.id,
+                        name: label + ' · ' + (addon.manifest.name || 'Addon') });
+                });
+            });
+            return cats;
+        });
+    }
+
+    function buildCatalogUrl(addon, type, id, extra) {
+        var extras = [];
+        if (extra) {
+            for (var k in extra) {
+                if (Object.prototype.hasOwnProperty.call(extra, k) && extra[k] !== undefined && extra[k] !== '') {
+                    extras.push(encodeURIComponent(k) + '=' + encodeURIComponent(extra[k]));
+                }
+            }
+        }
+        var tail = extras.length ? ('/' + extras.join('&')) : '';
+        return addon.base + '/catalog/' + encodeURIComponent(type) + '/' + encodeURIComponent(id) + tail + '.json';
+    }
+
+    function getCatalog(cat, extra) {
+        return U.getJSON(buildCatalogUrl(cat.addon, cat.type, cat.id, extra), 12000)
+            .then(function (res) { return (res && res.metas) ? res.metas : []; });
+    }
+
+    // ---- Meta ----
+    function getMeta(type, id) {
+        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)); }
+            var i = 0;
+            function tryNext() {
+                if (i >= providers.length) { return Promise.reject(new Error('Meta not found')); }
+                var a = providers[i++];
+                var url = a.base + '/meta/' + encodeURIComponent(type) + '/' + encodeURIComponent(id) + '.json';
+                return U.getJSON(url, 12000).then(function (res) {
+                    if (res && res.meta) { return res.meta; }
+                    return tryNext();
+                }, function () { return tryNext(); });
+            }
+            return tryNext();
+        });
+    }
+
+    // ---- Streams ----
+    // Aggregates stream lists from every addon that supports the (type,id).
+    function getStreams(type, id) {
+        return loadAddons().then(function (addons) {
+            var providers = addons.filter(function (a) { return supports(a, 'stream', type, id); });
+            var tasks = providers.map(function (a) {
+                return function () {
+                    var url = a.base + '/stream/' + encodeURIComponent(type) + '/' + encodeURIComponent(id) + '.json';
+                    return U.getJSON(url, 15000).then(function (res) {
+                        var arr = (res && res.streams) ? res.streams : [];
+                        arr.forEach(function (s) { s._addon = a.manifest.name || 'Addon'; });
+                        return arr;
+                    });
+                };
+            });
+            return U.settleAll(tasks, 4).then(function (results) {
+                var all = [];
+                results.forEach(function (r) { if (r.ok) { all = all.concat(r.value); } });
+                return all;
+            });
+        });
+    }
+
+    // A stream is directly playable on the TV only if it exposes an http(s) URL.
+    // Torrent (infoHash) / external-only streams need an engine this app doesn't embed.
+    function isPlayable(stream) {
+        return !!(stream && typeof stream.url === 'string' && /^https?:\/\//i.test(stream.url));
+    }
+
+    function streamLabel(stream) {
+        var t = stream.title || stream.name || stream.description || 'Stream';
+        return ('' + t).replace(/\n/g, ' ');
+    }
+
+    return {
+        DEFAULT_ADDONS: DEFAULT_ADDONS,
+        getAddonUrls: getAddonUrls, addAddon: addAddon, removeAddon: removeAddon,
+        loadAddons: loadAddons, listCatalogs: listCatalogs, getCatalog: getCatalog,
+        getMeta: getMeta, getStreams: getStreams,
+        isPlayable: isPlayable, streamLabel: streamLabel
+    };
+})();

package/js/util.js

@@ -0,0 +1,110 @@
+/* Utilities: DOM, HTTP, storage, formatting. Global namespace: U */
+var U = (function () {
+    'use strict';
+
+    function byId(id) { return document.getElementById(id); }
+
+    function el(tag, className, text) {
+        var node = document.createElement(tag);
+        if (className) { node.className = className; }
+        if (text !== undefined && text !== null) { node.textContent = text; }
+        return node;
+    }
+
+    function clear(node) { while (node.firstChild) { node.removeChild(node.firstChild); } }
+
+    /* GET JSON via XHR with timeout. Returns a Promise. */
+    function getJSON(url, timeoutMs) {
+        return new Promise(function (resolve, reject) {
+            var xhr = new XMLHttpRequest();
+            var done = false;
+            try { xhr.open('GET', url, true); } catch (e) { reject(e); return; }
+            xhr.timeout = timeoutMs || 15000;
+            xhr.onreadystatechange = function () {
+                if (xhr.readyState !== 4 || done) { return; }
+                done = true;
+                if (xhr.status >= 200 && xhr.status < 300) {
+                    try { resolve(JSON.parse(xhr.responseText)); }
+                    catch (e2) { reject(new Error('Bad JSON from ' + url)); }
+                } else {
+                    reject(new Error('HTTP ' + xhr.status + ' for ' + url));
+                }
+            };
+            xhr.ontimeout = function () { if (!done) { done = true; reject(new Error('Timeout: ' + url)); } };
+            xhr.onerror = function () { if (!done) { done = true; reject(new Error('Network error: ' + url)); } };
+            try { xhr.send(); } catch (e3) { reject(e3); }
+        });
+    }
+
+    /* localStorage JSON helpers, all guarded (storage can throw / be unavailable). */
+    var store = {
+        get: function (key, fallback) {
+            try {
+                var raw = window.localStorage.getItem(key);
+                return raw === null ? fallback : JSON.parse(raw);
+            } catch (e) { return fallback; }
+        },
+        set: function (key, value) {
+            try { window.localStorage.setItem(key, JSON.stringify(value)); return true; }
+            catch (e) { return false; }
+        },
+        remove: function (key) {
+            try { window.localStorage.removeItem(key); } catch (e) {}
+        }
+    };
+
+    var _toastTimer = null;
+    function toast(msg, ms) {
+        var t = byId('toast');
+        t.textContent = msg;
+        t.className = '';
+        if (_toastTimer) { clearTimeout(_toastTimer); }
+        _toastTimer = setTimeout(function () { t.className = 'hidden'; }, ms || 2600);
+    }
+
+    function spinner(on) { byId('spinner').className = on ? '' : 'hidden'; }
+
+    function fmtTime(sec) {
+        sec = Math.max(0, Math.floor(sec || 0));
+        var h = Math.floor(sec / 3600);
+        var m = Math.floor((sec % 3600) / 60);
+        var s = sec % 60;
+        function p(n) { return n < 10 ? '0' + n : '' + n; }
+        return (h > 0 ? h + ':' + p(m) : p(m)) + ':' + p(s);
+    }
+
+    /* Run an array of promise-returning fns with limited concurrency; never rejects.
+       Returns Promise of array of {ok, value|error} in original order. */
+    function settleAll(tasks, concurrency) {
+        concurrency = concurrency || 4;
+        return new Promise(function (resolve) {
+            var results = new Array(tasks.length);
+            var idx = 0, active = 0, finished = 0;
+            if (tasks.length === 0) { resolve(results); return; }
+            function launch() {
+                while (active < concurrency && idx < tasks.length) {
+                    (function (i) {
+                        active++;
+                        tasks[i]().then(function (v) {
+                            results[i] = { ok: true, value: v };
+                        }, function (e) {
+                            results[i] = { ok: false, error: e };
+                        }).then(function () {
+                            active--; finished++;
+                            if (finished === tasks.length) { resolve(results); }
+                            else { launch(); }
+                        });
+                    })(idx);
+                    idx++;
+                }
+            }
+            launch();
+        });
+    }
+
+    return {
+        byId: byId, el: el, clear: clear, getJSON: getJSON,
+        store: store, toast: toast, spinner: spinner,
+        fmtTime: fmtTime, settleAll: settleAll
+    };
+})();