electron#ipcMain JavaScript Examples

ipcMain.handle('show-save-dialog', async (event, options) => {
  const result = await dialog.showSaveDialog(BrowserWindow.fromWebContents(event.sender), {
    filters: options.filters,
    defaultPath: pathUtil.join(getLastAccessedDirectory(), options.suggestedName)
  });
  if (!result.canceled) {
    const {filePath} = result;
    setLastAccessedFile(filePath);
    allowedToAccessFiles.add(filePath);
  }
  return result;
});

ipcMain.on(RunDiscovery, event => {
  close();
  const discovery = (instance = new Discovery());

  discovery.on('message', host => {
    event.reply(DiscoveredHost, host);
  });

  discovery.listen();
});

ipcMain.on('locale-changed', (event, newLocale) => {
  if (newLocale === locale) {
    return;
  }
  log(`new locale: ${newLocale}`);
  locale = newLocale;
  set(STORAGE_KEY, locale);
  translations = getTranslations(locale);
});

constructor(mainWindow) {
    // Variable to hold the main window instance.
    this.mainWindow = mainWindow;

    // Active process pids, keyed by process name.
    this.processes = {};

    ipcMain.on('processSpawn', (event, { name, pid }) => {
      this.processes[name] = pid;
    });
    ipcMain.on('processExit', (event, { name }) => {
      this.processes[name] = null;
    });
  }

destroy() {
    this.removeAllListeners();
    this.wc.removeAllListeners();
    if (this.id) {
      ipcMain.removeListener(this.id, this.ipcListener);
    } else {
      // mark for `genUid` in constructor
      this.destroyed = true;
    }
  }

ipcMain.on('open-extension-store', () => {
    if (!net.isOnline()) {
        return dialog.showMessageBoxSync(_windows.main, {
            message: 'You need to be connected to the Internet to use the extension store.',
            type: 'info'
        });
    }
    _windows.extensionStore.loadURL('https://codingclip.com/extension/?desktop=1');
    _windows.extensionStore.show();
});

constructor(win) {
    super();
    this.win = win;
    this.ipcListener = this.ipcListener.bind(this);

    if (this.destroyed) {
      return;
    }

    const uid = uuid.v4();
    this.id = uid;

    ipcMain.on(uid, this.ipcListener);

    // we intentionally subscribe to `on` instead of `once`
    // to support reloading the window and re-initializing
    // the channel
    this.wc.on("did-finish-load", () => {
      this.wc.send("init", uid);
    });
  }

ipcMain.handle('write-file', async (event, file, content) => {
    try {
        await fs.writeFile(file, content);
    } catch (e) {
        await dialog.showMessageBox(_windows.main, {
            type: 'error',
            message: `Cannot write file:\n${file}`,
            detail: e.message
        });
    }
});

ipcMain.on('alert', (event, message) => {
  dialog.showMessageBoxSync(BrowserWindow.fromWebContents(event.sender), {
    title: APP_NAME,
    message: '' + message,
    buttons: [
      getTranslation('prompt.ok')
    ],
    noLink: true
  });
  // set returnValue to something to reply so the renderer can resume
  event.returnValue = 1;
});

ipcMain.on("stopMining", async (event, arg) => {
  store.dispatch("setPoolBalance", null);
  if (arg === "cpu") {
    if ($.miner) {
      $.miner.disconnect();
      delete $.miner;
      store.dispatch("setCpuHashrate", "0 kH/s");
    }
  } else {
    if ($.minerGPU) {
      $.minerGPU.disconnect();
      delete $.minerGPU;
    }
    if ($.nativeMiner) {
      $.nativeMiner.stop();
      delete $.nativeMiner;
      store.dispatch("setGpuHashrate", "0 kH/s");
    }
  }
});

constructor(eveApp) {
    this.eveApp = eveApp;

    // Set
    ipcMain.on("get", function (event, key, id, windowId) {
      event.sender.send("get-reply", key, eveApp[key], id, windowId);
    });

    // Get
    ipcMain.on("set", function (event, key, value, id, windowId) {
      eveApp[key] = value;
      event.sender.send("set-reply", key, value, id, windowId);
    });

    /*
        Trigger an eveApp method.
        This method firts parameter 'args' is the arguments object sent by ipcMain-client.
        The second parameter is an optionnal callback that can be added at the end of the method to send back a 'res' variable to ipcMain-client.
    */
    ipcMain.on("trigger", function (event, key, args, id, windowId) {
      if (typeof eveApp[key] !== "function") {
        console.error(key + " is not a valid eveApp method");
      } else {
        eveApp[key](args, windowId, function (res) {
          event.sender.send("trigger-reply", key, res, id, windowId);
        });
      }
    });
  }

ipcMain.handle('FETCH_FILE', async (event, args) => {
  const [year, fileName] = args
  const dataPath = getFilePath(year)
  const filePath = `${dataPath}/${fileName}.json`
  let file

  // create the file if it does not exist yet
  if (!fs.existsSync(filePath)) {
    file = fs.promises.mkdir(dataPath, { recursive: true }).then(() => {
      return fs.promises.writeFile(filePath, getDefaultData()).then(() => {
        return fs.promises.readFile(filePath, 'utf-8').then((data) => {
          return JSON.parse(data)
        })
      })
    })
  } else {
    file = fs.promises.readFile(filePath, 'utf-8').then(data => JSON.parse(data))
  }

  // return the file
  return file
})

ipcMain.on('export-addon-settings', async (event, settings) => {
  const result = await dialog.showSaveDialog(BrowserWindow.fromWebContents(event.sender), {
    defaultPath: 'turbowarp-addon-setting.json',
    filters: [
      {
        name: 'JSON',
        extensions: ['json']
      }
    ]
  });
  if (result.canceled) {
    return;
  }

  const path = result.filePath;
  await writeFile(path, JSON.stringify(settings));
});

// This method will be called when Electron has finished
// initialization and is ready to create browser windows.
// Some APIs can only be used after this event occurs.
app.on('ready', async () => {
  if (isDevelopment && !process.env.IS_TEST) {
    // Install Vue Devtools
    try {
      await installExtension(VUEJS_DEVTOOLS);
    } catch (e) {
      console.error('Vue Devtools failed to install:', e.toString());
    }
  }

  ipcMain.handle('process', processHandler);
  ipcMain.handle('file', fileHandler);
  ipcMain.handle('mods', modsHandler);

  createWindow();
});

startObserving_ipc () {
    const self = this
    ipcMain.on(
      'TXTRecords',
      function (event, params) {
        self._resolveJob(
          event,
          params.hostname,
          params.uuid // use uuid as resolverUUID
        )
      }
    )
    ipcMain.on(
      'TXTRecords-Abort',
      function (event, params) {
        self._abortJob(
          event,
          params.uuid
        )
      }
    )
  }

ipcMain.handle('request-url', (event, url) => {
  if (!allowedToAccessFiles.has(url)) {
    throw new Error('Not allowed to access URL');
  }
  return requestURLAsArrayBuffer(url);
});

ipc = ipcMain

function createWindow (startHideWindow) {
  // Create the browser window.

  win = new BrowserWindow({
    width: 900,
    height: 750,
    title: 'DevSidecar',
    webPreferences: {
      enableRemoteModule: true,
      contextIsolation: false,
      nativeWindowOpen: true, // ADD THIS
      // preload: path.join(__dirname, 'preload.js'),
      // Use pluginOptions.nodeIntegration, leave this alone
      // See nklayman.github.io/vue-cli-plugin-electron-builder/guide/security.html#node-integration for more info
      nodeIntegration: true// process.env.ELECTRON_NODE_INTEGRATION
    },
    show: !startHideWindow,
    // eslint-disable-next-line no-undef
    icon: path.join(__static, 'icon.png')
  })

  Menu.setApplicationMenu(null)
  win.setMenu(null)

  if (process.env.WEBPACK_DEV_SERVER_URL) {
    // Load the url of the dev server if in development mode
    win.loadURL(process.env.WEBPACK_DEV_SERVER_URL)
    if (!process.env.IS_TEST) win.webContents.openDevTools()
  } else {
    createProtocol('app')
    // Load the index.html when not in development
    win.loadURL('app://./index.html')
  }

  if (startHideWindow) {
    hideWin()
  }

  win.on('closed', async (e) => {
    win = null
    tray = null
  })

  ipcMain.on('close', async (event, message) => {
    if (message.value === 1) {
      quit()
    } else {
      hideWin()
    }
  })

  win.on('close', (e) => {
    if (forceClose) {
      return
    }
    e.preventDefault()
    if (isLinux()) {
      quit(app)
      return
    }
    const config = DevSidecar.api.config.get()
    const closeStrategy = config.app.closeStrategy
    if (closeStrategy === 0) {
      // 提醒
      win.webContents.send('close.showTip')
    } else if (closeStrategy === 1) {
      // 直接退出
      quit()
    } else if (closeStrategy === 2) {
      // 隐藏窗口
      hideWin()
    }
  })

  win.on('session-end', async (e) => {
    log.info('session-end', e)
    await quit()
  })
}

ipcMain.on("window-to-main", (event, arg) => {
  const ipcFunction =
    ipcFunctions[arg.message] ||
    (() => {
      log.error("Unknown winodw-to-main message: " + arg.message);
    });
  ipcFunction(event, arg);
});

/* 
 * IPC MAIN COMMUNICATION
 */

ipcMain.handle('GET_STORAGE_VALUE', (event, key) => {
  return global.storage.get(key)
})

initIpcMain() {
    ipcMain.on("IPC::ASK-OPEN-FILE", () => {
      this.dialog.askOpenFile();
    });
  }

createWindow = () => {
    // Rewrite URLs to handle host-relative URLs, which begin with a slash.
    protocol.registerBufferProtocol(scheme, (req, callback) => {
        let reqUrl = url.parse(req.url);
        let pathname = reqUrl.pathname;
        if (pathname.endsWith('/')) pathname += 'index.html';
        if (reqUrl.hostname === hostname) {
            let filePath = path.normalize(pathname);
            if (startsWith(filePath, prefixesStaticWithHtml)) {
                filePath += '.html';
            }
            filePath = path.join(webroot, filePath);

            fs.access(filePath, fs.constants.R_OK, (err) => {
                if (err) {
                    console.error(err);
                    callback(404);
                } else {
                    callback({
                        mimeType: mimeType(pathname), charset: 'UTF-8',
                        data:     fs.readFileSync(filePath)
                    });
                }
            });
        } else {
            serveLocalMirror(reqUrl, callback);
        }
    }, (err) => {
        if (err) console.error('ERROR: failed to register protocol', scheme);
    });
    protocol.registerServiceWorkerSchemes([scheme]);

    // Create the browser window.
    // https://electron.atom.io/docs/api/browser-window/
    mainWindow = new BrowserWindow({
        width: 1024, height: 768, backgroundColor: '#203C64',
        center:true, fullscreen:false,
        title: app.getName(),
        webPreferences: {
            nodeIntegration:false,
            preload: path.join(__dirname, 'preload.js')
        }
    });

    // and load the index.html of the app.
    mainWindow.loadURL(`${scheme}://${hostname}/`);

    // Open external URLs in the browser:
    mainWindow.webContents.on('will-navigate', (event, url) => {
        event.preventDefault();
        shell.openExternal(url);
    });

    // Open the DevTools.
    process.argv.some((arg) => {
        if (arg === '--dev') {
            mainWindow.webContents.openDevTools();
            return true;
        }
        return false;
    });

    // Implement window.prompt() and window.confirm() which are used by ZenGM:
    ipcMain.on('prompt', prompt);
    ipcMain.on('prompt-response', promptResponse);
    ipcMain.on('confirm', confirm);
    ipcMain.on('confirm-response', confirmResponse);

    // Emitted when the window is closed.
    mainWindow.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.
        mainWindow = null;
    });
}

ipcMain.on('projectWasCreated', (event, arg) => {
    scratchDesktopTelemetrySingleton.projectWasCreated(arg);
});

ipcMain.on('open-desktop-settings', () => {
  createDesktopSettingsWindow();
});

// IIFE

ipcMain.handle('get-initial-project-data', () => initialProjectDataPromise);

ipcMain.on("getGlobalHashrate", async (event) => {
  const globalHashrate = await getGlobalHashrate();
  event.reply("getGlobalHashrateReply", globalHashrate);
});

ipcMain.on(Close, event => {
  close();
  CurrentState = { code: 'none' };
  event.reply(GetAppState, CurrentState);
});

ipcMain.on('open-privacy-policy', () => {
  createPrivacyWindow()
});

ipcMain.handle('load-extension', (event, extension) => {
    _windows.main.webContents.send('loadExtensionFromFile', {extension});
});