#1 - Refactored code

Signed-off-by: Gregor Anders <gregor.anders@gmail.com>

Author: gregoranders

src/ipc.ts

@@ -1,11 +1,9 @@
 import { ipcMain, ipcRenderer } from "electron";
 
-export const mainChannel: string = "main-channel";
-
-export const renderChannel: string = "render-channel";
-
 export type IPCMessageType = "ping" | "pong";
 
+export type IPCChannel = "main-channel" | "render-channel";
+
 export interface IIPCMessage<T> {
   data: T;
   timestamp: Date;

src/ipcService.ts

@@ -0,0 +1,28 @@
+import * as log from "fancy-log";
+
+import { IIPCMessage, IPCChannel, IPCMessageType } from "./ipc";
+
+export abstract class IpcService<T extends Electron.IpcMainEvent | Electron.IpcRendererEvent> {
+
+  public register(ipc: NodeJS.EventEmitter, channel: string): void {
+    ipc.on(channel, (event: T, ...args: any[]): void => {
+      if (args && args.length === 1) {
+        const ipcMessage: IIPCMessage<any> = args[0];
+        this.handleMessage(event, ipcMessage);
+      } else {
+        log.warn(event, args);
+      }
+    });
+  }
+
+  protected abstract handleMessage<MT>(event: T, message: IIPCMessage<MT>): void;
+
+  protected send<MT>(sender: Electron.WebContents | Electron.IpcRenderer,
+                     channel: IPCChannel, type: IPCMessageType, data: MT): void {
+    sender.send(channel, {
+      data,
+      timestamp: new Date(),
+      type,
+    } as IIPCMessage<MT>);
+  }
+}

src/main.ts

@@ -1,4 +1,4 @@
-import { app, BrowserWindow, dialog, ipcMain, ipcRenderer } from "electron";
+import { app, BrowserWindow, dialog, ipcMain } from "electron";
 
 import { MainService } from "./mainService";
 
@@ -19,24 +19,22 @@ app.whenReady()
       },
     });
 
-    if (browserWindow) {
-      browserWindow.hide();
-      browserWindow.setMenuBarVisibility(false);
-      browserWindow.loadFile(path.join(__dirname, "index.html"))
-        .then((result: void): void => {
-          if (debug) {
-            browserWindow.webContents.openDevTools({
-              mode: "right",
-            });
-          }
-          const service: MainService = new MainService();
-          service.register();
-          browserWindow.show();
-        })
-        .catch((reason: any): void => {
-          dialog.showErrorBox("Error", JSON.stringify(reason));
-        });
-    }
+    browserWindow.hide();
+    browserWindow.setMenuBarVisibility(false);
+    browserWindow.loadFile(path.join(__dirname, "index.html"))
+      .then((result: void): void => {
+        if (debug) {
+          browserWindow.webContents.openDevTools({
+            mode: "right",
+          });
+        }
+        const service: MainService = new MainService();
+        service.register(ipcMain, "main-channel");
+        browserWindow.show();
+      })
+      .catch((reason: any): void => {
+        dialog.showErrorBox("Error", JSON.stringify(reason));
+      });
   }).catch((reason: any): void => {
     log.error(reason);
   });

src/mainService.ts

@@ -1,28 +1,25 @@
+import { ipcMain } from "electron";
+
 import * as log from "fancy-log";
 
-import { ipcMain } from "electron";
+import { IpcService } from "./ipcService";
 
-import { IIPCMessage, IPCMessageType,  mainChannel, renderChannel } from "./ipc";
+import { IIPCMessage } from "./ipc";
 
-export class MainService {
 
-  public register(): void {
-    ipcMain.on(mainChannel, (event: Electron.IpcMainEvent, ...args: any[]): void => {
-      if (args && args.length === 1) {
-        const ipcMessage: IIPCMessage<any> = args[0];
-        this.handleMainChannel(event, ipcMessage);
-      } else {
-        log.warn(event, args);
-      }
-    });
+export class MainService extends IpcService<Electron.IpcMainEvent> {
+
+  public constructor() {
+    super();
+    this.register(ipcMain, "main-channel");
   }
 
-  private handleMainChannel<T>(event: Electron.IpcMainEvent, message: IIPCMessage<T>): void {
+  protected handleMessage<T>(event: Electron.IpcMainEvent, message: IIPCMessage<T>): void {
     switch (message.type) {
       case "ping":
         log.info(message);
-        this.send(event.sender, "pong", message.data);
-        this.send(event.sender, "ping", message.data);
+        this.send(event.sender, "main-channel", "pong", message.data);
+        this.send(event.sender, "main-channel", "ping", message.data);
         break;
       case "pong":
           log.info(message);
@@ -31,12 +28,4 @@ export class MainService {
         log.warn(message);
     }
   }
-
-  private send<T>(sender: Electron.WebContents, type: IPCMessageType, data: T): void {
-    sender.send(renderChannel, {
-      data,
-      timestamp: new Date(),
-      type,
-    } as IIPCMessage<T>);
-  }
 }

src/renderer.tsx

@@ -1,11 +1,13 @@
 import * as React from "react";
 import { render } from "react-dom";
 
+import { ipcRenderer } from "electron";
+
 import { Application } from "./application";
 
 import { RendererService } from "./rendererService";
 
 const service: RendererService = new RendererService();
-service.register();
+service.register(ipcRenderer, "render-channel");
 
 render(<Application service={ service }/>, document.getElementById("content"));

src/rendererService.ts

@@ -1,29 +1,20 @@
-import { ipcMain, ipcRenderer } from "electron";
+import { ipcRenderer } from "electron";
 
-import { IIPCMessage, IPCMessageType, mainChannel, renderChannel } from "./ipc";
+import { IIPCMessage } from "./ipc";
 
-export class RendererService {
+import { IpcService } from "./ipcService";
 
-  public ping(): void {
-    this.send("ping", [1, 2, 3]);
-  }
+export class RendererService extends IpcService<Electron.IpcRendererEvent> {
 
-  public register(): void {
-    ipcRenderer.on(renderChannel, (event: Electron.IpcRendererEvent, ...args: any[]): void => {
-      if (args && args.length === 1) {
-        const ipcMessage: IIPCMessage<any> = args[0];
-        this.handleRenderChannel(event, ipcMessage);
-      } else {
-        console.log(event, args);
-      }
-    });
+  public ping(): void {
+    this.send(ipcRenderer, "render-channel", "ping", [1, 2, 3]);
   }
 
-  private handleRenderChannel<T>(event: Electron.IpcRendererEvent, message: IIPCMessage<T>): void {
+  protected handleMessage<MT>(event: Electron.IpcRendererEvent, message: IIPCMessage<MT>): void {
     switch (message.type) {
       case "ping":
         console.log(message);
-        this.send("pong", message.data);
+        this.send(event.sender, "render-channel", "pong", message.data);
         break;
       case "pong":
         console.log(message);
@@ -32,12 +23,4 @@ export class RendererService {
         console.log(message);
     }
   }
-
-  private send<T>(type: IPCMessageType, data: T): void {
-    ipcRenderer.send(mainChannel, {
-      data,
-      timestamp: new Date(),
-      type,
-    } as IIPCMessage<T>);
-  }
 }