electron#IpcMainEvent TypeScript Examples

/**
   * Initializes the listener that processes responses
   */
  constructor(public readonly window: BrowserWindow) {
    super();
    ipcMain.on(
      this.responseChannel,
      (_ev: IpcMainEvent, response: ResponseMessage) =>
        this.processResponse(response)
    );
  }

// 在主进程执行electron的代码
export function addCodeRunnerListener() {
  ipcMain.on('ACTION_CODE', (event: IpcMainEvent, fnStr: string) => {
    try {
      const mockConsole = new MockConsole()
      const fn = new Function(
        'exports',
        'require',
        'module',
        '__filename',
        '__dirname',
        'console',
        `return function(){
              try{
                ${fnStr}
              }catch(error){
                console.error('程序执行错误',error)
              }
             }`,
      )(exports, nativeRequire, module, __filename, __dirname, mockConsole)
      const result = fn()
      if (result) {
        mockConsole.log(result)
      }
      event.returnValue = mockConsole.logs
    } catch (err) {
      console.log('执行动态代码错误', err)
    }
  })
}

(async () => {
  await app.whenReady()
  ipcMain.on('OPEN_WINDOW', (event: IpcMainEvent, optionsProps: OpenWindowOptions) => {
    const { name } = optionsProps
    createWindow(name)

    event.returnValue = 1
  })

  ipcMain.on('CLOSE_WINDOW', (e, options) => {
    const win = BrowserWindow.fromWebContents(e.sender)
    win?.close()
  })

  ipcMain.on('MAXIMIZE_WINDOW', (e, options) => {
    const win = BrowserWindow.fromWebContents(e.sender)
    console.log(win?.isMaximized())
    win?.isMaximized() ? win?.unmaximize() : win?.maximize()
  })

  ipcMain.on('MINIMIZE_WINDOW', (e, options) => {
    const win = BrowserWindow.fromWebContents(e.sender)
    win?.isMinimized() ? win?.restore() : win?.minimize()
  })
})()

ipcMain.on(MainIpcListenChannels.OpenSecureFormPaymentWindow, async (event: IpcMainEvent, secureForm: string) => {
    const securePaymentWindow = new BrowserWindow({
        frame: true,
        fullscreen: false,
        fullscreenable: false,
        resizable: true,
        width: 770,
        height: 820,
        x: (mainWindow?.getBounds().x ?? 0) + 40,
        y: mainWindow?.getBounds().y,
    })
    return await securePaymentWindow.loadURL("data:text/html;charset=UTF-8," + encodeURIComponent(secureForm))
})

public async handle(
    event: IpcMainEvent,
    { filesToPlace }: PlacementChannelArgument
  ) {
    process.chdir("..");

    const filePlacer = new FilePlacer();

    const result =
      filesToPlace === "functionality"
        ? await filePlacer.placeNodeFunctionalityFiles()
        : await filePlacer.placeNodeDocumentationFiles();

    process.chdir("client");

    event.sender.send(this.name, result);
  }

export function initializeTelemetry(): void {
  setDefaultComponentId(`gatsby-desktop`)
  setGatsbyCliVersion(app.getVersion())
  startBackgroundUpdate()
  store = new Store<IConfigType>()

  const telemetryEnabled = store.get(`telemetryOptIn`)

  if (telemetryEnabled === false) {
    console.log(`running with telemetry disabled`)
    trackCli(`RUNNING_WITH_TELEMETRY_DISABLED`)
  } else {
    trackCli(`GATSBY_DESKTOP_STARTED`)
    console.log(`telemetry enabled or not chosen`, { telemetryEnabled })
  }
  ipcMain.on(
    `telemetry-trackFeatureIsUsed`,
    (event: IpcMainEvent, name: string): void =>
      telemetryTrackFeatureIsUsed(name)
  )
  ipcMain.on(
    `telemetry-trackEvent`,
    (
      event: IpcMainEvent,
      input: string | Array<string>,
      tags?: ITelemetryTagsPayload
    ): void => trackEvent(input, tags)
  )
}

/**
	 * Wraps window.webContents.send() in a Promise. Expects the render
	 * process to send back a response after handling the message.
	 * 
	 * This is needed because unlike `ipcRenderer`, electron `WebContents`
	 * has no invoke() method for when we expect a message result.  See:
	 *
	 *
	 */
	async invoke<T>(channel:string, ...args:any[]):Promise<T> {
		return new Promise<T>((resolve, reject) => {
			// generate unique id for event
			let responseId = `RENDER_DID_HANDLE::${channel}::${randomId()}`;
			// send message from main --> render
			this.window.webContents.send(channel, responseId, ...args);
			// expect response -- promise won't resolve otherwise
			/** @todo (7/12/20) accept timeout (seconds) as argument? */
			ipcMain.once(responseId, (evt:IpcMainEvent, success:boolean, result:any) => {
				if(success) { resolve(result); }
				else        { reject(result);  }
			});
		});
	}

/**
   * Initializes the listener that processes responses
   */
  constructor(public readonly window: BrowserWindow) {
    super();
    ipcMain.on(
      this.responseChannel,
      (_ev: IpcMainEvent, response: ResponseMessage) =>
        this.processResponse(response)
    );
  }

/**
   * Initializes the listener that processes responses
   */
  constructor(public readonly window: BrowserWindow) {
    super();
    ipcMain.on(
      this.responseChannel,
      (_ev: IpcMainEvent, response: ResponseMessage) =>
        this.processResponse(response)
    );
  }

/**
   * Initializes the listener that processes responses
   */
  constructor(public readonly window: BrowserWindow) {
    super();
    ipcMain.on(
      this.responseChannel,
      (_ev: IpcMainEvent, response: ResponseMessage) =>
        this.processResponse(response)
    );
  }

public async handle(event: IpcMainEvent, paramsBundle: DocsgenParamsBundle) {
    process.chdir("..");
    const generator = new NodeDocsGenerator(paramsBundle);
    const result = await generator.run();
    process.chdir("client");

    event.sender.send(this.name, result);
  }

public async handle(event: IpcMainEvent) {
    process.chdir("..");
    const emptier = new DirectoryEmptier();
    const result = await emptier.run();
    process.chdir("client");

    event.sender.send(this.name, result);
  }

public async handle(event: IpcMainEvent) {
    event.sender.send(this.name, "hello my name is erin");
  }

public async handle(event: IpcMainEvent, paramsBundle: NodegenParamsBundle) {
    process.chdir("..");
    const generator = new NodeFilesGenerator(paramsBundle);
    const result = await generator.run();
    process.chdir("client");

    event.sender.send(this.name, result);
  }

public async handle(event: IpcMainEvent, metaParameters: MetaParameters) {
    process.chdir("..");
    const generator = new PackageJsonGenerator(metaParameters);
    const result = await generator.run();
    process.chdir("client");

    event.sender.send(this.name, result);
  }

export function overlayOnEvent<Name extends ipc.IpcEvent['name']> (
  name: Name,
  cb: (e: IpcMainEvent, payload: ipc.IpcEventPayload<Name>) => void
) {
  ipcMain.on(name, cb)
}

ipcMain.on(MainIpcListenChannels.OpenSupportChat, async (event: IpcMainEvent, id: string) => {
    if (chatWindow == null) {
        chatWindow = await createChatWindow(id)
    }
    chatWindow.show()
})