Files
Jellyfin-Freebox/Core/Session.qml
T

404 lines
14 KiB
QML

import QtQuick 2.5
import fbx.application 1.0
// É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"
readonly property string clientVersion: "0.1.0"
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 tools/deploy.py --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), 0, 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 : tools/deploy.py --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));
});
});
}
// ------------------------------------------------------------------ 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 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) {
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 });
}
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()
}