refactor background.ts

src/background.ts

@@ -1,137 +1,27 @@
 "use strict";
+import {initApp} from './background/initApp';
+import {Recorder} from './background/recorder';
+var portAudio = require('naudiodon');
 
-import { app, protocol, BrowserWindow, ipcMain } from "electron";
-import { createProtocol } from "vue-cli-plugin-electron-builder/lib";
-import installExtension, { VUEJS_DEVTOOLS } from "electron-devtools-installer";
-const isDevelopment = process.env.NODE_ENV !== "production";
-import * as path from "path";
-const fs = require('fs');
-import WebSocket from "ws";
-const portAudio = require('naudiodon');
 
-// const ai = new portAudio.AudioIO({
+// NOTE Program Begins Here
-//   inOptions: audioOptions
+(async () => {
-// });
-//ai.pipe();
-// ai.start();
 
-// Keep a global reference of the window object, if you don't, the window will
+    const isDevelopment = process.env.NODE_ENV !== "production";
-// be closed automatically when the JavaScript object is garbage collected.
-let win: BrowserWindow | null;
 
-// Scheme must be registered before the app is ready
+    const recorder = new Recorder({
-protocol.registerSchemesAsPrivileged([
+        channelCount: 1,
-  { scheme: "app", privileges: { secure: true, standard: true } }
+        sampleFormat: portAudio.SampleFormat16Bit,
-]);
+        sampleRate: 16000,
+        deviceId: -1, // Use -1 or omit the deviceId to select the default device
+        closeOnError: true
+    }, 'binary');
 
-function createWindow() {
-  // Create the browser window.
-  win = new BrowserWindow({
-    width: 450,
-    height: 1025,
-    resizable: true,
-    webPreferences: {
-      // Use pluginOptions.nodeIntegration, leave this alone
-      // See nklayman.github.io/vue-cli-plugin-electron-builder/guide/security.html#node-integration for more info
-      nodeIntegration: (process.env
-        .ELECTRON_NODE_INTEGRATION as unknown) as boolean,
-      preload: path.join(__dirname, "preload.js")
-    }
-  });
-
-  if (process.env.WEBPACK_DEV_SERVER_URL) {
-    // Load the url of the dev server if in development mode
-    win.loadURL(process.env.WEBPACK_DEV_SERVER_URL as string);
-    // NOTE uncomment for dev tools on app launch
-    if (!process.env.IS_TEST) win.webContents.openDevTools();
-  } else {
-    createProtocol("app");
-    // Load the index.html when not in development
-    win.loadURL("app://./index.html");
-  }
-
-  win.webContents.on('did-finish-load', () => {
-
-    const ws = new WebSocket("ws://localhost:8080");
-    ws.on("open", function open() {
-      // ws.send("hernandeze2@xavier.edu");
-    });
-    ws.on("message", (message: any) => {
-      const parsed = JSON.parse(message);
-      console.log('new message', message)
-      if (win) {
-        win.webContents.send('render-message', {
-          message: parsed
-        })
-      }
-    });
-
-    ipcMain.on('update-menu-bar', (Event: any, payload: any) => {
-    // win.setTitle("Listening...");
-    })
-
-    ipcMain.on('send-message', (Event: any, payload: any) => {
-      ws.send(JSON.stringify(payload));
-      // win.setTitle("Listening...");
-    })
-
-    ipcMain.on('update-recorder', (Event: any, record: boolean) => {
-     if (record) {
-       // start recording
-     } else {
-       // stop recording
-     }
-    })
-  })
-
-  win.on("closed", () => {
-    win = null;
-  });
-}
-
-// Quit when all windows are closed.
-app.on("window-all-closed", () => {
-  // On macOS it is common for applications and their menu bar
-  // to stay active until the user quits explicitly with Cmd + Q
-  if (process.platform !== "darwin") {
-    app.quit();
-  }
-});
-
-app.on("activate", () => {
-  // On macOS 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 (win === null) {
-    createWindow();
-  }
-});
-
-// 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.
-app.on("ready", async () => {
-  if (isDevelopment && !process.env.IS_TEST) {
-    // Install Vue Devtools
     try {
-      await installExtension(VUEJS_DEVTOOLS);
+        // await authenticate method
+        initApp(isDevelopment);
     } catch (e) {
-      console.error("Vue Devtools failed to install:", e.toString());
+        console.log("Error", e);
     }
-  }
-  createWindow();
-});
 
-// Exit cleanly on request from parent process in development mode.
+})();
-if (isDevelopment) {
-  if (process.platform === "win32") {
-    process.on("message", data => {
-      if (data === "graceful-exit") {
-        app.quit();
-      }
-    });
-  } else {
-    process.on("SIGTERM", () => {
-      app.quit();
-    });
-  }
-}

src/background/initApp.ts

@@ -0,0 +1,100 @@
+"use strict";
+
+import { app, protocol, BrowserWindow, ipcMain } from "electron";
+import { createProtocol } from "vue-cli-plugin-electron-builder/lib";
+import installExtension, { VUEJS_DEVTOOLS } from "electron-devtools-installer";
+import { createProtocol } from "vue-cli-plugin-electron-builder/lib";
+import * as path from "path";
+
+var win: BrowserWindow | null;
+
+function createWindow() {
+  // Create the browser window.
+  win = new BrowserWindow({
+    width: 450,
+    height: 1025,
+    resizable: true,
+    webPreferences: {
+      // Use pluginOptions.nodeIntegration, leave this alone
+      // See nklayman.github.io/vue-cli-plugin-electron-builder/guide/security.html#node-integration for more info
+      nodeIntegration: (process.env
+        .ELECTRON_NODE_INTEGRATION as unknown) as boolean,
+      preload: path.join(__dirname, "preload.js")
+    }
+  });
+
+  if (process.env.WEBPACK_DEV_SERVER_URL) {
+    // Load the url of the dev server if in development mode
+    win.loadURL(process.env.WEBPACK_DEV_SERVER_URL as string);
+    // NOTE uncomment for dev tools on app launch
+    if (!process.env.IS_TEST) win.webContents.openDevTools();
+  } else {
+    createProtocol("app");
+    // Load the index.html when not in development
+    win.loadURL("app://./index.html");
+  }
+
+  win.webContents.on('did-finish-load', () => {
+      // do stuff once window has finished loading
+  })
+
+  win.on("closed", () => {
+    win = null;
+  });
+}
+
+export function initApp(isDev: boolean){
+
+    // Scheme must be registered before the app is ready
+    protocol.registerSchemesAsPrivileged([
+      { scheme: "app", privileges: { secure: true, standard: true } }
+    ]);
+
+    // 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.
+    app.on("ready", async () => {
+      if (isDev && !process.env.IS_TEST) {
+        // Install Vue Devtools
+        try {
+          await installExtension(VUEJS_DEVTOOLS);
+        } catch (e) {
+          console.error("Vue Devtools failed to install:", e.toString());
+        }
+      }
+      createWindow();
+    });
+
+    // Quit when all windows are closed.
+    app.on("window-all-closed", () => {
+      // On macOS it is common for applications and their menu bar
+      // to stay active until the user quits explicitly with Cmd + Q
+      if (process.platform !== "darwin") {
+        app.quit();
+      }
+    });
+
+    app.on("activate", () => {
+      // On macOS 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 (win === null) {
+        createWindow();
+      }
+    });
+
+    // Exit cleanly on request from parent process in development mode.
+    if (isDev) {
+      if (process.platform === "win32") {
+        process.on("message", data => {
+          if (data === "graceful-exit") {
+            app.quit();
+          }
+        });
+      } else {
+        process.on("SIGTERM", () => {
+          app.quit();
+        });
+      }
+    }
+}
+

src/background/recorder.ts

@@ -4,10 +4,11 @@ const portAudio = require('naudiodon');
 const { Writable } = require('stream');
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const { StringDecoder } = require('string_decoder');
+import { ipcMain } from "electron";
 
 interface RecorderI {
-  start(): void;
   stop(): string;
+  pause(): void;
 }
 
 class StringWritable extends Writable {
@@ -25,55 +26,88 @@ class StringWritable extends Writable {
        chunk = this._decoder.write(chunk);
      }
      this.data += chunk;
+     console.log('writing');
      callback();
    }
 
    _final(callback: (error? : Error) => void) {
+     console.log('yayayay');
      this.data += this._decoder.end();
      callback();
    }
+}
 
+type inputOptions = {clear
+
+    channelCount: number,
+    sampleFormat: string,
+    sampleRate: number,
+    deviceId: number,
+    closeOnError: boolean
 }
 
 export class Recorder implements RecorderI {
-  
+
   private ia: any;
   private micWritable: StringWritable;
+  private recorderOptions: inputOptions;
 
-  constructor(options: {
+  constructor(options: inputOptions, encoding: string) {
-
+    this.recorderOptions = options;
-  }) { 
-    this.ia = new portAudio.AudioIO({ 
-      inOptions: options
-    });   
     this.micWritable = new StringWritable({
-      defaultEncoding: 'binary'
+        defaultEncoding: encoding
+    })
+    this.restart();
+    ipcMain.on('update-recorder', this._update);
+  }
+
+  restart() {
+    this.ia = new portAudio.AudioIO({
+      inOptions: this.recorderOptions
     });
-    this.start();
+    this._start();
-  }
-
-  start(): void {
-    console.log('inititate recording');
-    this.ia.pipe(this.micWritable);
-    this.ia.start();
-    this.ia.pause();
-  }
-
-  record(): void {
-    this.ia.resume();
   }
 
   pause(): void {
      this.ia.pause();
   }
 
+  resume(){
+      this.ia.resume();
+  }
+
   getData(): string {
     return this.micWritable.data;
   }
 
   stop(): string {
     this.ia.quit();
-    return this.micWritable.data;
+    return this.getData();
   }
 
+  private _start(): void {
+    this.ia.pipe(this.micWritable);
+    this.ia.start();
+    this.pause();
+  }
+
+  private _update = (Event: any, record: boolean) => {
+      if (record) {
+          console.log('recording');
+          this.micWritable.data = '';
+          if(this.ia._readableState.paused){
+            this.resume();
+            return;
+          }
+          this.ia.pipe(this.micWritable);
+
+          console.log(this.ia._readableState.paused);
+      } else {
+          console.log('stop recording');
+          this.ia.unpipe(this.micWritable);
+          this.micWritable.on('finish', () => {
+              console.log('hello');
+          })
+      }
+  }
 }