634 lines
25 KiB
QML
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.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 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()
|
|
}
|