TypeScript app.setLoginItemSettings方法代码示例

    it('correctly sets and unsets the LoginItem', function () {
      expect(app.getLoginItemSettings().openAtLogin).to.equal(false)

      app.setLoginItemSettings({ openAtLogin: true })
      expect(app.getLoginItemSettings().openAtLogin).to.equal(true)

      app.setLoginItemSettings({ openAtLogin: false })
      expect(app.getLoginItemSettings().openAtLogin).to.equal(false)
    })

app.on('ready', () => {
  if (debugMode) {
    Menu.setApplicationMenu(Menu.buildFromTemplate([{
      label: 'Developer',
      submenu: [{role: 'reload'}, {role: 'forcereload'}, {role: 'toggledevtools'}]
    }]));
  } else {
    checkForUpdates();

    // Check every six hours
    setInterval(checkForUpdates, 6 * 60 * 60 * 1000);
  }

  // Set the app to launch at startup to connect automatically in case of a showdown while proxying.
  if (isLinux) {
    if (process.env.APPIMAGE) {
      const outlineAutoLauncher = new autoLaunch({
        name: 'OutlineClient',
        path: process.env.APPIMAGE,
      });

      outlineAutoLauncher.isEnabled()
          .then((isEnabled: boolean) => {
            if (isEnabled) {
              return;
            }
            outlineAutoLauncher.enable();
          })
          .catch((err: Error) => {
            console.error(`failed to add autolaunch entry for Outline ${err.message}`);
          });
    }
  } else {
    app.setLoginItemSettings({openAtLogin: true, args: [Options.AUTOSTART]});
  }

  // TODO: --autostart is never set on Linux, what can we do?
  if (process.argv.includes(Options.AUTOSTART)) {
    connectionStore.load()
        .then((connection) => {
          createWindow(connection);
        })
        .catch((e) => {
          // No connection at shutdown, or failure - either way, no need to start.
          // TODO: Instead of quitting, how about creating the system tray icon?
          console.log(`${Options.AUTOSTART} was passed but we were not connected at shutdown - exiting`);
          app.quit();
        });
  } else {
    createWindow();
  }
});

app.on('ready', () => {
  // TODO: Run this periodically, e.g. every 4-6 hours.
  autoUpdater.checkForUpdates();

  if (debugMode) {
    Menu.setApplicationMenu(Menu.buildFromTemplate([{
      label: 'Developer',
      submenu: [{role: 'reload'}, {role: 'forcereload'}, {role: 'toggledevtools'}]
    }]));
  }

  // Set the app to launch at startup to reset the system proxy configuration
  // in case of a showdown while proxying.
  app.setLoginItemSettings({openAtLogin: true, args: [Options.AUTOSTART]});

  if (process.argv.includes(Options.AUTOSTART)) {
    app.quit();  // Quitting the app will reset the system proxy configuration before exiting.
  } else {
    createWindow();
  }
});

 afterEach(() => {
   app.setLoginItemSettings({ openAtLogin: false })
   app.setLoginItemSettings({ openAtLogin: false, path: updateExe, args: processStartArgs })
 })

//.........这里部分代码省略.........
		{
			label: 'Show Unread Badge',
			type: 'checkbox',
			checked: config.get('showUnreadBadge'),
			click() {
				config.set('showUnreadBadge', !config.get('showUnreadBadge'));
			}
		},
		{
			label: 'Hardware Acceleration',
			type: 'checkbox',
			checked: config.get('hardwareAcceleration'),
			click() {
				config.set('hardwareAcceleration', !config.get('hardwareAcceleration'));
				showRestartDialog('Caprine needs to be restarted to change hardware acceleration.');
			}
		},
		{
			label: 'Always on Top',
			type: 'checkbox',
			accelerator: 'CommandOrControl+Shift+T',
			checked: config.get('alwaysOnTop'),
			click(menuItem, focusedWindow) {
				config.set('alwaysOnTop', menuItem.checked);
				focusedWindow.setAlwaysOnTop(menuItem.checked);
			}
		},
		{
			label: 'Launch at Login',
			visible: is.macos || is.windows,
			type: 'checkbox',
			checked: app.getLoginItemSettings().openAtLogin,
			click(menuItem) {
				app.setLoginItemSettings({
					openAtLogin: menuItem.checked,
					openAsHidden: menuItem.checked
				});
			}
		},
		{
			label: 'Auto Hide Menu Bar',
			type: 'checkbox',
			visible: !is.macos,
			checked: config.get('autoHideMenuBar'),
			click(menuItem, focusedWindow) {
				config.set('autoHideMenuBar', menuItem.checked);
				focusedWindow.setAutoHideMenuBar(menuItem.checked);
				focusedWindow.setMenuBarVisibility(!menuItem.checked);
			}
		},
		{
			label: 'Flash Window on Message',
			type: 'checkbox',
			visible: !is.macos,
			checked: config.get('flashWindowOnMessage'),
			click(menuItem) {
				config.set('flashWindowOnMessage', menuItem.checked);
			}
		},
		{
			label: 'Launch Minimized',
			type: 'checkbox',
			visible: !is.macos,
			checked: config.get('launchMinimized'),
			click() {
				config.set('launchMinimized', !config.get('launchMinimized'));

async function updateOpenAtLoginState(
  store: Store,
  openAtLogin: boolean,
  openAsHidden: boolean
) {
  logger.debug(
    `Updating login item settings, open=${openAtLogin}, hidden=${openAsHidden}`
  );

  const app = require("electron").app;

  if (process.platform === "linux") {
    // cf. https://standards.freedesktop.org/autostart-spec/autostart-spec-latest.html#startup
    const configHome =
      process.env.XDG_CONFIG_HOME ||
      ospath.join(app.getPath("home"), ".config", "autostart");
    const desktopFileName = `io.itch.${app.getName()}.desktop`;
    const desktopFilePath = ospath.join(
      "/usr/share/applications",
      desktopFileName
    );
    const autostartFilePath = ospath.join(configHome, desktopFileName);

    logger.debug(`Copying ${desktopFilePath} => ${autostartFilePath}`);

    if (openAtLogin) {
      try {
        if (!(await exists(desktopFilePath))) {
          store.dispatch(
            actions.openAtLoginError({ cause: "no_desktop_file" })
          );
          return;
        }

        if (!(await exists(configHome))) {
          await mkdir(configHome);
        }

        const desktopContents = await readFile(desktopFilePath, {
          encoding: "utf8",
        });
        if (await exists(autostartFilePath)) {
          await unlink(autostartFilePath);
        }

        await writeFile(autostartFilePath, desktopContents, {
          encoding: "utf8",
        });
      } catch (err) {
        logger.error(
          `Error while symlinking ${autostartFilePath}: ${err.message}`
        );
        store.dispatch(
          actions.openAtLoginError({ cause: "error", message: err.message })
        );
        return;
      }
    } else {
      try {
        await unlink(autostartFilePath);
      } catch (err) {
        if (err.code === "ENOENT") {
          // not even there, good!
        } else {
          logger.error(
            `Error while unlinking ${autostartFilePath}: ${err.message}`
          );
          return;
        }
      }

      store.dispatch(actions.openAtLoginError(null));
    }
  } else {
    // macOS, Windows
    app.setLoginItemSettings({
      openAtLogin: openAtLogin,
      openAsHidden: openAsHidden,
    });
  }
}