@lynker-desktop/electron-ipc/README.md

electron-ipc

# electron-ipc

✨ 异步 electron ipc 调用机制.

> 渲染进程 窗口注意设置 contextIsolation=false
> https://github.com/electron/electron/pull/20307
> contextIsolation=false

## 🌿 安装

安装方式 [npm](https://www.npmjs.com/package/@lynker-desktop/electron-ipc):

```shell
npm i @lynker-desktop/electron-ipc --save
```

    
## 🌿 使用

📍 它必须导入到主进程的入口文件中。

（ 否则，呈现进程之间将无法通信。 ）

```js
import {initialize} from '@lynker-desktop/electron-ipc/main'
initialize();
```

### 1. 在 [主进程](https://electronjs.org/docs/glossary#main-process) 

```js
import MainIPC from '@lynker-desktop/electron-ipc/main'
// ... other code ...
```

### 2. 在 [preload](https://www.electronjs.org/docs/latest/tutorial/tutorial-preload) 引入

```javascript
import '@lynker-desktop/electron-ipc/preload'
```

### 3. 在 [渲染进程](https://electronjs.org/docs/glossary#renderer-process)

```typescript
import RendererIPC from '@lynker-desktop/electron-ipc/renderer'
// ... other code ...
```

## 🌿 例子

#### 🌵  1. 主进程A  ↔  主进程B

主进程可以向主进程发送消息并接收回调，如下面的示例所示 :

```js
// 主进程A:
const res = await MainIPC.invokeMain(`${channel}`, ...args)

// 主进程B: (two choices) 
MainIPC.handleMain(`${channel}`, async (...args) => { return res })
MainIPC.handleMainOnce(`${channel}`, async (...args) => { return res })
```


#### 🌵  2. 主进程  ↔  渲染进程

主进程可以向呈现进程发送消息并接收回调，如下面的示例所示 :

```js
/* 主进程: (two choices) */
const res = await MainIPC.invokeRenderer(`${webContents}`, `${channel}`, ...args)
const res = await MainIPC.invokeAllRenderer(`${channel}`, ...args)

/* 渲染进程: (two choices) */
RendererIPC.handleMain(`${channel}`, async (...args) => { return res })
RendererIPC.handleMainOnce(`${channel}`, async (...args) => { return res })
```


#### 🌱  3. 渲染进程A  ↔  渲染进程B

渲染进程可以向渲染进程发送消息并接收回调，如下所示
 example :

```js
// 渲染进程A:
const res = await RendererIPC.invokeRenderer(`${channel}`, ...args)

// 渲染进程B: (two choices)
RendererIPC.handleRenderer(`${channel}`, async (...args) => { return res })
RendererIPC.handleRendererOnce(`${channel}`, async (...args) => { return res })
```


#### 🌱  4. Renderer  ↔  Main

渲染进程可以向主进程发送消息并接收回调，如下面的示例所示 :

```js
// RendererA:
const res = await RendererIPC.invokeMain(`${channel}`, ...args)

// MainB:
MainIPC.handleRenderer(`${channel}`, async (...args) => { return res })
```

这个例子是once的情况(handleRendererOnce必须与invokeMainOnce一起使用) :

```js
// RendererA:
const res = await RendererIPC.invokeMainOnce(`${channel}`, ...args)

// MainB:
MainIPC.handleRendererOnce(`${channel}`, async (...args) => { return res })
```