Abstract event of application activation from electron

Co-authored-by: Mikko Aspiala <mikko.aspiala@gmail.com>

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

src/main/electron-app/on-application-activate.injectable.ts

@@ -0,0 +1,25 @@
+/**
+ * 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";
+import type { ActivationArgs } from "../start-main-application/after-application-activation/after-application-activation-injection-token";
+
+const onApplicationActivateInjectable = getInjectable({
+  id: "on-application-activate",
+
+  instantiate: (di) => {
+    const app = di.inject(electronAppInjectable);
+
+    return (callback: (args: ActivationArgs) => Promise<void>) => {
+      app.on("activate", async (_, windowIsVisible) => {
+        await callback({
+          windowIsVisible,
+        });
+      });
+    };
+  },
+});
+
+export default onApplicationActivateInjectable;

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

@@ -1,28 +0,0 @@
-/**
- * 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/getDiForUnitTesting.ts

@@ -56,7 +56,6 @@ import applicationMenuInjectable from "./menu/application-menu.injectable";
 import windowManagerInjectable from "./window-manager.injectable";
 import isDevelopmentInjectable from "../common/vars/is-development.injectable";
 import setupSystemCaInjectable from "./start-main-application/before-application-is-ready/implementations/setup-system-ca.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";
@@ -70,6 +69,7 @@ import shouldStartHiddenInjectable from "./electron-app/should-start-hidden.inje
 import registerProtocolClientInjectable from "./electron-app/register-protocol-client.injectable";
 import getElectronAppPathInjectable from "./app-paths/get-electron-app-path/get-electron-app-path.injectable";
 import setElectronAppPathInjectable from "./app-paths/set-electron-app-path/set-electron-app-path.injectable";
+import onApplicationActivateInjectable from "./electron-app/on-application-activate.injectable";
 
 export const getDiForUnitTesting = (
   { doGeneralOverrides } = { doGeneralOverrides: false },
@@ -190,7 +190,7 @@ const overrideOperatingSystem = (di: DiContainer) => {
 };
 
 const overrideElectron = (di: DiContainer) => {
-  di.override(whenApplicationIsActivatedInjectable, () => () => {});
+  di.override(onApplicationActivateInjectable, () => () => {});
   di.override(whenApplicationWillQuitInjectable, () => () => {});
   di.override(whenOpeningUrlInjectable, () => () => {});
   di.override(whenSecondInstanceInjectable, () => () => {});

src/main/start-main-application/after-application-activation/after-application-activation-injection-token.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectionToken } from "@ogre-tools/injectable";
+import type { Runnable } from "../run-many-for";
+
+export interface ActivationArgs {
+  windowIsVisible: boolean;
+}
+
+export const afterApplicationActivationInjectionToken = getInjectionToken<Runnable<ActivationArgs>>({
+  id: "after-application-activation",
+});

src/main/start-main-application/after-application-activation/implementations/ensure-main-window-visibility.injectable.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 loggerInjectable from "../../../../common/logger.injectable";
+import windowManagerInjectable from "../../../window-manager.injectable";
+import { afterApplicationActivationInjectionToken } from "../after-application-activation-injection-token";
+
+const ensureMainWindowVisibilityInjectable = getInjectable({
+  id: "ensure-main-window-visibility",
+
+  instantiate: (di) => {
+    const logger = di.inject(loggerInjectable);
+    const windowManager = di.inject(windowManagerInjectable);
+
+    return {
+      run: async ({ windowIsVisible }) => {
+        logger.info("APP:ACTIVATE", { hasVisibleWindows: windowIsVisible });
+
+        if (!windowIsVisible) {
+          await windowManager.ensureMainWindow(false);
+        }
+      },
+    };
+  },
+
+  injectionToken: afterApplicationActivationInjectionToken,
+});
+
+export default ensureMainWindowVisibilityInjectable;

src/main/start-main-application/after-application-is-ready/implementations/setup-application-activation-events.injectable.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 { runManyFor } from "../../run-many-for";
+import onApplicationActivateInjectable from "../../../electron-app/on-application-activate.injectable";
+import type { ActivationArgs } from "../../after-application-activation/after-application-activation-injection-token";
+import { afterApplicationActivationInjectionToken } from "../../after-application-activation/after-application-activation-injection-token";
+import { afterApplicationIsReadyInjectionToken } from "../after-application-is-ready-injection-token";
+
+const setupApplicationActivationEventsInjectable = getInjectable({
+  id: "setup-application-activation-events",
+
+  instantiate: (di) => {
+    const onApplicationActivate = di.inject(onApplicationActivateInjectable);
+    const runRunnablesAfterApplicationActivation = runManyFor(di)(afterApplicationActivationInjectionToken);
+
+    return {
+      run: () => {
+        onApplicationActivate(async (activationArgs: ActivationArgs) => {
+          await runRunnablesAfterApplicationActivation(activationArgs);
+        });
+      },
+    };
+  },
+
+  injectionToken: afterApplicationIsReadyInjectionToken,
+});
+
+export default setupApplicationActivationEventsInjectable;

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

@@ -1,36 +0,0 @@
-/**
- * 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 loggerInjectable from "../../../../common/logger.injectable";
-import windowManagerInjectable from "../../../window-manager.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",
-
-  instantiate: (di) => {
-    const logger = di.inject(loggerInjectable);
-    const windowManager = di.inject(windowManagerInjectable);
-    const whenApplicationIsActivated = di.inject(whenApplicationIsActivatedInjectable);
-
-    return {
-      run: () => {
-        whenApplicationIsActivated(async ({ windowIsVisible }) => {
-          logger.info("APP:ACTIVATE", { hasVisibleWindows: windowIsVisible });
-
-          if (!windowIsVisible) {
-            await windowManager.ensureMainWindow(false);
-          }
-        });
-
-      },
-    };
-  },
-
-  injectionToken: beforeApplicationIsReadyInjectionToken,
-});
-
-export default setupMainWindowVisibilityInjectable;