From 8e6392a84ccb5d4e28fe9ee6271ee35edc9992d8 Mon Sep 17 00:00:00 2001 From: stilobique Date: Sun, 8 Nov 2026 12:06:15 +0100 Subject: [PATCH] Add basic behavior to play, show catalog and more basic feature --- CLAUDE.md | 14 +- Components/MediaCard.qml | 115 ++++++++++++++++ Components/MediaRow.qml | 73 +++++++++++ Components/Page.qml | 13 ++ Components/VideoSurface.qml | 162 +++++++++++++++++++++++ Components/qmldir | 3 + Core/DeviceProfile.js | 44 +++++++ Core/Navigator.qml | 12 ++ Core/Session.qml | 253 ++++++++++++++++++++++++++++++++++-- Jellyfin.qml | 4 +- Shared/Format.js | 77 +++++++++++ Shared/Theme.qml | 7 + Views/DetailsView.qml | 123 ++++++++++++++++++ Views/HomeView.qml | 120 ++++++++++++++--- Views/LibraryView.qml | 91 +++++++++++++ Views/PlayerView.qml | 244 ++++++++++++++++++++++++++++++++++ Views/SeasonView.qml | 134 +++++++++++++++++++ 17 files changed, 1455 insertions(+), 34 deletions(-) create mode 100644 Components/MediaCard.qml create mode 100644 Components/MediaRow.qml create mode 100644 Components/VideoSurface.qml create mode 100644 Core/DeviceProfile.js create mode 100644 Shared/Format.js create mode 100644 Views/DetailsView.qml create mode 100644 Views/LibraryView.qml create mode 100644 Views/PlayerView.qml create mode 100644 Views/SeasonView.qml diff --git a/CLAUDE.md b/CLAUDE.md index 6ae4e4c..31205ab 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -28,12 +28,13 @@ There is no build system or test suite. ## Architecture -- `Jellyfin.qml` — root `Application`: logo panel (1/3) + `Navigator` (2/3), owns the single `Session` instance. -- `Core/Navigator.qml` — screen stack on a `Loader`. `push("Name")` loads `Views/NameView.qml`; also `replace`, `pop`, `reset`. Every view gets `navigator` and `session` injected, plus any props passed to `push`. Remote Back/Escape pops; at the root it propagates (exits app). After loading, focus goes to the view's `initialFocus`. -- `Core/Session.qml` — Jellyfin API client over `XMLHttpRequest` (`_request()`: JSON, `Authorization: MediaBrowser …` header with `Token` once signed in, per-request timeout via a dynamically created `Timer` since Qt 5.5 XHR has none). Holds saved servers (`ListModel`, persisted through `fbx.application` `Settings` — works on the box only; on the PC `App is not defined` warnings are expected and nothing persists), `currentServer`, `currentUser`, `accessToken`. Endpoints: `/System/Info/Public` (server probe), `/Users/Public`, `/Users/AuthenticateByName`, `/Sessions/Logout`, `/QuickConnect/*`. Async functions call `callback(error, result)` with `error` a user-facing French message. Every public callback is wrapped by `_guard()`; `cancel()` (called by views on destruction) drops pending callbacks and stops Quick Connect polling. -- `Components/` — reusable widgets, listed in `Components/qmldir`. -- `Shared/` — `Theme` singleton (colors, spacing, fonts; the only type in `Shared/qmldir`) and `Remote.js` (`.pragma library`, `isAccept`/`isBack` key mapping, imported `as Remote`). -- `Views/` — one screen per file, each rooted in `Page` (title/subtitle header + content area). Current flow: `ServerSelect` → `ServerAdd` → `UserSelect` → `Login` (password or Quick Connect) → `Home` (placeholder). +- `Jellyfin.qml` — root `Application`: logo panel (1/3) + `Navigator` (2/3), owns the single `Session` instance. The logo panel hides when the current page sets `fullscreen: true` (catalog and player screens). +- `Core/Navigator.qml` — screen stack on a `Loader`. `push("Name")` loads `Views/NameView.qml`; also `replace`, `pop`, `reset`. Every view gets `navigator` and `session` injected, plus any props passed to `push`. Remote Back/Escape pops; at the root it propagates (exits app). After loading, focus goes to the view's `initialFocus`. `openItem(item)` routes a catalog item to `Library` / `Season` / `Details`. +- `Core/Session.qml` — Jellyfin API client over `XMLHttpRequest` (`_request()`: JSON, `Authorization: MediaBrowser …` header with `Token` once signed in, per-request timeout via a dynamically created `Timer` since Qt 5.5 XHR has none). Holds saved servers (`ListModel`, persisted through `fbx.application` `Settings` — works on the box only; on the PC `App is not defined` warnings are expected and nothing persists), `currentServer`, `currentUser`, `accessToken`. Endpoints: `/System/Info/Public` (server probe: all candidates in parallel, first success in priority order wins so a slow first TLS handshake doesn't fall back to http), `/Users/Public`, `/Users/AuthenticateByName`, `/Sessions/Logout`, `/QuickConnect/*`; catalog `/UserViews`, `/UserItems/Resume`, `/Items/Latest`, `/Items`, `/Shows/{id}/Seasons|Episodes`; playback `/Items/{id}/PlaybackInfo` and `/Sessions/Playing[/Progress|/Stopped]`. API items are flattened by `_toItem()` (no `index` key: reserved role name in `ListModel`). Image URLs via `posterUrl()` / `thumbUrl()` / `backdropUrl()`. Async functions call `callback(error, result)` with `error` a user-facing French message. Every public callback is wrapped by `_guard()`; `cancel()` (called by views on destruction) drops pending callbacks and stops Quick Connect polling. +- `Core/DeviceProfile.js` — what the Freebox Player can play, sent in `PlaybackInfo`: direct play H.264 only (the Revolution has no HEVC), otherwise HLS transcode. Text subtitles must stay declared `External` and `SubtitleStreamIndex: -1` sent, or Jellyfin transcodes to burn them in (`SubtitleCodecNotSupported`). +- `Components/` — reusable widgets, listed in `Components/qmldir`. `MediaCard` / `MediaRow` for catalog cards and horizontal rows. `VideoSurface` wraps the player: it tries the Freebox native `fbx.media` `VideoPlayer` then QtMultimedia `Video`, both created with `Qt.createQmlObject` so a missing module doesn't break loading; it polls the backend and exposes `position`/`duration` (ms) and `playerState`. **On the box, `fbx.media` is not installed: QtMultimedia is what plays** (verified: HLS transcode, seek/resume, pause, positions in ms). The fbx branch is kept as a fallback but is untested. +- `Shared/` — `Theme` singleton (colors, spacing, fonts, card sizes; the only type in `Shared/qmldir`), `Remote.js` (`isAccept`/`isBack` key mapping) and `Format.js` (durations, ticks↔ms, card labels), both `.pragma library`. +- `Views/` — one screen per file, each rooted in `Page` (title/subtitle header + content area). Flow: `ServerSelect` → `ServerAdd` → `UserSelect` → `Login` (password or Quick Connect) → `Home` (rows: Reprendre, Mes médias, latest per library) → `Library` (paged poster grid) / `Details` (movie, episode, or series with seasons) → `Season` (episodes) → `Player` (`PlayerView` is a plain `FocusScope`, not a `Page`). ## Platform constraints @@ -47,4 +48,5 @@ There is no build system or test suite. - every imported directory needs a `qmldir` listing all its types (`Core/`, `Components/`, `Shared/`); a missing one gives "X is not a type" only on the box; - a singleton must not live in the same directory as the components that use it, and a directory must hold at most one singleton — otherwise "Cyclic dependency detected". Put helpers in `.pragma library` JS files instead of new singletons; - no `import "."` self-imports. +- **Playback reporting must never clobber the server's resume point**: `PlayerView` reports start/progress/stop only once playback actually started *and* the resume position was reached, and never with position 0. (A failed playback reporting a stop at 0 wipes the user's resume position.) - Don't disable (`enabled: false`) a focused control during loading — it loses focus and the remote stops responding; guard with a `busy` flag instead. diff --git a/Components/MediaCard.qml b/Components/MediaCard.qml new file mode 100644 index 0000000..6ad55b2 --- /dev/null +++ b/Components/MediaCard.qml @@ -0,0 +1,115 @@ +import QtQuick 2.5 +import "../Shared" + +// Carte du catalogue : image (affiche ou vignette), titre, sous-titre, avancement. +Item { + id: card + + property string title: "" + property string subtitle: "" + property url imageSource: "" + property int imageHeight: Theme.posterHeight + property real progress: 0 + property bool played: false + property bool highlighted: false + property bool showText: true + signal clicked() + + height: imageHeight + (showText ? Theme.cardTextHeight : 0) + z: highlighted ? 1 : 0 + + Rectangle { + id: frame + width: parent.width + height: card.imageHeight + radius: Theme.radius + color: Theme.surface + border.width: card.highlighted ? 3 : 0 + border.color: Theme.focusBackground + scale: card.highlighted ? 1.06 : 1 + + Behavior on scale { NumberAnimation { duration: Theme.animFast } } + + // Initiale tant que l'image n'est pas chargée (ou absente). + Text { + anchors.centerIn: parent + visible: image.status !== Image.Ready + text: card.title.charAt(0).toUpperCase() + color: Theme.textMuted + font.pixelSize: 48 + font.bold: true + } + + Image { + id: image + anchors.fill: parent + anchors.margins: frame.border.width + source: card.imageSource + fillMode: Image.PreserveAspectCrop + asynchronous: true + clip: true + sourceSize.height: card.imageHeight + } + + Rectangle { + visible: card.progress > 0.01 && !card.played + anchors { left: parent.left; right: parent.right; bottom: parent.bottom; margins: 8 } + height: 4 + radius: 2 + color: "#99000000" + + Rectangle { + width: parent.width * Math.min(1, card.progress) + height: parent.height + radius: 2 + color: Theme.accent + } + } + + Rectangle { + visible: card.played + anchors { top: parent.top; right: parent.right; margins: 8 } + width: playedText.implicitWidth + Theme.spacingS * 2 + height: playedText.implicitHeight + 4 + radius: height / 2 + color: Theme.accent + + Text { + id: playedText + anchors.centerIn: parent + text: "VU" + color: Theme.text + font.pixelSize: 11 + font.bold: true + } + } + } + + Column { + visible: card.showText + anchors { top: frame.bottom; topMargin: Theme.spacingS; left: parent.left; right: parent.right } + + Text { + width: parent.width + text: card.title + elide: Text.ElideRight + color: card.highlighted ? Theme.text : Theme.textMuted + font.pixelSize: Theme.fontSmall + 1 + font.bold: card.highlighted + } + + Text { + width: parent.width + visible: text !== "" + text: card.subtitle + elide: Text.ElideRight + color: Theme.textMuted + font.pixelSize: Theme.fontSmall - 1 + } + } + + MouseArea { + anchors.fill: parent + onClicked: card.clicked() + } +} diff --git a/Components/MediaRow.qml b/Components/MediaRow.qml new file mode 100644 index 0000000..d57ea93 --- /dev/null +++ b/Components/MediaRow.qml @@ -0,0 +1,73 @@ +import QtQuick 2.5 +import "../Shared" +import "../Shared/Remote.js" as Remote +import "../Shared/Format.js" as Format + +// Rangée horizontale de cartes avec un titre (accueil, saisons…). +// `items` : éléments aplatis par Session._toItem(). +FocusScope { + id: row + + property string title: "" + property var items: [] + property bool landscape: false + property var session: null + property alias currentIndex: list.currentIndex + signal activated(var item) + + readonly property int cardWidth: landscape ? Theme.thumbWidth : Theme.posterWidth + readonly property int imageHeight: landscape ? Theme.thumbHeight : Theme.posterHeight + + height: titleText.height + Theme.spacingM + imageHeight + Theme.cardTextHeight + Theme.spacingM + + Text { + id: titleText + text: row.title + color: row.activeFocus ? Theme.text : Theme.textMuted + font.pixelSize: Theme.fontBody + font.bold: true + } + + ListView { + id: list + anchors { + top: titleText.bottom + topMargin: Theme.spacingM + left: parent.left + right: parent.right + bottom: parent.bottom + } + orientation: ListView.Horizontal + spacing: Theme.spacingM + focus: true + // Marge pour la carte agrandie (scale) au bord gauche. + leftMargin: 8 + rightMargin: 8 + highlightMoveDuration: 150 + model: row.items + + delegate: MediaCard { + width: row.cardWidth + imageHeight: row.imageHeight + title: Format.cardTitle(modelData) + subtitle: Format.cardSubtitle(modelData) + imageSource: !row.session ? "" + : row.landscape ? row.session.thumbUrl(modelData) + : row.session.posterUrl(modelData) + progress: Format.progress(modelData) + played: modelData.played + highlighted: ListView.isCurrentItem && list.activeFocus + onClicked: { + list.currentIndex = index; + row.activated(modelData); + } + } + + Keys.onPressed: { + if (Remote.isAccept(event.key) && currentIndex >= 0) { + event.accepted = true; + row.activated(row.items[currentIndex]); + } + } + } +} diff --git a/Components/Page.qml b/Components/Page.qml index d629967..71874dd 100644 --- a/Components/Page.qml +++ b/Components/Page.qml @@ -10,11 +10,24 @@ FocusScope { property var session: null // Élément qui reçoit le focus quand l'écran s'affiche. property Item initialFocus: null + // true : masque le panneau du logo (écrans du catalogue). + property bool fullscreen: false + // Image de fond facultative (assombrie). + property alias backdrop: backdropImage.source property alias title: titleText.text property alias subtitle: subtitleText.text default property alias content: body.data + Image { + id: backdropImage + anchors.fill: parent + visible: status === Image.Ready + fillMode: Image.PreserveAspectCrop + asynchronous: true + opacity: 0.25 + } + Column { id: header anchors { diff --git a/Components/VideoSurface.qml b/Components/VideoSurface.qml new file mode 100644 index 0000000..395e309 --- /dev/null +++ b/Components/VideoSurface.qml @@ -0,0 +1,162 @@ +import QtQuick 2.5 + +// Surface vidéo avec une interface unique, quel que soit le lecteur disponible : +// - "fbx" : VideoPlayer de libfbxqml (fbx.media) — absent du Freebox Player testé, +// conservé en premier choix au cas où, mais jamais vérifié ; +// - "qtmultimedia" : Video de QtMultimedia — c'est lui qui lit sur la box (HLS, reprise, +// pause et déplacement vérifiés ; positions en millisecondes). +// Les deux sont créés dynamiquement : un module absent ne fait pas échouer le chargement. +// +// position / duration en millisecondes ; playerState : "idle", "loading", "playing", +// "paused", "ended" ou "error". Les états bruts du lecteur sont écrits dans le log. +Item { + id: root + + property string source: "" + property real position: 0 + property real duration: 0 + property string playerState: "idle" + property string errorString: "" + property string backendName: "" + signal ended() + + property var _backend: null + property string _lastRaw: "" + + function play() { + if (_backend) + _backend.play(); + } + + function pause() { + if (_backend) + _backend.pause(); + } + + function togglePause() { + if (playerState === "playing") + pause(); + else + play(); + } + + function seek(ms) { + if (!_backend) + return; + var target = Math.max(0, duration > 0 ? Math.min(ms, duration - 1000) : ms); + console.log("Lecteur : déplacement à " + Math.round(target / 1000) + " s"); + _backend.seek(target); + } + + function stop() { + if (!_backend) + return; + _backend.stop(); + if (backendName === "fbx" && _backend.close) + _backend.close(); + } + + function _create() { + var attempts = [ + { name: "fbx", qml: 'import QtQuick 2.5; import fbx.media 1.0; VideoPlayer { anchors.fill: parent }' }, + { name: "qtmultimedia", qml: 'import QtQuick 2.5; import QtMultimedia 5.0; ' + + 'Video { anchors.fill: parent; fillMode: VideoOutput.PreserveAspectFit }' } + ]; + for (var i = 0; i < attempts.length && !_backend; i++) { + try { + _backend = Qt.createQmlObject(attempts[i].qml, root, "VideoSurface-" + attempts[i].name); + backendName = attempts[i].name; + } catch (e) { + console.log("Lecteur " + attempts[i].name + " indisponible : " + e); + } + } + if (!_backend) { + _fail("Aucun lecteur vidéo disponible."); + return; + } + console.log("Lecteur vidéo : " + backendName); + if (backendName === "fbx" && _backend.error) { + _backend.error.connect(function (message, fatal) { + console.log("Lecteur fbx : erreur " + message + (fatal ? " (fatale)" : "")); + if (fatal) + _fail(String(message)); + }); + } + if (source !== "") + _open(); + } + + function _open() { + errorString = ""; + playerState = "loading"; + _backend.source = source; + _backend.play(); + } + + function _fail(message) { + errorString = message; + playerState = "error"; + } + + // Lecture périodique de l'état du lecteur (identique pour les deux backends). + function _poll() { + if (!_backend || playerState === "error") + return; + var raw; + if (backendName === "fbx") { + raw = "mediaState=" + _backend.mediaState + " playbackState=" + _backend.playbackState + + " status=" + _backend.status; + position = _backend.position || 0; + duration = _backend.duration || 0; + var media = String(_backend.mediaState); + var playback = String(_backend.playbackState); + if (media === "ended") + _setState("ended"); + else if (playback === "playing") + _setState("playing"); + else if (playback === "paused") + _setState("paused"); + else + _setState("loading"); + } else { + // Valeurs de MediaPlayer : playbackState 1 = lecture, 2 = pause ; + // status 7 = fin du média, 8 = média invalide. + raw = "status=" + _backend.status + " playbackState=" + _backend.playbackState; + position = _backend.position || 0; + duration = _backend.duration > 0 ? _backend.duration : 0; + if (_backend.status === 8 || (_backend.errorString && _backend.error !== 0)) + _fail(_backend.errorString || "Média illisible."); + else if (_backend.status === 7) + _setState("ended"); + else if (_backend.playbackState === 1) + _setState(_backend.status === 4 || _backend.status === 5 ? "loading" : "playing"); + else if (_backend.playbackState === 2) + _setState("paused"); + } + if (raw !== _lastRaw) { + _lastRaw = raw; + console.log("Lecteur " + backendName + " : " + raw + " position=" + Math.round(position) + + " durée=" + Math.round(duration)); + } + } + + function _setState(state) { + if (state === playerState) + return; + playerState = state; + if (state === "ended") + ended(); + } + + onSourceChanged: if (_backend && source !== "") _open() + + Timer { + interval: 250 + repeat: true + running: root._backend !== null && root.source !== "" + onTriggered: root._poll() + } + + Component.onCompleted: _create() + Component.onDestruction: stop() +} diff --git a/Components/qmldir b/Components/qmldir index 4c45cbe..4312736 100644 --- a/Components/qmldir +++ b/Components/qmldir @@ -4,3 +4,6 @@ TextField 1.0 TextField.qml ServerItem 1.0 ServerItem.qml UserCard 1.0 UserCard.qml Logo 1.0 Logo.qml +MediaCard 1.0 MediaCard.qml +MediaRow 1.0 MediaRow.qml +VideoSurface 1.0 VideoSurface.qml diff --git a/Core/DeviceProfile.js b/Core/DeviceProfile.js new file mode 100644 index 0000000..03fd361 --- /dev/null +++ b/Core/DeviceProfile.js @@ -0,0 +1,44 @@ +.pragma library + +// Ce que le Freebox Player (Revolution) sait lire, déclaré à Jellyfin dans PlaybackInfo. +// Jellyfin choisit alors : lecture directe si le fichier convient, sinon transcodage HLS. +// Hypothèses prudentes (H.264 seulement : pas de HEVC sur la Revolution), à ajuster +// d'après les essais sur la box. + +var maxBitrate = 20000000; + +function profile() { + return { + Name: "Freebox Player", + MaxStreamingBitrate: maxBitrate, + MaxStaticBitrate: maxBitrate, + DirectPlayProfiles: [ + { Type: "Video", Container: "mp4,m4v,mkv,ts,mov", VideoCodec: "h264", AudioCodec: "aac,mp3,ac3" } + ], + TranscodingProfiles: [ + { + Type: "Video", Container: "ts", Protocol: "hls", Context: "Streaming", + VideoCodec: "h264", AudioCodec: "aac,ac3", MaxAudioChannels: "6", + MinSegments: 1, BreakOnNonKeyFrames: true + } + ], + CodecProfiles: [ + { + Type: "Video", Codec: "h264", + Conditions: [ + { Condition: "LessThanEqual", Property: "Width", Value: "1920" }, + { Condition: "LessThanEqual", Property: "VideoBitDepth", Value: "8" } + ] + } + ], + // Sous-titres texte déclarés « externes » : sans ça, Jellyfin transcode pour les + // incruster (SubtitleCodecNotSupported). Le lecteur ne les affiche pas encore. + SubtitleProfiles: [ + { Format: "srt", Method: "External" }, + { Format: "subrip", Method: "External" }, + { Format: "ass", Method: "External" }, + { Format: "ssa", Method: "External" }, + { Format: "vtt", Method: "External" } + ] + }; +} diff --git a/Core/Navigator.qml b/Core/Navigator.qml index 398c331..9d23128 100644 --- a/Core/Navigator.qml +++ b/Core/Navigator.qml @@ -10,6 +10,7 @@ FocusScope { property var session: null property int depth: 0 + readonly property bool fullscreen: loader.item !== null && loader.item.fullscreen === true property var _stack: [] function push(name, props) { @@ -36,6 +37,17 @@ FocusScope { push(name, props); } + // Ouvre l'écran adapté à un élément du catalogue (Session._toItem()). + function openItem(item) { + if (item.type === "CollectionFolder") + push("Library", { library: { id: item.id, name: item.name, collectionType: item.collectionType } }); + else if (item.type === "Season") + push("Season", { seriesId: item.seriesId, seasonId: item.id, seasonName: item.name, + seriesName: item.seriesName }); + else + push("Details", { itemId: item.id }); + } + function _load() { var entry = _stack[_stack.length - 1]; var props = { navigator: root, session: root.session }; diff --git a/Core/Session.qml b/Core/Session.qml index e3ca5a1..8a66158 100644 --- a/Core/Session.qml +++ b/Core/Session.qml @@ -1,5 +1,6 @@ import QtQuick 2.5 import fbx.application 1.0 +import "DeviceProfile.js" as DeviceProfile // État de connexion et appels à l'API Jellyfin : serveurs enregistrés, // serveur et utilisateur courants, jeton d'accès. @@ -59,7 +60,7 @@ QtObject { callback("Le port doit être un nombre entre 1 et 65535."); return; } - _probeCandidates(serverCandidates(host, portText), 0, function (err, server) { + _probeCandidates(serverCandidates(host, portText), function (err, server) { if (err) { callback(err); return; @@ -229,6 +230,207 @@ QtObject { }); } + // --------------------------------------------------------------- Catalogue + // Les éléments renvoyés sont « aplatis » par _toItem() (voir ses champs) pour + // pouvoir aller tels quels dans un ListModel ou un modèle JS. + + // Bibliothèques de l'utilisateur : Films, Séries… + function loadLibraries(callback) { + callback = _guard(callback); + _request("GET", "/UserViews?" + _query({ userId: currentUser.id }), null, function (err, data) { + callback(err ? _describe(err) : null, err ? [] : _toItems(data.Items)); + }); + } + + // « Reprendre » : vidéos commencées. + function loadResume(callback) { + callback = _guard(callback); + _request("GET", "/UserItems/Resume?" + _query({ + userId: currentUser.id, limit: 20, mediaTypes: "Video", enableTotalRecordCount: false + }), null, function (err, data) { + callback(err ? _describe(err) : null, err ? [] : _toItems(data.Items)); + }); + } + + // Derniers ajouts d'une bibliothèque. + function loadLatest(libraryId, callback) { + callback = _guard(callback); + _request("GET", "/Items/Latest?" + _query({ userId: currentUser.id, parentId: libraryId, limit: 20 }), + null, function (err, data) { + callback(err ? _describe(err) : null, err ? [] : _toItems(data)); + }); + } + + // Contenu d'une bibliothèque, par pages. callback(err, items, total) + function loadLibraryItems(library, startIndex, limit, callback) { + callback = _guard(callback); + var types = library.collectionType === "tvshows" ? "Series" + : library.collectionType === "movies" ? "Movie" : "Movie,Series,Video"; + _request("GET", "/Items?" + _query({ + userId: currentUser.id, parentId: library.id, recursive: true, includeItemTypes: types, + sortBy: "SortName", sortOrder: "Ascending", startIndex: startIndex, limit: limit, + fields: "PrimaryImageAspectRatio" + }), null, function (err, data) { + if (err) + callback(_describe(err), [], 0); + else + callback(null, _toItems(data.Items), data.TotalRecordCount || 0); + }); + } + + function loadItem(itemId, callback) { + callback = _guard(callback); + _request("GET", "/Items/" + itemId + "?" + _query({ userId: currentUser.id }), null, function (err, data) { + callback(err ? _describe(err) : null, err ? null : _toItem(data)); + }); + } + + function loadSeasons(seriesId, callback) { + callback = _guard(callback); + _request("GET", "/Shows/" + seriesId + "/Seasons?" + _query({ userId: currentUser.id }), null, + function (err, data) { + callback(err ? _describe(err) : null, err ? [] : _toItems(data.Items)); + }); + } + + function loadEpisodes(seriesId, seasonId, callback) { + callback = _guard(callback); + _request("GET", "/Shows/" + seriesId + "/Episodes?" + _query({ + userId: currentUser.id, seasonId: seasonId, fields: "Overview" + }), null, function (err, data) { + callback(err ? _describe(err) : null, err ? [] : _toItems(data.Items)); + }); + } + + // URL d'image (pas d'authentification nécessaire). kind : "Primary", "Backdrop", "Thumb". + function imageUrl(itemId, kind, tag, maxHeight) { + if (!currentServer || !itemId || !tag) + return ""; + return currentServer.address + "/Items/" + itemId + "/Images/" + kind + "?" + + _query({ tag: tag, maxHeight: maxHeight || 360, quality: 90 }); + } + + // Affiche : celle de l'élément, sinon celle de sa série. + function posterUrl(item, maxHeight) { + if (item.imageTag) + return imageUrl(item.id, "Primary", item.imageTag, maxHeight); + return imageUrl(item.seriesId, "Primary", item.seriesPrimaryTag, maxHeight); + } + + // Vignette 16:9 : image principale des bibliothèques/épisodes, sinon Thumb, sinon fond. + function thumbUrl(item, maxHeight) { + maxHeight = maxHeight || 300; + if ((item.type === "CollectionFolder" || item.type === "Episode") && item.imageTag) + return imageUrl(item.id, "Primary", item.imageTag, maxHeight); + if (item.thumbTag) + return imageUrl(item.id, "Thumb", item.thumbTag, maxHeight); + return backdropUrl(item, maxHeight) || posterUrl(item, maxHeight); + } + + function backdropUrl(item, maxHeight) { + if (item.backdropTag) + return imageUrl(item.id, "Backdrop", item.backdropTag, maxHeight || 720); + return imageUrl(item.parentBackdropItemId, "Backdrop", item.parentBackdropTag, maxHeight || 720); + } + + // ----------------------------------------------------------------- Lecture + + // Demande à Jellyfin comment lire l'élément pour ce Player (profil DeviceProfile.js). + // callback(err, { url, itemId, mediaSourceId, playSessionId, playMethod }) + function preparePlayback(itemId, callback) { + callback = _guard(callback); + _request("POST", "/Items/" + itemId + "/PlaybackInfo?" + _query({ userId: currentUser.id }), + // SubtitleStreamIndex -1 : pas de sous-titres (évite leur incrustation par transcodage). + { DeviceProfile: DeviceProfile.profile(), MaxStreamingBitrate: DeviceProfile.maxBitrate, + SubtitleStreamIndex: -1 }, + function (err, data) { + if (err) { + callback(_describe(err)); + return; + } + var source = data.MediaSources && data.MediaSources[0]; + if (data.ErrorCode || !source) { + callback("Lecture impossible (" + (data.ErrorCode || "aucune source") + ")."); + return; + } + var info = { itemId: itemId, mediaSourceId: source.Id, playSessionId: data.PlaySessionId }; + if (source.SupportsDirectPlay || source.SupportsDirectStream) { + info.playMethod = source.SupportsDirectPlay ? "DirectPlay" : "DirectStream"; + info.url = currentServer.address + "/Videos/" + itemId + "/stream?" + _query({ + static: true, mediaSourceId: source.Id, playSessionId: data.PlaySessionId, + deviceId: _settings.deviceId, api_key: accessToken + }); + } else if (source.SupportsTranscoding && source.TranscodingUrl) { + info.playMethod = "Transcode"; + info.url = currentServer.address + source.TranscodingUrl; + } else { + callback("Ce média ne peut pas être lu sur la Freebox."); + return; + } + console.log("Lecture : " + info.playMethod + " (" + (source.Container || "?") + ")"); + callback(null, info); + }); + } + + // Suivi de lecture côté serveur (reprise, « vu »). event : "start", "progress", "stop". + function reportPlayback(event, info, positionMs, paused) { + var path = event === "start" ? "/Sessions/Playing" + : event === "stop" ? "/Sessions/Playing/Stopped" : "/Sessions/Playing/Progress"; + _request("POST", path, { + ItemId: info.itemId, MediaSourceId: info.mediaSourceId, PlaySessionId: info.playSessionId, + PlayMethod: info.playMethod, PositionTicks: Math.floor((positionMs || 0) * 10000), + IsPaused: !!paused, CanSeek: true + }, function () {}); + } + + function _query(params) { + var parts = []; + for (var key in params) { + if (params[key] !== undefined && params[key] !== null && params[key] !== "") + parts.push(encodeURIComponent(key) + "=" + encodeURIComponent(params[key])); + } + return parts.join("&"); + } + + function _toItems(list) { + var items = []; + for (var i = 0; i < (list || []).length; i++) + items.push(_toItem(list[i])); + return items; + } + + function _toItem(i) { + var userData = i.UserData || {}; + return { + id: i.Id, + name: i.Name || "", + type: i.Type || "", + collectionType: i.CollectionType || "", + isFolder: !!i.IsFolder, + year: i.ProductionYear || 0, + overview: i.Overview || "", + runtimeTicks: i.RunTimeTicks || 0, + rating: i.OfficialRating || "", + communityRating: i.CommunityRating || 0, + imageTag: (i.ImageTags && i.ImageTags.Primary) || "", + thumbTag: (i.ImageTags && i.ImageTags.Thumb) || "", + backdropTag: (i.BackdropImageTags && i.BackdropImageTags[0]) || "", + parentBackdropItemId: i.ParentBackdropItemId || "", + parentBackdropTag: (i.ParentBackdropImageTags && i.ParentBackdropImageTags[0]) || "", + seriesId: i.SeriesId || "", + seriesName: i.SeriesName || "", + seriesPrimaryTag: i.SeriesPrimaryImageTag || "", + seasonId: i.SeasonId || "", + // (pas de champ « index » : rôle réservé dans les ListModel) + indexNumber: i.IndexNumber || 0, + parentIndexNumber: i.ParentIndexNumber || 0, + childCount: i.ChildCount || 0, + positionTicks: userData.PlaybackPositionTicks || 0, + playedPercentage: userData.PlayedPercentage || 0, + played: !!userData.Played + }; + } + // ------------------------------------------------------------------ Divers // Ignore les réponses en attente (appelé quand un écran est détruit). @@ -253,20 +455,47 @@ QtObject { return currentUser; } - // Essaie les adresses une par une ; renvoie la première qui répond comme un serveur Jellyfin. - function _probeCandidates(candidates, index, callback) { - if (index >= candidates.length) { + // Essaie toutes les adresses en parallèle et retient la première, dans l'ordre de + // priorité, qui répond comme un serveur Jellyfin. Une adresse moins prioritaire (http) + // n'est retenue qu'une fois les plus prioritaires (https) réellement en échec : un + // premier échange TLS lent (chargement des certificats, CPU de la box) ne doit pas + // faire basculer sur http. + function _probeCandidates(candidates, callback) { + var results = []; + var settled = false; + + function settle() { + if (settled) + return; + for (var i = 0; i < candidates.length; i++) { + if (results[i] === undefined) + return; // une adresse plus prioritaire n'a pas encore répondu + if (results[i]) { + settled = true; + callback(null, results[i]); + return; + } + } + settled = true; + callback("Aucun serveur Jellyfin trouvé à cette adresse."); + } + + if (candidates.length === 0) { callback("Aucun serveur Jellyfin trouvé à cette adresse."); return; } - var address = candidates[index]; - _request("GET", "/System/Info/Public", null, function (err, info) { - if (!err && info && info.Id) { - callback(null, { name: info.ServerName || _hostOf(address), address: address, id: info.Id }); - return; - } - _probeCandidates(candidates, index + 1, callback); - }, { baseUrl: address, timeout: 5000 }); + for (var i = 0; i < candidates.length; i++) { + (function (index, address) { + _request("GET", "/System/Info/Public", null, function (err, info) { + results[index] = !err && info && info.Id + ? { name: info.ServerName || _hostOf(address), address: address, id: info.Id } + : null; + if (!results[index]) + console.log("Serveur : " + address + " ne répond pas (" + (err ? err.kind + " " + err.status : "réponse inattendue") + ")"); + settle(); + }, { baseUrl: address, timeout: 10000 }); + })(i, candidates[i]); + } } function _describe(err) { diff --git a/Jellyfin.qml b/Jellyfin.qml index 0798b78..c1fce8f 100644 --- a/Jellyfin.qml +++ b/Jellyfin.qml @@ -17,9 +17,11 @@ Application { Row { anchors.fill: parent + // Masqué sur les écrans du catalogue (Page.fullscreen). Logo { id: logo - width: parent.width / 3 + visible: !navigator.fullscreen + width: visible ? parent.width / 3 : 0 height: parent.height } diff --git a/Shared/Format.js b/Shared/Format.js new file mode 100644 index 0000000..026c58c --- /dev/null +++ b/Shared/Format.js @@ -0,0 +1,77 @@ +.pragma library + +// Mise en forme des durées et des libellés de médias. + +var TICKS_PER_MS = 10000; // Jellyfin compte en « ticks » de 100 ns + +function ticksToMs(ticks) { + return Math.floor((ticks || 0) / TICKS_PER_MS); +} + +function msToTicks(ms) { + return Math.floor((ms || 0) * TICKS_PER_MS); +} + +// « 1 h 34 min », « 52 min » +function runtime(ticks) { + var minutes = Math.round(ticksToMs(ticks) / 60000); + if (minutes <= 0) + return ""; + if (minutes < 60) + return minutes + " min"; + var m = minutes % 60; + return Math.floor(minutes / 60) + " h" + (m > 0 ? " " + (m < 10 ? "0" : "") + m + " min" : ""); +} + +// « 1:02:03 », « 4:05 » +function clock(ms) { + var total = Math.max(0, Math.floor((ms || 0) / 1000)); + var h = Math.floor(total / 3600); + var m = Math.floor((total % 3600) / 60); + var s = total % 60; + var mm = h > 0 && m < 10 ? "0" + m : String(m); + return (h > 0 ? h + ":" : "") + mm + ":" + (s < 10 ? "0" : "") + s; +} + +// « S1 · É3 » pour un épisode +function episodeCode(item) { + if (!item || item.type !== "Episode") + return ""; + return "S" + (item.parentIndexNumber || 0) + " · É" + (item.indexNumber || 0); +} + +// Libellés des cartes du catalogue. +function cardTitle(item) { + return item.type === "Episode" && item.seriesName ? item.seriesName : item.name; +} + +function cardSubtitle(item) { + if (item.type === "Episode") + return episodeCode(item) + " – " + item.name; + if (item.type === "Series" && item.childCount) + return item.childCount + " saison" + (item.childCount > 1 ? "s" : ""); + return item.year ? String(item.year) : ""; +} + +// Avancement 0..1 (pour la barre de progression des cartes). +function progress(item) { + if (item.playedPercentage) + return item.playedPercentage / 100; + return item.runtimeTicks ? item.positionTicks / item.runtimeTicks : 0; +} + +// Ligne d'informations : « 1997 · 1 h 34 min · Tous publics » +function infoLine(item) { + var parts = []; + if (item.type === "Episode") + parts.push(episodeCode(item)); + if (item.year) + parts.push(String(item.year)); + if (item.runtimeTicks) + parts.push(runtime(item.runtimeTicks)); + if (item.rating) + parts.push(item.rating); + if (item.communityRating) + parts.push(item.communityRating.toFixed(1).replace(".", ",") + "/10"); + return parts.join(" · "); +} diff --git a/Shared/Theme.qml b/Shared/Theme.qml index 604ef6a..9dbc7ab 100644 --- a/Shared/Theme.qml +++ b/Shared/Theme.qml @@ -31,6 +31,13 @@ QtObject { readonly property int fontTitle: 32 readonly property int fontCode: 56 + // Cartes du catalogue (affiche 2:3, vignette 16:9) + readonly property int posterWidth: 150 + readonly property int posterHeight: 225 + readonly property int thumbWidth: 267 + readonly property int thumbHeight: 150 + readonly property int cardTextHeight: 52 + // Contrôles readonly property int controlHeight: 48 readonly property int radius: 6 diff --git a/Views/DetailsView.qml b/Views/DetailsView.qml new file mode 100644 index 0000000..22e0146 --- /dev/null +++ b/Views/DetailsView.qml @@ -0,0 +1,123 @@ +import QtQuick 2.5 +import "../Components" +import "../Shared" +import "../Shared/Format.js" as Format + +// Fiche d'un film, d'un épisode ou d'une série (saisons). +Page { + id: page + + property string itemId: "" + property var item: null + property var seasons: [] + property string error: "" + + readonly property bool isSeries: item !== null && item.type === "Series" + readonly property real resumeMs: item ? Format.ticksToMs(item.positionTicks) : 0 + + fullscreen: true + title: item ? item.name : "" + subtitle: item ? (item.type === "Episode" && item.seriesName ? item.seriesName + " · " : "") + + Format.infoLine(item) : "" + backdrop: item && page.session ? page.session.backdropUrl(item, 720) : "" + initialFocus: playButton + + function play(startMs) { + var label = item.type === "Episode" + ? item.seriesName + " · " + Format.episodeCode(item) + " – " + item.name : item.name; + page.navigator.push("Player", { itemId: item.id, title: label, startMs: startMs }); + } + + Component.onCompleted: { + page.session.loadItem(itemId, function (err, loaded) { + if (err) { + page.error = err; + return; + } + page.item = loaded; + if (loaded.type === "Series") { + page.session.loadSeasons(loaded.id, function (e, list) { + page.seasons = list; + seasonsRow.forceActiveFocus(); + }); + } else { + playButton.forceActiveFocus(); + } + }); + } + + Component.onDestruction: if (page.session) page.session.cancel() + + Rectangle { + id: poster + width: 200 + height: 300 + radius: Theme.radius + color: Theme.surface + + Image { + anchors.fill: parent + // Épisode : affiche de la série (l'image de l'épisode est en 16:9). + source: !page.item || !page.session ? "" + : page.item.type === "Episode" && page.item.seriesPrimaryTag + ? page.session.imageUrl(page.item.seriesId, "Primary", page.item.seriesPrimaryTag, 450) + : page.session.posterUrl(page.item, 450) + fillMode: Image.PreserveAspectCrop + asynchronous: true + sourceSize.height: 300 + } + } + + Column { + anchors { + left: poster.right + leftMargin: Theme.spacingXL + right: parent.right + top: parent.top + } + spacing: Theme.spacingL + + Text { + width: parent.width + visible: text !== "" + text: page.error !== "" ? page.error : page.item ? page.item.overview : "Chargement…" + color: page.error !== "" ? Theme.error : Theme.text + font.pixelSize: Theme.fontBody + wrapMode: Text.WordWrap + maximumLineCount: page.isSeries ? 4 : 8 + elide: Text.ElideRight + lineHeight: 1.15 + } + + Row { + spacing: Theme.spacingM + visible: page.item !== null && !page.isSeries + + FocusButton { + id: playButton + primary: true + text: page.resumeMs > 0 ? "Reprendre à " + Format.clock(page.resumeMs) : "Lire" + KeyNavigation.right: restartButton.visible ? restartButton : null + onClicked: page.play(page.resumeMs) + } + + FocusButton { + id: restartButton + visible: page.resumeMs > 0 + text: "Lire depuis le début" + KeyNavigation.left: playButton + onClicked: page.play(0) + } + } + + MediaRow { + id: seasonsRow + width: parent.width + visible: page.seasons.length > 0 + title: "Saisons" + items: page.seasons + session: page.session + onActivated: page.navigator.openItem(item) + } + } +} diff --git a/Views/HomeView.qml b/Views/HomeView.qml index 5f6a906..a629089 100644 --- a/Views/HomeView.qml +++ b/Views/HomeView.qml @@ -3,27 +3,75 @@ import "../Components" import "../Shared" import "../Shared/Remote.js" as Remote -// Écran d'accueil provisoire : confirme la connexion en attendant la vraie bibliothèque. +// Accueil : rangées « Reprendre », « Mes médias » et derniers ajouts de chaque bibliothèque. +// Toutes les rangées sont chargées avant affichage, pour ne pas déplacer le focus en cours de route. Page { id: page - title: page.session && page.session.currentUser - ? "Bonjour " + page.session.currentUser.name - : "Accueil" - subtitle: page.session && page.session.currentServer - ? "Connecté à " + page.session.currentServer.name + "." - : "" - initialFocus: backButton + property var rows: [] + property bool loading: true + property string error: "" - // La pile a été réinitialisée à la connexion : on reconstruit Serveurs > Utilisateurs - // pour revenir au choix de l'utilisateur. + fullscreen: true + title: page.session && page.session.currentUser ? "Bonjour " + page.session.currentUser.name : "Accueil" + subtitle: page.session && page.session.currentServer ? page.session.currentServer.name : "" + initialFocus: switchUserButton + + // La pile a été réinitialisée à la connexion : on reconstruit Serveurs > Utilisateurs. function goBack() { page.navigator.reset("ServerSelect"); page.navigator.push("UserSelect"); } - // La touche Retour de la télécommande fait la même chose que le bouton - // (sinon, à la racine de la pile, elle fermerait l'application). + function load() { + page.session.loadLibraries(function (err, libraries) { + if (err) { + page.error = err; + page.loading = false; + return; + } + var resume = []; + var latest = []; + var pending = 1 + libraries.length; + function done() { + if (--pending === 0) + page.build(libraries, resume, latest); + } + page.session.loadResume(function (e, items) { + resume = items; + done(); + }); + for (var i = 0; i < libraries.length; i++) { + (function (index) { + page.session.loadLatest(libraries[index].id, function (e, items) { + latest[index] = items; + done(); + }); + })(i); + } + }); + } + + function build(libraries, resume, latest) { + var list = []; + if (resume.length > 0) + list.push({ title: "Reprendre", items: resume, landscape: true }); + if (libraries.length > 0) + list.push({ title: "Mes médias", items: libraries, landscape: true }); + for (var i = 0; i < libraries.length; i++) { + if (latest[i] && latest[i].length > 0) + list.push({ title: "Ajouts récents · " + libraries[i].name, items: latest[i], landscape: false }); + } + rows = list; + loading = false; + if (list.length > 0) + rowsList.forceActiveFocus(); + } + + Component.onCompleted: load() + Component.onDestruction: if (page.session) page.session.cancel() + + // Retour : choix de l'utilisateur (sinon, à la racine de la pile, l'app se fermerait). Keys.onPressed: { if (Remote.isBack(event.key)) { event.accepted = true; @@ -32,23 +80,65 @@ Page { } Row { + id: actions spacing: Theme.spacingM FocusButton { - id: backButton - text: "Retour" + id: switchUserButton + text: "Changer d'utilisateur" KeyNavigation.right: logoutButton + KeyNavigation.down: rowsList onClicked: page.goBack() } FocusButton { id: logoutButton text: "Se déconnecter" - KeyNavigation.left: backButton + KeyNavigation.left: switchUserButton + KeyNavigation.down: rowsList onClicked: { page.session.logout(); page.goBack(); } } } + + ListView { + id: rowsList + anchors { + top: actions.bottom + topMargin: Theme.spacingL + left: parent.left + right: parent.right + bottom: parent.bottom + } + clip: true + spacing: Theme.spacingS + model: page.rows + + delegate: MediaRow { + width: rowsList.width + title: modelData.title + items: modelData.items + landscape: modelData.landscape + session: page.session + onActivated: page.navigator.openItem(item) + } + + // La rangée courante reste en haut de la zone visible. + onCurrentIndexChanged: positionViewAtIndex(currentIndex, ListView.Beginning) + + KeyNavigation.priority: KeyNavigation.AfterItem + KeyNavigation.up: switchUserButton + } + + Text { + anchors.centerIn: rowsList + visible: text !== "" + text: page.loading ? "Chargement…" + : page.error !== "" ? page.error + : page.rows.length === 0 ? "Aucun média disponible pour ce compte." : "" + color: page.error !== "" ? Theme.error : Theme.textMuted + font.pixelSize: Theme.fontBody + } } diff --git a/Views/LibraryView.qml b/Views/LibraryView.qml new file mode 100644 index 0000000..f568488 --- /dev/null +++ b/Views/LibraryView.qml @@ -0,0 +1,91 @@ +import QtQuick 2.5 +import "../Components" +import "../Shared" +import "../Shared/Remote.js" as Remote +import "../Shared/Format.js" as Format + +// Contenu d'une bibliothèque en grille d'affiches, chargé par pages à mesure qu'on descend. +Page { + id: page + + property var library: null // { id, name, collectionType } + property int total: 0 + property bool loading: false + property string error: "" + + readonly property int pageSize: 60 + + fullscreen: true + title: library ? library.name : "" + subtitle: total > 0 ? total + " élément" + (total > 1 ? "s" : "") : "" + initialFocus: grid + + function loadMore() { + if (loading || (total > 0 && itemsModel.count >= total)) + return; + loading = true; + page.session.loadLibraryItems(library, itemsModel.count, pageSize, function (err, items, count) { + page.loading = false; + if (err) { + page.error = err; + return; + } + page.total = count; + for (var i = 0; i < items.length; i++) + itemsModel.append(items[i]); + }); + } + + Component.onCompleted: loadMore() + Component.onDestruction: if (page.session) page.session.cancel() + + ListModel { + id: itemsModel + } + + GridView { + id: grid + anchors.fill: parent + clip: true + focus: true + // Marges pour la carte agrandie (scale). + leftMargin: 8 + topMargin: 8 + cellWidth: Theme.posterWidth + Theme.spacingL + cellHeight: Theme.posterHeight + Theme.cardTextHeight + Theme.spacingL + model: itemsModel + + delegate: MediaCard { + width: Theme.posterWidth + title: model.name + subtitle: Format.cardSubtitle(model) + imageSource: page.session ? page.session.posterUrl(model) : "" + progress: Format.progress(model) + played: model.played + highlighted: GridView.isCurrentItem && grid.activeFocus + onClicked: { + grid.currentIndex = index; + page.navigator.openItem(itemsModel.get(index)); + } + } + + // Page suivante quand on approche de la fin. + onCurrentIndexChanged: if (currentIndex >= count - 14) page.loadMore() + + Keys.onPressed: { + if (Remote.isAccept(event.key) && currentIndex >= 0) { + event.accepted = true; + page.navigator.openItem(itemsModel.get(currentIndex)); + } + } + } + + Text { + anchors.centerIn: parent + visible: text !== "" + text: page.error !== "" ? page.error + : itemsModel.count === 0 ? (page.loading ? "Chargement…" : "Cette bibliothèque est vide.") : "" + color: page.error !== "" ? Theme.error : Theme.textMuted + font.pixelSize: Theme.fontBody + } +} diff --git a/Views/PlayerView.qml b/Views/PlayerView.qml new file mode 100644 index 0000000..d98159c --- /dev/null +++ b/Views/PlayerView.qml @@ -0,0 +1,244 @@ +import QtQuick 2.5 +import "../Components" +import "../Shared" +import "../Shared/Remote.js" as Remote +import "../Shared/Format.js" as Format + +// Lecteur plein écran. +// Télécommande : OK = lecture/pause, Gauche/Droite = -10 s/+30 s, Haut/Bas = afficher les +// informations, Retour = quitter (géré par le Navigator). +// La progression est signalée au serveur (reprise, « vu ») au démarrage, toutes les 10 s et à l'arrêt. +FocusScope { + id: player + + // Injectés par le Navigator + property var navigator: null + property var session: null + property Item initialFocus: null + property bool fullscreen: true + + // Paramètres de push("Player", …) + property string itemId: "" + property string title: "" + property real startMs: 0 + + property var info: null // résultat de Session.preparePlayback() + property bool started: false // lecture effectivement démarrée et signalée + property bool resumed: false + // Reprise atteinte (ou lecture depuis le début) : avant ça, on ne signale rien, pour + // ne pas écraser le point de reprise si le déplacement initial échoue. + property bool resumeReached: startMs <= 0 + property bool finished: false + property string error: "" + + function showOsd() { + osd.shown = true; + osdTimer.restart(); + } + + function seekBy(deltaMs) { + if (video.duration <= 0) + return; + video.seek(video.position + deltaMs); + showOsd(); + } + + // Rien n'est signalé tant que la lecture n'a pas réellement démarré : un arrêt + // signalé à la position 0 effacerait le point de reprise sur le serveur. + function report(event) { + if (!player.info || !player.started) + return; + if (event !== "start" && video.position <= 0) + return; + player.session.reportPlayback(event, player.info, video.position, video.playerState === "paused"); + } + + // Signale le démarrage une fois la lecture lancée ET la position de reprise atteinte. + function maybeReportStart() { + if (player.started || !player.info || video.playerState !== "playing" || !player.resumeReached) + return; + player.started = true; + player.report("start"); + } + + function finish() { + if (finished) + return; + finished = true; + report("stop"); + player.navigator.pop(); + } + + Component.onCompleted: { + showOsd(); + player.session.preparePlayback(itemId, function (err, playback) { + if (err) { + player.error = err; + return; + } + player.info = playback; + video.source = playback.url; + }); + } + + // Retour (le Navigator dépile) ou fin : on signale l'arrêt au serveur. + Component.onDestruction: { + if (!finished) { + finished = true; + report("stop"); + } + } + + Keys.onPressed: { + var key = event.key; + if (Remote.isAccept(key) || key === Qt.Key_Space || key === Qt.Key_MediaTogglePlayPause + || key === Qt.Key_MediaPlay || key === Qt.Key_MediaPause) { + video.togglePause(); + showOsd(); + } else if (key === Qt.Key_Left || key === Qt.Key_AudioRewind) { + seekBy(-10000); + } else if (key === Qt.Key_Right || key === Qt.Key_AudioForward) { + seekBy(30000); + } else if (key === Qt.Key_Up || key === Qt.Key_Down) { + showOsd(); + } else { + return; + } + event.accepted = true; + } + + Rectangle { + anchors.fill: parent + color: "black" + } + + VideoSurface { + id: video + anchors.fill: parent + + onPlayerStateChanged: { + player.maybeReportStart(); + if (playerState === "paused") + player.showOsd(); + } + // Reprise : déplacement une fois la durée connue. + onDurationChanged: { + if (!player.resumed && player.startMs > 0 && duration > 0) { + player.resumed = true; + seek(player.startMs); + } + } + onPositionChanged: { + if (!player.resumeReached && position >= player.startMs - 15000) { + player.resumeReached = true; + player.maybeReportStart(); + } + } + onEnded: player.finish() + } + + Timer { + interval: 10000 + repeat: true + running: player.started && !player.finished + onTriggered: player.report("progress") + } + + // Messages au centre : chargement / erreur. + Text { + anchors.centerIn: parent + width: parent.width * 0.7 + horizontalAlignment: Text.AlignHCenter + wrapMode: Text.WordWrap + visible: text !== "" + text: player.error !== "" ? player.error + "\nAppuyez sur Retour pour quitter." + : video.playerState === "error" ? video.errorString + "\nAppuyez sur Retour pour quitter." + : video.playerState === "loading" || video.playerState === "idle" ? "Chargement…" : "" + color: player.error !== "" || video.playerState === "error" ? Theme.error : Theme.text + font.pixelSize: Theme.fontBody + style: Text.Outline + styleColor: "black" + } + + // Informations de lecture (masquées après 4 s, sauf en pause). + Item { + id: osd + + property bool shown: true + + anchors.fill: parent + opacity: shown || video.playerState === "paused" ? 1 : 0 + + Behavior on opacity { NumberAnimation { duration: 200 } } + + Rectangle { + anchors { left: parent.left; right: parent.right; bottom: parent.bottom } + height: 170 + gradient: Gradient { + GradientStop { position: 0; color: "transparent" } + GradientStop { position: 1; color: "#E0000000" } + } + } + + Column { + anchors { + left: parent.left + right: parent.right + bottom: parent.bottom + margins: Theme.pageMargin + } + spacing: Theme.spacingS + + Text { + width: parent.width + text: player.title + elide: Text.ElideRight + color: Theme.text + font.pixelSize: Theme.fontTitle - 6 + font.bold: true + } + + Rectangle { + width: parent.width + height: 6 + radius: 3 + color: "#55FFFFFF" + + Rectangle { + width: video.duration > 0 ? parent.width * Math.min(1, video.position / video.duration) : 0 + height: parent.height + radius: 3 + color: Theme.accent + } + } + + Item { + width: parent.width + height: stateText.implicitHeight + + Text { + id: stateText + text: video.playerState === "paused" ? "Pause" + : video.playerState === "playing" ? "Lecture" + : video.playerState === "loading" ? "Chargement…" : "" + color: Theme.text + font.pixelSize: Theme.fontSmall + font.bold: true + } + + Text { + anchors.right: parent.right + text: Format.clock(video.position) + " / " + Format.clock(video.duration) + color: Theme.text + font.pixelSize: Theme.fontSmall + } + } + } + } + + Timer { + id: osdTimer + interval: 4000 + onTriggered: osd.shown = false + } +} diff --git a/Views/SeasonView.qml b/Views/SeasonView.qml new file mode 100644 index 0000000..cd8be02 --- /dev/null +++ b/Views/SeasonView.qml @@ -0,0 +1,134 @@ +import QtQuick 2.5 +import "../Components" +import "../Shared" +import "../Shared/Remote.js" as Remote +import "../Shared/Format.js" as Format + +// Épisodes d'une saison ; OK ouvre la fiche de l'épisode. +Page { + id: page + + property string seriesId: "" + property string seasonId: "" + property string seasonName: "" + property string seriesName: "" + property var episodes: [] + property bool loading: true + property string error: "" + + fullscreen: true + title: seriesName + subtitle: seasonName + initialFocus: list + + Component.onCompleted: { + page.session.loadEpisodes(seriesId, seasonId, function (err, items) { + page.loading = false; + if (err) { + page.error = err; + return; + } + page.episodes = items; + list.forceActiveFocus(); + }); + } + + Component.onDestruction: if (page.session) page.session.cancel() + + ListView { + id: list + anchors.fill: parent + clip: true + focus: true + spacing: Theme.spacingS + model: page.episodes + + delegate: Rectangle { + id: row + + readonly property bool highlighted: ListView.isCurrentItem && list.activeFocus + + width: list.width + height: 150 + radius: Theme.radius + color: highlighted ? Theme.focusBackground : "transparent" + + MediaCard { + id: thumb + anchors { left: parent.left; leftMargin: Theme.spacingS; verticalCenter: parent.verticalCenter } + width: 240 + height: 135 + imageHeight: 135 + showText: false + imageSource: page.session ? page.session.thumbUrl(modelData) : "" + progress: Format.progress(modelData) + played: modelData.played + title: modelData.name + } + + Column { + anchors { + left: thumb.right + leftMargin: Theme.spacingL + right: parent.right + rightMargin: Theme.spacingM + verticalCenter: parent.verticalCenter + } + spacing: 4 + + Text { + width: parent.width + text: modelData.name + elide: Text.ElideRight + color: row.highlighted ? Theme.textOnFocus : Theme.text + font.pixelSize: Theme.fontBody + font.bold: true + } + + Text { + width: parent.width + visible: text !== "" + text: "Épisode " + modelData.indexNumber + + (modelData.runtimeTicks ? " · " + Format.runtime(modelData.runtimeTicks) : "") + color: row.highlighted ? Theme.textOnFocusMuted : Theme.textMuted + font.pixelSize: Theme.fontSmall + } + + Text { + width: parent.width + text: modelData.overview + wrapMode: Text.WordWrap + maximumLineCount: 3 + elide: Text.ElideRight + color: row.highlighted ? Theme.textOnFocusMuted : Theme.textMuted + font.pixelSize: Theme.fontSmall + } + } + + MouseArea { + anchors.fill: parent + onClicked: { + list.currentIndex = index; + page.navigator.openItem(modelData); + } + } + } + + Keys.onPressed: { + if (Remote.isAccept(event.key) && currentIndex >= 0) { + event.accepted = true; + page.navigator.openItem(page.episodes[currentIndex]); + } + } + } + + Text { + anchors.centerIn: parent + visible: text !== "" + text: page.loading ? "Chargement…" + : page.error !== "" ? page.error + : page.episodes.length === 0 ? "Aucun épisode." : "" + color: page.error !== "" ? Theme.error : Theme.textMuted + font.pixelSize: Theme.fontBody + } +}