+
+
+
diff --git a/src/index.js b/src/index.js
new file mode 100644
index 0000000..07a304e
--- /dev/null
+++ b/src/index.js
@@ -0,0 +1,77 @@
+const {app, BrowserWindow, ipcMain, Menu, globalShortcut} = require('electron');
+const path = require('path');
+const fs = require("fs");
+
+// Handle creating/removing shortcuts on Windows when installing/uninstalling.
+// eslint-disable-next-line global-require
+if (require('electron-squirrel-startup')) {
+ app.quit();
+}
+
+// store the main window to use a file dialog that blocks access to the app if open.
+let mainWindow;
+
+const createWindow = () => {
+ // Create the browser window.
+ mainWindow = new BrowserWindow({
+ width: 1200,
+ height: 900,
+ webPreferences: {
+ // not a security problem, as no external content is loaded. see official documentation
+ // https://github.com/electron/electron/blob/main/docs/tutorial/security.md#2-do-not-enable-nodejs-integration-for-remote-content
+ nodeIntegration: true,
+ contextIsolation: false
+ },
+ });
+
+ // and load the index.html of the app.
+ mainWindow.loadFile(path.join(__dirname, 'index.html'));
+
+ // Open the DevTools.
+ // mainWindow.webContents.openDevTools();
+ Menu.setApplicationMenu(null)
+};
+
+// This method will be called when Electron has finished
+// initialization and is ready to create browser windows.
+// Some APIs can only be used after this event occurs.
+// Add shortcut for devtools
+app.whenReady().then(() => {
+ globalShortcut.register('Shift+CommandOrControl+I', () => {
+ mainWindow.webContents.toggleDevTools();
+ })
+}).then(createWindow)
+
+// Quit when all windows are closed, except on macOS. There, it's common
+// for applications and their menu bar to stay active until the user quits
+// explicitly with Cmd + Q.
+app.on('window-all-closed', () => {
+ if (process.platform !== 'darwin') {
+ app.quit();
+ }
+});
+
+app.on('activate', () => {
+ // On OS X it's common to re-create a window in the app when the
+ // dock icon is clicked and there are no other windows open.
+ if (BrowserWindow.getAllWindows().length === 0) {
+ createWindow();
+ }
+});
+
+
+// open a file/folder selection dialog on the main process
+// https://www.tutorialspoint.com/electron/electron_system_dialogs.htm
+ipcMain.on('openDialog', (event, data) => {
+ const {dialog} = require('electron')
+ const type = data.type === 'file' ? 'openFile' : 'openDirectory'
+ const multiselect = data.multiselect ? "multiSelections" : ""
+
+ dialog.showOpenDialog(mainWindow, {properties: [type, 'createDirectory', multiselect], filters: data.filters})
+ .then((result) => {
+ result.subFolder = data.subFolder
+ if (!result.canceled && result.filePaths) {
+ event.sender.send(data.callback, result)
+ }
+ })
+});
\ No newline at end of file
diff --git a/src/index.scss b/src/index.scss
new file mode 100644
index 0000000..d31adc9
--- /dev/null
+++ b/src/index.scss
@@ -0,0 +1,8 @@
+@import "../node_modules/bootstrap/scss/bootstrap.scss";
+
+body {
+ font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica,
+ Arial, sans-serif;
+ margin: auto;
+ padding: 2.5rem;
+}
diff --git a/src/models/AdbDevice.js b/src/models/AdbDevice.js
new file mode 100644
index 0000000..0c17f4e
--- /dev/null
+++ b/src/models/AdbDevice.js
@@ -0,0 +1,244 @@
+const Device = require("./Device")
+
+const fs = require("fs-extra");
+const toast = require("../helper/toasts");
+const files = require("../helper/files");
+const path = require("path");
+const {Adb} = require("@devicefarmer/adbkit");
+const Bluebird = require('bluebird')
+
+let client = Adb.createClient()
+
+class AdbDevice extends Device {
+
+ constructor(brand, model, id) {
+ super()
+ this.brand = brand
+ this.model = model
+ this.id = id
+ this.name = `${brand} ${model} - ${id}`
+ this.deviceClient = client.getDevice(id)
+ }
+
+ /**
+ * Download all logs found inside the sub-folder /ExperimentLogs. The files are downloaded recursively.
+ * @param destinationFolder where the files should be saved to
+ * @returns {Promise} true: download complete, false otherwise
+ */
+ async downloadLogs(destinationFolder) {
+ try {
+ // get all files to download
+ const fileList = await this.getFilesRecursively('', AdbDevice.PATH + '/ExperimentLogs')
+
+ // download one file after the other
+ for (const file of fileList) {
+ const transfer = await this.deviceClient.pull(AdbDevice.PATH + '/ExperimentLogs' + file)
+ await new Bluebird(function (resolve, reject) {
+ const filename = destinationFolder + file
+
+ // make sure the target folder exists
+ if (!fs.existsSync(path.dirname(filename))) {
+ fs.mkdirSync(path.dirname(filename), {recursive: true})
+ }
+ transfer.on('end', () => {
+ console.log(`download complete: ${file}`)
+ resolve();
+ })
+ transfer.on('error', () => {
+ console.error(`download error on file: ${file}`)
+ reject();
+ })
+ transfer.pipe(fs.createWriteStream(filename))
+ })
+ }
+ } catch (e) {
+ console.error(e.message)
+ return false
+ }
+ return true
+ }
+
+ /**
+ * Upload a list of files. Each entry in the array must contain full source and target name of the file.
+ *
+ * @param fileList array of objects having the attributes "source" and "target"
+ * @returns {Promise} true: all uploads complete, false otherwise
+ */
+ async upload(fileList) {
+ try {
+ for (const file of fileList) {
+ // start the upload of one file
+ const transfer = await this.deviceClient.push(file.source, file.target)
+ // wait for a result to arrive. will throw an exception if something goes wrong
+ await new Bluebird(function (resolve, reject) {
+ transfer.on('end', () => {
+ console.log(`upload completed: ${file.source}`)
+ resolve()
+ })
+ transfer.on('error', () => {
+ console.error(`upload error on file: ${file.source}`)
+ reject()
+ })
+ })
+ }
+ } catch (e) {
+ console.error(e.message)
+ return false
+ }
+ return true
+ }
+
+ /**
+ * Upload a file and rename it "config.json". The file will be placed where the game is looking for the
+ * configuration.
+ * @param file configuration file to rename and upload
+ * @returns {Promise} true: upload complete, false otherwise
+ */
+ async uploadConfig(file) {
+ return await this.upload([{source: file, target: AdbDevice.PATH + '/config.json'}])
+ }
+
+ /**
+ * Prepares a list of files and uploads them after preparing. Preparing means: converting the list into list of
+ * objects with properties "source" and "target". The files will be uploaded into the given sub-folder.
+ * @param filePaths list of files to upload with full (absolute) file names
+ * @param subFolder sub-folder on the target device
+ * @returns {Promise} true: all files uploaded, false otherwise
+ */
+ async prepareAndUpload(filePaths, subFolder) {
+ let fileList = files.prepare(filePaths, AdbDevice.PATH + '/' + subFolder + '/')
+ return await this.upload(fileList)
+ }
+
+ /**
+ * Deletes a list of files with names that are relative to "rootFolder".
+ * @param fileList list of files to delete, with relative file names
+ * @param rootFolder root folder where all files to be deleted are contained
+ * @returns {Promise} true: all files deleted successfully, false otherwise
+ */
+ async remove(fileList, rootFolder) {
+ try {
+ for (const file of fileList) {
+ // delete a file
+ const command = await this.deviceClient.shell(`rm -rf "${rootFolder}${file}"`)
+ // wait for the result of this command
+ await new Bluebird(function (resolve, reject) {
+ command.on('end', () => {
+ console.log(`file deleted: ${rootFolder + file}`)
+ resolve()
+ })
+ command.on('error', () => {
+ console.error(`error deleting file: ${rootFolder + file}`)
+ reject()
+ })
+ })
+ }
+ } catch (e) {
+ console.error(e.message)
+ return false
+ }
+ return true
+ }
+
+ /**
+ * Get a list of all files inside "rootFolder" recursively. Can include folders if flag is set. The resulting list
+ * will contain file names relative to "rootFolder".
+ * @param subFolder leave empty. used on recursive calls.
+ * @param rootFolder root folder where to start looking for files
+ * @param includeFolders whether or not the resulting list should include folders
+ * @returns {Promise<*[]>} list of files
+ */
+ async getFilesRecursively(subFolder, rootFolder, includeFolders) {
+ let results = []
+
+ const fileList = await this.deviceClient.readdir(rootFolder)
+
+ // for each entry in the directory
+ for (const file of fileList) {
+ if (!file.isFile()) {
+ // for folders: read the content of this folder and add all files to the result list
+ results = results.concat(await this.getFilesRecursively(subFolder + "/" + file.name, rootFolder + "/" + file.name))
+ }
+ if (file.isFile() || includeFolders) {
+ // for files: add relative path of this file to the result list. add folders as well if the flag is set
+ results.push(subFolder + "/" + file)
+ }
+ }
+
+ return results
+ }
+
+ /**
+ * Get the absolute path of the game files and concatenate it if a given list of sub-folders (if present).
+ * @param subFolders string to concatenate to the path. should not have any "/" at start and end
+ * @returns {string} path of game files, concatenated with "subFolder"
+ */
+ getPath(subFolders) {
+ let result = AdbDevice.PATH
+
+ if (subFolders) {
+ for (const folder of subFolders) {
+ result += '/' + folder
+ }
+ }
+
+ return result
+ }
+
+ /**
+ * The name of this device.
+ * @returns {string} the name
+ */
+ toString() {
+ return this.name
+ }
+
+ /**
+ * Get a list of connected ADB devices. For this to work, a standalone ADB server must be running on the host
+ * device.
+ * @returns {Promise<*[]>} list of devices
+ */
+ static async getDevices() {
+ let devices = []
+
+ if (client) {
+ try {
+ let adbDevices = await client.listDevices()
+
+ // read all devices that answer to ADB
+ const deviceList = await Bluebird.map(adbDevices, async (device) => {
+ const properties = await client.getDevice(device.id).getProperties()
+ return new AdbDevice(properties['ro.product.manufacturer'], properties['ro.product.model'], device.id)
+ })
+
+ // store devices in variable for later use
+ devices = devices.concat(deviceList)
+ } catch (err) {
+ console.error(err.message)
+ toast.create("Erreur de detection d'appareil adb. Acceptez la connexion sur l'appareil.", 'text-bg-danger', 10)
+ }
+ }
+ return devices
+ }
+
+ // ---------
+ // constants
+ // ---------
+
+ /**
+ * The root folder where the game files are stored.
+ */
+ static get PATH() {
+ return '/sdcard/Android/data/com.HEIAFR.ImmersiveSeriousGameFactory/files'
+ }
+
+ /**
+ * The type of this device.
+ */
+ static get TYPE() {
+ return 'adb'
+ }
+
+}
+
+module.exports = AdbDevice;
\ No newline at end of file
diff --git a/src/models/Device.js b/src/models/Device.js
new file mode 100644
index 0000000..7f1a04a
--- /dev/null
+++ b/src/models/Device.js
@@ -0,0 +1,58 @@
+/**
+ * Abstract class used for devices that can be used as targets for uploading/downloading files.
+ */
+class Device {
+
+ constructor() {
+ if (this.constructor === Device) {
+ throw new Error("Abstract classes can't be instantiated.")
+ }
+ }
+
+ downloadLogs(destinationFolder) {
+ throw new Error("Method 'downloadLogs()' must be implemented.")
+ }
+
+ upload(fileList) {
+ throw new Error("Method 'upload()' must be implemented.")
+ }
+
+ uploadConfig(file) {
+ throw new Error("Method 'uploadConfig()' must be implemented.")
+ }
+
+ prepareAndUpload(filePaths, subFolder){
+ throw new Error("Method 'prepareAndUpload()' must be implemented.")
+ }
+
+ remove(fileList, rootFolder) {
+ throw new Error("Method 'remove()' must be implemented.")
+ }
+
+ getFilesRecursively(subFolder, rootFolder, includeFolders) {
+ throw new Error("Method 'getFilesRecursively()' must be implemented.")
+ }
+
+ getPath(){
+ throw new Error("Method 'getPath()' must be implemented.")
+ }
+
+ toString(){
+ throw new Error("Method 'toString()' must be implemented.")
+ }
+
+ static getDevices(){
+ throw new Error("Method 'getDevices()' must be implemented.")
+ }
+
+ static get PATH(){
+ throw new Error("Method 'PATH()' must be implemented.")
+ }
+
+ static get TYPE(){
+ throw new Error("Method 'TYPE()' must be implemented.")
+ }
+
+}
+
+module.exports = Device;
\ No newline at end of file
diff --git a/src/models/LocalDevice.js b/src/models/LocalDevice.js
new file mode 100644
index 0000000..41bd8bd
--- /dev/null
+++ b/src/models/LocalDevice.js
@@ -0,0 +1,168 @@
+const Device = require("./Device")
+
+const fs = require("fs-extra");
+const files = require("../helper/files");
+
+class LocalDevice extends Device {
+
+ constructor(name) {
+ super()
+ this.name = name
+ }
+
+ /**
+ * Download all logs found inside the sub-folder /ExperimentLogs. The files are downloaded recursively.
+ * @param destinationFolder where the files should be saved to
+ * @returns {Promise} true: download complete, false otherwise
+ */
+ async downloadLogs(destinationFolder) {
+ try {
+ await fs.copy(LocalDevice.PATH + '\\ExperimentLogs', destinationFolder)
+ return true
+ } catch (e) {
+ console.error(e.message)
+ return false
+ }
+ }
+
+ /**
+ * Copy files to the application folder on the local computer.
+ * @param fileList list of files to copy
+ * @returns {Promise}
+ */
+ async upload(fileList) {
+ for (const file of fileList) {
+ // copy one file at a time
+ let copy_ok = false;
+ try {
+ await fs.copy(file.source, file.target)
+ console.log(`upload complete: ${file.source}`)
+ } catch (e) {
+ console.error(e.message)
+ return false
+ }
+ }
+ return true
+ }
+
+ /**
+ * Copy a JSON file to the application folder of the local computer and rename it to 'config.json'.
+ * @param file file to copy
+ * @returns {Promise}
+ */
+ async uploadConfig(file) {
+ return await this.upload([{source: file, target: LocalDevice.PATH + '\\config.json'}])
+ }
+
+ /**
+ * Prepares a list of files and uploads them after preparing. Preparing means: converting the list into list of
+ * objects with properties "source" and "target". The files will be uploaded into the given sub-folder.
+ * @param filePaths list of files to upload with full (absolute) file names
+ * @param subFolder sub-folder on the target device
+ * @returns {Promise} true: all files uploaded, false otherwise
+ */
+ async prepareAndUpload(filePaths, subFolder) {
+ // include here, as there would be a circular file requirement otherwise
+ const files = require("../helper/files");
+
+ let fileList = files.prepare(filePaths, LocalDevice.PATH + '\\' + subFolder + '\\')
+ return await this.upload(fileList)
+ }
+
+ /**
+ * Deletes a list of files with names that are relative to "rootFolder".
+ * @param fileList list of files to delete, with relative file names
+ * @param rootFolder root folder where all files to be deleted are contained
+ * @returns {Promise} true: all files deleted successfully, false otherwise
+ */
+ async remove(fileList, rootFolder) {
+ try {
+ for (const file of fileList) {
+ await fs.remove(rootFolder + '\\' + file)
+ }
+ } catch (e) {
+ console.error(e.message)
+ return false
+ }
+ return true
+ }
+
+ /**
+ * Get a list of all files inside "rootFolder" recursively. Can include folders if flag is set. The resulting list
+ * will contain file names relative to "rootFolder".
+ * @param subFolder leave empty. used on recursive calls.
+ * @param rootFolder root folder where to start looking for files
+ * @param includeFolders whether or not the resulting list should include folders
+ * @returns {Promise<*[]>} list of files
+ */
+ async getFilesRecursively(subFolder, rootFolder, includeFolders) {
+ let results = []
+ const files = await fs.readdir(rootFolder, {withFileTypes: true})
+
+ // for each entry in the directory
+ for (const file of files) {
+ if (file.isFile()) {
+ // for files: add relative path of this file to the result list
+ results.push(subFolder + "\\" + file.name)
+ } else {
+ if (includeFolders) results.push(subFolder + "\\" + file.name)
+ // for folders: read the content of this folder and add all files to the result list
+ results = results.concat(await this.getFilesRecursively(subFolder + "\\" + file.name, rootFolder + "\\" + file.name, includeFolders))
+ }
+ }
+
+ return results
+ }
+
+ /**
+ * Get the path of the games concatenated with a list of sub-folders. Uses the correct separator for this type of
+ * device.
+ * @param subFolders
+ * @returns {string}
+ */
+ getPath(subFolders) {
+ let result = LocalDevice.PATH
+
+ if (subFolders) {
+ for (const folder of subFolders) {
+ result += '\\' + folder
+ }
+ }
+
+ return result
+ }
+
+ /**
+ * This device's name.
+ */
+ toString() {
+ return this.name
+ }
+
+ /**
+ * Returns a list of devices. For now, this is a static list including only this computer.
+ */
+ static async getDevices() {
+ return [new LocalDevice('Cet ordinateur')]
+ }
+
+ // ---------
+ // constants
+ // ---------
+
+ /**
+ * The root folder where the game files are stored.
+ */
+ static get PATH() {
+ return process.env.LOCALAPPDATA + 'Low\\HEIAFR\\ImmersiveSeriousGameFactory'
+ }
+
+ /**
+ * The type of this device.
+ */
+ static get TYPE() {
+ return 'local'
+ }
+}
+
+module.exports = LocalDevice;
\ No newline at end of file
diff --git a/src/preload.js b/src/preload.js
new file mode 100644
index 0000000..5e9d369
--- /dev/null
+++ b/src/preload.js
@@ -0,0 +1,2 @@
+// See the Electron documentation for details on how to use preload scripts:
+// https://www.electronjs.org/docs/latest/tutorial/process-model#preload-scripts
diff --git a/src/renderer.js b/src/renderer.js
new file mode 100644
index 0000000..0eed830
--- /dev/null
+++ b/src/renderer.js
@@ -0,0 +1,275 @@
+const $ = jQuery = require('jquery')
+const {ipcRenderer} = require('electron')
+const {Adb} = require("@devicefarmer/adbkit");
+
+const toast = require('./helper/toasts.js')
+const AdbDevice = require('./models/AdbDevice.js')
+const LocalDevice = require('./models/LocalDevice.js')
+
+// client only used to detect if an ADB server is available
+let client = Adb.createClient()
+
+// Buttons
+const btnLoadConfig = $('#btnLoadConfig')
+const btnImportLogs = $('#btnImportLogs')
+const btnDeleteLogs = $('#btnDeleteLogs')
+
+const btnLoadAssetBundles = $('#btnLoadAssetBundles')
+const btnDeleteAssetBundles = $('#btnDeleteAssetBundles')
+const btnLoadVisuals = $('#btnLoadVisuals')
+const btnDeleteVisuals = $('#btnDeleteVisuals')
+const btnLoadSounds = $('#btnLoadSounds')
+const btnDeleteSounds = $('#btnDeleteSounds')
+
+const btnSearchDevices = $('#btnSearchDevices')
+
+// modal elements
+const modal = new bootstrap.Modal('#deleteModal')
+const modalTitle = $('#deleteModalTitle')
+const modalBody = $('#deleteModalBody')
+const modalBtn = $('#deleteModalBtn')
+const modalSpinner = $('#deleteModalSpinner')
+
+// list of devices, as objects and as a DOM element
+let devices = undefined;
+const lstDevices = $('#lstDevices')
+
+
+// ------------------
+// UI event listeners
+// ------------------
+// open file selector for copying a scenario
+btnLoadConfig.on('click', () => {
+ ipcRenderer.send('openDialog', {
+ type: 'file',
+ filters: [{name: 'JSON', extensions: ['json']}],
+ callback: 'configSelected'
+ })
+})
+
+// open folder selector for copying logs
+btnImportLogs.on('click', () => {
+ ipcRenderer.send('openDialog', {
+ type: 'folder',
+ callback: 'directorySelected'
+ })
+})
+
+// open a confirmation dialog when deleting log files
+btnDeleteLogs.on('click', () => {
+ modalTitle.text('Vous êtes en train de supprimer tous les logs. Êtes-vous sûr?')
+ confirmDelete(getSelectedDevice().getPath(['ExperimentLogs']))
+})
+
+// call the main process to open a file dialog
+btnLoadAssetBundles.on('click', () => {
+ ipcRenderer.send('openDialog', {
+ type: 'file',
+ multiselect: true,
+ callback: 'filesSelected',
+ subFolder: 'AssetBundles'
+ })
+})
+
+// open a confirmation dialog when deleting AssenBundles
+btnDeleteAssetBundles.on('click', () => {
+ modalTitle.text('Vous êtes en train de supprimer tous les AssetBundles. Êtes-vous sûr?')
+ confirmDelete(getSelectedDevice().getPath(['AssetBundles']))
+})
+
+// call the main process to open a file dialog
+btnLoadSounds.on('click', () => {
+ ipcRenderer.send('openDialog', {
+ type: 'file',
+ multiselect: true,
+ callback: 'filesSelected',
+ subFolder: 'Sounds',
+ filters: [{name: 'Audio', extensions: ['wav', 'mp3']}]
+ })
+})
+
+// open a confirmation dialog when deleting sound files
+btnDeleteSounds.on('click', () => {
+ modalTitle.text('Vous êtes en train de supprimer tous les sons. Êtes-vous sûr?')
+ confirmDelete(getSelectedDevice().getPath(['Sounds']))
+})
+
+// call the main process to open a file dialog
+btnLoadVisuals.on('click', () => {
+ ipcRenderer.send('openDialog', {
+ type: 'file',
+ multiselect: true,
+ callback: 'filesSelected',
+ subFolder: 'Visuals',
+ filters: [{name: 'Visuals', extensions: ['jpg', 'png', 'mp4']}]
+ })
+})
+
+// open a confirmation dialog when deleting visual interference files
+btnDeleteVisuals.on('click', () => {
+ modalTitle.text('Vous êtes en train de supprimer tous les visuels. Êtes-vous sûr?')
+ confirmDelete(getSelectedDevice().getPath(['Visuals']))
+})
+
+// update the access path when the selected device changes
+lstDevices.on('change', () => {
+ updatePath()
+})
+
+// update the list of connected devices
+btnSearchDevices.on('click', async () => {
+ await listDevices()
+})
+
+// -------------------------------------
+// listeners for calls from main process
+// -------------------------------------
+
+// called after a file has been selected. decides depending on the selected device type what function must be
+// called
+ipcRenderer.on('configSelected', async (event, data) => {
+ if (await getSelectedDevice().uploadConfig(data.filePaths[0])) {
+ toast.create('Chargement du scénario complet.', 'text-bg-success')
+ } else {
+ toast.create('Erreur au chargement du scénario', 'text-bg-danger')
+ }
+})
+
+// called after a file has been selected. decides depending on the selected device type what function must be
+// called
+ipcRenderer.on('filesSelected', async (event, data) => {
+ if (await getSelectedDevice().prepareAndUpload(data.filePaths, data.subFolder)) {
+ toast.create('Chargement des fichiers complet.', 'text-bg-success')
+ } else {
+ toast.create('Erreur, chargement des fichiers incomplet.', 'text-bg-danger')
+ }
+})
+
+// called after a directory has been selected. decides depending on the selected device type what function must be
+// called
+ipcRenderer.on('directorySelected', async (event, data) => {
+ if (await getSelectedDevice().downloadLogs(data.filePaths[0])) {
+ toast.create('Téléchargement des logs complet.', 'text-bg-success')
+ } else {
+ toast.create('Erreur au téléchargement des logs.', 'text-bg-danger')
+ }
+})
+
+// ---------
+// functions
+// ---------
+
+/**
+ * Open a modal dialog that asks for confirmation. Shows all files that will be deleted.
+ * @param rootFolder the folder whose content will be deleted
+ */
+async function confirmDelete(rootFolder) {
+ let device = getSelectedDevice()
+ let fileList
+ // try to get a list of file. might fail if the selected device is no longer connected
+ try {
+ fileList = await device.getFilesRecursively('', rootFolder, true)
+ } catch (e) {
+ console.error(e.message)
+ toast.create(`Erreur de connexion avec l'appareil ${device.name}.`, 'text-bg-danger')
+ return
+ }
+
+ // if folder contains no file, inform the user and then do nothing
+ if (fileList.length === 0) {
+ toast.create('Aucun fichier à supprimer sur ' + device, 'text-bg-primary')
+ return
+ }
+
+ // create list of files that will be deleted
+ let text = 'Les fichiers suivants vont être supprimés sur ' + device + ':
'
+ for (const file of fileList) text += '
' + file + '
'
+ text += '
'
+
+ // prepare the modal
+ modalBody.html(text)
+ modalSpinner.hide()
+ modalBtn.prop('disabled', false)
+
+ // remove prior listener and add new one
+ modalBtn.unbind()
+ modalBtn.on('click', async () => {
+ // show loading with spinner
+ modalSpinner.show()
+ modalBtn.prop('disabled', true)
+ // try to delete the data
+ try {
+ if (await device.remove(fileList, rootFolder)) {
+ toast.create('Suppression complète.', 'text-bg-success')
+ } else {
+ toast.create('Erreur, la suppression des fichiers est incomplet.', 'text-bg-danger')
+ }
+ } catch (e) {
+ console.error(e.mesage)
+ toast.create(`Erreur de connexion avec l'appareil ${device.name}.`, 'text-bg-danger')
+ } finally {
+ modal.hide()
+ }
+ })
+ modal.show()
+}
+
+/**
+ * List all ADB devices that are currently connected to this computer, including the computer itself, and put them into
+ * the lstDevices select.
+ */
+async function listDevices() {
+ // try to get a list of connected devices
+ try {
+ let ld = await LocalDevice.getDevices()
+ let ad = await AdbDevice.getDevices()
+ devices = ld.concat(ad)
+ } catch (e) {
+ console.error(e.message)
+ toast.create('Erreur à la recherche des appareils.', 'text-bg-danger')
+ return
+ }
+
+ // empty the list
+ lstDevices.empty()
+ for (let i = 0; i < devices.length; i++) {
+ lstDevices.append(new Option(devices[i], i))
+ }
+
+ // store devices in variable for later use
+ toast.create(`Recherche d'appareil complet. ${devices.length} appareil(s) à dipsosition.`, 'text-bg-success')
+ updatePath()
+}
+
+/**
+ * Set the path under which the currently selected device is available.
+ */
+function updatePath() {
+ $('#path span').text(getSelectedDevice().getPath())
+}
+
+/**
+ * Get the selected device
+ */
+function getSelectedDevice() {
+ return devices[lstDevices.val()]
+}
+
+
+$(async () => {
+ // check if an ADB server is available. if not: show a warning as toast
+ try {
+ let version = await client.version()
+ console.log('adb version: ' + version)
+ } catch (e) {
+ toast.create(
+ 'Les outils ADB ne sont pas detectés: des appareils Oculus Quest ne peuvent pas être utilisés.',
+ 'text-bg-warning', 10000)
+
+ console.warn('adb not installed')
+ client = undefined
+ }
+ // update the list of connected devices
+ await listDevices()
+ updatePath()
+})
\ No newline at end of file