Introduce abstractions for electron application events

Signed-off-by: Janne Savolainen <janne.savolainen@live.fi>

src/main/app-paths/get-electron-app-path/get-electron-app-path.injectable.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import electronAppInjectable from "./electron-app/electron-app.injectable";
+import electronAppInjectable from "../../electron-app/electron-app.injectable";
 import { getElectronAppPath } from "./get-electron-app-path";
 
 const getElectronAppPathInjectable = getInjectable({

src/main/app-paths/get-electron-app-path/get-electron-app-path.test.ts

@@ -2,7 +2,7 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import electronAppInjectable from "./electron-app/electron-app.injectable";
+import electronAppInjectable from "../../electron-app/electron-app.injectable";
 import getElectronAppPathInjectable from "./get-electron-app-path.injectable";
 import { getDiForUnitTesting } from "../../getDiForUnitTesting";
 import type { App } from "electron";

src/main/app-paths/set-electron-app-path/set-electron-app-path.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import type { PathName } from "../../../common/app-paths/app-path-names";
-import electronAppInjectable from "../get-electron-app-path/electron-app/electron-app.injectable";
+import electronAppInjectable from "../../electron-app/electron-app.injectable";
 
 const setElectronAppPathInjectable = getInjectable({
   id: "set-electron-app-path",

src/main/electron-app/when-application-is-activated.injectable.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import electronAppInjectable from "./electron-app.injectable";
+
+interface CallbackArgs {
+  windowIsVisible: boolean;
+}
+
+const whenApplicationIsActivatedInjectable = getInjectable({
+  id: "when-application-is-activated",
+
+  instantiate: (di) => {
+    const app = di.inject(electronAppInjectable);
+
+    return (callback: (args: CallbackArgs) => void | Promise<void>) => {
+      app.on("activate", async (_, hasVisibleWindows) => {
+        await callback({
+          windowIsVisible: hasVisibleWindows,
+        });
+      });
+    };
+  },
+});
+
+export default whenApplicationIsActivatedInjectable;

src/main/electron-app/when-application-will-quit.injectable.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import electronAppInjectable from "./electron-app.injectable";
+
+interface CallbackArgs {
+  cancel: () => void;
+}
+
+const whenApplicationWillQuitInjectable = getInjectable({
+  id: "when-application-will-quit",
+
+  instantiate: (di) => {
+    const app = di.inject(electronAppInjectable);
+
+    return (callback: (args: CallbackArgs) => void) => {
+      app.on("will-quit", (event) => {
+        callback({
+          cancel: () => { event.preventDefault(); },
+        });
+      });
+    };
+  },
+});
+
+export default whenApplicationWillQuitInjectable;

src/main/electron-app/when-opening-url.injectable.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import electronAppInjectable from "./electron-app.injectable";
+
+interface CallbackArgs {
+  cancel: () => void;
+  url: string;
+}
+
+const whenOpeningUrlInjectable = getInjectable({
+  id: "when-opening-url",
+
+  instantiate: (di) => {
+    const app = di.inject(electronAppInjectable);
+
+    return (callback: (args: CallbackArgs) => void | Promise<void>) => {
+      app.on("open-url", async (event, url) => {
+        await callback({
+          cancel: () => {
+            event.preventDefault();
+          },
+
+          url,
+        });
+      });
+    };
+  },
+});
+
+export default whenOpeningUrlInjectable;

src/main/electron-app/when-second-instance.injectable.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import electronAppInjectable from "./electron-app.injectable";
+
+interface CallbackArgs {
+  commandLineArguments: string[];
+}
+
+const whenSecondInstanceInjectable = getInjectable({
+  id: "when-second-instance",
+
+  instantiate: (di) => {
+    const app = di.inject(electronAppInjectable);
+
+    return (callback: (args: CallbackArgs) => void | Promise<void>) => {
+      app.on("second-instance", async (_, commandLineArguments) => {
+        await callback({
+          commandLineArguments,
+        });
+      });
+    };
+  },
+});
+
+export default whenSecondInstanceInjectable;

src/main/getDiForUnitTesting.ts

@@ -35,6 +35,10 @@ import { getAbsolutePathFake } from "../common/test-utils/get-absolute-path-fake
 import joinPathsInjectable from "../common/path/join-paths.injectable";
 import { joinPathsFake } from "../common/test-utils/join-paths-fake";
 import hotbarStoreInjectable from "../common/hotbar-store.injectable";
+import whenApplicationIsActivatedInjectable from "./electron-app/when-application-is-activated.injectable";
+import whenApplicationWillQuitInjectable from "./electron-app/when-application-will-quit.injectable";
+import whenOpeningUrlInjectable from "./electron-app/when-opening-url.injectable";
+import whenSecondInstanceInjectable from "./electron-app/when-second-instance.injectable";
 
 export const getDiForUnitTesting = (
   { doGeneralOverrides } = { doGeneralOverrides: false },
@@ -63,6 +67,11 @@ export const getDiForUnitTesting = (
     di.override(getAbsolutePathInjectable, () => getAbsolutePathFake);
     di.override(joinPathsInjectable, () => joinPathsFake);
 
+    di.override(whenApplicationIsActivatedInjectable, () => () => {});
+    di.override(whenApplicationWillQuitInjectable, () => () => {});
+    di.override(whenOpeningUrlInjectable, () => () => {});
+    di.override(whenSecondInstanceInjectable, () => () => {});
+
     // eslint-disable-next-line unused-imports/no-unused-vars-ts
     di.override(extensionsStoreInjectable, () => ({ isEnabled: ({ id, isBundled }) => false }) as ExtensionsStore);
 

src/main/start-main-application/after-application-is-ready/implementations/setup-deep-linking.injectable.ts

@@ -6,7 +6,8 @@ import { getInjectable } from "@ogre-tools/injectable";
 import lensProtocolRouterMainInjectable from "../../../protocol-handler/lens-protocol-router-main/lens-protocol-router-main.injectable";
 import windowManagerInjectable from "../../../window-manager.injectable";
 import { afterApplicationIsReadyInjectionToken } from "../after-application-is-ready-injection-token";
-import electronAppInjectable from "../../../app-paths/get-electron-app-path/electron-app/electron-app.injectable";
+import whenOpeningUrlInjectable from "../../../electron-app/when-opening-url.injectable";
+import whenSecondInstanceInjectable from "../../../electron-app/when-second-instance.injectable";
 
 const setupDeepLinking = getInjectable({
   id: "setup-deep-linking",
@@ -14,17 +15,18 @@ const setupDeepLinking = getInjectable({
   instantiate: (di) => {
     const lensProtocolRouterMain = di.inject(lensProtocolRouterMainInjectable);
     const windowManager = di.inject(windowManagerInjectable);
-    const app = di.inject(electronAppInjectable);
+    const whenOpeningUrl = di.inject(whenOpeningUrlInjectable);
+    const whenSecondInstance = di.inject(whenSecondInstanceInjectable);
 
     return {
       run: () => {
-        app.on("open-url", async (event, url) => {
+        whenOpeningUrl(({ cancel, url }) => {
-          event.preventDefault();
+          cancel();
 
-          await lensProtocolRouterMain.route(url);
+          lensProtocolRouterMain.route(url);
         });
 
-        app.on("second-instance", async (_, commandLineArguments) => {
+        whenSecondInstance(async ({ commandLineArguments }) => {
           for (const arg of commandLineArguments) {
             if (arg.toLowerCase().startsWith("lens://")) {
               await lensProtocolRouterMain.route(arg);

src/main/start-main-application/after-application-is-ready/implementations/setup-hardware-acceleration.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import { afterApplicationIsReadyInjectionToken } from "../after-application-is-ready-injection-token";
-import electronAppInjectable from "../../../app-paths/get-electron-app-path/electron-app/electron-app.injectable";
+import electronAppInjectable from "../../../electron-app/electron-app.injectable";
 
 const setupHardwareAccelerationInjectable = getInjectable({
   id: "setup-hardware-acceleration",

src/main/start-main-application/after-application-is-ready/implementations/setup-lens-proxy.injectable.ts

@@ -8,7 +8,7 @@ import {
   getAppVersion,
   getAppVersionFromProxyServer,
 } from "../../../../common/utils";
-import exitAppInjectable from "../../../app-paths/get-electron-app-path/electron-app/exit-app.injectable";
+import exitAppInjectable from "../../../electron-app/exit-app.injectable";
 import lensProxyInjectable from "../../../lens-proxy.injectable";
 import loggerInjectable from "../../../../common/logger.injectable";
 import { dialog } from "electron";

src/main/start-main-application/after-application-is-ready/implementations/setup-protocol-router-main.injectable.ts

@@ -6,9 +6,9 @@ import { getInjectable } from "@ogre-tools/injectable";
 import { afterApplicationIsReadyInjectionToken } from "../after-application-is-ready-injection-token";
 import { productName } from "../../../../common/vars";
 import loggerInjectable from "../../../../common/logger.injectable";
-import electronAppInjectable from "../../../app-paths/get-electron-app-path/electron-app/electron-app.injectable";
+import electronAppInjectable from "../../../electron-app/electron-app.injectable";
 import lensProtocolRouterMainInjectable from "../../../protocol-handler/lens-protocol-router-main/lens-protocol-router-main.injectable";
-import exitAppInjectable from "../../../app-paths/get-electron-app-path/electron-app/exit-app.injectable";
+import exitAppInjectable from "../../../electron-app/exit-app.injectable";
 
 const setupProtocolRouterMainInjectable = getInjectable({
   id: "setup-protocol-router-main",

src/main/start-main-application/after-application-is-ready/implementations/start-main-window.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import windowManagerInjectable from "../../../window-manager.injectable";
-import electronAppInjectable from "../../../app-paths/get-electron-app-path/electron-app/electron-app.injectable";
+import electronAppInjectable from "../../../electron-app/electron-app.injectable";
 import loggerInjectable from "../../../../common/logger.injectable";
 import isMacInjectable from "../../../../common/vars/is-mac.injectable";
 import { afterApplicationIsReadyInjectionToken } from "../after-application-is-ready-injection-token";

src/main/start-main-application/before-application-is-ready/implementations/setup-application-name.injectable.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import electronAppInjectable from "../../../app-paths/get-electron-app-path/electron-app/electron-app.injectable";
+import electronAppInjectable from "../../../electron-app/electron-app.injectable";
 import appNameInjectable from "../../../app-paths/app-name/app-name.injectable";
 import { beforeApplicationIsReadyInjectionToken } from "../before-application-is-ready-injection-token";
 

src/main/start-main-application/before-application-is-ready/implementations/setup-closing-of-application.injectable.ts

@@ -3,16 +3,16 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import electronAppInjectable from "../../../app-paths/get-electron-app-path/electron-app/electron-app.injectable";
 import { beforeApplicationIsReadyInjectionToken } from "../before-application-is-ready-injection-token";
 import { onApplicationSoftQuitInjectionToken } from "../../on-application-soft-quit/on-application-soft-quit-injection-token";
 import { runManyFor } from "../../run-many-for";
+import whenApplicationWillQuitInjectable from "../../../electron-app/when-application-will-quit.injectable";
 
 const setupClosingOfApplicationInjectable = getInjectable({
   id: "setup-closing-of-application",
 
   instantiate: (di) => {
-    const app = di.inject(electronAppInjectable);
+    const whenApplicationWillQuit = di.inject(whenApplicationWillQuitInjectable);
 
     const runManyForApplicationClose = runManyFor(di)(
       onApplicationSoftQuitInjectionToken,
@@ -20,8 +20,8 @@ const setupClosingOfApplicationInjectable = getInjectable({
 
     return {
       run: () => {
-        app.on("will-quit", async (event) => {
+        whenApplicationWillQuit(async args => {
-          await runManyForApplicationClose({ event });
+          await runManyForApplicationClose(args);
         });
       },
     };

src/main/start-main-application/before-application-is-ready/implementations/setup-main-window-visibility.injectable.ts

@@ -5,8 +5,8 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import loggerInjectable from "../../../../common/logger.injectable";
 import windowManagerInjectable from "../../../window-manager.injectable";
-import electronAppInjectable from "../../../app-paths/get-electron-app-path/electron-app/electron-app.injectable";
 import { beforeApplicationIsReadyInjectionToken } from "../before-application-is-ready-injection-token";
+import whenApplicationIsActivatedInjectable from "../../../electron-app/when-application-is-activated.injectable";
 
 const setupMainWindowVisibilityInjectable = getInjectable({
   id: "setup-main-window-visibility",
@@ -14,17 +14,18 @@ const setupMainWindowVisibilityInjectable = getInjectable({
   instantiate: (di) => {
     const logger = di.inject(loggerInjectable);
     const windowManager = di.inject(windowManagerInjectable);
-    const app = di.inject(electronAppInjectable);
+    const whenApplicationIsActivated = di.inject(whenApplicationIsActivatedInjectable);
 
     return {
       run: () => {
-        app.on("activate", async (_, hasVisibleWindows) => {
+        whenApplicationIsActivated(async ({ windowIsVisible }) => {
-          logger.info("APP:ACTIVATE", { hasVisibleWindows });
+          logger.info("APP:ACTIVATE", { hasVisibleWindows: windowIsVisible });
 
-          if (!hasVisibleWindows) {
+          if (!windowIsVisible) {
             await windowManager.ensureMainWindow(false);
           }
         });
+
       },
     };
   },

src/main/start-main-application/before-application-is-ready/implementations/setup-shutdown-of-application-when-system-shutdowns.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import { powerMonitor } from "electron";
-import exitAppInjectable from "../../../app-paths/get-electron-app-path/electron-app/exit-app.injectable";
+import exitAppInjectable from "../../../electron-app/exit-app.injectable";
 import { beforeApplicationIsReadyInjectionToken } from "../before-application-is-ready-injection-token";
 
 const setupShutdownOfApplicationWhenSystemShutdownsInjectable = getInjectable({

src/main/start-main-application/on-application-hard-quit/on-application-hard-quit-injection-token.ts

@@ -4,10 +4,9 @@
  */
 import { getInjectionToken } from "@ogre-tools/injectable";
 import type { Runnable } from "../run-many-for";
-import type { Event } from "electron";
 
 export const onApplicationHardQuitInjectionToken = getInjectionToken<
-  Runnable<{ event: Event }>
+  Runnable<{ cancel: () => void }>
->({
+    >({
-  id: "on-application-hard-quit",
+      id: "on-application-hard-quit",
-});
+    });

src/main/start-main-application/on-application-soft-quit/on-application-soft-quit-injection-token.ts

@@ -4,10 +4,9 @@
  */
 import { getInjectionToken } from "@ogre-tools/injectable";
 import type { Runnable } from "../run-many-for";
-import type { Event } from "electron";
 
 export const onApplicationSoftQuitInjectionToken = getInjectionToken<
-  Runnable<{ event: Event }>
+  Runnable<{ cancel: () => void }>
->({
+    >({
-  id: "on-application-soft-quit",
+      id: "on-application-soft-quit",
-});
+    });

src/main/start-main-application/start-main-application.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 
-import electronAppInjectable from "../app-paths/get-electron-app-path/electron-app/electron-app.injectable";
+import electronAppInjectable from "../electron-app/electron-app.injectable";
 import { beforeApplicationIsReadyInjectionToken } from "./before-application-is-ready/before-application-is-ready-injection-token";
 import { afterApplicationIsReadyInjectionToken } from "./after-application-is-ready/after-application-is-ready-injection-token";
 import { runManyFor } from "./run-many-for";

src/main/stop-services-and-exit-app.injectable.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import exitAppInjectable from "./app-paths/get-electron-app-path/electron-app/exit-app.injectable";
+import exitAppInjectable from "./electron-app/exit-app.injectable";
 import clusterManagerInjectable from "./cluster-manager.injectable";
 import windowManagerInjectable from "./window-manager.injectable";
 import appEventBusInjectable from "../common/app-event-bus/app-event-bus.injectable";