merged origin/main into main

crash.log

@@ -0,0 +1,4 @@
+PID 335844 received SIGSEGV for address: 0xc
+/home/enrique/Developer/electron-app/node_modules/segfault-handler/build/Release/segfault-handler.node(+0x37a5)[0x7f1c071387a5]
+/lib/x86_64-linux-gnu/libpthread.so.0(+0x153c0)[0x7f1c10ffa3c0]
+/home/enrique/Developer/electron-app/node_modules/electron/dist/electron dist_electron(+0x72d9550)[0x55ccd61fe550]

src/background.ts

@@ -1,27 +1,24 @@
-"use strict";
-import {initApp} from './background/initApp';
-import {Recorder} from './background/recorder';
-const portAudio = require('naudiodon');
+/*
+ * Entry point for Crimata electron app.
+ * "Look on my Works, ye Mighty, and despair!"
+ */
 
+"use strict";
+import { protocol } from "electron";
+import { initApp } from './background/initApp';
+
+// Scheme must be registered before the app is ready
+protocol.registerSchemesAsPrivileged([
+    { scheme: "app", privileges: { secure: true, standard: true } }
+]);
+
+// Load environment variable
+const isDevelopment = process.env.NODE_ENV !== "production";
 
 // NOTE Program Begins Here
 (async () => {
 
-    const isDevelopment = process.env.NODE_ENV !== "production";
-
-    const recorder = new Recorder({
-        channelCount: 1,
-        sampleFormat: portAudio.SampleFormat16Bit,
-        sampleRate: 16000,
-        deviceId: -1, // Use -1 or omit the deviceId to select the default device
-        closeOnError: true
-    }, 'binary');
-
-    try {
-        // await authenticate method
-        initApp(isDevelopment);
-    } catch (e) {
-        console.log("Error", e);
-    }
+    console.log('Starting Crimata electron app.');
+    initApp(isDevelopment);
 
 })();

src/background/createWindow.ts

@@ -0,0 +1,38 @@
+"use strict";
+
+import { BrowserWindow } from "electron";
+import { createProtocol } from "vue-cli-plugin-electron-builder/lib";
+import * as path from "path";
+
+export function createWindow(options: {
+    width: number;
+    height: number;
+    resizable: boolean;
+}): BrowserWindow {
+
+  const win: BrowserWindow = new BrowserWindow({
+    width: options.width,
+    height: options.height,
+    resizable: options.resizable,
+    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);
+  } else {
+    createProtocol("app");
+    // Load the index.html when not in development
+    win.loadURL("app://./index.html");
+  }
+
+  return win;
+}
+
+

src/background/initApp.ts

@@ -1,94 +1,38 @@
 "use strict";
 
-import { app, protocol, BrowserWindow } 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";
+import { app } from "electron";
+import { main } from './run';
+import { windowEmitter } from './windowEmitter';
 
-let win: BrowserWindow | null;
+export function initApp(dev: boolean): void {
 
-function createWindow() {
-  // Create the browser window.
-  win = new BrowserWindow({
-    width: 350,
-    height: 500,
-    resizable: true,
+    let winActive: boolean;
 
-    x: 10,
-    y: 10,
+    windowEmitter.on('window-active', (state: boolean) => {
+        winActive =  state;
+    });
 
-    webPreferences: {
-      devTools: false,
-      // 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();
+    app.on("ready", () => {
+      main();
     });
 
     // 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();
       }
     });
 
+    // TODO: Debug activate functionaity: currently not working.
+    // Might have to de-reference window object
     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();
+      if (winActive === false) {
+        main();
       }
     });
 
     // Exit cleanly on request from parent process in development mode.
-    if (isDev) {
+    if (dev) {
       if (process.platform === "win32") {
         process.on("message", data => {
           if (data === "graceful-exit") {

src/background/recorder.ts

@@ -4,13 +4,20 @@ 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 {
   stop(): string;
   pause(): void;
 }
 
+type inputOptions = {
+    channelCount: number;
+    sampleFormat: number;
+    sampleRate: number;
+    deviceId: number;
+    closeOnError: boolean;
+}
+
 class StringWritable extends Writable {
 
   constructor(options: {
@@ -37,15 +44,6 @@ class StringWritable extends Writable {
    }
 }
 
-type inputOptions = {clear;
-
-    channelCount: number;
-    sampleFormat: string;
-    sampleRate: number;
-    deviceId: number;
-    closeOnError: boolean;
-}
-
 export class Recorder implements RecorderI {
 
   private ia: any;
@@ -56,16 +54,21 @@ export class Recorder implements RecorderI {
     this.recorderOptions = options;
     this.micWritable = new StringWritable({
         defaultEncoding: encoding
-    })
-    this.restart();
-    ipcMain.on('update-recorder', this._update);
+    });
+    try {
+        this.start();
+    } catch(e) {
+        console.log('RECORDER ERROR!', e);
+    }
   }
 
-  restart() {
+  private start(): void {
     this.ia = new portAudio.AudioIO({
       inOptions: this.recorderOptions
     });
-    this._start();
+    this.ia.pipe(this.micWritable);
+    this.ia.start();
+    this.pause();
   }
 
   pause(): void {
@@ -77,37 +80,13 @@ export class Recorder implements RecorderI {
   }
 
   getData(): string {
-    return this.micWritable.data;
+    const data = this.micWritable.data;
+    this.micWritable.data = '';
+    return data;
   }
 
   stop(): string {
     this.ia.quit();
     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');
-          })
-      }
-  }
 }

src/background/run.ts

@@ -0,0 +1,83 @@
+import { createWindow } from './createWindow';
+import WebSocket from 'ws';
+import { Recorder } from './recorder';
+import { ipcMain, BrowserWindow } from "electron";
+import { windowEmitter } from './windowEmitter';
+
+/*
+ * The main function will be run after electron app is ready.
+ */
+export function main(): void {
+
+    // create main window.
+    let win: BrowserWindow | null;
+    win = createWindow({ width: 350, height: 525, resizable: false });
+
+    // Instantiate ws session with crimata-platorm.
+    const ws = new WebSocket('ws://localhost:8080');
+
+    // Instantiate portAudio recorder.
+    const recorder = new Recorder({
+        channelCount: 1,
+        sampleFormat: 16,
+        sampleRate: 16000,
+        deviceId: -1,
+        closeOnError: false,
+    }, 'binary');
+
+    const initSession = (): void => {
+        ws.send('hernandeze2@xavier.edu');
+    }
+
+    const sendMessage = (Event: any, payload: any): void => {
+        ws.send(JSON.stringify(payload));
+    }
+
+    const sendAudio = (data: string): void => {
+        ws.send(data);
+    }
+
+    const receiveMessage = (message: string): void => {
+      // NOTE assuming message is JSON string
+      const parsed = JSON.parse(message);
+      win.webContents.send('render-message', {
+        message: parsed
+      });
+    }
+
+    const updateRecorder = (Event: any, record: boolean): void => {
+      if (record) {
+          recorder.resume();
+      } else {
+          recorder.pause();
+          const data = recorder.getData();
+          sendAudio(data);
+      }
+    }
+
+    const windowMount = (): void => {
+        console.log('testing mount');
+        // ipc event handlers
+        windowEmitter.emit('window-active', true);
+        ipcMain.on('update-recorder', updateRecorder);
+        ipcMain.on('send-message', sendMessage);
+    }
+
+    const windowDismount = (): void => {
+        console.log('testing dismount');
+        // TODO: Gracefully close ws connection
+         win = null;
+         windowEmitter.emit('window-active', false);
+         ipcMain.removeListener('update-recorder', updateRecorder);
+         ipcMain.removeListener('send-message', sendMessage);
+    }
+
+    // ws handlers
+    ws.on('connect', initSession);
+    ws.on("message", receiveMessage);
+
+    // Handle window mount and dismount.
+    win.webContents.on('did-finish-load', windowMount);
+    win.on("closed", windowDismount);
+
+}

src/background/windowEmitter.ts

@@ -0,0 +1,5 @@
+const EventEmitter = require('events');
+
+class WindowEmitter extends EventEmitter {}
+
+export const windowEmitter = new WindowEmitter();