code refactor

main/components/menu.js

@@ -4,7 +4,7 @@ const os = require('os');
 const electron = require('electron');
 
 const core = require('../core');
-const ipc = require('../ipc');
+const ipcEvents = require('../ipc/events');
 
 const app = electron.app;
 const Menu = electron.Menu;
@@ -25,7 +25,7 @@ let buildMenu = function(context) {
                 {
                     label: getMenuTitle(context, 'AboutAriaNgNative', 'About AriaNg Native'),
                     click: function () {
-                        ipc.notifyRenderProcessNavigateToAriaNgSettings();
+                        ipcEvents.notifyRenderProcessNavigateToAriaNgSettings();
                     }
                 },
                 {

main/components/tray.js

@@ -11,7 +11,7 @@ const Menu = electron.Menu;
 const Tray = electron.Tray;
 
 let instance = null;
-let iconPath = path.join(__dirname, '..', 'assets', 'AriaNg.ico');
+let iconPath = path.join(__dirname, '../../', 'assets', 'AriaNg.ico');
 
 let init = function () {
     if (instance === null && os.platform() === 'win32') {

main/config/constants.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const ariaNgPageLocations = {
+    NewTask: '/new',
+    AriaNgSettings: '/settings/ariang'
+};
+
+const supportedFileExtensions = {
+    '.torrent': 'torrent',
+    '.meta4': 'metalink',
+    '.metalink': 'metalink'
+};
+
+module.exports = {
+    ariaNgPageLocations: ariaNgPageLocations,
+    supportedFileExtensions: supportedFileExtensions
+}

main/ipc.js

@@ -1,273 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const url = require('url');
-const electron = require('electron');
-
-const pkgfile = require('../package');
-const core = require('./core');
-const config = require('./config/config');
-const menu = require('./components/menu');
-const tray = require('./components/tray');
-const localfs = require('./lib/localfs');
-const bittorrent = require('./lib/bittorrent');
-
-const shell = electron.shell;
-const ipcMain = electron.ipcMain;
-
-const supportedFileExtensions = {
-    '.torrent': 'torrent',
-    '.meta4': 'metalink',
-    '.metalink': 'metalink'
-};
-
-let isContainsSupportedFileArg = function (arg) {
-    if (!arg) {
-        return false;
-    }
-
-    let fileExtension = path.extname(arg);
-
-    if (!supportedFileExtensions[fileExtension]) {
-        return false;
-    }
-
-    return fs.existsSync(arg);
-};
-
-let getIndexUrl = function () {
-    return url.format({
-        protocol: 'file',
-        slashes: true,
-        pathname: path.join(__dirname, '..', pkgfile.entry)
-    });
-};
-
-let loadIndexUrl = function () {
-    core.mainWindow.loadURL(getIndexUrl());
-};
-
-let loadNewTaskUrl = function () {
-    core.mainWindow.loadURL(getIndexUrl() + '#!/new');
-};
-
-let notifyRenderProcessWindowMaximized = function (maximized) {
-    core.mainWindow.webContents.send('on-main-window-maximized', maximized);
-};
-
-let notifyRenderProcessWindowUnmaximized = function (maximized) {
-    core.mainWindow.webContents.send('on-main-window-unmaximized', maximized);
-};
-
-let notifyRenderProcessShowErrorMessage = function (message) {
-    core.mainWindow.webContents.send('on-main-show-error', message);
-};
-
-let notifyRenderProcessNavigateToPath = function (routeUrl) {
-    core.mainWindow.webContents.send('on-main-navigate-to', routeUrl);
-};
-
-let notifyRenderProcessNavigateToNewTask = function () {
-    notifyRenderProcessNavigateToPath('/new');
-};
-
-let notifyRenderProcessNavigateToAriaNgSettings = function () {
-    notifyRenderProcessNavigateToPath('/settings/ariang');
-};
-
-let notifyRenderProcessNewTaskFromFile = function (filePath, async) {
-    let fileExtension = path.extname(filePath);
-
-    if (!supportedFileExtensions[fileExtension]) {
-        notifyRenderProcessShowErrorMessage('The selected file type is invalid!');
-        return;
-    }
-
-    let result = null;
-
-    try {
-        let fileContent = fs.readFileSync(filePath);
-
-        result = {
-            type: supportedFileExtensions[fileExtension],
-            fileName: path.basename(filePath),
-            base64Content: Buffer.from(fileContent).toString('base64'),
-            async: !!async
-        };
-    } catch (e) {
-        result = {
-            exception: e
-        }
-    }
-
-    core.mainWindow.webContents.send('on-main-new-task-from-file', result);
-};
-
-let notifyRenderProcessNewTaskFromText = function (text, async) {
-    let result = {
-        text: text,
-        async: !!async
-    };
-
-    core.mainWindow.webContents.send('on-main-new-task-from-text', result);
-};
-
-let notifyRenderProcessNewNewTaskFromFileAfterViewLoaded = function (filePath) {
-    if (!filePath) {
-        return;
-    }
-
-    ipcMain.once('on-render-view-content-loaded', (event, arg) => {
-        notifyRenderProcessNewTaskFromFile(filePath, true);
-    });
-};
-
-let notifyRenderProcessNewNewTaskFromTextAfterViewLoaded = function (text) {
-    if (!text) {
-        return;
-    }
-
-    ipcMain.once('on-render-view-content-loaded', (event, arg) => {
-        notifyRenderProcessNewTaskFromText(text, true);
-    });
-};
-
-let onRenderProcessNewDropFile = function (callback) {
-    ipcMain.on('on-render-new-drop-file', callback);
-};
-
-let onRenderProcessNewDropText = function (callback) {
-    ipcMain.on('on-render-new-drop-text', callback);
-};
-
-ipcMain.on('render-sync-get-runtime-environment', (event) => {
-    if (!process || !process.versions) {
-        return null;
-    }
-
-    var versions = process.versions;
-
-    event.returnValue = [
-        {
-            name: 'Electron',
-            value: versions.electron
-        },
-        {
-            name: 'Node.js',
-            value: versions.node
-        },
-        {
-            name: 'Chrome',
-            value: versions.chrome
-        },
-        {
-            name: 'V8',
-            value: versions.v8
-        }
-    ];
-});
-
-ipcMain.on('render-sync-get-global-setting', (event, key) => {
-    event.returnValue = global.settings[key];
-});
-
-ipcMain.handle('render-get-native-window-maximized', (event) => {
-    return core.mainWindow.isMaximized();
-});
-
-ipcMain.on('render-minimize-native-window', (event) => {
-    core.mainWindow.minimize();
-});
-
-ipcMain.on('render-maximize-or-restore-native-window', (event) => {
-    if (!core.mainWindow.isMaximized()) {
-        core.mainWindow.maximize();
-    } else {
-        core.mainWindow.unmaximize();
-    }
-});
-
-ipcMain.on('render-reload-native-window', (event) => {
-    core.mainWindow.reload();
-});
-
-ipcMain.on('render-exit-native-app', (event) => {
-    core.mainWindow.close();
-});
-
-ipcMain.on('render-update-app-menu-label', (event, labels) => {
-    menu.setApplicationMenu({
-        labels: labels
-    });
-});
-
-ipcMain.on('render-update-tray-menu-label', (event, labels) => {
-    tray.setContextMenu({
-        labels: labels
-    });
-});
-
-ipcMain.on('render-update-tray-tip', (event, tooltip) => {
-    tray.setToolTip(tooltip);
-});
-
-ipcMain.on('render-sync-get-native-config', (event) => {
-    event.returnValue = {
-        defaultPosition: config.defaultPosition,
-        minimizedToTray: config.minimizedToTray
-    };
-});
-
-ipcMain.on('render-set-native-config-default-position', (event, value) => {
-    config.defaultPosition = value;
-    config.save('defaultPosition');
-});
-
-ipcMain.on('render-set-native-config-minimized-to-tray', (event, value) => {
-    config.minimizedToTray = !!value;
-    config.save('minimizedToTray');
-});
-
-ipcMain.on('render-open-external-url', (event, url) => {
-    shell.openExternal(url);
-});
-
-ipcMain.on('render-sync-get-package-file-content', (event, path) => {
-    event.returnValue = localfs.readPackageFile(path);
-});
-
-ipcMain.handle('render-get-localfs-exists', (event, fullpath) => {
-    return localfs.isExists(fullpath);
-});
-
-ipcMain.on('render-open-local-directory', (event, dir, filename) => {
-    let fullpath = localfs.getFullPath(dir, filename);
-
-    if (localfs.isExists(fullpath)) {
-        shell.showItemInFolder(fullpath);
-    } else {
-        shell.openItem(dir);
-    }
-});
-
-ipcMain.on('render-sync-parse-bittorrent-info', (event, data) => {
-    event.returnValue = bittorrent.parseBittorrentInfo(data);
-});
-
-module.exports = {
-    isContainsSupportedFileArg: isContainsSupportedFileArg,
-    loadIndexUrl: loadIndexUrl,
-    loadNewTaskUrl: loadNewTaskUrl,
-    notifyRenderProcessWindowMaximized: notifyRenderProcessWindowMaximized,
-    notifyRenderProcessWindowUnmaximized: notifyRenderProcessWindowUnmaximized,
-    notifyRenderProcessShowErrorMessage: notifyRenderProcessShowErrorMessage,
-    notifyRenderProcessNavigateToNewTask: notifyRenderProcessNavigateToNewTask,
-    notifyRenderProcessNavigateToAriaNgSettings: notifyRenderProcessNavigateToAriaNgSettings,
-    notifyRenderProcessNewTaskFromFile: notifyRenderProcessNewTaskFromFile,
-    notifyRenderProcessNewTaskFromText: notifyRenderProcessNewTaskFromText,
-    notifyRenderProcessNewNewTaskFromFileAfterViewLoaded: notifyRenderProcessNewNewTaskFromFileAfterViewLoaded,
-    notifyRenderProcessNewNewTaskFromTextAfterViewLoaded: notifyRenderProcessNewNewTaskFromTextAfterViewLoaded,
-    onRenderProcessNewDropFile: onRenderProcessNewDropFile,
-    onRenderProcessNewDropText: onRenderProcessNewDropText
-};

main/ipc/events.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const electron = require('electron');
+
+const core = require('../core');
+const constants = require('../config/constants');
+
+const ipcMain = electron.ipcMain;
+
+let notifyRenderProcessWindowMaximized = function (maximized) {
+    core.mainWindow.webContents.send('on-main-window-maximized', maximized);
+};
+
+let notifyRenderProcessWindowUnmaximized = function (maximized) {
+    core.mainWindow.webContents.send('on-main-window-unmaximized', maximized);
+};
+
+let notifyRenderProcessShowErrorMessage = function (message) {
+    core.mainWindow.webContents.send('on-main-show-error', message);
+};
+
+let notifyRenderProcessNavigateToPath = function (routeUrl) {
+    core.mainWindow.webContents.send('on-main-navigate-to', routeUrl);
+};
+
+let notifyRenderProcessNavigateToNewTask = function () {
+    notifyRenderProcessNavigateToPath(constants.ariaNgPageLocations.NewTask);
+};
+
+let notifyRenderProcessNavigateToAriaNgSettings = function () {
+    notifyRenderProcessNavigateToPath(constants.ariaNgPageLocations.AriaNgSettings);
+};
+
+let notifyRenderProcessNewTaskFromFile = function (filePath, async) {
+    let fileExtension = path.extname(filePath);
+
+    if (!constants.supportedFileExtensions[fileExtension]) {
+        notifyRenderProcessShowErrorMessage('The selected file type is invalid!');
+        return;
+    }
+
+    let result = null;
+
+    try {
+        let fileContent = fs.readFileSync(filePath);
+
+        result = {
+            type: constants.supportedFileExtensions[fileExtension],
+            fileName: path.basename(filePath),
+            base64Content: Buffer.from(fileContent).toString('base64'),
+            async: !!async
+        };
+    } catch (e) {
+        result = {
+            exception: e
+        }
+    }
+
+    core.mainWindow.webContents.send('on-main-new-task-from-file', result);
+};
+
+let notifyRenderProcessNewTaskFromText = function (text, async) {
+    let result = {
+        text: text,
+        async: !!async
+    };
+
+    core.mainWindow.webContents.send('on-main-new-task-from-text', result);
+};
+
+let notifyRenderProcessNewNewTaskFromFileAfterViewLoaded = function (filePath) {
+    if (!filePath) {
+        return;
+    }
+
+    ipcMain.once('on-render-view-content-loaded', (event, arg) => {
+        notifyRenderProcessNewTaskFromFile(filePath, true);
+    });
+};
+
+let notifyRenderProcessNewNewTaskFromTextAfterViewLoaded = function (text) {
+    if (!text) {
+        return;
+    }
+
+    ipcMain.once('on-render-view-content-loaded', (event, arg) => {
+        notifyRenderProcessNewTaskFromText(text, true);
+    });
+};
+
+let onRenderProcessNewDropFile = function (callback) {
+    ipcMain.on('on-render-new-drop-file', callback);
+};
+
+let onRenderProcessNewDropText = function (callback) {
+    ipcMain.on('on-render-new-drop-text', callback);
+};
+
+module.exports = {
+    notifyRenderProcessWindowMaximized: notifyRenderProcessWindowMaximized,
+    notifyRenderProcessWindowUnmaximized: notifyRenderProcessWindowUnmaximized,
+    notifyRenderProcessShowErrorMessage: notifyRenderProcessShowErrorMessage,
+    notifyRenderProcessNavigateToNewTask: notifyRenderProcessNavigateToNewTask,
+    notifyRenderProcessNavigateToAriaNgSettings: notifyRenderProcessNavigateToAriaNgSettings,
+    notifyRenderProcessNewTaskFromFile: notifyRenderProcessNewTaskFromFile,
+    notifyRenderProcessNewTaskFromText: notifyRenderProcessNewTaskFromText,
+    notifyRenderProcessNewNewTaskFromFileAfterViewLoaded: notifyRenderProcessNewNewTaskFromFileAfterViewLoaded,
+    notifyRenderProcessNewNewTaskFromTextAfterViewLoaded: notifyRenderProcessNewNewTaskFromTextAfterViewLoaded,
+    onRenderProcessNewDropFile: onRenderProcessNewDropFile,
+    onRenderProcessNewDropText: onRenderProcessNewDropText
+}

main/ipc/methods.js

@@ -0,0 +1,127 @@
+'use strict';
+
+const electron = require('electron');
+
+const core = require('../core');
+const config = require('../config/config');
+const menu = require('../components/menu');
+const tray = require('../components/tray');
+const localfs = require('../lib/localfs');
+const bittorrent = require('../lib/bittorrent');
+
+const shell = electron.shell;
+const ipcMain = electron.ipcMain;
+
+ipcMain.on('render-sync-get-runtime-environment', (event) => {
+    if (!process || !process.versions) {
+        return null;
+    }
+
+    var versions = process.versions;
+
+    event.returnValue = [
+        {
+            name: 'Electron',
+            value: versions.electron
+        },
+        {
+            name: 'Node.js',
+            value: versions.node
+        },
+        {
+            name: 'Chrome',
+            value: versions.chrome
+        },
+        {
+            name: 'V8',
+            value: versions.v8
+        }
+    ];
+});
+
+ipcMain.on('render-sync-get-global-setting', (event, key) => {
+    event.returnValue = global.settings[key];
+});
+
+ipcMain.handle('render-get-native-window-maximized', (event) => {
+    return core.mainWindow.isMaximized();
+});
+
+ipcMain.on('render-minimize-native-window', (event) => {
+    core.mainWindow.minimize();
+});
+
+ipcMain.on('render-maximize-or-restore-native-window', (event) => {
+    if (!core.mainWindow.isMaximized()) {
+        core.mainWindow.maximize();
+    } else {
+        core.mainWindow.unmaximize();
+    }
+});
+
+ipcMain.on('render-reload-native-window', (event) => {
+    core.mainWindow.reload();
+});
+
+ipcMain.on('render-exit-native-app', (event) => {
+    core.mainWindow.close();
+});
+
+ipcMain.on('render-update-app-menu-label', (event, labels) => {
+    menu.setApplicationMenu({
+        labels: labels
+    });
+});
+
+ipcMain.on('render-update-tray-menu-label', (event, labels) => {
+    tray.setContextMenu({
+        labels: labels
+    });
+});
+
+ipcMain.on('render-update-tray-tip', (event, tooltip) => {
+    tray.setToolTip(tooltip);
+});
+
+ipcMain.on('render-sync-get-native-config', (event) => {
+    event.returnValue = {
+        defaultPosition: config.defaultPosition,
+        minimizedToTray: config.minimizedToTray
+    };
+});
+
+ipcMain.on('render-set-native-config-default-position', (event, value) => {
+    config.defaultPosition = value;
+    config.save('defaultPosition');
+});
+
+ipcMain.on('render-set-native-config-minimized-to-tray', (event, value) => {
+    config.minimizedToTray = !!value;
+    config.save('minimizedToTray');
+});
+
+ipcMain.on('render-open-external-url', (event, url) => {
+    shell.openExternal(url);
+});
+
+ipcMain.on('render-sync-get-package-file-content', (event, path) => {
+    event.returnValue = localfs.readPackageFile(path);
+});
+
+ipcMain.handle('render-get-localfs-exists', (event, fullpath) => {
+    return localfs.isExists(fullpath);
+});
+
+ipcMain.on('render-open-local-directory', (event, dir, filename) => {
+    let fullpath = localfs.getFullPath(dir, filename);
+
+    if (localfs.isExists(fullpath)) {
+        shell.showItemInFolder(fullpath);
+    } else {
+        shell.openItem(dir);
+    }
+});
+
+ipcMain.on('render-sync-parse-bittorrent-info', (event, data) => {
+    event.returnValue = bittorrent.parseBittorrentInfo(data);
+});

main/lib/file.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const constants = require('../config/constants');
+
+let isContainsSupportedFileArg = function (arg) {
+    if (!arg) {
+        return false;
+    }
+
+    let fileExtension = path.extname(arg);
+
+    if (!constants.supportedFileExtensions[fileExtension]) {
+        return false;
+    }
+
+    return fs.existsSync(arg);
+};
+
+module.exports = {
+    isContainsSupportedFileArg: isContainsSupportedFileArg
+}

main/lib/localfs.js

@@ -12,7 +12,7 @@ let isExists = function (fullPath) {
 };
 
 let readPackageFile = function (filePath) {
-    return fs.readFileSync(path.join(__dirname, '../app/', filePath), 'UTF-8');
+    return fs.readFileSync(path.join(__dirname, '../../app/', filePath), 'UTF-8');
 };
 
 module.exports = {

main/lib/page.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const url = require('url');
+const path = require('path');
+
+const pkgfile = require('../../package');
+
+let getIndexUrl = function () {
+    return url.format({
+        protocol: 'file',
+        slashes: true,
+        pathname: path.join(__dirname, '../../', pkgfile.entry)
+    });
+};
+
+let getPageFullUrl = function (location) {
+    if (!location) {
+        return getIndexUrl();
+    }
+
+    return getIndexUrl() + '#!' + location;
+};
+
+module.exports = {
+    getPageFullUrl: getPageFullUrl
+}

main/main.js

@@ -5,12 +5,17 @@ const electron = require('electron');
 const electronLocalshortcut = require('electron-localshortcut');
 
 const pkgfile = require('../package');
+
+const core = require('./core');
+const cmd = require('./cmd');
 const config = require('./config/config');
+const constants = require('./config/constants');
 const menu = require('./components/menu');
 const tray = require('./components/tray');
-const core = require('./core');
-const cmd = require('./cmd');
-const ipc = require('./ipc');
+const file = require('./lib/file');
+const page = require('./lib/page');
+const ipcEvents = require('./ipc/events');
+require('./ipc/methods');
 
 const app = electron.app;
 const BrowserWindow = electron.BrowserWindow;
@@ -32,7 +37,7 @@ function isEnableCloseToHide() {
 
 global.settings = {
     version: pkgfile.version,
-    ariaNgVersion: pkgfile["ariang-version"],
+    ariaNgVersion: pkgfile['ariang-version'],
     isDevMode: cmd.argv.development,
     useCustomAppTitle: false
 };
@@ -91,9 +96,9 @@ app.on('second-instance', (event, argv, workingDirectory, additionalData) => {
             filePath = cmd.parseFilePath(argv);
         }
 
-        if (filePath && ipc.isContainsSupportedFileArg(filePath)) {
-            ipc.notifyRenderProcessNewNewTaskFromFileAfterViewLoaded(filePath);
-            ipc.notifyRenderProcessNavigateToNewTask();
+        if (filePath && file.isContainsSupportedFileArg(filePath)) {
+            ipcEvents.notifyRenderProcessNewNewTaskFromFileAfterViewLoaded(filePath);
+            ipcEvents.notifyRenderProcessNavigateToNewTask();
         }
     }
 });
@@ -150,11 +155,11 @@ app.on('ready', () => {
     menu.init();
     tray.init();
 
-    if (ipc.isContainsSupportedFileArg(filePathInCommandLine)) {
-        ipc.notifyRenderProcessNewNewTaskFromFileAfterViewLoaded(filePathInCommandLine);
-        ipc.loadNewTaskUrl();
+    if (file.isContainsSupportedFileArg(filePathInCommandLine)) {
+        ipcEvents.notifyRenderProcessNewNewTaskFromFileAfterViewLoaded(filePathInCommandLine);
+        core.mainWindow.loadURL(page.getPageFullUrl(constants.ariaNgPageLocations.NewTask));
     } else {
-        ipc.loadIndexUrl();
+        core.mainWindow.loadURL(page.getPageFullUrl());
     }
 
     core.mainWindow.once('ready-to-show', () => {
@@ -169,12 +174,12 @@ app.on('ready', () => {
 
     core.mainWindow.on('maximize', () => {
         config.maximized = core.mainWindow.isMaximized();
-        ipc.notifyRenderProcessWindowMaximized(core.mainWindow.isMaximized());
+        ipcEvents.notifyRenderProcessWindowMaximized(core.mainWindow.isMaximized());
     });
 
     core.mainWindow.on('unmaximize', () => {
         config.maximized = core.mainWindow.isMaximized();
-        ipc.notifyRenderProcessWindowUnmaximized(core.mainWindow.isMaximized());
+        ipcEvents.notifyRenderProcessWindowUnmaximized(core.mainWindow.isMaximized());
     });
 
     core.mainWindow.on('move', () => {
@@ -216,7 +221,7 @@ app.on('ready', () => {
         core.mainWindow = null;
     });
 
-    ipc.onRenderProcessNewDropFile((event, arg) => {
+    ipcEvents.onRenderProcessNewDropFile((event, arg) => {
         if (!arg) {
             return;
         }
@@ -225,14 +230,14 @@ app.on('ready', () => {
         let location = arg.location;
 
         if (location.indexOf('/new') === 0) {
-            ipc.notifyRenderProcessNewTaskFromFile(filePath);
+            ipcEvents.notifyRenderProcessNewTaskFromFile(filePath);
         } else {
-            ipc.notifyRenderProcessNewNewTaskFromFileAfterViewLoaded(filePath);
-            ipc.notifyRenderProcessNavigateToNewTask();
+            ipcEvents.notifyRenderProcessNewNewTaskFromFileAfterViewLoaded(filePath);
+            ipcEvents.notifyRenderProcessNavigateToNewTask();
         }
     });
 
-    ipc.onRenderProcessNewDropText((event, arg) => {
+    ipcEvents.onRenderProcessNewDropText((event, arg) => {
         if (!arg) {
             return;
         }
@@ -241,10 +246,10 @@ app.on('ready', () => {
         let location = arg.location;
 
         if (location.indexOf('/new') === 0) {
-            ipc.notifyRenderProcessNewTaskFromText(text);
+            ipcEvents.notifyRenderProcessNewTaskFromText(text);
         } else {
-            ipc.notifyRenderProcessNewNewTaskFromTextAfterViewLoaded(text);
-            ipc.notifyRenderProcessNavigateToNewTask();
+            ipcEvents.notifyRenderProcessNewNewTaskFromTextAfterViewLoaded(text);
+            ipcEvents.notifyRenderProcessNavigateToNewTask();
         }
     });
 });