From 388765c3c9a29f4f608aee2c9d7481fbdd2bdde4 Mon Sep 17 00:00:00 2001 From: Xmader Date: Thu, 17 Oct 2019 00:41:58 -0400 Subject: [PATCH] =?UTF-8?q?v1.2.0=20-=20=E6=94=AF=E6=8C=81=E4=BF=9D?= =?UTF-8?q?=E5=AD=98=E9=85=8D=E7=BD=AE=E4=BF=AE=E6=94=B9=E5=88=B0=20aria2.?= =?UTF-8?q?conf=20=E9=85=8D=E7=BD=AE=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- config.xml | 2 +- package-lock.json | 2 +- package.json | 2 +- www/main.js | 228 +++++++++++++++++++++++++++++++++++++--------- 4 files changed, 188 insertions(+), 46 deletions(-) diff --git a/config.xml b/config.xml index 1eba3d2..597a838 100644 --- a/config.xml +++ b/config.xml @@ -1,5 +1,5 @@ - + AriaNgGUI 一个 Aria2 图形界面跨平台客户端 (此为Android版) diff --git a/package-lock.json b/package-lock.json index b030d9b..94e82be 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,6 +1,6 @@ { "name": "com.xmader.aria_ng_gui_android", - "version": "1.1.2", + "version": "1.2.0", "lockfileVersion": 1, "requires": true, "dependencies": { diff --git a/package.json b/package.json index b21b454..8bb9b67 100644 --- a/package.json +++ b/package.json @@ -1,7 +1,7 @@ { "name": "com.xmader.aria_ng_gui_android", "displayName": "AriaNg GUI for Android", - "version": "1.1.2", + "version": "1.2.0", "description": "一个 Aria2 图形界面跨平台客户端 (此为Android版)", "repository": { "type": "git", diff --git a/www/main.js b/www/main.js index 01d197c..8b94e8e 100644 --- a/www/main.js +++ b/www/main.js @@ -1,5 +1,13 @@ "use strict"; +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } + +function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } @@ -148,6 +156,80 @@ function () { return function requestWriteExternalStoragePermission() { return _ref.apply(this, arguments); }; +}(); +/** + * 获取文件/目录 Entry + * @param {string} path 文件路径 + * @returns {Promise} + */ + + +var getEntry = function getEntry(path) { + return new Promise(function (resolve, reject) { + window.resolveLocalFileSystemURL(path, resolve, reject); + }); +}; +/** + * 写入文件 + * @param {FileEntry} entry + * @param {BlobPart} data 文件内容 + */ + + +var writeFileEntry = function writeFileEntry(entry, data) { + return new Promise(function (resolve, reject) { + entry.createWriter(function (fileWriter) { + fileWriter.onwriteend = function () { + return resolve(); + }; + + fileWriter.onerror = reject; + var blob = new Blob([data]); + fileWriter.write(blob); + }); + }); +}; +/** + * 读取文件 + * @param {FileEntry} entry + * @returns {Promise} + */ + + +var readFileEntry = +/*#__PURE__*/ +function () { + var _ref2 = _asyncToGenerator( + /*#__PURE__*/ + regeneratorRuntime.mark(function _callee2(entry) { + return regeneratorRuntime.wrap(function _callee2$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + return _context2.abrupt("return", new Promise(function (resolve, reject) { + var errorCallback = reject; + entry.file(function (file) { + var reader = new FileReader(); + + reader.onloadend = function () { + resolve(this.result); + }; + + reader.readAsText(file); + }, errorCallback); + })); + + case 1: + case "end": + return _context2.stop(); + } + } + }, _callee2); + })); + + return function readFileEntry(_x) { + return _ref2.apply(this, arguments); + }; }(); // 等待 Cordova 完全加载 @@ -155,11 +237,11 @@ document.addEventListener("deviceready", /*#__PURE__*/ _asyncToGenerator( /*#__PURE__*/ -regeneratorRuntime.mark(function _callee2() { - var appDir, dataDir, aria2FileURL, aria2ConfFileURL, downloadDir, appVersion, logoDiv, copiedFileEntry, copiedAria2FileURL, copiedAria2ConfFileURL, n, res; - return regeneratorRuntime.wrap(function _callee2$(_context2) { +regeneratorRuntime.mark(function _callee4() { + var appDir, dataDir, aria2FileURL, aria2ConfFileURL, downloadDir, appVersion, logoDiv, copiedFileEntry, copiedAria2FileURL, copiedAria2ConfFileURL, confFileEntry, conf, saveLocalConfig, n, res; + return regeneratorRuntime.wrap(function _callee4$(_context4) { while (1) { - switch (_context2.prev = _context2.next) { + switch (_context4.prev = _context4.next) { case 0: appDir = top.cordova.file.applicationDirectory; dataDir = top.cordova.file.dataDirectory; @@ -167,11 +249,11 @@ regeneratorRuntime.mark(function _callee2() { aria2ConfFileURL = appDir + "www/aria2/aria2.conf"; downloadDir = "/storage/emulated/0/Download/"; // 显示 AriaNg GUI for Android 的版本号 - _context2.next = 7; + _context4.next = 7; return top.cordova.getAppVersion.getVersionNumber(); case 7: - appVersion = _context2.sent; + appVersion = _context4.sent; logoDiv = document.getElementById("aria-ng-logo"); logoDiv.title = "AriaNg GUI for Android v".concat(appVersion, " | ").concat(logoDiv.title); // const savedAppVersion = localStorage.getItem("appVersion") // console.log(savedAppVersion) @@ -180,99 +262,159 @@ regeneratorRuntime.mark(function _callee2() { // } // 手动请求 存储空间读写 的权限 - _context2.next = 12; + _context4.next = 12; return requestWriteExternalStoragePermission(); case 12: - _context2.next = 14; + _context4.next = 14; return fileOrDirExistsPromise(dataDir + "aria2.conf"); case 14: - if (_context2.sent) { - _context2.next = 17; + if (_context4.sent) { + _context4.next = 17; break; } - _context2.next = 17; + _context4.next = 17; return copyFilePromise(aria2ConfFileURL, dataDir); case 17: - _context2.next = 19; + _context4.next = 19; return copyFilePromise(aria2FileURL, dataDir); case 19: - copiedFileEntry = _context2.sent; + copiedFileEntry = _context4.sent; // 获取复制到的文件路径 copiedAria2FileURL = copiedFileEntry.nativeURL.replace("file://", ""); - copiedAria2ConfFileURL = copiedAria2FileURL.replace(/\/aria2c$/, "/aria2.conf"); // 运行aria2c前的准备工作 + copiedAria2ConfFileURL = copiedAria2FileURL.replace(/\/aria2c$/, "/aria2.conf"); // 支持保存配置修改到 aria2.conf 配置文件 + + _context4.next = 24; + return getEntry("file://" + copiedAria2ConfFileURL); + + case 24: + confFileEntry = _context4.sent; + conf = ""; + + saveLocalConfig = + /*#__PURE__*/ + function () { + var _ref4 = _asyncToGenerator( + /*#__PURE__*/ + regeneratorRuntime.mark(function _callee3(options) { + return regeneratorRuntime.wrap(function _callee3$(_context3) { + while (1) { + switch (_context3.prev = _context3.next) { + case 0: + if (conf) { + _context3.next = 4; + break; + } + + _context3.next = 3; + return readFileEntry(confFileEntry); + + case 3: + conf = _context3.sent; + + case 4: + Object.entries(options).forEach(function (_ref5) { + var _ref6 = _slicedToArray(_ref5, 2), + key = _ref6[0], + value = _ref6[1]; + + var r = new RegExp("^(?:#\\s*)?(".concat(key, "=).*"), "m"); + + if (r.test(conf)) { + conf = conf.replace(r, "$1" + value); + } else { + conf += "\n".concat(key, "=").concat(value); + } + }); + _context3.next = 7; + return writeFileEntry(confFileEntry, conf); + + case 7: + case "end": + return _context3.stop(); + } + } + }, _callee3); + })); + + return function saveLocalConfig(_x2) { + return _ref4.apply(this, arguments); + }; + }(); + + window.saveLocalConfig = saveLocalConfig; // 运行aria2c前的准备工作 // 1. 创建aria2.session会话文件 - _context2.next = 24; + _context4.next = 30; return shellExecPromise(["touch", downloadDir + "aria2.session"]); - case 24: - _context2.next = 26; + case 30: + _context4.next = 32; return shellExecPromise(["chmod", "0777", copiedAria2FileURL]); - case 26: + case 32: // 创建因为端口被占用而运行失败的次数的计数器 n = 0; // 在aria2c异常关闭后自动重启aria2c - case 27: + case 33: if (!true) { - _context2.next = 48; + _context4.next = 54; break; } - _context2.prev = 28; - _context2.next = 31; + _context4.prev = 34; + _context4.next = 37; return shellExecPromise([copiedAria2FileURL, "--conf-path=" + copiedAria2ConfFileURL]); - case 31: - res = _context2.sent; + case 37: + res = _context4.sent; console.log(res.output); // 被手动关闭时取消自动重启aria2c if (!res.output.includes("second(s) has passed. Stopping application.")) { - _context2.next = 35; + _context4.next = 41; break; } - return _context2.abrupt("break", 48); + return _context4.abrupt("break", 54); - case 35: - _context2.next = 46; + case 41: + _context4.next = 52; break; - case 37: - _context2.prev = 37; - _context2.t0 = _context2["catch"](28); - console.log(_context2.t0.output); // 端口被占用达到一定次数后时取消自动重启aria2c + case 43: + _context4.prev = 43; + _context4.t0 = _context4["catch"](34); + console.log(_context4.t0.output); // 端口被占用达到一定次数后时取消自动重启aria2c - if (!_context2.t0.output.includes("Failed to bind a socket, cause: Address already in use")) { - _context2.next = 46; + if (!_context4.t0.output.includes("Failed to bind a socket, cause: Address already in use")) { + _context4.next = 52; break; } if (!(n > 5)) { - _context2.next = 45; + _context4.next = 51; break; } - return _context2.abrupt("break", 48); + return _context4.abrupt("break", 54); - case 45: + case 51: n++; - case 46: - _context2.next = 27; + case 52: + _context4.next = 33; break; - case 48: + case 54: case "end": - return _context2.stop(); + return _context4.stop(); } } - }, _callee2, null, [[28, 37]]); + }, _callee4, null, [[34, 43]]); })), false); -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/main.js"],"names":[],"mappings":"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","file":"main.js","sourcesContent":["/**\r\n * AriaNg GUI for Android\r\n * @author Xmader\r\n * @copyright Copyright (c) 2018-2019 Xmader. All Rights Reserved.\r\n * @license MIT\r\n */\r\n\r\n// 输出版权信息\r\nconsole.info(`AriaNg GUI for Android\r\n\r\nCopyright (c) 2018-2019 Xmader\r\nReleased under the MIT license\r\n\r\nSource Code: https://github.com/Xmader/aria-ng-gui-android/\r\n`)\r\n\r\n/**\r\n * 运行一个 shell 子进程并在 shell 上运行命令\r\n * @param {string | string[]} cmd \r\n * @returns {Promise<{ exitStatus: number; output: string; }>}\r\n */\r\nconst shellExecPromise = (cmd) => {\r\n    return new Promise((resolve, reject) => {\r\n        window.ShellExec.exec(cmd, (res) => {\r\n            if (res.exitStatus == 0) {\r\n                resolve(res)\r\n            } else {\r\n                reject(res)\r\n            }\r\n        })\r\n    })\r\n}\r\n\r\n/**\r\n * 复制文件\r\n * 如果文件已存在, 则自动覆盖\r\n * @param {string} srcPath 源文件路径\r\n * @param {string} destDir 目标目录\r\n * @param {string=} destFileName 目标文件名 (如果留空, 则不改变文件名)\r\n * @returns {Promise<Entry>}\r\n */\r\nconst copyFilePromise = (srcPath, destDir, destFileName = null) => {\r\n    return new Promise((resolve, reject) => {\r\n        const successCallback = (entry) => resolve(entry)\r\n        const errorCallback = (e) => reject(e)\r\n\r\n        window.resolveLocalFileSystemURL(srcPath, function (fileEntry) {\r\n            window.resolveLocalFileSystemURL(destDir, function (dirEntry) {\r\n                fileEntry.copyTo(dirEntry, destFileName || fileEntry.name, successCallback, errorCallback)\r\n            })\r\n        }, errorCallback)\r\n    })\r\n}\r\n\r\n/**\r\n * 判断文件或目录是否存在\r\n * @param {string} filePath\r\n * @returns {Promise<boolean>}\r\n */\r\nconst fileOrDirExistsPromise = (filePath) => {\r\n    return new Promise((resolve) => {\r\n        const successCallback = () => resolve(true)\r\n        const errorCallback = (e) => {\r\n            if (e.code == 1) { // 文件或目录不存在 FileError.NOT_FOUND_ERR\r\n                resolve(false)\r\n            } else { // 其它错误\r\n                resolve(true)\r\n            }\r\n        }\r\n\r\n        window.resolveLocalFileSystemURL(filePath, successCallback, errorCallback)\r\n    })\r\n}\r\n\r\n/**\r\n * 从一个文件路径获取文件名\r\n * @param {string} filePath \r\n */\r\nconst getFileName = (filePath) => {\r\n    return filePath.split(\"/\").pop()\r\n}\r\n\r\n/**\r\n * 把全部给定的路径片段连接到一起\r\n * @param {...string} paths \r\n */\r\nconst joinPath = (...paths) => {\r\n    return paths.join(\"/\").replace(/([^:])\\/{3,}|([^/:])\\/{2}/g, \"$1$2/\")\r\n}\r\n\r\n/**\r\n * 手动请求 android.permission.WRITE_EXTERNAL_STORAGE 权限 \r\n * @returns {Promise<boolean>}\r\n */\r\nconst requestWriteExternalStoragePermission = async () => {\r\n    \r\n    // @ts-ignore\r\n    const permissions = window.cordova.plugins.permissions\r\n    const name = permissions.WRITE_EXTERNAL_STORAGE\r\n\r\n    return new Promise((resolve, reject) => {\r\n        permissions.requestPermission(name, (result) => {\r\n            if (result && result.hasPermission) {\r\n                resolve(true)\r\n            } else {\r\n                reject(false)\r\n            }\r\n        }, (err) => {\r\n            reject(err)\r\n        })\r\n    })\r\n\r\n}\r\n\r\n// 等待 Cordova 完全加载\r\ndocument.addEventListener(\"deviceready\", async function () {\r\n    const appDir = top.cordova.file.applicationDirectory\r\n    const dataDir = top.cordova.file.dataDirectory\r\n\r\n    const aria2FileURL = appDir + \"www/aria2/android/aria2c\"\r\n    const aria2ConfFileURL = appDir + \"www/aria2/aria2.conf\"\r\n    const downloadDir = \"/storage/emulated/0/Download/\"\r\n\r\n    // 显示 AriaNg GUI for Android 的版本号\r\n    const appVersion = await top.cordova.getAppVersion.getVersionNumber()\r\n    const logoDiv = document.getElementById(\"aria-ng-logo\")\r\n    logoDiv.title = `AriaNg GUI for Android v${appVersion} | ${logoDiv.title}`\r\n\r\n    // const savedAppVersion = localStorage.getItem(\"appVersion\")\r\n    // console.log(savedAppVersion)\r\n    // if (appVersion != savedAppVersion || !(await fileOrDirExistsPromise(dataDir + \"aria2c\"))) {\r\n    //     top.localStorage.setItem(\"appVersion\", appVersion)\r\n    // }\r\n\r\n    // 手动请求 存储空间读写 的权限\r\n    await requestWriteExternalStoragePermission()\r\n\r\n    // 仅当aria2.conf文件不存在时复制aria2.conf, 防止配置文件被覆盖\r\n    if (!await fileOrDirExistsPromise(dataDir + \"aria2.conf\")) {\r\n        await copyFilePromise(aria2ConfFileURL, dataDir)\r\n    }\r\n\r\n    // 复制aria2c\r\n    const copiedFileEntry = await copyFilePromise(aria2FileURL, dataDir)\r\n\r\n    // 获取复制到的文件路径\r\n    const copiedAria2FileURL = copiedFileEntry.nativeURL.replace(\"file://\", \"\")\r\n    const copiedAria2ConfFileURL = copiedAria2FileURL.replace(/\\/aria2c$/, \"/aria2.conf\")\r\n\r\n    // 运行aria2c前的准备工作\r\n    // 1. 创建aria2.session会话文件\r\n    await shellExecPromise([\"touch\", downloadDir + \"aria2.session\"])\r\n    // 2. 让aria2c可执行文件有运行权限\r\n    await shellExecPromise([\"chmod\", \"0777\", copiedAria2FileURL])\r\n\r\n    // 创建因为端口被占用而运行失败的次数的计数器\r\n    let n = 0\r\n\r\n    // 在aria2c异常关闭后自动重启aria2c\r\n    while (true) {\r\n        try {\r\n            // 运行aria2c\r\n            const res = await shellExecPromise([copiedAria2FileURL, \"--conf-path=\" + copiedAria2ConfFileURL])\r\n            console.log(res.output)\r\n\r\n            // 被手动关闭时取消自动重启aria2c\r\n            if (res.output.includes(\"second(s) has passed. Stopping application.\")) {\r\n                break;\r\n            }\r\n        } catch (res) {\r\n            console.log(res.output)\r\n\r\n            // 端口被占用达到一定次数后时取消自动重启aria2c\r\n            if (res.output.includes(\"Failed to bind a socket, cause: Address already in use\")) {\r\n                if (n > 5) {\r\n                    break;\r\n                } else {\r\n                    n++\r\n                }\r\n            }\r\n        }\r\n    }\r\n}, false)\r\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/main.js"],"names":[],"mappings":"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","file":"main.js","sourcesContent":["/**\r\n * AriaNg GUI for Android\r\n * @author Xmader\r\n * @copyright Copyright (c) 2018-2019 Xmader. All Rights Reserved.\r\n * @license MIT\r\n */\r\n\r\n// 输出版权信息\r\nconsole.info(`AriaNg GUI for Android\r\n\r\nCopyright (c) 2018-2019 Xmader\r\nReleased under the MIT license\r\n\r\nSource Code: https://github.com/Xmader/aria-ng-gui-android/\r\n`)\r\n\r\n/**\r\n * 运行一个 shell 子进程并在 shell 上运行命令\r\n * @param {string | string[]} cmd \r\n * @returns {Promise<{ exitStatus: number; output: string; }>}\r\n */\r\nconst shellExecPromise = (cmd) => {\r\n    return new Promise((resolve, reject) => {\r\n        window.ShellExec.exec(cmd, (res) => {\r\n            if (res.exitStatus == 0) {\r\n                resolve(res)\r\n            } else {\r\n                reject(res)\r\n            }\r\n        })\r\n    })\r\n}\r\n\r\n/**\r\n * 复制文件\r\n * 如果文件已存在, 则自动覆盖\r\n * @param {string} srcPath 源文件路径\r\n * @param {string} destDir 目标目录\r\n * @param {string=} destFileName 目标文件名 (如果留空, 则不改变文件名)\r\n * @returns {Promise<Entry>}\r\n */\r\nconst copyFilePromise = (srcPath, destDir, destFileName = null) => {\r\n    return new Promise((resolve, reject) => {\r\n        const successCallback = (entry) => resolve(entry)\r\n        const errorCallback = (e) => reject(e)\r\n\r\n        window.resolveLocalFileSystemURL(srcPath, function (fileEntry) {\r\n            window.resolveLocalFileSystemURL(destDir, function (dirEntry) {\r\n                fileEntry.copyTo(dirEntry, destFileName || fileEntry.name, successCallback, errorCallback)\r\n            })\r\n        }, errorCallback)\r\n    })\r\n}\r\n\r\n/**\r\n * 判断文件或目录是否存在\r\n * @param {string} filePath\r\n * @returns {Promise<boolean>}\r\n */\r\nconst fileOrDirExistsPromise = (filePath) => {\r\n    return new Promise((resolve) => {\r\n        const successCallback = () => resolve(true)\r\n        const errorCallback = (e) => {\r\n            if (e.code == 1) { // 文件或目录不存在 FileError.NOT_FOUND_ERR\r\n                resolve(false)\r\n            } else { // 其它错误\r\n                resolve(true)\r\n            }\r\n        }\r\n\r\n        window.resolveLocalFileSystemURL(filePath, successCallback, errorCallback)\r\n    })\r\n}\r\n\r\n/**\r\n * 从一个文件路径获取文件名\r\n * @param {string} filePath \r\n */\r\nconst getFileName = (filePath) => {\r\n    return filePath.split(\"/\").pop()\r\n}\r\n\r\n/**\r\n * 把全部给定的路径片段连接到一起\r\n * @param {...string} paths \r\n */\r\nconst joinPath = (...paths) => {\r\n    return paths.join(\"/\").replace(/([^:])\\/{3,}|([^/:])\\/{2}/g, \"$1$2/\")\r\n}\r\n\r\n/**\r\n * 手动请求 android.permission.WRITE_EXTERNAL_STORAGE 权限 \r\n * @returns {Promise<boolean>}\r\n */\r\nconst requestWriteExternalStoragePermission = async () => {\r\n\r\n    // @ts-ignore\r\n    const permissions = window.cordova.plugins.permissions\r\n    const name = permissions.WRITE_EXTERNAL_STORAGE\r\n\r\n    return new Promise((resolve, reject) => {\r\n        permissions.requestPermission(name, (result) => {\r\n            if (result && result.hasPermission) {\r\n                resolve(true)\r\n            } else {\r\n                reject(false)\r\n            }\r\n        }, (err) => {\r\n            reject(err)\r\n        })\r\n    })\r\n\r\n}\r\n\r\n/**\r\n * 获取文件/目录 Entry\r\n * @param {string} path 文件路径\r\n * @returns {Promise<Entry>}\r\n */\r\nconst getEntry = (path) => {\r\n    return new Promise((resolve, reject) => {\r\n        window.resolveLocalFileSystemURL(path, resolve, reject)\r\n    })\r\n}\r\n\r\n/**\r\n * 写入文件\r\n * @param {FileEntry} entry \r\n * @param {BlobPart} data 文件内容\r\n */\r\nconst writeFileEntry = (entry, data) => {\r\n    return new Promise((resolve, reject) => {\r\n        entry.createWriter((fileWriter) => {\r\n            fileWriter.onwriteend = () => resolve()\r\n            fileWriter.onerror = reject\r\n            const blob = new Blob([data])\r\n            fileWriter.write(blob)\r\n        })\r\n    })\r\n}\r\n\r\n/**\r\n * 读取文件\r\n * @param {FileEntry} entry\r\n * @returns {Promise<string>}\r\n */\r\nconst readFileEntry = async (entry) => {\r\n    return new Promise((resolve, reject) => {\r\n        const errorCallback = reject\r\n        entry.file((file) => {\r\n            const reader = new FileReader()\r\n            reader.onloadend = function () {\r\n                resolve(this.result)\r\n            }\r\n            reader.readAsText(file)\r\n        }, errorCallback)\r\n    })\r\n}\r\n\r\n// 等待 Cordova 完全加载\r\ndocument.addEventListener(\"deviceready\", async function () {\r\n    const appDir = top.cordova.file.applicationDirectory\r\n    const dataDir = top.cordova.file.dataDirectory\r\n\r\n    const aria2FileURL = appDir + \"www/aria2/android/aria2c\"\r\n    const aria2ConfFileURL = appDir + \"www/aria2/aria2.conf\"\r\n    const downloadDir = \"/storage/emulated/0/Download/\"\r\n\r\n    // 显示 AriaNg GUI for Android 的版本号\r\n    const appVersion = await top.cordova.getAppVersion.getVersionNumber()\r\n    const logoDiv = document.getElementById(\"aria-ng-logo\")\r\n    logoDiv.title = `AriaNg GUI for Android v${appVersion} | ${logoDiv.title}`\r\n\r\n    // const savedAppVersion = localStorage.getItem(\"appVersion\")\r\n    // console.log(savedAppVersion)\r\n    // if (appVersion != savedAppVersion || !(await fileOrDirExistsPromise(dataDir + \"aria2c\"))) {\r\n    //     top.localStorage.setItem(\"appVersion\", appVersion)\r\n    // }\r\n\r\n    // 手动请求 存储空间读写 的权限\r\n    await requestWriteExternalStoragePermission()\r\n\r\n    // 仅当aria2.conf文件不存在时复制aria2.conf, 防止配置文件被覆盖\r\n    if (!await fileOrDirExistsPromise(dataDir + \"aria2.conf\")) {\r\n        await copyFilePromise(aria2ConfFileURL, dataDir)\r\n    }\r\n\r\n    // 复制aria2c\r\n    const copiedFileEntry = await copyFilePromise(aria2FileURL, dataDir)\r\n\r\n    // 获取复制到的文件路径\r\n    const copiedAria2FileURL = copiedFileEntry.nativeURL.replace(\"file://\", \"\")\r\n    const copiedAria2ConfFileURL = copiedAria2FileURL.replace(/\\/aria2c$/, \"/aria2.conf\")\r\n\r\n    // 支持保存配置修改到 aria2.conf 配置文件\r\n    const confFileEntry = await getEntry(\"file://\" + copiedAria2ConfFileURL)\r\n    let conf = \"\"\r\n    const saveLocalConfig = async (options) => {\r\n        if (!conf) {\r\n            conf = await readFileEntry(confFileEntry)\r\n        }\r\n\r\n        Object.entries(options).forEach(([key, value]) => {\r\n            const r = new RegExp(`^(?:#\\\\s*)?(${key}=).*`, \"m\")\r\n            if (r.test(conf)) {\r\n                conf = conf.replace(\r\n                    r,\r\n                    \"$1\" + value\r\n                )\r\n            } else {\r\n                conf += `\\n${key}=${value}`\r\n            }\r\n        })\r\n\r\n        await writeFileEntry(confFileEntry, conf)\r\n    }\r\n    window.saveLocalConfig = saveLocalConfig\r\n\r\n    // 运行aria2c前的准备工作\r\n    // 1. 创建aria2.session会话文件\r\n    await shellExecPromise([\"touch\", downloadDir + \"aria2.session\"])\r\n    // 2. 让aria2c可执行文件有运行权限\r\n    await shellExecPromise([\"chmod\", \"0777\", copiedAria2FileURL])\r\n\r\n    // 创建因为端口被占用而运行失败的次数的计数器\r\n    let n = 0\r\n\r\n    // 在aria2c异常关闭后自动重启aria2c\r\n    while (true) {\r\n        try {\r\n            // 运行aria2c\r\n            const res = await shellExecPromise([copiedAria2FileURL, \"--conf-path=\" + copiedAria2ConfFileURL])\r\n            console.log(res.output)\r\n\r\n            // 被手动关闭时取消自动重启aria2c\r\n            if (res.output.includes(\"second(s) has passed. Stopping application.\")) {\r\n                break;\r\n            }\r\n        } catch (res) {\r\n            console.log(res.output)\r\n\r\n            // 端口被占用达到一定次数后时取消自动重启aria2c\r\n            if (res.output.includes(\"Failed to bind a socket, cause: Address already in use\")) {\r\n                if (n > 5) {\r\n                    break;\r\n                } else {\r\n                    n++\r\n                }\r\n            }\r\n        }\r\n    }\r\n}, false)\r\n"]} \ No newline at end of file