code refactor

app/scripts/controllers/task-detail.js

@@ -86,8 +86,10 @@
             }
 
             if (angular.isUndefined($scope.nativeContext.directoryExists)) {
-                ariaNgNativeElectronService.getLocalFSExists(task.dir, function (exists) {
-                    $scope.nativeContext.directoryExists = exists;
+                ariaNgNativeElectronService.getLocalFSExistsAsync(task.dir, function (exists) {
+                    $scope.$apply(function () {
+                        $scope.nativeContext.directoryExists = exists;
+                    });
                 });
             }
 

app/scripts/core/root.js

@@ -172,7 +172,7 @@
                 var file = getDropFile(e.originalEvent);
 
                 if (file) {
-                    ariaNgNativeElectronService.sendNewDropFileMessageToMainProcess({
+                    ariaNgNativeElectronService.notifyMainProcessorNewDropFile({
                         filePath: file.path,
                         location: $location.url()
                     });
@@ -182,7 +182,7 @@
                 var text = getDropText(e.originalEvent);
 
                 if (text) {
-                    ariaNgNativeElectronService.sendNewDropTextMessageToMainProcess({
+                    ariaNgNativeElectronService.notifyMainProcessorNewDropText({
                         text: text,
                         location: $location.url()
                     });
@@ -599,7 +599,7 @@
         });
 
         $rootScope.$on('$viewContentLoaded', function () {
-            ariaNgNativeElectronService.sendViewLoadedMessageToMainProcess($location.path());
+            ariaNgNativeElectronService.notifyMainProcessViewLoaded($location.path());
         });
 
         $rootScope.$on('$translateChangeSuccess', function(event, current, previous) {

app/scripts/services/ariaNgNativeElectronService.js

@@ -133,7 +133,7 @@
             readPackageFile: function (path) {
                 return invokeSyncMainProcessMethod('render-sync-get-package-file-content', path);
             },
-            getLocalFSExists: function (fullpath, callback) {
+            getLocalFSExistsAsync: function (fullpath, callback) {
                 return invokeAsyncMainProcessMethod('render-get-localfs-exists', fullpath)
                     .then(function onReceive(exists) {
                         if (callback) {
@@ -152,38 +152,38 @@
 
                 return info;
             },
+            notifyMainProcessViewLoaded: function (locationPath) {
+                invokeMainProcessMethod('on-render-view-content-loaded', locationPath);
+            },
+            notifyMainProcessorNewDropFile: function (message) {
+                invokeMainProcessMethod('on-render-new-drop-file', message);
+            },
+            notifyMainProcessorNewDropText: function (message) {
+                invokeMainProcessMethod('on-render-new-drop-text', message);
+            },
             onMainWindowMaximize: function (callback) {
                 onMainProcessEvent('on-main-window-maximized', callback);
             },
             onMainWindowUnmaximize: function (callback) {
                 onMainProcessEvent('on-main-window-unmaximized', callback);
             },
-            onMainProcessNavigateTo: function (callback) {
-                onMainProcessEvent('navigate-to', callback);
-            },
             onMainProcessShowError: function (callback) {
-                onMainProcessEvent('show-error', callback);
+                onMainProcessEvent('on-main-show-error', callback);
+            },
+            onMainProcessNavigateTo: function (callback) {
+                onMainProcessEvent('on-main-navigate-to', callback);
             },
             onMainProcessNewTaskFromFile: function (callback) {
-                onMainProcessEvent('new-task-from-file', callback);
+                onMainProcessEvent('on-main-new-task-from-file', callback);
             },
             onMainProcessNewTaskFromText: function (callback) {
-                onMainProcessEvent('new-task-from-text', callback);
+                onMainProcessEvent('on-main-new-task-from-text', callback);
             },
             removeMainProcessNewTaskFromFileCallback: function (callback) {
-                removeMainProcessEvent('new-task-from-file', callback);
+                removeMainProcessEvent('on-main-new-task-from-file', callback);
             },
             removeMainProcessNewTaskFromTextCallback: function (callback) {
-                removeMainProcessEvent('new-task-from-text',  callback);
-            },
-            sendViewLoadedMessageToMainProcess: function (message) {
-                invokeMainProcessMethod('view-content-loaded', message);
-            },
-            sendNewDropFileMessageToMainProcess: function (message) {
-                invokeMainProcessMethod('new-drop-file', message);
-            },
-            sendNewDropTextMessageToMainProcess: function (message) {
-                invokeMainProcessMethod('new-drop-text', message);
+                removeMainProcessEvent('on-main-new-task-from-text',  callback);
             }
         };
     }]);

main/ipc.js

@@ -22,6 +22,20 @@ const supportedFileExtensions = {
     '.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',
@@ -38,49 +52,35 @@ let loadNewTaskUrl = function () {
     core.mainWindow.loadURL(getIndexUrl() + '#!/new');
 };
 
-let navigateTo = function (routeUrl) {
-    core.mainWindow.webContents.send('navigate-to', routeUrl);
+let notifyRenderProcessWindowMaximized = function (maximized) {
+    core.mainWindow.webContents.send('on-main-window-maximized', maximized);
 };
 
-let navigateToNewTask = function () {
-    navigateTo('/new');
+let notifyRenderProcessWindowUnmaximized = function (maximized) {
+    core.mainWindow.webContents.send('on-main-window-unmaximized', maximized);
 };
 
-let navigateToAriaNgSettings = function () {
-    navigateTo('/settings/ariang');
+let notifyRenderProcessShowErrorMessage = function (message) {
+    core.mainWindow.webContents.send('on-main-show-error', message);
 };
 
-let showErrorMessage = function (message) {
-    core.mainWindow.webContents.send('show-error', message);
+let notifyRenderProcessNavigateToPath = function (routeUrl) {
+    core.mainWindow.webContents.send('on-main-navigate-to', routeUrl);
 };
 
-let onNewDropFile = function (callback) {
-    ipcMain.on('new-drop-file', callback);
+let notifyRenderProcessNavigateToNewTask = function () {
+    notifyRenderProcessNavigateToPath('/new');
 };
 
-let onNewDropText = function (callback) {
-    ipcMain.on('new-drop-text', callback);
+let notifyRenderProcessNavigateToAriaNgSettings = function () {
+    notifyRenderProcessNavigateToPath('/settings/ariang');
 };
 
-let isContainsSupportedFileArg = function (arg) {
-    if (!arg) {
-        return false;
-    }
-
-    let fileExtension = path.extname(arg);
-
-    if (!supportedFileExtensions[fileExtension]) {
-        return false;
-    }
-
-    return fs.existsSync(arg);
-};
-
-let newTaskFromFile = function (filePath, async) {
+let notifyRenderProcessNewTaskFromFile = function (filePath, async) {
     let fileExtension = path.extname(filePath);
 
     if (!supportedFileExtensions[fileExtension]) {
-        showErrorMessage('The selected file type is invalid!');
+        notifyRenderProcessShowErrorMessage('The selected file type is invalid!');
         return;
     }
 
@@ -101,45 +101,45 @@ let newTaskFromFile = function (filePath, async) {
         }
     }
 
-    core.mainWindow.webContents.send('new-task-from-file', result);
+    core.mainWindow.webContents.send('on-main-new-task-from-file', result);
 };
 
-let asyncNewTaskFromFile = function (filePath) {
-    if (!filePath) {
-        return;
-    }
-
-    ipcMain.once('view-content-loaded', (event, arg) => {
-        newTaskFromFile(filePath, true);
-    });
-};
-
-let newTaskFromText = function (text, async) {
+let notifyRenderProcessNewTaskFromText = function (text, async) {
     let result = {
         text: text,
         async: !!async
     };
 
-    core.mainWindow.webContents.send('new-task-from-text', result);
+    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 asyncNewTaskFromText = function (text) {
+let notifyRenderProcessNewNewTaskFromTextAfterViewLoaded = function (text) {
     if (!text) {
         return;
     }
 
-    ipcMain.once('view-content-loaded', (event, arg) => {
-        newTaskFromText(text, true);
+    ipcMain.once('on-render-view-content-loaded', (event, arg) => {
+        notifyRenderProcessNewTaskFromText(text, true);
     });
 };
 
-let notifyRenderProcessWindowMaximizedAsync = function (maximized) {
-    core.mainWindow.webContents.send('on-main-window-maximized', maximized);
-}
+let onRenderProcessNewDropFile = function (callback) {
+    ipcMain.on('on-render-new-drop-file', callback);
+};
 
-let notifyRenderProcessWindowUnmaximizedAsync = function (maximized) {
-    core.mainWindow.webContents.send('on-main-window-unmaximized', maximized);
-}
+let onRenderProcessNewDropText = function (callback) {
+    ipcMain.on('on-render-new-drop-text', callback);
+};
 
 ipcMain.on('render-sync-get-runtime-environment', (event) => {
     if (!process || !process.versions) {
@@ -256,21 +256,18 @@ ipcMain.on('render-sync-parse-bittorrent-info', (event, data) => {
 });
 
 module.exports = {
-    notifyRenderProcessWindowMaximizedAsync: notifyRenderProcessWindowMaximizedAsync,
-    notifyRenderProcessWindowUnmaximizedAsync: notifyRenderProcessWindowUnmaximizedAsync,
-
-
-
+    isContainsSupportedFileArg: isContainsSupportedFileArg,
     loadIndexUrl: loadIndexUrl,
     loadNewTaskUrl: loadNewTaskUrl,
-    navigateToNewTask: navigateToNewTask,
-    navigateToAriaNgSettings: navigateToAriaNgSettings,
-    showErrorMessage: showErrorMessage,
-    onNewDropFile: onNewDropFile,
-    onNewDropText: onNewDropText,
-    isContainsSupportedFileArg: isContainsSupportedFileArg,
-    newTaskFromFile: newTaskFromFile,
-    asyncNewTaskFromFile: asyncNewTaskFromFile,
-    newTaskFromText: newTaskFromText,
-    asyncNewTaskFromText: asyncNewTaskFromText
+    notifyRenderProcessWindowMaximized: notifyRenderProcessWindowMaximized,
+    notifyRenderProcessWindowUnmaximized: notifyRenderProcessWindowUnmaximized,
+    notifyRenderProcessShowErrorMessage: notifyRenderProcessShowErrorMessage,
+    notifyRenderProcessNavigateToNewTask: notifyRenderProcessNavigateToNewTask,
+    notifyRenderProcessNavigateToAriaNgSettings: notifyRenderProcessNavigateToAriaNgSettings,
+    notifyRenderProcessNewTaskFromFile: notifyRenderProcessNewTaskFromFile,
+    notifyRenderProcessNewTaskFromText: notifyRenderProcessNewTaskFromText,
+    notifyRenderProcessNewNewTaskFromFileAfterViewLoaded: notifyRenderProcessNewNewTaskFromFileAfterViewLoaded,
+    notifyRenderProcessNewNewTaskFromTextAfterViewLoaded: notifyRenderProcessNewNewTaskFromTextAfterViewLoaded,
+    onRenderProcessNewDropFile: onRenderProcessNewDropFile,
+    onRenderProcessNewDropText: onRenderProcessNewDropText
 };

main/main.js

@@ -92,8 +92,8 @@ app.on('second-instance', (event, argv, workingDirectory, additionalData) => {
         }
 
         if (filePath && ipc.isContainsSupportedFileArg(filePath)) {
-            ipc.asyncNewTaskFromFile(filePath);
-            ipc.navigateToNewTask();
+            ipc.notifyRenderProcessNewNewTaskFromFileAfterViewLoaded(filePath);
+            ipc.notifyRenderProcessNavigateToNewTask();
         }
     }
 });
@@ -151,7 +151,7 @@ app.on('ready', () => {
     tray.init();
 
     if (ipc.isContainsSupportedFileArg(filePathInCommandLine)) {
-        ipc.asyncNewTaskFromFile(filePathInCommandLine);
+        ipc.notifyRenderProcessNewNewTaskFromFileAfterViewLoaded(filePathInCommandLine);
         ipc.loadNewTaskUrl();
     } else {
         ipc.loadIndexUrl();
@@ -169,12 +169,12 @@ app.on('ready', () => {
 
     core.mainWindow.on('maximize', () => {
         config.maximized = core.mainWindow.isMaximized();
-        ipc.notifyRenderProcessWindowMaximizedAsync(core.mainWindow.isMaximized());
+        ipc.notifyRenderProcessWindowMaximized(core.mainWindow.isMaximized());
     });
 
     core.mainWindow.on('unmaximize', () => {
         config.maximized = core.mainWindow.isMaximized();
-        ipc.notifyRenderProcessWindowUnmaximizedAsync(core.mainWindow.isMaximized());
+        ipc.notifyRenderProcessWindowUnmaximized(core.mainWindow.isMaximized());
     });
 
     core.mainWindow.on('move', () => {
@@ -216,7 +216,7 @@ app.on('ready', () => {
         core.mainWindow = null;
     });
 
-    ipc.onNewDropFile((event, arg) => {
+    ipc.onRenderProcessNewDropFile((event, arg) => {
         if (!arg) {
             return;
         }
@@ -225,14 +225,14 @@ app.on('ready', () => {
         let location = arg.location;
 
         if (location.indexOf('/new') === 0) {
-            ipc.newTaskFromFile(filePath);
+            ipc.notifyRenderProcessNewTaskFromFile(filePath);
         } else {
-            ipc.asyncNewTaskFromFile(filePath);
-            ipc.navigateToNewTask();
+            ipc.notifyRenderProcessNewNewTaskFromFileAfterViewLoaded(filePath);
+            ipc.notifyRenderProcessNavigateToNewTask();
         }
     });
 
-    ipc.onNewDropText((event, arg) => {
+    ipc.onRenderProcessNewDropText((event, arg) => {
         if (!arg) {
             return;
         }
@@ -241,10 +241,10 @@ app.on('ready', () => {
         let location = arg.location;
 
         if (location.indexOf('/new') === 0) {
-            ipc.newTaskFromText(text);
+            ipc.notifyRenderProcessNewTaskFromText(text);
         } else {
-            ipc.asyncNewTaskFromText(text);
-            ipc.navigateToNewTask();
+            ipc.notifyRenderProcessNewNewTaskFromTextAfterViewLoaded(text);
+            ipc.notifyRenderProcessNavigateToNewTask();
         }
     });
 });

main/menu.js

@@ -25,7 +25,7 @@ let buildMenu = function(context) {
                 {
                     label: getMenuTitle(context, 'AboutAriaNgNative', 'About AriaNg Native'),
                     click: function () {
-                        ipc.navigateToAriaNgSettings();
+                        ipc.notifyRenderProcessNavigateToAriaNgSettings();
                     }
                 },
                 {