404 lines
14 KiB
QML
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()
|
|
}
|