Add more behavior with the local test env.
This commit is contained in:
1 parent
acb58142d9
commit
df847becc8
10 files changed
+450
-114
No files matched your search
+309
-69
@@ -1,29 +1,55 @@
|
||||
import QtQuick 2.5
|
||||
import fbx.application 1.0
|
||||
|
||||
// État de connexion : serveurs connus, serveur et utilisateur courants.
|
||||
// Les appels réseau sont SIMULÉS (_simulate) : à remplacer par l'API Jellyfin
|
||||
// en gardant la forme des callbacks `callback(erreur, résultat)`.
|
||||
// É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
|
||||
|
||||
property ListModel servers: ListModel {
|
||||
// Données fictives
|
||||
ListElement { name: "Maison"; address: "http://192.168.1.20:8096"; discovered: false }
|
||||
ListElement { name: "jellyfin-nas"; address: "http://192.168.1.42:8096"; discovered: true }
|
||||
}
|
||||
readonly property string clientName: "Jellyfin Freebox"
|
||||
readonly property string clientVersion: "0.1.0"
|
||||
readonly property string deviceName: "Freebox Player"
|
||||
|
||||
property var currentServer: null // { name, address }
|
||||
property var currentUser: null // { name }
|
||||
// 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 };
|
||||
currentServer = { name: server.name, address: server.address, id: server.id };
|
||||
}
|
||||
|
||||
// Ajoute (ou retrouve) un serveur à partir de l'hôte saisi et d'un port facultatif.
|
||||
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;
|
||||
@@ -33,21 +59,45 @@ QtObject {
|
||||
callback("Le port doit être un nombre entre 1 et 65535.");
|
||||
return;
|
||||
}
|
||||
_probeCandidates(serverCandidates(host, portText), 0, function (err, address) {
|
||||
_probeCandidates(serverCandidates(host, portText), 0, function (err, server) {
|
||||
if (err) {
|
||||
callback(err);
|
||||
return;
|
||||
}
|
||||
var index = _indexOfServer(address);
|
||||
if (index < 0) {
|
||||
servers.insert(0, { name: _hostOf(address), address: address, discovered: false });
|
||||
index = 0;
|
||||
}
|
||||
selectServer(index);
|
||||
callback(null, currentServer);
|
||||
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) {
|
||||
@@ -73,19 +123,6 @@ QtObject {
|
||||
];
|
||||
}
|
||||
|
||||
// Essaie les adresses une par une ; renvoie la première qui répond.
|
||||
// TODO API : GET <adresse>/System/Info/Public, accepter si la réponse contient un Id,
|
||||
// et utiliser ServerName comme nom. Simulation : la première adresse « répond ».
|
||||
function _probeCandidates(candidates, index, callback) {
|
||||
if (index >= candidates.length) {
|
||||
callback("Aucun serveur Jellyfin trouvé à cette adresse.");
|
||||
return;
|
||||
}
|
||||
_simulate(function () {
|
||||
callback(null, candidates[index]);
|
||||
});
|
||||
}
|
||||
|
||||
function isValidPort(text) {
|
||||
if (!/^\d+$/.test(text))
|
||||
return false;
|
||||
@@ -93,71 +130,274 @@ QtObject {
|
||||
return value >= 1 && value <= 65535;
|
||||
}
|
||||
|
||||
// TODO API : GET /Users/Public
|
||||
function publicUsers() {
|
||||
return [
|
||||
{ name: "Alice", hasPassword: true },
|
||||
{ name: "Bob", hasPassword: false },
|
||||
{ name: "Enfants", hasPassword: false }
|
||||
];
|
||||
// ------------------------------------------------------------ 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);
|
||||
});
|
||||
}
|
||||
|
||||
// TODO API : POST /Users/AuthenticateByName
|
||||
function authenticate(username, password, callback) {
|
||||
callback = _guard(callback);
|
||||
var name = (username || "").trim();
|
||||
if (name === "") {
|
||||
callback("Veuillez saisir votre nom d'utilisateur.");
|
||||
return;
|
||||
}
|
||||
_simulate(function () {
|
||||
currentUser = { name: name };
|
||||
callback(null, currentUser);
|
||||
_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));
|
||||
});
|
||||
}
|
||||
|
||||
// TODO API : POST /QuickConnect/Initiate puis interroger /QuickConnect/Connect
|
||||
function startQuickConnect() {
|
||||
var code = "";
|
||||
for (var i = 0; i < 6; i++)
|
||||
code += Math.floor(Math.random() * 10);
|
||||
return code;
|
||||
}
|
||||
|
||||
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() {
|
||||
_pending = null;
|
||||
_latency.stop();
|
||||
_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(address) {
|
||||
function _indexOfServer(id) {
|
||||
for (var i = 0; i < servers.count; i++) {
|
||||
if (servers.get(i).address === address)
|
||||
if (servers.get(i).id === id)
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Simulation de latence réseau.
|
||||
property var _pending: null
|
||||
property Timer _latency: Timer {
|
||||
interval: 700
|
||||
onTriggered: {
|
||||
var callback = session._pending;
|
||||
session._pending = null;
|
||||
if (callback)
|
||||
callback();
|
||||
}
|
||||
// ------------------------------------------------------------ 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 _simulate(callback) {
|
||||
_pending = callback;
|
||||
_latency.restart();
|
||||
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()
|
||||
}
|
||||
Reference in new issue
Block a user