Files
Jellyfin-Freebox/app/Core/Session.qml
T
stilobiqueandClaude Opus 5.5 d0d019ac1e
CI / Release Gitea (push) Successful in 13s
CI / Vérifications et paquet (push) Successful in 1m56s
Release 0.1.1
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 23:48:39 +01:00

634 lines
25 KiB
QML

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.
// Les fonctions asynchrones appellent `callback(erreur, résultat)` ; `erreur` est un
// message prêt à afficher. cancel() ignore les réponses encore en attente.
QtObject {
id: session
readonly property string clientName: "Jellyfin Freebox"
// Doit rester égale à « version » dans manifest.json (vérifié par freebox-jellyfin package).
readonly property string clientVersion: "0.1.1"
readonly property string deviceName: "Freebox Player"
// Serveurs enregistrés : { name, address, id }
property ListModel servers: ListModel {}
property var currentServer: null // { name, address, id }
property var currentUser: null // { name, id }
property string accessToken: ""
// Comptes de test fournis par freebox-jellyfin deploy --user : { name, password? }
property var devUsers: []
// ---------------------------------------------------------------- Serveurs
function selectServer(index) {
var server = servers.get(index);
currentServer = { name: server.name, address: server.address, id: server.id };
}
function removeServer(index) {
servers.remove(index);
_saveServers();
}
// Ajoute (ou met à jour) un serveur à partir de l'hôte saisi et d'un port facultatif.
// Le clavier de la box n'a ni « : » ni « / » : le protocole et le port sont
// détectés en essayant chaque adresse de serverCandidates() dans l'ordre.
function connectToServer(host, port, callback) {
callback = _guard(callback);
_addServer(host, port, function (err) {
if (err) {
callback(err);
return;
}
selectServer(0);
callback(null, currentServer);
});
}
// Ajoute le serveur en tête de liste (sans le sélectionner) ; non lié à cancel().
function _addServer(host, port, callback) {
if ((host || "").trim() === "") {
callback("Veuillez saisir l'adresse du serveur.");
return;
}
var portText = (port || "").trim();
if (portText !== "" && !isValidPort(portText)) {
callback("Le port doit être un nombre entre 1 et 65535.");
return;
}
_probeCandidates(serverCandidates(host, portText), function (err, server) {
if (err) {
callback(err);
return;
}
var index = _indexOfServer(server.id);
if (index >= 0)
servers.remove(index);
servers.insert(0, server);
_saveServers();
callback(null, server);
});
}
// Test sur la box : freebox-jellyfin deploy --server <adresse> --user <nom[:mdp]> sert
// dev-config.json à côté de l'app ; chaque serveur listé est ajouté et les comptes
// sont proposés sur « Qui regarde ? ». Absent (404) hors test : rien ne se passe.
function loadDevConfig(url) {
if (!/^https?:/i.test(url))
return; // app chargée depuis le disque (aperçu PC) : pas de dev-config
_request("GET", "", null, function (err, config) {
if (err || !config)
return;
if (config.users && config.users.length > 0) {
devUsers = config.users;
console.log("dev-config : " + config.users.length + " utilisateur(s) de test");
}
var hosts = config.servers || [];
for (var i = 0; i < hosts.length; i++) {
(function (host) {
_addServer(host, "", function (err2, server) {
console.log(err2 ? "dev-config : " + host + " → " + err2
: "dev-config : serveur ajouté " + server.address);
});
})(String(hosts[i]));
}
}, { baseUrl: url, timeout: 3000 });
}
// Adresses à essayer, de la plus probable à la moins probable
// (même logique que les clients Jellyfin officiels).
function serverCandidates(host, port) {
var text = (host || "").trim().replace(/\/+$/, "");
if (text === "")
return [];
// Adresse complète (saisie depuis un clavier qui a « : ») : utilisée telle quelle.
if (/^https?:\/\//i.test(text)) {
if (port && !/:\d+$/.test(text.replace(/^https?:\/\//i, "")))
text += ":" + port;
return [text];
}
if (port)
return ["https://" + text + ":" + port, "http://" + text + ":" + port];
// Port déjà inclus dans l'hôte (ex. 192.168.1.20:8096).
if (/:\d+$/.test(text))
return ["https://" + text, "http://" + text];
return [
"https://" + text,
"http://" + text + ":8096",
"https://" + text + ":8920",
"http://" + text
];
}
function isValidPort(text) {
if (!/^\d+$/.test(text))
return false;
var value = parseInt(text, 10);
return value >= 1 && value <= 65535;
}
// ------------------------------------------------------------ Utilisateurs
// Comptes affichés sur l'écran de connexion du serveur (peut être vide).
function loadPublicUsers(callback) {
callback = _guard(callback);
_request("GET", "/Users/Public", null, function (err, data) {
if (err) {
callback(_describe(err));
return;
}
var users = [];
for (var i = 0; i < (data || []).length; i++)
users.push({ name: data[i].Name, id: data[i].Id, hasPassword: data[i].HasPassword });
callback(null, users);
});
}
function authenticate(username, password, callback) {
callback = _guard(callback);
var name = (username || "").trim();
if (name === "") {
callback("Veuillez saisir votre nom d'utilisateur.");
return;
}
_request("POST", "/Users/AuthenticateByName", { Username: name, Pw: password || "" }, function (err, data) {
if (err) {
callback(err.status === 401 ? "Nom d'utilisateur ou mot de passe incorrect." : _describe(err));
return;
}
callback(null, _signedIn(data));
});
}
function logout() {
if (accessToken !== "")
_request("POST", "/Sessions/Logout", null, function () {});
accessToken = "";
currentUser = null;
}
// ----------------------------------------------------------- Quick Connect
function isQuickConnectEnabled(callback) {
callback = _guard(callback);
_request("GET", "/QuickConnect/Enabled", null, function (err, data) {
callback(null, !err && data === true);
});
}
// onCode(erreur, code) : code à afficher ; onSignedIn(erreur, utilisateur) : autorisation reçue.
function startQuickConnect(onCode, onSignedIn) {
stopQuickConnect();
onCode = _guard(onCode);
_quickConnect.onSignedIn = _guard(onSignedIn);
_request("POST", "/QuickConnect/Initiate", null, function (err, data) {
if (err || !data || !data.Secret) {
onCode(err && err.status === 401
? "Quick Connect est désactivé sur ce serveur."
: _describe(err || { kind: "invalid" }));
return;
}
_quickConnect.secret = data.Secret;
_quickConnectPoll.start();
onCode(null, data.Code);
});
}
function stopQuickConnect() {
_quickConnectPoll.stop();
_quickConnect.secret = "";
}
property var _quickConnect: ({ secret: "", onSignedIn: null })
property Timer _quickConnectPoll: Timer {
interval: 5000
repeat: true
onTriggered: session._pollQuickConnect()
}
function _pollQuickConnect() {
var secret = _quickConnect.secret;
if (secret === "")
return;
_request("GET", "/QuickConnect/Connect?Secret=" + encodeURIComponent(secret), null, function (err, data) {
if (secret !== _quickConnect.secret || err || !data || !data.Authenticated)
return;
stopQuickConnect();
_request("POST", "/Users/AuthenticateWithQuickConnect", { Secret: secret }, function (err2, auth) {
var done = _quickConnect.onSignedIn;
if (!done)
return;
if (err2)
done(_describe(err2));
else
done(null, _signedIn(auth));
});
});
}
// --------------------------------------------------------------- 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).
function cancel() {
_generation++;
stopQuickConnect();
}
property int _generation: 0
function _guard(callback) {
var generation = _generation;
return function () {
if (generation === session._generation && callback)
callback.apply(null, arguments);
};
}
function _signedIn(data) {
accessToken = data.AccessToken;
currentUser = { name: data.User.Name, id: data.User.Id };
return currentUser;
}
// 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;
}
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) {
if (!err)
return "";
if (err.kind === "timeout")
return "Le serveur ne répond pas.";
if (err.kind === "network")
return "Impossible de contacter le serveur.";
if (err.kind === "invalid")
return "Réponse inattendue du serveur.";
return "Erreur du serveur (" + err.status + ").";
}
function _authorization() {
var value = 'MediaBrowser Client="' + clientName + '", Device="' + deviceName
+ '", DeviceId="' + _settings.deviceId + '", Version="' + clientVersion + '"';
if (accessToken !== "")
value += ', Token="' + accessToken + '"';
return value;
}
// Requête JSON. callback(erreur, données) avec erreur = { kind, status } :
// kind vaut "timeout", "network" (pas de réponse), "http" (statut != 2xx) ou "invalid".
function _request(method, path, body, callback, options) {
options = options || {};
var url = (options.baseUrl || (currentServer ? currentServer.address : "")) + path;
var xhr = new XMLHttpRequest();
var finished = false;
var timer = _timerComponent.createObject(session, { interval: options.timeout || 15000 });
function finish(err, data) {
if (finished)
return;
finished = true;
timer.stop();
timer.destroy();
callback(err, data);
}
timer.triggered.connect(function () {
finish({ kind: "timeout", status: 0 });
xhr.abort();
});
xhr.onreadystatechange = function () {
if (xhr.readyState !== XMLHttpRequest.DONE || finished)
return;
if (xhr.status === 0) {
finish({ kind: "network", status: 0 });
} else if (xhr.status < 200 || xhr.status >= 300) {
finish({ kind: "http", status: xhr.status });
} else if (xhr.responseText === "") {
finish(null, null);
} else {
try {
finish(null, JSON.parse(xhr.responseText));
} catch (e) {
finish({ kind: "invalid", status: xhr.status });
}
}
};
xhr.open(method, url);
xhr.setRequestHeader("Authorization", _authorization());
timer.start();
if (body) {
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(JSON.stringify(body));
} else {
xhr.send();
}
}
property Component _timerComponent: Component {
Timer {}
}
function _hostOf(address) {
return address.replace(/^https?:\/\//i, "").split(/[:\/]/)[0];
}
function _indexOfServer(id) {
for (var i = 0; i < servers.count; i++) {
if (servers.get(i).id === id)
return i;
}
return -1;
}
// ------------------------------------------------------------ Persistance
// Stockage de la box (fbx.application Settings) ; sans effet sur PC.
property Settings _settings: Settings {
property string serverList: ""
property string deviceId: ""
onReady: session._restore()
}
function _restore() {
if (_settings.deviceId === "")
_settings.deviceId = _randomId();
if (servers.count > 0)
return;
var list = [];
try {
// Encodé (voir _saveServers) ; ancien format JSON brut accepté.
var raw = _settings.serverList;
list = JSON.parse(raw.charAt(0) === "%" ? decodeURIComponent(raw) : (raw || "[]"));
} catch (e) {
}
for (var i = 0; i < list.length; i++)
servers.append({ name: list[i].name, address: list[i].address, id: list[i].id });
}
function _saveServers() {
var list = [];
for (var i = 0; i < servers.count; i++) {
var s = servers.get(i);
list.push({ name: s.name, address: s.address, id: s.id });
}
// Encodé (%XX) pour n'enregistrer que des caractères simples.
_settings.serverList = encodeURIComponent(JSON.stringify(list));
}
function _randomId() {
var id = "";
for (var i = 0; i < 32; i++)
id += Math.floor(Math.random() * 16).toString(16);
return id;
}
Component.onCompleted: _restore()
}