TypeScript electron.protocol类代码示例

function createWindow() {
  // Create the browser window.
  win = new BrowserWindow({ width: 800, height: 600 });

  // and load the index.html of the app.
  win.loadURL(
    url.format({
      pathname: path.join(__dirname, "index.html"),
      protocol: "file:",
      slashes: true
    })
  );

  // Open the DevTools.
  win.webContents.openDevTools();

  // Emitted when the window is closed.
  win.on("closed", () => {
    // Dereference the window object, usually you would store windows
    // in an array if your app supports multi windows, this is the time
    // when you should delete the corresponding element.
    win = null;
  });

  protocol.registerBufferProtocol("dictp", async (request, callback) => {
    const urlContents = request.url.substr(8).split(":");
    const type = urlContents[0]; // image/audio/lookup
    if (type === "image" || type === "audio") {
      await loadResources(request, callback);
    } else if (type === "lookup") {
    }
  });
}

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)
  })
})

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;
        const filesystemPath = path.join(__dirname, 'server_manager/web_app', appPath);
        callback(filesystemPath);
      },
      (error) => {
        if (error) {
          throw new Error('Failed to register outline protocol');
        }
      });
  mainWindow = createMainWindow();
});

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 }));
    }
  });
//.........这里部分代码省略.........

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;

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

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 }));
    }
  });
}