hendrik/lens
1
0
Fork 0
mirror of https://github.com/lensapp/lens.git synced 2025-05-20 05:10:56 +00:00
Code Issues Projects Releases Wiki Activity

Abstract event of application activation from electron

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

Signed-off-by: Janne Savolainen <janne.savolainen@live.fi>
This commit is contained in:
Janne Savolainen 2022-04-20 09:50:33 +03:00
parent 5a501c4ad0
commit 5e12e783d4
No known key found for this signature in database
GPG Key ID: 8C6CFB2FFFE8F68A
7 changed files with 103 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
src/main/electron-app/on-application-activate.injectable.ts Normal file
View File

@ -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;

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

@ -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;

4
src/main/getDiForUnitTesting.ts
View File

@ -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, () => () => {});

14
src/main/start-main-application/after-application-activation/after-application-activation-injection-token.ts Normal file
View File

@ -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",
});

31
src/main/start-main-application/after-application-activation/implementations/ensure-main-window-visibility.injectable.ts Normal file
View File

@ -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;

31
src/main/start-main-application/after-application-is-ready/implementations/setup-application-activation-events.injectable.ts Normal file
View File

@ -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;

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

@ -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;