Bunding precomstackdo binario en aplicación electrónica

¿Existe una buena solución sobre cómo incluir binarios precomstackdos de terceros como imagemgick en una aplicación electrónica? hay módulos node.js pero todos son envoltorios o enlaces nativos a las bibliotecas instaladas en todo el sistema. Me pregunto si es posible agrupar binarios precomstackdos dentro de la distribución.

Encontré una solución a esto, pero no tengo idea de si esto se considera la mejor práctica. No pude encontrar ninguna buena documentación para incluir binarios precomstackdos de terceros, así que simplemente jugué con ella hasta que finalmente funcionó con mi binario ffmpeg. Esto es lo que hice (comenzando con el inicio rápido de electron, node.js v6):

Método Mac OS X

Desde el directorio de aplicaciones ejecuté los siguientes comandos en Terminal para incluir el binario ffmpeg como un módulo:

mkdir node_modules/ffmpeg cp /usr/local/bin/ffmpeg node_modules/ffmpeg/ cd node_modules/.bin ln -s ../ffmpeg/ffmpeg ffmpeg 

(Reemplace /usr/local/bin/ffmpeg con su ruta binaria actual, descárguelo desde aquí) Al colocar el enlace, el paquete de electrones incluido para incluir el binario que node_modules/ffmpeg/ en node_modules/ffmpeg/ .

Luego, para obtener la ruta de la aplicación incluida (de modo que pudiera usar una ruta absoluta para mi binario … las rutas relativas no parecían funcionar a pesar de lo que hice) instalé el paquete npm app-root-dir ejecutando lo siguiente mando:

 npm i -S app-root-dir 

Ahora que tenía el directorio de la aplicación raíz, solo agregué la subcarpeta para mi binario y la generé desde allí. Este es el código que puse en renderer.js :.

 var appRootDir = require('app-root-dir').get(); var ffmpegpath=appRootDir+'/node_modules/ffmpeg/ffmpeg'; console.log(ffmpegpath); const spawn = require( 'child_process' ).spawn, ffmpeg = spawn( ffmpegpath, ['-i',clips_input[0]]); //add whatever switches you need here ffmpeg.stdout.on( 'data', data => { console.log( `stdout: ${data}` ); }); ffmpeg.stderr.on( 'data', data => { console.log( `stderr: ${data}` ); }); 

Método de Windows

  1. Abra su carpeta base electrónica (electron-quick-start es el nombre predeterminado), luego vaya a la carpeta node_modules. Cree una carpeta allí llamada ffmpeg y copie su binario estático en este directorio. Nota: debe ser la versión estática de su binario, para ffmpeg tomé la última comstackción de Windows aquí .
  2. Para obtener la ruta de la aplicación incluida (de modo que pudiera usar una ruta absoluta para mi binario … las rutas relativas no parecen funcionar a pesar de lo que hice). Instalé el paquete npm app-root-dir ejecutando el siguiente comando desde un indicador de comando en mi directorio de aplicaciones:

      npm i -S app-root-dir 
  3. Dentro de su carpeta node_modules, navegue a la subcarpeta .bin. Debe crear un par de archivos de texto aquí para indicar al nodo que incluya el archivo exe binario que acaba de copiar. Use su editor de texto favorito y cree dos archivos, uno llamado ffmpeg con los siguientes contenidos:

     #!/bin/sh basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')") case `uname` in *CYGWIN*) basedir=`cygpath -w "$basedir"`;; esac if [ -x "$basedir/node" ]; then "$basedir/node" "$basedir/../ffmpeg/ffmpeg" "$@" ret=$? else node "$basedir/../ffmpeg/ffmpeg" "$@" ret=$? fi exit $ret 

    Y el segundo archivo de texto, llamado ffmpeg.cmd :

     @IF EXIST "%~dp0\node.exe" ( "%~dp0\node.exe" "%~dp0\..\ffmpeg\ffmpeg" %* ) ELSE ( @SETLOCAL @SET PATHEXT=%PATHEXT:;.JS;=;% node "%~dp0\..\ffmpeg\ffmpeg" %* ) 

A continuación, puede ejecutar ffmpeg en su distribución electrónica de Windows (en renderer.js) de la siguiente manera (también estoy usando el módulo de nodo app-root-dir). Tenga en cuenta las citas agregadas a la ruta binaria, si su aplicación se instala en un directorio con espacios (por ejemplo, C:\Program Files\YourApp ) no funcionará sin estos.

 var appRootDir = require('app-root-dir').get(); var ffmpegpath = appRootDir + '\\node_modules\\ffmpeg\\ffmpeg'; const spawn = require( 'child_process' ).spawn; var ffmpeg = spawn( 'cmd.exe', ['/c', '"'+ffmpegpath+ '"', '-i', clips_input[0]]); //add whatever switches you need here, test on command line first ffmpeg.stdout.on( 'data', data => { console.log( `stdout: ${data}` ); }); ffmpeg.stderr.on( 'data', data => { console.log( `stderr: ${data}` ); }); 

Aquí hay otro método, probado con Mac y Windows hasta ahora. Requiere el paquete ‘app-root-dir’, no requiere agregar nada manualmente a node_modules dir.

  1. Coloque sus archivos en recursos / $ os /, donde $ os es “mac” , “linux” o “win” . El proceso de comstackción copiará los archivos de esos directorios según el sistema operativo de destino de comstackción.

  2. Ponga la opción extraFiles en sus configuraciones de construcción de la siguiente manera:

paquete.json

  "build": { "extraFiles": [ { "from": "resources/${os}", "to": "Resources/bin", "filter": ["**/*"] } ], 
  1. Utilice algo como esto para determinar la plataforma actual.

get-platform.js

 import { platform } from 'os'; export default () => { switch (platform()) { case 'aix': case 'freebsd': case 'linux': case 'openbsd': case 'android': return 'linux'; case 'darwin': case 'sunos': return 'mac'; case 'win32': return 'win'; } }; 
  1. Llame al ejecutable desde su aplicación dependiendo de env y OS. Aquí asumo que las versiones construidas están en modo de producción y versiones de origen en otros modos, pero puede crear su propia lógica de llamada.
 import { join as joinPath, dirname } from 'path'; import { exec } from 'child_process'; import appRootDir from 'app-root-dir'; import env from './env'; import getPlatform from './get-platform'; const execPath = (env.name === 'production') ? joinPath(dirname(appRootDir.get()), 'bin'): joinPath(appRootDir.get(), 'resources', getPlatform()); const cmd = `${joinPath(execPath, 'my-executable')}`; exec(cmd, (err, stdout, stderr) => { // do things }); 

Creo que estaba usando electron-builder como base, la generación de archivos env viene con eso. Básicamente es solo un archivo de configuración JSON.

tl; dr:

¡sí tu puedes! pero requiere que escribas tu propio complemento autónomo que no hace ninguna suposición en las bibliotecas del sistema. Además, en algunos casos debes asegurarte de que tu complemento esté comstackdo para el sistema operativo deseado.


Vamos a romper esta pregunta en varias partes:

– Complementos (módulos nativos) :

Los complementos son objetos compartidos dinámicamente vinculados.

En otras palabras, puede escribir su propio complemento sin depender de bibliotecas de todo el sistema (por ejemplo, vinculando estáticamente los módulos necesarios) que contienen todo el código que necesita.

Debe tener en cuenta que dicho enfoque es específico del sistema operativo, lo que significa que debe comstackr su complemento para cada sistema operativo que desee admitir. (Dependiendo de que otras bibliotecas pueda usar)

– Módulos nativos para electron :

Electron admite los módulos de Node nativos, pero dado que Electron está utilizando una versión V8 diferente a la del Nodo oficial, debe especificar manualmente la ubicación de los encabezados de Electron al crear módulos nativos

Esto significa que un módulo nativo que se ha construido contra encabezados de nodo debe reconstruirse para ser utilizado dentro de electron. Usted puede encontrar cómo en documentos electrónicos.

– Paquetes de paquetes con aplicación electrónica :

Supongo que desea tener su aplicación como un ejecutable independiente sin requerir que los usuarios instalen electron en sus máquinas. Si es así, puedo sugerir el uso de empaquetador de electrones .