Open menu

1°/ Principes

 L'objectif d'électron est de construire un exécutable à partir du code d'une application web de type SPA, par exemple écrite en vuejs. Pour ce faire, electron embarque dans l'exécutable un moteur d'interprétation JS, qui va afficher le résultat dans une fenêtre classique, telle que celle qu'on crée dans une application Java ou Qt.

 

2°/ Avec vuejs v3

2.1°/ From sractch 

Il existe différentes façons d'empaqueter une application electron en utilisant vuejs+vite. Dans le cas général, le plus simple est de commencer le développement avec un "kit de base" (une "boiler plate"), qui va intégrer tous les plugins/scripts nécessaires à la production d'une version de dev. et de production de l'application, tout en conservant les facilités de vite et du développement interactif. Il existe différent projets node de type boiler plate, avec une architecture plus ou moins complète. Un des plus simple à mettre en place est : https://github.com/electron-vite/electron-vite-vue/blob/main/README.md. Une fois installé, il suffit de créer ses sources dans src/ , comme avec n'importe quel projet vue classique. La différence est que l'exécution du script de dev produit une application electron au lieu de se lancer dans un navigateur.

2.2°/ Depuis un existant

Si l'on dispose déjà d'un projet complet existant, il est possible de le "passer" sous electron avec quelques modifications/ajouts simples décrits ci-après (NB : tirés de la boiler plate indiquée ci-dessus). Attention cependant, il n'est plus possible de le lancer en mode développement avec une visualisation dans un navigateur.

Pour créer une application electron à partir d'un projet vuejs, la première étape est d'inclure les plugins liés à electron et vite au projet, comme dépendances de développement :

npm install electron --save-dev
npm install electron-builder --save-dev
npm install vite-plugin-electron --save-dev

 

Ensuite, il faut modifier le fichier de configuration de vite afin de paramétrer electron. Pour cela, il faut éditer le fichier vite.config.mjs (l'extension peut être .ts si projet en typescript) et le modifier comme suivant :

...
// adding electron-vite support
import electron from 'vite-plugin-electron/simple'
...
export default defineConfig( {
  plugins: [
     ...
    // electron config
    electron({
      main: {
        entry: 'electron/index.js',
        /* If needed, use onstart to define what to do before starting up the app
           In the present case, just display a message.
           NB: seems to only work in dev mode.
         */
        onstart({startup}) {
          console.log("starting app")
          startup()
        },
      },
    }),
    ...
  ],
  ...
})

Remarques :

  • on peut mettre la configuration electron n'importe où dans le tableau plugins, par exemple juste après celle de vue.
  • le fichier electron/index.js sert à vite-plugin-electron pour construire la fenêtre de l'application en mode dev, et définir certains comportement basiques de celle-ci. Ce fichier est également "transformé" pour en faire une version utilisée en mode production (cf. dernière étape)

Comme indiqué ci-dessus, il faut nécessairement fournir un fichier qui décrit comment construire la fenêtre principale de l'application. Pour écrire ce fichier, on peut se référer à la documentation de electron, mais le plus simple est de reprendre et modifier des exemples trouvés sur le net, qui conviennent généralement à tous les projets. Exemple possible (tiré de la démonstration) : index.js.

Cet exemple est un peu plus complexe que l'exemple de départ de la documentation electron. En effet, il permet de :

  • différencier le mode de lancement de l'application (dev ou production),
  • de permettre ou non l'utilisation de l'inspecteur (cf. options devTools) selon le mode d'exécution,
  • d'éviter que des liens vers d'autres sites s'ouvrent directement dans la fenêtre principale (cf. gestionnaire d'événement will-navigate),
  • de fermer correctement l'application,
  • etc.

Les seules modifications à apporter pour une autre application sont essentiellement changer le titre et la dimension de la fenêtre.

Selon la configuration du projet, l'emplacement de ce fichier peut différer. Dans le cas présent, on a clairement indiqué à vite-plugin-electron que ce fichier se trouve dans electron/index.js. Il faut donc créer le répertoire à la racine du projet, puis créer index.js dedans.

 

L'avant dernière étape consiste à configurer electron-builder pour lui indiquer comment créer les exécutable. Pour cela, il faut écrire un fichier de configuration, au format yml ou json. Le plus simple est de nouveau d'utiliser des exemples tirés du net, tels que : electron-builder.json5. (NB: json5 est un format json qui permet les commentaires)

Remarques :

  • le nom du fichier a son importance car electron-builder cherche par défaut sa configuration dans un fichier avec ce nom.
  • les répertoires contenant les sources à empaqueter sont données via le champ files. Dans le cas présent, on remarque que electron-builder doit inclure tout le code compilé de l'application vue (c.a.d. dans dist) mais aussi le contenu de dist-electron (cf. dernière étape ci-dessous)
  • cet exemple doit être modifié en changeant l'id et le nom de l'application. On peut également changer le type de produit. Par exemple, sur un distribution linux, cette configuration produit une AppImage, mais il est possible de créer des paquet .deb, ou encore d'autre formats (cf. documentation electron-builder : https://www.electron.build/app-builder-lib.interface.linuxconfiguration)

 

Enfin, il faut modifier le fichier package.json en ajoutant un champ main, et en modifiant la valeur du champ build dans l'objet scripts, comme suivant :

{
  ...
  "main": "dist-electron/index.js"
  ...
  "scripts": {
    ...
    "build": "vite build && electron-builder",
    ...
  }
  ...
}

Le premier ajout permet d'indiquer à vite-plugin-electron où il doit déposer le fichier permettant de créer la fenêtre applicative en mode production (pour rappel : ce fichier est créé à partir de electron/index.js). Dans le cas présent, on le met dans dist-electron, pour que cela corresponde à la configuration de electron-builder.

Le deuxième modification permet simplement de lancer automatiquement electron-builder après avoir créé la version de production de l'application web. Cela évite de le faire manuellement.

 

Pour créer l'exécutable : npm run build. Le résultat se trouve dans le répertoire release (cf. electron-builder.json5). Sous linux, il s'agit d'une AppImage que l'on peut exécuter directement (NB : il faut cependant que libfuse2 soit installé)

 

3°/ Problèmes classiques

3.1°/ mode de l'historique de vue-router.

Dans certains cas, vue-router ne fonctionne pas correctement en version de production electron. Dans ce cas, il faut que vue-routeur gère l'historique de navigation dans un mode nommé hash. Généralement, le mode par défaut est history.

Pour régler ce problème, il suffit d'éditer le fichier définissant les routes, contenant généralement la création de l'instance de vue-router. Lors de cette instanciation, il suffit de régler le mode en fonction de si on utilise electron ou non :

const router = createRouter({
  history: process.env.IS_ELECTRON ? createWebHashHistory(import.meta.env.BASE_URL) : createWebHistory(import.meta.env.BASE_URL),
  routes: routes,
})

 

3.2°/ certificats SSL invalides

Il est fréquent qu'un site ou une API utilise des certificats ssl auto-signé, qui ne sont donc pas reconnus par les navigateurs. Dans ce cas, un message d'alerte apparaît et l'on peut passer outre en ajoutant une exception pour le site. En revanche, ce mécanisme d'exception n'est pas disponible dans une application electron. Il faut donc le faire par des instructions.

Pour cela, il faut éditer le fichier electron/index.js mentionné plus haut et ajouter dedans :

// SSL certificate error pass-through
app.on('certificate-error', (event, webContents, url, error, certificate, callback) => {
    if ( (VITE_DEV_SERVER_URL) && (url.startsWith("https://localhost:4567/") ) {
    event.preventDefault()
    callback(true)
  } else {
    callback(false)
  }
})

 

Le test sur l'URL doit bien entendu être modifié pour correspondre à l'adresse du site ou de l'API qui fonctionne avec des certificats auto-signés.

ATTENTION : en production, ce genre de "contournement" est proscrit. C'est pourquoi on ne le fait que si l'application est en mode dev.