Cómo se comunican la interfaz y el proceso principal en Electron (IPC)

Cuando haces tu primera app en Electron, llega un momento en que quieres leer un archivo desde un botón de tu pantalla. Escribes require('fs') en tu página y aparece un error. Ahí te enteras de que tu app tiene dos mundos separados y que tienes que aprender a comunicarlos con IPC.

Esa comunicación se llama IPC (siglas de “comunicación entre procesos”). Una vez que la entiendes, el resto de Electron se vuelve mucho más claro: guardar archivos, usar una base de datos o imprimir se hacen todos con este mecanismo.

Aquí te explico cómo funciona y te dejo los dos patrones que vas a usar el 95 % del tiempo.

Los dos mundos de Electron y cómo los une el IPC

  • Proceso principal: corre en Node.js. Puede abrir archivos, crear ventanas, usar la base de datos y hablar con el sistema operativo. Solo hay uno.
  • Proceso de renderizado: es la página web dentro de cada ventana. Se ve y responde a clics, pero por seguridad no puede tocar el sistema directamente.

Si la página necesita algo del sistema, le pide al proceso principal que lo haga y espera la respuesta. Eso es IPC.

Patrón 1: pedir algo y esperar respuesta

Es el más común. La página pregunta y el principal contesta. Se usa ipcRenderer.invoke de un lado y ipcMain.handle del otro.

En el proceso principal (main.js):

const { ipcMain, app } = require('electron')

ipcMain.handle('app:version', () => {
  return app.getVersion()
})

ipcMain.handle('suma', (evento, a, b) => {
  return a + b
})

En el preload (preload.js), expones una función para la página:

const { contextBridge, ipcRenderer } = require('electron')

contextBridge.exposeInMainWorld('api', {
  version: () => ipcRenderer.invoke('app:version'),
  sumar: (a, b) => ipcRenderer.invoke('suma', a, b)
})

Y en tu página:

const version = await window.api.version()
const resultado = await window.api.sumar(2, 3)
console.log(version, resultado) // 1.0.0 5

Fíjate que la página nunca ve ipcRenderer. Solo ve las dos funciones que tú decidiste mostrar. Por qué importa tanto eso lo explico en el siguiente artículo.

Patrón 2: avisar desde el principal a la página

A veces el aviso va al revés: el principal quiere decirle algo a la página sin que ella lo pida. Por ejemplo, “terminó la descarga” o “el usuario hizo clic en el menú”.

En el principal:

ventana.webContents.send('descarga:lista', 'archivo.zip')

En el preload:

contextBridge.exposeInMainWorld('api', {
  alTerminarDescarga: (callback) => {
    ipcRenderer.on('descarga:lista', (evento, nombre) => callback(nombre))
  }
})

En la página:

window.api.alTerminarDescarga((nombre) => {
  console.log('Se descargó', nombre)
})

Por qué a veces “no responde”

Si tu app se queda congelada, casi siempre es por una de estas razones:

  1. Trabajo pesado en el proceso principal. Un fs.readFileSync de un archivo enorme o un bucle largo bloquea todo. Usa las versiones asíncronas (fs.promises).
  2. Olvidaste el await. Con invoke siempre recibes una promesa. Si no la esperas, obtienes Promise { <pending> } en vez del dato.
  3. El nombre del canal no coincide. 'app:version' y 'app-version' son canales distintos y no marca error, solo se queda esperando.
  4. Error dentro del handle. Si el código falla, el invoke de la página rechaza la promesa. Envuelve las llamadas en try/catch para verlo.

Reglas simples para no perderte

  • Ponle a cada canal un nombre claro con prefijo: archivos:leer, ventas:guardar, impresora:imprimir.
  • Usa invoke y handle siempre que necesites respuesta. Deja send y on para avisos.
  • Revisa los datos que llegan al handle. Eso también es parte de la seguridad, y lo vemos más adelante.

Con esto ya puedes conectar cualquier botón de tu pantalla con cualquier función de tu computadora.

Dejar un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *