dexie added

src/commons/model/index.ts

@@ -0,0 +1 @@
+export * from './launch-state';

src/commons/model/launch-state.ts

@@ -0,0 +1,20 @@
+/** The timing stats for app launch. */
+export interface LaunchState {
+  /**
+   * The time (in milliseconds) it takes from when our main process code is
+   * first loaded until the app `ready` event is emitted.
+   */
+  readonly mainReadyTime: number
+
+  /**
+   * The time (in milliseconds) it takes from when loading begins to loading
+   * end.
+   */
+  readonly loadTime: number
+
+  /**
+   * The time (in milliseconds) it takes from when our renderer process code is
+   * first loaded until the renderer `ready` event is emitted.
+   */
+  readonly rendererReadyTime: number
+}

src/commons/service/database.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import Dexie from 'dexie';
+import { LaunchState } from '../model';
+
+const DatabaseVersion = 1;
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DatabaseService extends Dexie {
+
+  public launches!: Dexie.Table<LaunchState, number>
+
+
+  public constructor() {
+    super('overflow-scanner');
+    this.version(1).stores({
+      launches: '++',
+    });
+
+  }
+
+}

src/commons/service/electron-proxy.service.ts

@@ -1,13 +1,48 @@
 import { Injectable } from '@angular/core';
-import { Observable } from 'rxjs';
-
+import { Observable, of } from 'rxjs';
+import { catchError, exhaustMap, map, tap, take } from 'rxjs/operators';
+import { Store } from '@ngrx/store';
 import { ipcRenderer } from 'electron';
 
-@Injectable()
+import { MenuEvent } from '../type';
+import { LaunchState } from '../model';
+import { LaunchService } from './launch.service';
+
+@Injectable({
+  providedIn: 'root'
+})
 export class ElectronProxyService {
 
   public constructor(
+    private store: Store<any>,
+    private launchService: LaunchService,
   ) {
+    this.bindIPCRenderer();
+  }
+
+  private bindIPCRenderer(): void {
+    ipcRenderer.on('menu-event',
+      (event: Electron.IpcMessageEvent, { name }: { name: MenuEvent }) => {
+
+      }
+    );
+
+    ipcRenderer.on('launch-timing-stats',
+      (event: Electron.IpcMessageEvent, { state }: { state: LaunchState }) => {
+        console.info(`App ready time: ${state.mainReadyTime}ms`)
+        console.info(`Load time: ${state.loadTime}ms`)
+        console.info(`Renderer ready time: ${state.rendererReadyTime}ms`)
+
+        this.launchService.save(state).pipe(
+          map((id: number) => {
+          }),
+          catchError(error => {
+            return of();
+          }),
+          take(1),
+        ).subscribe();
+      }
+    )
   }
 
   public sendReady(time: number): void {

src/commons/service/index.ts

@@ -1,5 +1,9 @@
+import { DatabaseService } from './database.service';
 import { ElectronProxyService } from './electron-proxy.service';
+import { LaunchService } from './launch.service';
 
 export const SERVICES = [
+  DatabaseService,
   ElectronProxyService,
+  LaunchService,
 ];

src/commons/service/launch.service.ts

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import { Observable, defer } from 'rxjs';
+
+import { DatabaseService } from './database.service';
+import { LaunchState } from '../model';
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class LaunchService {
+
+  public constructor(
+    private readonly databaseService: DatabaseService,
+  ) {
+  }
+
+  public save(launchState: LaunchState): Observable<number> {
+    return defer(async () => {
+      return await this.databaseService.launches.add(launchState);
+    });
+  }
+
+}

src/electron/app-window.ts

@@ -11,7 +11,8 @@ import { registerWindowStateChangedEvents } from '@overflow/core/window-state';
 import { URLActionType } from '@overflow/core/parse-app-url';
 import { now } from '@overflow/core/now';
 
-import { MenuEvent } from './menu';
+import { MenuEvent } from '../commons/type';
+import { LaunchState } from '../commons/model';
 
 let windowStateKeeper: any | null = null;
 
@@ -217,9 +218,9 @@ export class AppWindow {
   }
 
   /** Send the app launch timing stats to the renderer. */
-  // public sendLaunchTimingStats(stats: ILaunchStats) {
-  //   this.window.webContents.send('launch-timing-stats', { stats });
-  // }
+  public sendLaunchTimingStats(state: LaunchState) {
+    this.window.webContents.send('launch-timing-stats', { state });
+  }
 
   /** Send the app menu to the renderer. */
   // public sendAppMenu() {

src/electron/main.ts

@@ -27,7 +27,7 @@ let readyTime: number | null = null;
 
 type OnDidLoadFn = (window: AppWindow) => void;
 /** See the `onDidLoad` function. */
-const onDidLoadFns: Array<OnDidLoadFn> | null = [];
+let onDidLoadFns: Array<OnDidLoadFn> | null = [];
 
 function handleUncaughtException(error: Error) {
   preventQuit = true;
@@ -428,17 +428,17 @@ function createWindow() {
 
   window.onDidLoad((data: any) => {
     window.show();
-    // window.sendLaunchTimingStats({
-    //   mainReadyTime: readyTime!,
-    //   loadTime: window.loadTime!,
-    //   rendererReadyTime: window.rendererReadyTime!,
-    // });
+    window.sendLaunchTimingStats({
+      mainReadyTime: readyTime!,
+      loadTime: window.loadTime!,
+      rendererReadyTime: window.rendererReadyTime!,
+    });
 
-    // const fns = onDidLoadFns!;
-    // onDidLoadFns = null;
-    // for (const fn of fns) {
-    //   fn(window);
-    // }
+    let fns = onDidLoadFns!;
+    onDidLoadFns = null;
+    for (const fn of fns) {
+      fn(window);
+    }
   });
 
   window.load();