Aller au contenu principal

Windows sur ARM

Si votre application fonctionne avec Electron 6.0.8 ou supérieur, vous pouvez maintenant la compiler pour Windows 10 sur Arm. Cela améliore considérablement la performance, mais nécessite une recompilation de tous les modules natifs utilisés dans votre application. Il peut également nécessiter de petites corrections pour vos scripts de compilation et d'empaquetage.

Exécution d'une application de base​

Si votre application n'utilise aucun module natif, alors il est vraiment facile de créer une version Arm de votre application.

  1. Assurez-vous que le dossier node_modules de votre application est vide.
  2. À l’aide de l'invite de commandes, exécutez set npm_config_arch=arm64 avant d’exécuter npm install/yarn install comme d’habitude.
  3. Si vous avez Electron installé en tant que dépendance de développement, npm téléchargera et décompressera la version arm64. Vous pouvez ensuite empaqueter et distribuer votre application comme d’habitude.

Considérations générales​

Code spécifique à l’architecture​

Beaucoup de code spécifique à Windows contient des logiques "if... else" qui sélectionne entre les architectures x64 ou x86.

if (process.arch === 'x64') {
  // code 64-bit...
} else {
  // Code 32-bit...
}

Si vous souhaitez cibler l'architecture arm64, une logique comme celle-ci sélectionnera généralement la mauvaise architecture, alors vérifiez soigneusement votre application et créez des scripts pour des conditions comme celle-ci. Dans les scripts de compilation et d’empaquetage personnalisés, vous devez toujours vérifier dans l’environnement la valeur de la variable npm_config_arch , plutôt que de vous fier simplement à l’architecture du processus actuel.

Modules natifs​

Si vous utilisez des modules natifs, vous devez vous assurer qu’ils sont compilés avec à la version 142 du compilateur MSVC (fourni dans Visual Studio 2017). Vous devez également vérifier que tous les fichiers .dll ou .lib prédéfinis fournis ou référencés par le module natif sont disponibles pour Windows sur Arm.

Tester votre application​

Pour tester votre application, utilisez un appareil Windows 10 sur Arm (version 1903 ou ultérieure). Assurez-vous de copier votre application sur l'ordinateur cible - le bac à sable de Chromium ne fonctionnera pas correctement lors du chargement de vos ressources d’application à partir d’un emplacement réseau.

Prérequis au développement​

Node.js/node-gyp​

Node.js v12.9.0 ou supérieur est recommandé. Si la mise à jour vers une nouvelle version de Node n'est pas souhaitable, vous pouvez plutôt mettre à jour manuellement la copie de node-gyp de npm vers la version 5.0.2 ou ultérieure, qui contient les changements nécessaires pour compiler les modules natifs pour Arm.

Visual Studio 2017​

Visual Studio 2017 (n'importe quelle édition) est requis pour la compilation croisée de modules natifs. Vous pouvez télécharger Visual Studio Community 2017 via le programme Microsoft Visual Studio Dev Essentials. Après l'installation, vous pouvez ajouter les composants spécifiques à Arm en exécutant ce qui suit à partir de l'invite de commandes:

vs_installer.exe ^
--add Microsoft.VisualStudio.Workload.NativeDesktop ^
--add Microsoft.VisualStudio.Component.VC.ATLMFC ^
--add Microsoft.VisualStudio.Component.VC.Tools.ARM64 ^
--add Microsoft.VisualStudio.Component.VC.MFC.ARM64 ^
--includeRecommended

Création d'une invite de commande de compilation croisée​

Définir le variable npm_config_arch=arm64 dans l'environnement crée les bons fichiers .obj pour l'architecture arm64, mais l'invite de commandes standard pour VS 2017 utilisera le lien x64. Pour régler ce problème :

  1. Dupliquez le raccourci x64_x86 Invite de commandes des outils croisés pour VS 2017 (p. ex. en le localisant dans le menu Démarrer, faisant un clic droit, sélectionnant Ouvrir l'emplacement du fichier et en le copiant) dans un endroit pratique.
  2. Faites un clic droit sur le nouveau raccourci et choisissez Propriétés.
  3. Modifiez le champ Cible pour lire vcvarsamd64_arm64.bat à la fin au lieu de vcvarsamd64_x86.bat.

Si cela est fait avec succès, l'invite de commande devrait afficher quelque chose de similaire à cela au démarrage:

**********************************************************************
** Visual Studio 2017 Developer Command Prompt v15.9.15
** Copyright (c) 2017 Microsoft Corporation
**********************************************************************
[vcvarsall.bat] Environment initialized for: 'x64_arm64'

Si vous souhaitez développer votre application directement sur un appareil Arm, substituer vcvarsx86_arm64.bat dans Cible afin que la compilation croisée puisse se produire avec l'émulation x86 de l'appareil.

Liaison avec le bon node.lib​

Par défaut, node-gyp décompresse les en-têtes d'Electron et télécharge les versions x86 et x64 de node.lib dans %APPDATA%\..\Local\node-gyp\Cache, mais il ne télécharge pas la version arm64 (un correctif est en cours de développement.) Pour régler ce problème :

  1. Téléchargez le node.lib pour arm64 au lien suivant : https://electronjs.org/headers/v6.0.9/win-arm64/node.lib
  2. Déplacez-le au dossier %APPDATA%\..\Local\node-gyp\Cache\6.0.9\arm64\node.lib

Remplacez 6.0.9 par la version que vous utilisez.

Compilation croisée des modules natifs​

Après avoir complété tout ce qui précède, ouvrez votre invite de commande de compilation croisée et exécutez set npm_config_arch=arm64. Utilisez ensuite npm install pour générer votre projet comme d'habitude. Comme avec la compilation croisée des modules x86, vous devrez peut-être supprimer votre dossier node_modules pour forcer la recompilation des modules natifs s'ils ont été déjà compilés pour une autre architecture.

Débogage des modules natifs​

Le débogage des modules natifs peut être fait à l'aide de Visual Studio 2017 (exécuté sur votre machine de développement) et du débogueur distant Visual Studio s'exécutant sur le périphérique cible. Pour déboguer :

  1. Lancez votre application .exe sur l'appareil cible via l'invite de commande (en passant --inspect-brk pour mettre en pause avant le chargement des modules natifs).
  2. Lancez Visual Studio 2017 sur votre machine de développement.
  3. Connectez-vous à l'appareil cible en sélectionnant Débogage > Attacher au processus... et entrez l'adresse IP de l'appareil et le numéro de port affiché par l'outil de débogage à distance Visual Studio.
  4. Cliquez sur Rafraîchir et sélectionnez le processus Electron approprié à attacher.
  5. Vous devrez peut-être vous assurer que tous les symboles des modules natifs de votre application sont chargés correctement. Pour configurer cela, accédez aux Débogage > Options... dans Visual Studio 2017 et ajoutez les dossiers contenant vos symboles .pdb sous Débogage > Symboles.
  6. Une fois attaché, définissez tous les points d'arrêt appropriés et reprenez l'exécution JavaScript à l'aide des outils distants de Chrome pour Node.

Obtenir de l’aide supplémentaire​

Si vous rencontrez un problème avec cette documentation, ou si votre application fonctionne lorsqu'elle est compilée pour x86 mais pas pour arm64, veuillez remplir un ticket avec "Windows on Arm" dans le titre.