TypeScript protocol.registerStandardSchemes方法代码示例

elc.app.on('will-finish-launching', function() {
  // Register Aether's aether:// as a standard (http-like) protocol
  elc.protocol.registerStandardSchemes(['aether'])

  elc.app.on('open-url', function(e: any, url: any) {
    e.preventDefault()
    linkToLoadAtBoot = url.substring(8)
  })
})

export function main() {
  mainLogger.info(
    `${env.appName}@${app.getVersion()} on electron@${
      process.versions.electron
    } in ${env.production ? "production" : "development"}`
  );

  if (process.env.CAPSULE_LIBRARY_PATH) {
    // disable acceleration when captured by capsule
    app.disableHardwareAcceleration();
  } else {
    try {
      const prefs = loadPreferencesSync();
      if (prefs.disableHardwareAcceleration) {
        app.disableHardwareAcceleration();
      }
    } catch (e) {
      // oh well
    }
  }

  if (env.production) {
    app.enableMixedSandbox();
  }

  // cf. https://github.com/itchio/itch/issues/2026
  app.commandLine.appendSwitch("ignore-connections-limit", "127.0.0.1");

  if (process.env.ITCH_IGNORE_CERTIFICATE_ERRORS === "1") {
    app.commandLine.appendSwitch("ignore-certificate-errors");
  }
  protocol.registerStandardSchemes(["itch-cave", "itch"]);

  let store: Store = require("main/store").default;

  let onReady = () => {
    if (!env.integrationTests) {
      const shouldQuit = app.makeSingleInstance((argv, cwd) => {
        // we only get inside this callback when another instance
        // is launched - so this executes in the context of the main instance
        store.dispatch(
          actions.processUrlArguments({
            args: argv,
          })
        );
        store.dispatch(actions.focusWind({ wind: "root" }));
      });
      if (shouldQuit) {
        app.exit(0);
        return;
      }
    }

    store.dispatch(
      actions.processUrlArguments({
        args: process.argv,
      })
    );

    globalShortcut.register("Control+Alt+Backspace", function() {
      store.dispatch(actions.forceCloseLastGame({}));
    });

    // Emitted when the application is activated. Various actions can trigger
    // this event, such as launching the application for the first time,
    // attempting to re-launch the application when it's already running, or
    // clicking on the application's dock or taskbar icon.
    app.on("activate", () => {
      store.dispatch(actions.focusWind({ wind: "root" }));
    });

    app.on("before-quit", e => {
      e.preventDefault();
      store.dispatch(actions.quit({}));
    });

    store.dispatch(actions.preboot({}));

    setInterval(() => {
      try {
        store.dispatch(actions.tick({}));
      } catch (e) {
        mainLogger.error(`While dispatching tick: ${e.stack}`);
      }
    }, 1 * 1000 /* every second */);
  };
  app.on("ready", onReady);

  app.on("will-finish-launching", () => {
    app.setAppUserModelId(appUserModelId);
  });

  // macOS (Info.pList)
  app.on("open-url", (e: Event, url: string) => {
    if (isItchioURL(url)) {
      // otherwise it'll err -600
      e.preventDefault();
      store.dispatch(actions.handleItchioURI({ uri: url }));
    }
  });
//.........这里部分代码省略.........

export const registerProtocols = () => {
  protocol.registerStandardSchemes(['wexond']);

  (app as any).on('session-created', (sess: Electron.session) => {
    sess.protocol.registerBufferProtocol(
      'wexond-extension',
      (request, callback) => {
        const parsed = parse(request.url.replace('%3F', '?'));

        if (!parsed.hostname || !parsed.pathname) {
          return callback();
        }

        const manifest = global.extensions[parsed.hostname];

        if (!manifest) {
          return callback();
        }

        const page = global.backgroundPages[parsed.hostname];

        if (page && parsed.pathname === `/${page.name}`) {
          return callback({
            mimeType: 'text/html',
            data: page.html,
          });
        }

        readFile(
          join(manifest.srcDirectory, parsed.pathname),
          (err, content) => {
            if (err) {
              return (callback as any)(-6); // FILE_NOT_FOUND
            }
            return callback(content);
          },
        );

        return null;
      },
      error => {
        if (error) {
          console.error(
            `Failed to register wexond-extension protocol: ${error}`,
          );
        }
      },
    );
    sess.protocol.registerFileProtocol(
      'wexond',
      (request, callback: any) => {
        const parsed = parse(request.url);

        if (parsed.hostname === 'build' && parsed.path) {
          return callback({ path: join(__dirname, 'build', parsed.path) });
        }

        if (parsed.hostname === 'newtab' || parsed.hostname === 'history') {
          if (parsed.path === '/') {
            return callback({
              path: join(__dirname, 'static/pages', parsed.hostname + '.html'),
            });
          }

          return callback({
            path: join(__dirname, 'static/pages', parsed.path),
          });
        }
      },
      error => {
        if (error) console.error('Failed to register protocol');
      },
    );
  });
};

import * as url from 'url';

import {LoadingWindow} from './loading_window';
import * as menu from './menu';

const app = electron.app;
const ipcMain = electron.ipcMain;
const shell = electron.shell;

const debugMode = process.env.OUTLINE_DEBUG === 'true';

// prevent window being garbage collected
let mainWindow: Electron.BrowserWindow;

// Mark secure to avoid mixed content warnings when loading DigitalOcean pages via https://.
electron.protocol.registerStandardSchemes(['outline'], {secure: true});

app.on('ready', () => {
  const menuTemplate = menu.getMenuTemplate(debugMode);
  if (menuTemplate.length > 0) {
    electron.Menu.setApplicationMenu(electron.Menu.buildFromTemplate(menuTemplate));
  }

  // Register a custom protocol so we can use absolute paths in the web app.
  // This also acts as a kind of chroot for the web app, so it cannot access
  // the user's filesystem (important for the DigitalOcean pages we customise).
  // Hostnames are ignored.
  electron.protocol.registerFileProtocol(
      'outline',
      (request, callback) => {
        const appPath = new url.URL(request.url).pathname;

function main() {
  if (process.env.CAPSULE_LIBRARY_PATH) {
    // disable acceleration when captured by capsule
    app.disableHardwareAcceleration();
  } else {
    try {
      const prefs = loadPreferencesSync();
      if (prefs.disableHardwareAcceleration) {
        app.disableHardwareAcceleration();
      }
    } catch (e) {
      // oh well
    }
  }

  if (env.production) {
    app.enableMixedSandbox();
  }

  if (process.env.ITCH_IGNORE_CERTIFICATE_ERRORS === "1") {
    app.commandLine.appendSwitch("ignore-certificate-errors");
  }
  protocol.registerStandardSchemes(["itch-cave"]);

  let store: IStore = require("main/store").default;

  let onReady = () => {
    if (!env.integrationTests) {
      const shouldQuit = app.makeSingleInstance((argv, cwd) => {
        // we only get inside this callback when another instance
        // is launched - so this executes in the context of the main instance
        store.dispatch(
          actions.processUrlArguments({
            args: argv,
          })
        );
        store.dispatch(actions.focusWindow({ window: "root" }));
      });

      if (shouldQuit) {
        app.exit(0);
        return;
      }
    }

    store.dispatch(
      actions.processUrlArguments({
        args: process.argv,
      })
    );

    globalShortcut.register("Control+Alt+Backspace", function() {
      store.dispatch(actions.forceCloseLastGame({}));
    });

    if (rt) {
      rt.end();
    }

    store.dispatch(actions.preboot({}));

    setInterval(() => {
      try {
        store.dispatch(actions.tick({}));
      } catch (e) {
        logger.error(`While dispatching tick: ${e.stack}`);
      }
    }, 1 * 1000 /* every second */);
  };
  app.on("ready", onReady);

  app.on("will-finish-launching", () => {
    app.setAppUserModelId(appUserModelId);
  });

  // macOS (Info.pList)
  app.on("open-url", (e: Event, url: string) => {
    if (isItchioURL(url)) {
      // otherwise it'll err -600
      e.preventDefault();
      store.dispatch(actions.handleItchioURI({ uri: url }));
    }
  });
}