session

Gère les sessions du navigateur, les cookies, le cache, les paramètres de proxy, etc.

Processus : Main

Le module session peut être utilisé pour créer des objets Session.

Vous pouvez également accéder à la session des pages existantes à l’aide de la propriété session des WebContents, ou le module session.

const { BrowserWindow } = require('electron')

const win = new BrowserWindow({ width: 800, height: 600 })
win.loadURL('http://github.com')

const ses = win.webContents.session
console.log(ses.getUserAgent())

Méthodes

Le module session dispose des méthodes suivantes :

session.fromPartition(partition[, options])

• partition string
• options Object (facultatif)
  • cache booléen - Indique si il faut activer le cache.

Retourne Session - Une instance de session de la chaîne de caractères partition. Quand il y a une Session existante avec la même partition, elle sera retournée; sinon une nouvelle instance Session sera créée avec options.

Si partition commence par persist:, la page utilisera une session persistante disponible pour toutes les pages de l'application avec la même partition. s'il n'y a pas de persist: préfixe, la page utilisera une session en mémoire. Si le partition est vide puis la session par défaut de l'application sera retournée.

Pour créer une Session avec options, vous devez vous assurer que la Session avec la partition n'a jamais été utilisée auparavant. Il n'y a pas moyen de changer les options d'un objet Session existant.

Propriétés

Le module session dispose des propriétés suivantes :

session.defaultSession

Un objet Session, l'objet d'une session par défaut de l'application.

Classe : Session

Les propriétés getter et setter d'une session.

Processus : Principal
Cette classe n'est pas exportée depuis le module 'electron'. Elle n'est disponible qu'en tant que valeur de retour des autres méthodes dans l'API Electron.

Vous pouvez créer un objet Session avec le module session :

const { session } = require('electron')
const ses = session.fromPartition('persist:name')
console.log(ses.getUserAgent())

Événements d’instance

Les événements suivants sont disponibles pour les instances de Session :

Événement : 'will-download'

Retourne :

• event Event
• item DownloadItem
• webContents WebContents

Émis lorsque Electron est sur le point de télécharger item dans webContents.

Faire appel à Event.preventDefault () annule le téléchargement et item ne sera pas disponible dans le battement suivant du processus.

const { session } = require('electron')
session.defaultSession.on('will-download', (event, item, webContents) => {
  event.preventDefault()
  require('got')(item.getURL()).then((response) => {
    require('fs').writeFileSync('/somewhere', response.body)
  })
})

Événement : 'extension-loaded'

Retourne :

• event Event
• extension Extension

Émis après le chargement d’une extension. Cela se produit chaque fois qu’une extension ajoutée à l’ensemble d’extensions « activées ». Ceci comprend :

• Extensions chargées à partir session.loadExtension.
• Extensions rechargées :
  • à partir d'un plantage.
  • si l'extension l'a demandée (chrome.runtime.reload()).

Événement : 'extension-unloaded'

Retourne :

• event Event
• extension Extension

Émis après le déchargement d’une extension. Cela se produit lorsque Session.removeExtension est appelée.

Événement : 'extension-ready'

Retourne :

• event Event
• extension Extension

Émis après le chargement d’une extension et l’initialisation de tout l’état du navigateur nécessaire pour prendre en charge le démarrage de la page d’arrière-plan de l’extension.

Événement : 'preconnect'

Retourne :

• event Event
• preconnectUrl string - URL demandée pour la préconnexion par le moteur de rendu.
• allowCredentials boolean - Vrai si le moteur de rendu demande que la connexion inclue les identifiants (voir la spécification pour plus de détails.)

Émis lorsqu'un processus de rendu demande de préconnexion à une URL, généralement à cause de un hintressource .

Événement : 'spellcheck-dictionary-initialized'

Retourne :

• event Event
• String languageCode - Code de la langue du fichier de dictionnaire

Émis lorsqu'un fichier de dictionnaire hunspell a été initialisé avec succès. Émis après le téléchargement du fichier.

Événement : 'spellcheck-dictionary-download-begin'

Retourne :

• event Event
• languageCode string - Code de langue du fichier de dictionnaire

Émis lors du début de téléchargement d'un fichier de dictionnaire hunspell

Événement : 'spellcheck-dictionary-download-success'

Retourne :

• event Event
• languageCode string - Code de langue du fichier de dictionnaire

Émis lorsqu'un fichier de dictionnaire hunspell a été téléchargé avec succès

Événement : 'spellcheck-dictionary-download-failure'

Retourne :

• event Event
• languageCode string - Code de langue du fichier de dictionnaire

Émis lorsque le téléchargement d'un fichier de dictionnaire hunspell échoue. Pour plus de détails sur l'échec, vous devriez collecter un log réseau et inspecter la demande de téléchargement.

Événement : 'select-hid-device'

Retourne :

• event Event
• Objet details
  • deviceList HIDDevice[]
  • frame WebFrameMain
• callback Function
  • deviceId string | null (optional)

Émis lorsqu'un périphérique HID doit être selectionné lors de l'appel de navigator.hid.requestDevice. callback doit être appelé avec le deviceId à sélectionner, le passage d'une string vide à la callback annulera la requête. De plus, la permission sur navigator.hid pourra être gérée ultérieurement en utilisant ses.setPermissionCheckHandler(handler) et ses.setDevicePermissionHandler(handler)`.

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

let win = null

app.whenReady().then(() => {
  win = new BrowserWindow()

  win.webContents.session.setPermissionCheckHandler((webContents, permission, requestingOrigin, details) => {
    if (permission === 'hid') {
      // Add logic here to determine if permission should be given to allow HID selection
      return true
    }
    return false
  })

  // Optionally, retrieve previously persisted devices from a persistent store
  const grantedDevices = fetchGrantedDevices()

  win.webContents.session.setDevicePermissionHandler((details) => {
    if (new URL(details.origin).hostname === 'some-host' && details.deviceType === 'hid') {
      if (details.device.vendorId === 123 && details.device.productId === 345) {
        // Always allow this type of device (this allows skipping the call to `navigator.hid.requestDevice` first)
        return true
      }

      // Search through the list of devices that have previously been granted permission
      return grantedDevices.some((grantedDevice) => {
        return grantedDevice.vendorId === details.device.vendorId &&
              grantedDevice.productId === details.device.productId &&
              grantedDevice.serialNumber && grantedDevice.serialNumber === details.device.serialNumber
      })
    }
    return false
  })

  win.webContents.session.on('select-hid-device', (event, details, callback) => {
    event.preventDefault()
    const selectedDevice = details.deviceList.find((device) => {
      return device.vendorId === '9025' && device.productId === '67'
    })
    callback(selectedDevice?.deviceId)
  })
})

Événement : 'hid-device-added'

Retourne :

• event Event
• Objet details
  • device HIDDevice[]
  • frame WebFrameMain

Émis après l'appel à navigator.hid.requestDevice et le déclenchement de select-hid-device si un nouvel appareil est disponible avant que la callback de select-hid-device ne soit appelée. Cet événement est destiné à être utilisé lors de l'utilisation d'une interface utilisateur demandant aux utilisateurs de choisir un appareil afin que celui-ci puisse être mise à jour avec le périphérique nouvellement ajouté.

Événement : 'hid-device-removed'

Retourne :

• event Event
• Objet details
  • device HIDDevice[]
  • frame WebFrameMain

Émis après l'appel à navigator.hid.requestDevice et le déclenchement de select-hid-device si un nouvel appareil est disponible avant que la callback de select-hid-device ne soit appelée. Cet événement est destiné à être utilisé lors de l'utilisation d'une interface utilisateur demandant aux utilisateurs de choisir un appareil afin que celui-ci puisse être mise à jour avec le périphérique nouvellement ajouté.

Événement : 'hid-device-revoked'

Retourne :

• event Event
• Objet details
  • device HIDDevice[]
  • origin string (facultatif) - Origine à, partir de laquelle l’appareil a été révoqué.

Émis après que HIDDevice.forget() ai été appelé. Cet événement peut être utilisé pour faciliter le stockage permanent des permissions lorsque setDevicePermissionHandler est utilisé.

Événement : 'select-serial-port'

Retourne :

• event Event
• portList SerialPort[]
• webContents WebContents
• callback Function
  • portId string

Émis lorsqu'un port série doit être sélectionné lorsqu'un appel à navigator.serial.requestPort est effectué. callback doit être appelé avec le portId à sélectionner, le passage d'une string vide à la callback annulera la requête. De plus, la permission sur navigator.serial pourra être gérée en utilisant ses.setPermissionCheckHandler(handler) . avec la permission serial.

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

let win = null

app.whenReady(). hen(() => {
  win = new BrowserWindow({
    width: 800,
    height: 600
  })

  win.webContents.session. etPermissionCheckHandler((webContents, permission, requestingOrigin, details) => {
    if (permission === 'serial') {
      // Ajoute une logique ici pour déterminer si l'autorisation doit être donnée pour permettre la sélection en série
      return true
    }
    return false
  })

  // Optionnellement, récupérer des périphériques stockés depuis un magasin persistant
  const accortedDevices = fetchGrantedDevices()

  win. webContents.session.setDevicePermissionHandler((détails) => {
    if (new URL(details.origin). ostname === 'some-host' && details.deviceType === 'serial') {
      if (détails. evice.vendorId === 123 && details.device. roductId === 345) {
        // Toujours autoriser ce type de périphérique (cela permet de ne
  // pas devoir appeller d'abord  `navigator. sérial. equestPort` )
        return true
      }

      // Recherchez dans la liste des périphériques qui ont été précédemment autorisés
      return accordés. ome((accortedDevice) => {
        return grantedDevice. endorId === details.device.vendorId &&
              grantedDevice. roductId === details.device. roductId &&
              accortedDevice. erialNumber && grantedDevice.serialNumber === details.device. erialNumber
      })
    }
    retour faux
  })

  victoire. session eContents.. n('select-serial-port', (event, portList, webContents, callback) => {
    event.preventDefault()
    const selectedPort = portList. ind((device) => {
      return device.vendorId === '9025' && device. roductId === '67'
    })
    if (! electedPort) {
      callback('')
    } else {
      callback(selectedPort. ortId)
    }
  })
})

Événement : 'serial-port-added'

Retourne :

• event Event
• port SerialPort
• webContents WebContents

Émis après l'appel à navigator.serial.requestPort et le déclenchement de select-serial-port si un nouvel appareil est disponible avant que la callback de select-serial-port ne soit appelée. Cet événement est destiné à être utilisé lors de l'utilisation d'une interface utilisateur demandant aux utilisateurs de choisir un appareil afin que celui-ci puisse être mise à jour avec le périphérique nouvellement ajouté.

Événement : 'serial-port-removed'

Retourne :

• event Event
• port SerialPort
• webContents WebContents

Émis après l'appel à navigator.serial.requestPort et le déclenchement de select-serial-port si un nouvel appareil est disponible avant que la callback de select-serial-port ne soit appelée. Cet événement est destiné à être utilisé lors de l'utilisation d'une interface utilisateur demandant aux utilisateurs de choisir un appareil afin que celui-ci puisse être mise à jour avec le périphérique nouvellement ajouté.

Événement : 'serial-port-revoked'

Retourne :

• event Event
• Objet details
  • port SerialPort
  • frame WebFrameMain
  • origin string - Origine à, partir de laquelle l’appareil a été révoqué.

Émis après que SerialPort.forget() ai été appelé. Cet événement peut être utilisé pour faciliter le stockage permanent des permissions lorsque setDevicePermissionHandler est utilisé.

// Processus de Navigateur
const { app, BrowserWindow } = require('electron')

app.whenReady().then(() => {
  const win = new BrowserWindow({
    width: 800,
    height: 600
  })

  win.webContents.session.on('serial-port-revoked', (event, details) => {
    console.log(`Access revoked for serial device from origin ${details.origin}`)
  })
})

// Processus de rendu

const portConnect = async () => {
  // Demande un port.
  const port = attendre navigator.serial.requestPort()

  // Attente de l'ouverture du port série.
  await port.open({ baudRate: 9600 })

  // ...plus tard supprime l'acces au port série.
  await port.forget()
}

Event: 'select-usb-device'

Retourne :

• event Event
• Objet details
  • deviceList USBDevice[]
  • frame WebFrameMain
• callback Function
  • deviceId string (optional)

Emitted when a USB device needs to be selected when a call to navigator.usb.requestDevice is made. callback doit être appelé avec le deviceId à sélectionner, le passage d'une string vide à la callback annulera la requête. Additionally, permissioning on navigator.usb can be further managed by using ses.setPermissionCheckHandler(handler) and ses.setDevicePermissionHandler(handler)`.

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

let win = null

app.whenReady().then(() => {
  win = new BrowserWindow()

  win.webContents.session.setPermissionCheckHandler((webContents, permission, requestingOrigin, details) => {
    if (permission === 'usb') {
      // Add logic here to determine if permission should be given to allow USB selection
      return true
    }
    return false
  })

  // Optionally, retrieve previously persisted devices from a persistent store (fetchGrantedDevices needs to be implemented by developer to fetch persisted permissions)
  const grantedDevices = fetchGrantedDevices()

  win.webContents.session.setDevicePermissionHandler((details) => {
    if (new URL(details.origin).hostname === 'some-host' && details.deviceType === 'usb') {
      if (details.device.vendorId === 123 && details.device.productId === 345) {
        // Always allow this type of device (this allows skipping the call to `navigator.usb.requestDevice` first)
        return true
      }

      // Search through the list of devices that have previously been granted permission
      return grantedDevices.some((grantedDevice) => {
        return grantedDevice.vendorId === details.device.vendorId &&
              grantedDevice.productId === details.device.productId &&
              grantedDevice.serialNumber && grantedDevice.serialNumber === details.device.serialNumber
      })
    }
    return false
  })

  win.webContents.session.on('select-usb-device', (event, details, callback) => {
    event.preventDefault()
    const selectedDevice = details.deviceList.find((device) => {
      return device.vendorId === '9025' && device.productId === '67'
    })
    if (selectedDevice) {
      // Optionally, add this to the persisted devices (updateGrantedDevices needs to be implemented by developer to persist permissions)
      grantedDevices.push(selectedDevice)
      updateGrantedDevices(grantedDevices)
    }
    callback(selectedDevice?.deviceId)
  })
})

Event: 'usb-device-added'

Retourne :

• event Event
• Objet details
  • device USBDevice
  • frame WebFrameMain

Emitted after navigator.usb.requestDevice has been called and select-usb-device has fired if a new device becomes available before the callback from select-usb-device is called. Cet événement est destiné à être utilisé lors de l'utilisation d'une interface utilisateur demandant aux utilisateurs de choisir un appareil afin que celui-ci puisse être mise à jour avec le périphérique nouvellement ajouté.

Event: 'usb-device-removed'

Retourne :

• event Event
• Objet details
  • device USBDevice
  • frame WebFrameMain

Emitted after navigator.usb.requestDevice has been called and select-usb-device has fired if a device has been removed before the callback from select-usb-device is called. Cet événement est destiné à être utilisé lors de l'utilisation d'une interface utilisateur demandant aux utilisateurs de choisir un appareil afin que celui-ci puisse être mise à jour avec le périphérique nouvellement ajouté.

Event: 'usb-device-revoked'

Retourne :

• event Event
• Objet details
  • device USBDevice[]
  • origin string (facultatif) - Origine à, partir de laquelle l’appareil a été révoqué.

Emitted after USBDevice.forget() has been called. Cet événement peut être utilisé pour faciliter le stockage permanent des permissions lorsque setDevicePermissionHandler est utilisé.

Méthodes d’instance

Les méthodes suivantes sont disponibles pour les instances de Session :

ses.getCacheSize()

Retourne Promise<Integer> - la taille actuelle du cache de la session, en octets.

ses.clearCache()

Retourne Promise<void> - résout lorsque l'opération de nettoyage du cache est terminée.

Efface le cache HTTP de la session.

ses.clearStorageData([options])

• options Object (facultatif)
  • origin string (facultatif) - Doit suivre le scheme://host:port représentant l' window.location.origin .
  • storages string[] (optional) - Les storages à nettoyer peuvent être des types suivants: cookies, filesystem, indexdb, localstorage, shadercache, websql, serviceworkers, cachestorage. Si rien n'est spécifié, tous les types de stockage seront nettoyés.
  • quotas string[] (optional) - The types of quotas to clear, can contain: temporary, syncable. S'il n'est pas spécifié, effacez tous les quotas.

Retourne une Promise<void> - qui se résout lorsque les données de stockage ont été effacées.

ses.flushStorageData()

Écrit toutes les données du DOMStorage non écrites sur le disque.

ses.setProxy(config)

• config Object
  • mode string (facultatif) - Le mode proxy. Doit être une des valeurs suivantes: direct, auto_detect, pac_script, fixed_servers ou system. Le mode sera automatiquement déterminé si il n'est pas spécifié et ceci en fonction d'autres options spécifiées.
    • direct En mode direct, toutes les connexions sont créées directement, sans qu'aucun proxy ne soit impliqué.
    • auto_detect En mode auto_detect la configuration du proxy est déterminée par un script PAC qui peut être téléchargé sur http://wpad/wpad.dat.
    • pac_script En mode pac_script, la configuration du proxy est déterminée par un script PAC qui est récupéré à partir de l'URL spécifiée dans le pacScript. C'est le mode par défaut si pacScript est spécifié.
    • fixed_servers En mode fixed_servers, la configuration du proxy est spécifiée dans proxyRules. Il s'agit du mode par défaut si proxyRules est spécifié.
    • system En mode système, la configuration du proxy est titrée du système d'exploitation. Notez que le mode système est différent de celui obtenu en absence de configuration de proxy. Dans ce dernier cas, Electron se rabat sur les paramètres du système seulement si aucune option de ligne de commande n'influe sur la configuration du proxy.
  • pacScript string (facultatif) - URL associée au fichier PAC.
  • proxyRules string (facultatif) - Règles indiquant quels proxys utiliser.
  • proxyBypassRules string (facultatif) - Règles indiquant quelles URLs doivent contourner les paramètres du proxy.

Retourne une Promise<void> - Elle se résout lorsque l'opération de sélection de proxy est terminée.

Indique les paramètres de proxy.

Lorsque mode n'est pas spécifié, pacScript et proxyRules sont fournis ensemble, l'option proxyRules est ignorée et la configuration pacScript est appliquée.

Vous pourriez avoir besoin de ses.closeAllConnections pour fermer les connexions en cours afin d'empêcher que sockets du pool utilisant un proxy précédant ne soient réutilisées par les futures requêtes.

Les proxyRules doivent suivre les règles ci-dessous :

proxyRules = schemeProxies[";"<schemeProxies>]
schemeProxies = [<urlScheme>"="]<proxyURIList>
urlScheme = "http" | "https" | "ftp" | "socks"
proxyURIList = <proxyURL>[","<proxyURIList>]
proxyURL = [<proxyScheme>"://"]<proxyHost>[":"<proxyPort>]

Par exemple :

• http=foopy:80;ftp=foopy2 - Utiliser le proxy HTTP foopy:80 pour http:// URLs, et le proxy HTTP foopy2:80 pour ftp:// URLs.
• foopy:80 - Utiliser le proxy HTTP foopy:80 pour toutes les URL.
• foopy:80,bar,direct:// - Utiliser le proxy HTTP foopy:80 pour toutes les URLs et se rabattre sur bar si foopy:80 est indisponible, et sinon n'utiliser aucun proxy.
• socks4://foopy - Utiliser le proxy SOCKS v4 foopy:1080 pour toutes les URL.
• http=foopy,socks5://bar.com - Utilisez le proxy HTTP foopy pour les URL http, et basculer vers le proxy SOCKS5 bar.com si foopy n'est pas disponible.
• http=foopy,direct:// - Utiliser le proxy HTTP foopy pour les URL http, et n'utiliser aucun proxy si foopy n'est pas disponible.
• http=foopy;socks=foopy2 - Utiliser le proxy HTTP foopy pour les URLs en http et utiliser socks4://foopy2 pour toutes les autres URLs.

Le proxyBypassRules est une liste de règles séparées par des virgules, comme décrites ci-dessous :

• [ URL_SCHEME "://" ] HOSTNAME_PATTERN [ ":" <port> ]

  Correspond à tous les noms d'hôte qui correspondent au pattern HOSTNAME_PATTERN.

  Exemples: "foobar.com", "foobar.com", ".foobar.com", "foobar.com:99", "https://x..y.com:99"

• "." HOSTNAME_SUFFIX_PATTERN [ ":" PORT ]

  Correspond à un suffixe de domaine particulier.

  Exemples: ".google.com", ".com", "http://.google.com"

• [ SCHEME "://" ] IP_LITERAL [ ":" PORT ]

  Correspond aux URLs qui sont des adresses IP littérales.

  Exemples: "127.0.1", "[0:0::1]", "[::1]", "http://[::1]:99"

• IP_LITERAL "/" PREFIX_LENGTH_IN_BITS

  Faire correspondre n'importe quelle URL qui est à une adresse IP littérale dans la plage donnée. La plage IP est spécifiée en utilisant la notation CIDR.

  Exemples: "192.168.1.1/16", "fefe:13::abc/33".

• <local>

  Correspond aux adresses locales. Le sens de <local> indique si l'hôte correspond à une des valeurs "127.0.0.1", "::1" ou "localhost".

ses.resolveProxy(url)

• url URL

Retourne une Promise<string> - qui se résout avec les informations du proxy pour url.

ses.forceReloadProxyConfig()

Retourne une Promise<void> - qui se résout lorsque tous les états internes du service proxy sont réinitialisés et que la dernière configuration du proxy est réappliquée si elle est déjà disponible. Le script pac sera à nouveau extrait de pacScript si le mode proxy est pac_script.

ses.setDownloadPath(path)

• path string - Emplacement du téléchargement.

Définit le répertoire de sauvegarde des téléchargements. Par défaut, le répertoire de téléchargement sera le Telechargements dans le dossier d'application respectif.

ses.enableNetworkEmulation(options)

• Objet options
  • offline boolean (optionelle) - Émuler une panne de réseau. false par défaut.
  • latency Double (facultatif) - RTT en ms. 0 par défaut, ce qui désactive la limitation de latence.
  • downloadThroughput Double (facultatif) - vitesse de téléchargement en Bps. La valeur par défaut est 0 qui désactive la limitation de téléchargement.
  • uploadThroughput Double (facultatif) - vitesse de téléversement en Bps. La valeur par défaut est 0 qui désactive la limitation.

Emule le réseau avec la configuration donnée pour la session.

// Pour émuler une connexion GPRS avec un débit de 50kbps et une latence de 500 ms.
window.webContents.session.enableNetworkEmulation({
  latency: 500,
  downloadThroughput: 6400,
  uploadThroughput: 6400
})

// Pour simuler une panne réseau.
window.webContents.session.enableNetworkEmulation({ offline: true })

ses.preconnect(options)

• Objet options
  • url string - URL pour la préconnexion. Seule l'origine est pertinente pour l'ouverture du socket.
  • numSockets number (facultatif) - nombre de sockets à préconnecter. Doit être compris entre 1 et 6. 1 par défaut.

Préconnecte le nombre de sockets donné pour une origine.

ses.closeAllConnections()

Retourne Promise<void> - qui se résout lorsque toutes les connexions sont fermées.

Note: Mettra fin / fera échouer toutes les requêtes ctuellement en cours.

ses.disableNetworkEmulation()

Désactive toute émulation de réseau déjà active pour la session. Réinitialise à la configuration réseau initiale.

ses.setCertificateVerifyProc(proc)

• proc Function | null
  • request Object
    • hostname string
    • certificate Certificate
    • validatedCertificate Certificate
    • isIssuedByKnownRoot booléen - true si Chromium reconnaît le CA racine comme une racine standard. Si ce n'est pas le cas, il est probable que ce certificat ait été généré par un proxy MITM dont la racine a été installée localement (par exemple, par un proxy d'entreprise). Cela ne devrait pas être approuvé si le verificationResult n'est pas OK.
    • verificationResult string - OK si le certificat est approuvé, sinon une erreur comme CERT_REVOKED.
    • errorCode Integer - Code d'erreur.
  • callback Function
    • verificationResult Entier - La valeur peut être l’un des codes d’erreur de certificat que l'on peut trouver ici. En dehors des codes d'erreur du certificat, les codes spéciaux suivants peuvent être utilisés.
      • 0 - Indique la réussite et désactive la vérification de transparence de certificat.
      • -2 - Indique l'échec.
      • -3 - Utilise le résultat de la vérification de Chromium.

Définit le proc de vérification du certificat pour session, le proc sera appelé avec proc(request, callback) chaque fois qu'une vérification de certificat de serveur est demandée. L'appel à callback(0) accepte le certificat, appeler callback(-2) le rejette.

L'appel à setCertificateVerifyProc(null) réinitialisera au proc de vérification du certificat par défaut.

const { BrowserWindow } = require('electron')
const win = new BrowserWindow()

win.webContents.session.setCertificateVerifyProc((request, callback) => {
  const { hostname } = request
  if (hostname === 'github.com') {
    callback(0)
  } else {
    callback(-2)
  }
})

REMARQUE : Le résultat de cette procédure est mis en cache par le service réseau.

ses.setPermissionRequestHandler(handler)

• handler Function | null
  • webContents WebContents - WebContents qui demandent la permission. Veuillez noter que si la demande provient d'une sous-frame, vous devez utiliser requestingUrl pour vérifier l'origine de la demande.
  • permission string - Type d’autorisation demandée.
    • clipboard-read - Demande d'accès à la lecture depuis le presse-papiers.
    • clipboard-sanitized-write - Demande d'accès à l'écriture dans le presse-papiers.
    • média - Demande l'accès à des périphériques multimédia tels que la caméra, le microphone et les haut-parleurs.
    • display-capture - Demande d'accès pour capturer l'écran.
    • mediaKeysystem - Demande d’accès au contenu protégé par DRM.
    • geolocation - Demande d'accès à l'emplacement actuel de l'utilisateur.
    • notifications - Demande la création de notifications et la possibilité de les afficher dans la barre d’état système de l’utilisateur.
    • midi - Demande d'accès MIDI dans l'API webmidi.
    • midiSysex - Demande l'utilisation des messages exclusifs du système dans l'API webmidi.
    • pointerLock - Demande d'interpréter directement les mouvements de la souris comme une méthode de saisie. Cliquez ici pour en savoir plus. Ces requêtes semblent toujours provenir de la frame principale.
    • fullscreen - Demande de l'application pour passer en mode plein écran.
    • openExternal - Demande d’ouverture de liens dans des applications externes.
    • window-management - Demande l'accès à l'énumération des écrans en utilisant l'API getScreenDetails.
    • unknown - Demande d’autorisation non reconnue
  • callback Function
    • permissionGranted booléen - Autoriser ou refuser la permission.
  • Objet details - Certaines propriétés ne sont disponibles que sur certains types de permissions.
    • externalURL string (facultatif) : Url de la demande de openExternal .
    • securityOrigin string (facultatif) - La source de sécurité de la requête media.
    • mediaTypes string[] (facultatif) - Types d'accès aux médias demandés, les éléments peuvent être video ou audio
    • requestingUrl string - La dernière URL chargée par la frame chargée
    • isMainFrame booléen - Indique sir la frame à l'origine de la requête est la frame principale

Définit le gestionnaire qui peut être utilisé pour répondre aux vérifications de permissions pour la session. L'appeler à callback(true) autorisera la permission et callback(false) le rejettera. Pour supprimer le gestionnaire, appelez setPermissionRequestHandler(null). Veuillez noter que vous devez également implémenter setPermissionCheckHandler pour obtenir la gestion complète des permissions. La plupart des API web font une vérification des permissions, puis, si la vérification est refusée, font une demande de permission .

const { session } = require('electron')
session.fromPartition('some-partition').setPermissionRequestHandler((webContents, permission, callback) => {
  if (webContents.getURL() === 'some-host' && permission === 'notifications') {
    return callback(false) // interdit.
  }

  callback(true)
})

ses.setPermissionCheckHandler(handler)

• handler Function<boolean> | null
  • webContents (WebContents | null) - WebContents demandant la permission. Veuillez noter que si la demande provient d'une sous-frame, vous devez utiliser requestingUrl pour vérifier l'origine de la demande. Toutes les frames de cross origin effectuant des vérifications de permission passeront un null webContents à ce gestionnaire, alors que certaines autres vérifications de permissions, telles que notifications , passeront toujours null. Vous devez utiliser embeddingOrigin et requestingOrigin pour déterminer quelles sont respectivement la frame propriétaire et celle effectuant la demande.
  • permission string - Type de vérification des permissions. Valid values are midiSysex, notifications, geolocation, media,mediaKeySystem,midi, pointerLock, fullscreen, openExternal, hid, serial, or usb.
  • requestingOrigin string - URL d'origine de la vérification des permissions
  • Objet details - Certaines propriétés ne sont disponibles que sur certains types de permissions.
    • embeddingOrigin string (optionelle) - L'origine de la frame incorporant la frame ayant effectué la vérification des permissions. Est uniquement defini pour les sous-frames cross--origin qui effectuent des vérifications d'autorisation.
    • securityOrigin string (optionelle) - L'origine de sécurité de la vérification de media.
    • mediaType string (facultatif) - Le type de média demandé peut être video, audio ou unknown
    • requestingUrl string (optionelle) - Dernière URL que la frame faisant la demande a chargé. Ceci n'est pas prévu pour les sub-frames cross-origin effectuant des vérifications d'autorisation.
    • isMainFrame booléen - Indique sir la frame à l'origine de la requête est la frame principale

Définit le gestionnaire qui peut être utilisé pour répondre aux vérifications de permissions pour la session. Retourne true pour autoriser la permission et false pour la rejetter. Veuillez noter que vous devez également implémenter setPermissionRequestHandler pour obtenir la gestion complète des permissions. La plupart des API web font une vérification des permissions, puis, si la vérification est refusée, font une demande de permission . Pour effacer le gestionnaire, appelez setPermissionCheckHandler(null).

const { session } = require('electron')
const url = require('url')
session.fromPartition('some-partition').setPermissionCheckHandler((webContents, permission, requestingOrigin) => {
  if (new URL(requestingOrigin).hostname === 'some-host' && permission === 'notifications') {
    return true // granted
  }

  return false // denied
})

ses.setDisplayMediaRequestHandler(handler)

• handler Function | null
  • request Object
    • frame WebFrameMain - Frame qui demande l'accès aux médias.
    • securityOrigin String - Origine de la page faisant la demande.
    • videoRequested Booléen - true si le contenu web a demandé un flux vidéo.
    • audioRequested Booléen - true si le contenu Web a demandé un flux audio.
    • userGesture Booléen - Indique si un geste utilisateur était actif quand cette requête a été déclenchée.
  • callback Function
    • Object streams
      • video Object | WebFrameMain (facultatif)
        • id String - id du flux en cours d'autorisation. Il provient le plus souvent d'un objet de type DesktopCapturerSource.
        • name String - Nom du flux en cours d'autorisation. Il provient le plus souvent d'un objet de type DesktopCapturerSource.
      • audio String | WebFrameMain (facultatif) - Si spécifiée, peut être loopback ou loopbackWithMute. Spécifier un périphérique de rebouclage va capturer l'audio du système et n'est actuellement pris en charge que sur Windows. Si une WebFrameMain est spécifiée, capturera l'audio à partir de cette frame.
      • enableLocalEcho booléen (facultatif) - Si audio est un WebFrameMain et que la valeur est à true, la lecture locale de l’audio ne sera pas désactivée (par ex. en utilisant MediaRecorder l'enregistrement de WebFrameMain avec ce drapeau à true permettra au son de passer par les haut-parleurs pendant l’enregistrement). Par défaut la valeur est false.

Ce gestionnaire sera appelé lorsque le contenu Web demande l'accès pour afficher les médias via l'API navigator.mediaDevices.getDisplayMedia. Utilisez l'API desktopCapturer pour choisir le(s) stream(s) auquel accorder l'accès.

const { session, desktopCapturer } = require('electron')

session.defaultSession.setDisplayMediaRequestHandler((request, callback) => {
  desktopCapturer. etSources({ types: ['screen'] }).then((sources) => {
    // Autoriser l'accès au premier screen trouvé.
    callback({ video: sources[0] })
  })
})

Spécifier un objet WebFrameMain en tant que flux vidéo ou audio capturera le flux vidéo ou audio à partir de cette frame.

const { session } = require('electron')

session.defaultSession.setDisplayMediaRequestHandler((request, callback) => {
  // Permet à l'onglet de se capturer lui même.
  callback({ video: request.frame })
})

Le passage de null au lieu d'une fonction réinitialise le gestionnaire à son état par défaut.

ses.setDevicePermissionHandler(handler)

• handler Function<boolean> | null
  • Objet details
    • deviceType string - Type de périphérique pour lequel la permission est demandée, peut être hid , serial ou usb.
    • origin string - URL à l'origine de la demande de vérification d'autorisation du périphérique.
    • device HIDDevice | SerialPort- périphérique pour lequel l'autorisation est demandée.

Définit le gestionnaire pouvant être utilisé pour répondre aux vérifications des permissions de l'appareil pour la session. Retourner true permettra à l'appareil d'être autorisé et false le rejettera. Pour supprimer le gestionnaire, appelez setDevicePermissionHandler(null). Ce gestionnaire peut être utilisé pour fournir des autorisations par défaut aux appareils sans avoir d'abord demandé celle ci (par exemple via navigator.hid.requestDevice). Si ce gestionnaire n'est pas défini, les permissions par défaut accordées via la sélection de l'appareil (par exemple via navigator.hid.requestDevice) seront utilisées. De plus, le comportement par défaut d'Electron est de stocker dans la mémoire la permission accordée au périphérique. Si un stockage à plus long terme est nécessaire, le développeur peut stocker les autorisations accordées au périphérique (par exemple lors de la gestion de l'événement select-hid-device ) pour ensuite les lire depuis ce stockage avec setDevicePermissionHandler.

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

let win = null

app.whenReady(). hen(() => {
  win = new BrowserWindow()

  win.webContents.session. etPermissionCheckHandler((webContents, permission, requestingOrigin, details) => {
    if (permission === 'hid') {
      // Ajoute une logique ici pour déterminer si l'autorisation doit être donnée pour permettre la sélection HID
      return true
    } else if (permission === 'serial') {
      // Ajoute une logique ici pour déterminer si l'autorisation doit être donnée pour autoriser la sélection du port série
    } else if (permission === 'usb') {
      // Ajoute une logique ici pour déterminer si l'autorisation doit être donnée pour permettre la sélection du périphérique USB
    }
    return false
  })

  // Optionnellement, récupérer la victoire des périphériques persistants depuis un magasin persistant
  const accortedDevices = fetchGrantedDevices()

  . ebContents.session.setDevicePermissionHandler((détails) => {
    if (new URL(details.origin). ostname === 'some-host' && details.deviceType === 'hid') {
      if (détails. evice.vendorId === 123 && details.device. roductId === 345) {
        // Toujours autoriser ce type de périphérique (cela permet de passer l'appel à `navigator. identifiant. equestDevice` d'abord)
        return true
      }

      // Rechercher dans la liste des périphériques qui ont été précédemment autorisés
      return accordés. ome((grantedDevice) => {
        return grantedDevice.vendorId === details.device. endorId &&
              grantedDevice.productId === détails. evice.productId &&
              accortedDevice. erialNumber && grantedDevice.serialNumber === details.device. erialNumber
      })
    } autre si (détails. eviceType === 'serial') {
      if (details.device. endorId === 123 && details.device. roductId === 345) {
        // Toujours autoriser ce type de périphérique (cela permet de passer l'appel à `navigator. id.requestDevice` d'abord)
        return true
      }
    }
    return false
  })

  win. session eContents.. n('select-hid-device', (événement, détails, callback) => {
    événement. reventDefault()
    const selectedDevice = details.deviceList.find((device) => {
      return device. endorId === '9025' && appareil. roductId === '67'
    })
    callback(selectedPort?.deviceId)
  })
})

ses.setBluetoothPairingHandler(handler) Windows Linux

• handler Function | null
  • Objet details
    • deviceId string
    • pairingKind string -Type de l'invite d'appairage demandé. Une des valeurs suivantes:
      • confirm Cette invite demande la confirmation que le périphérique Bluetooth doit être apparié.
      • confirmPin Cette invite demande la confirmation que le code PIN fourni correspond au code affiché sur l'appareil.
      • providePin Cette invite demande qu'un code soit fourni pour le périphérique.
    • frame WebFrameMain
    • pin string (facultatif) - Valeur du code Pin à vérifier si pairingKind est confirmPin.
  • callback Function
    • Objet response
      • confirmed booléen - false doit être passé si la boîte de dialogue est annulée. Si le pairingKind est confirm ou confirmPin, cette valeur doit indiquer si le jumelage est confirmé. Si le pairingKind est providePin, doit être à true lorsqu'une valeur est fournie.
      • pin string | null (optionelle) - Lorsque le pairingKind est providePin cette valeur doit être le PIN requis pour le périphérique Bluetooth.

Définit un gestionnaire pour répondre aux demandes d'appairage Bluetooth. Ce gestionnaire permet aux développeurs de gérer les périphériques qui nécessitent une validation supplémentaire avant de s'appairer. Lorsqu'un gestionnaire n'est pas défini, toute appairage sous Linux ou Windows nécessitant une validation supplémentaire sera automatiquement annulée. macOS ne nécessite pas de gestionnaire car il gère le jumelage automatiquement. Pour supprimer le gestionnaire, appelez setBluetoothPairingHandler(null).

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

let bluetoothPinCallback = null

function createWindow () {
  const mainWindow = new BrowserWindow({
    webPreferences: {
      preload: path. oin(__dirname, 'preload. s')
    }
  })
}

// Écoutez d'un message IPC du moteur de rendu pour obtenir la réponse pour le jumelage Bluetooth.
ipcMain.on('bluetooth-pairing-response', (event, response) => {
  bluetoothPinCallback(response)
})

mainWindow.webContents.session.setBluetoothPairingHandler((details, callback) => {
  bluetoothPinCallback = callback
  // Send a IPC message to the renderer to prompt the user to confirm the pairing.
  // Notez que cela nécessitera dans le moteur de rendu du code pour gérer ce message et 
  // l'affichage d'une invite à l'utilisateur.
  mainWindow.webContents.send('bluetooth-pairing-request', details)
})

app.whenReady().then(() => {
  createWindow()
})

ses.clearHostResolverCache()

Retourne une Promise<void> - Elle se résout lorsque l'opération est terminée.

Vide le cache de résolution de l'hôte.

ses.allowNTLMCredentialsForDomains(domains)

• domains string - Liste séparés par des virgules de serveurs pour lesquels l'authentification intégrée est activée.

Définit dynamiquement s'il faut toujours envoyer des identifiants pour l'authentification HTTP NTLM ou Négocier .

const { session } = require('electron')
// considère n'importe quelle url se terminant par `example.com`, `foobar.com`, `baz`
// pour une authentification intégrée.
session.defaultSession.allowNTLMCredentialsForDomains('*example.com, *foobar.com, *baz')

// considère toutes les urls pour une authentification intégrée.
session.defaultSession.allowNTLMCredentialsForDomains('*')

ses.setUserAgent(userAgent[, acceptLanguages])

• userAgent string
• acceptLanguages string (facultatif)

Remplace les userAgent et acceptLanguages pour cette session.

Le acceptLanguages doit être une liste ordonnée de codes de langue séparés par des virgules, pour exemple "en-US,fr,de,ko,zh-CN,ja".

Cela n'affecte pas les WebContents, et chaque WebContents peut utiliser webContents.setUserAgent pour remplacer l'agent utilisateur à l'échelle de la session.

ses.isPersistent()

Retourne boolean - Indique si cette session est persistante ou non. Par défaut, la session du webContents d'une BrowserWindow est persistante. Lors de la création d'une session à partir d'une partition, les sessions préfixées avec persist: seront persistantes, tandis que les autres seront temporaires.

ses.getUserAgent()

Renvoie string - L'user agent de cette session.

ses.setSSLConfig(config)

• config Object
  • minVersion string (facultatif) - Peut être tls1, tls1.1, tls1.2 ou tls1.3. La version minimale SSL à autoriser lors de la connexion à des serveurs distants. tls1 par défaut.
  • maxVersion string (facultatif) -Peut être tls1.2 ou tls1.3. La version SSL maximale à autoriser lors de la connexion à des serveurs distants. tls1.3 par défaut.
  • disabledCipherSuites Integer[] (optionelle) - Liste des suites de chiffrement qui doivent être empêchées explicitement d'être utilisées en plus de celles désactivées par la politique intégrée du réseau. Formes littérales supportées : 0xAABB, où AA est cipher_suite[0] et BB est cipher_suite[1], tel que défini dans RFC 2246, Section 7.4.1.2. Les suites de chiffrement non reconnues mais analysables dans ce formulaire ne retourneront pas d'erreur. Ex: Pour désactiver TLS_RSA_WITH_RC4_128_MD5, spécifiez 0x0004, tandis que pour désactiver TLS_ECDH_ECDSA_WITH_RC4_128_SHA, spécifiez 0xC002. Notez que les chiffrements TLSv1.3 ne peuvent pas être désactivés en utilisant ce mécanisme.

Définit la configuration SSL pour la session. Toutes les requêtes réseau suivantes utiliseront cette nouvelle configuration. Les connexions réseau existantes (telles que les connexions WebSocket) ne seront pas cloturées, mais les anciennes sockets dans le pool ne seront pas réutilisées pour de nouvelles connexions.

ses.getBlobData(identifier)

• identifier string - UUID valide.

Retourne Promise<Buffer> - se résout avec des données Blob.

ses.downloadURL(url)

• url string

Lance le téléchargement de la ressource située à l'url. L'API va générer un DownloadItem accessible par l'événement will-download .

Note: Ceci n'effectue aucune vérification de sécurité concernant l'origine d'une page, contrairement à webContents.downloadURL.

ses.createInterruptedDownload(options)

• Objet options
  • path string - Chemin d'accès absolu pour le téléchargement.
  • urlChain string[] - Chaîne de caractère complète de l'URL du téléchargement.
  • mimeType string (facultatif)
  • offset Integer - Portée de départ pour le téléchargement.
  • length Integer - Longueur totale du le téléchargement.
  • lastModified string (facultatif) - Valeur de l'en-tête Last-Modified.
  • eTag string (facultatif) - Valeur de l'en-tête ETag.
  • startTime Double (facultatif) - Heure du début de téléchargement, en nombre de secondes depuis la date initiale UNIX (1er janvier 1970 à 0 heure (UTC)).

Autorise la reprise des téléchargements annulés ou interrompus depuis la Sessionprécédente. L'API va générer un DownloadItem accessible avec l'événement will-download . Le DownloadItem n'aura aucun WebContents associé et l'état initial sera <interrupted. Le téléchargement ne démarrera que lorsque l'API resume est appelée sur le DownloadItem.

ses.clearAuthCache()

Retourne Promise<void> - résout lorsque le cache d'authentification HTTP de la session a été effacé.

ses.setPreloads(preloads)

• preloads string[] - Tableau des chemins absolus des scripts de preload

Ajoute des scripts qui seront exécutés sur TOUS les contenus web qui sont associés à cette session et ceci juste avant l'exécution normale des scripts de preload.

ses.getPreloads()

Retourne string[] un tableau des chemins des scripts de preload enregistrés.

ses.setCodeCachePath(path)

• path String - Chemin absolu pour stocker le cache de code JS généré par v8.

Définit le répertoire pour stocker le cache de code du JS généré pour cette session. Le répertoire n'a pas besoin d'être forcemment créé par l'utilisateur avant cet appel, le runtime créera le répertoire s'il n'existe pas sinon il utilisera le répertoire existant. Si le répertoire ne peut pas être créé, le cache de code ne sera pas utilisé et toutes les opérations liées au cache de code échoueront silencieusement. Par défaut, le répertoire sera Code Cache sous le dossier respectif des donéées de l'utilisateur.

ses.clearCodeCaches(options)

• Objet options
  • urls String[] (facultatif) - Tableau d'urls correspondant à la ressource dont le cache de code généré doit être supprimé. Si la liste est vide, toutes les entrées du répertoire de cache seront supprimées.

Retourne Promise<void> -qui se résout lorsque l'opération de nettoyage du cache est terminée.

ses.setSpellCheckerEnabled(enable)

• enable boolean

Définit s'il faut activer le correcteur orthographique intégré.

ses.isSpellCheckerEnabled()

boolean indique si le correcteur orthographique interne est activé.

ses.setSpellCheckerLanguages(languages)

• languages string[] - Tableau des codes de langue pour lesquels vérificateur d'orthographe sera activé.

Le correcteur orthographique intégré ne détecte pas automatiquement la langue dans laquelle un utilisateur tape. Afin que le correcteur orthographique vérifie correctement les mots, vous devez exécuter cette API avec un tableau de codes de langue. Vous pouvez obtenir la liste des codes de langue pris en charge avec la propriété ses.availableSpellCheckerLanguages.

Note : Sur macOS, le correcteur orthographique de l'OS est utilisé et détectera automatiquement votre langage. Cette API est sans aucun effet sur macOS.

ses.getSpellCheckerLanguages()

Retourne string[] - Un tableau de codes de langue pour lesquels le correcteur orthographique est activé. Si cette liste est vide, le correcteur orthographique utilisera en-US. Par défaut au lancement si ce paramètre est une liste vide, Electron essaiera de remplir ce paramètre avec la locale actuelle de l'OS. Ce paramètre est maintenu lors de redémarrage.

Remarque: Sur macOS, le correcteur orthographique de l'OS est utilisé et a sa propre liste de langues. Sur macOS, cette API retournera les langues qui ont été configurées par l'OS.

ses.setSpellCheckerDictionaryDownloadURL(url)

• url string - Une URL de base à partir de laquelle Electron peut télécharger des dictionnaires hunspell.

Par défaut, Electron téléchargera les dictionnaires hunspell à partir du CDN Chromium. Si vous voulez remplacer ce comportement vous pouvez utiliser cette API pour pointer le téléchargeur de dictionnaire sur votre propre version hébergée des dictionnaires hunspell. Avec chaque version, nous publions un fichier hunspell_dictionaries.zip contenant les fichiers dont vous avez besoin pour l'héberger .

Le serveur de fichiers doit être insensible à la casse. Si ce n'est pas le cas, vous devez télécharger chaque fichier deux fois : une fois avec la casse du fichier ZIP et une autre fois avec le nom du fichier toute en minuscule.

Si les fichiers présents dans hunspell_dictionaries.zip sont disponibles à https://example.com/dictionaries/language-code.bdic alors vous devrez appeler cette api avec ses.setSpellCheckerDictionaryDownloadURL('https://example.com/dictionaries/'). Veuillez noter la barre oblique de fin. L'URL des dictionnaires est sous la forme ${url}${filename}.

Note: Sur macOS le correcteur orthographique de l'OS est utilisé et nous ne téléchargeons donc aucun fichier de dictionnaire. Cette API est sans aucun effet sur macOS.

ses.listWordsInSpellCheckerDictionary()

Retourne Promise<string[]> - Un tableau de tous les mots du dictionnaire personnalisé de l'application. Elle se résout lorsque le dictionnaire complet est chargé à partir du disque.

ses.addWordToSpellCheckerDictionary(word)

• String word - Le mot que vous voulez ajouter au dictionnaire

Retourne boolean - Si le mot a été écrit avec succès dans le dictionnaire personnalisé. Cette API ne fonctionnera pas sur des sessions non persistantes (en mémoire).

Note: Sur macOS et Windows 10, ce mot sera également inscrit dans le dictionnaire personnalisé de l'OS

ses.removeWordFromSpellCheckerDictionary(word)

• String word - Le mot que vous voulez supprimer du dictionnaire

Retourne boolean - Si le mot a été supprimé avec succès dans le dictionnaire personnalisé. Cette API ne fonctionnera pas sur des sessions non persistantes (en mémoire).

Note: Sur macOS et Windows 10, ce mot sera également supprimé du dictionnaire personnalisé de l'OS

ses.loadExtension(path[, options])

• String path - Chemin vers un répertoire contenant une extension Chrome décompressée
• options Object (facultatif)
  • allowFileAccess boolean - Permet à l'extension de lire des fichiers locaux sous le protocole file:// et d'injecter des scripts de contenu dans file://. Ceci est requis par exemple pour charger les extensions devtools sur les URLs file://. false par défaut.

Retourne Promise<Extension> - se résout lorsque l'extension est chargée.

Cette méthode déclenche une exception si l’extension n’a pas pu être chargée. Si il y a des avertissements lors de l'installation de l'extension (par ex. si l'extension utilise une API non prise en charge par Electron) ceux-ci seront enregistrés dans la console.

Notez qu'Electron ne prend pas en charge la gamme complète des API d'extensions Chrome. Voir: les API d'extensions compatibles pour plus de détails sur celles prisent en charge.

Notez que dans les versions précédentes d'Electron, les extensions qui avaient été chargées etaient mémorisées pour les exécutions futures de l'application. Ce n'est plus le cas : loadExtension doit être appelé à chaque démarrage de votre application si vous voulez que l'extension soit chargée.

const { app, session } = require('electron')
const path = require('path')

app.on('ready', async () => {
  await session.defaultSession.loadExtension(
    path.join(__dirname, 'react-devtools'),
    // allowFileAccess est requis pour charger l'extension des devtools avec les URL en  file:// .
    { allowFileAccess: true }
  )
  // Notez que pour utiliser l'extension React DevTools, vous aurez besoin de
  // télécharger et décompresser une copie de l'extension.
})

Cette API ne supporte pas le chargement des extensions compressées (.crx).

Remarque : Cette API ne peut pas être appelée avant que l'événement prêt du module app ne soit émis.

Remarque : Le chargement d'extensions en session mémoire (non-persistantes) n'est pas supporté et va générer une erreur.

ses.removeExtension(extensionId)

• extensionId string - ID de l'extension à supprimer

Décharge une extension.

Remarque : Cette API ne peut pas être appelée avant que l'événement prêt du module app ne soit émis.

ses.getExtension(extensionId)

• extensionId string - ID de l'extension demandée

Retourne Extension | null - L'extension chargée avec l'ID donné.

Remarque : Cette API ne peut pas être appelée avant que l'événement prêt du module app ne soit émis.

ses.getAllExtensions()

Retourne Extension[] - Une liste de toutes les extensions chargées.

Remarque : Cette API ne peut pas être appelée avant que l'événement prêt du module app ne soit émis.

ses.getStoragePath()

Retourne string | null - Chemin absolu du système de fichiers où les données pour cette session sont enregistrées sur le disque. Retourne null dans le cas des sessions en mémoire.

Propriétés d'instance

Les propriétés suivantes sont disponibles pour les instances de Session :

ses.availableSpellCheckerLanguages Readonly

Tableau string[] se composant de tous les langages connus du correcteur orthographique disponible. Une erreur surviendra si un code de langue absent de ce tableau est fournit à l'API setSpellCheckerLanguages.

ses.spellCheckerEnabled

boolean indique si le correcteur orthographique interne est activé.

ses.storagePath Readonly

string | null indique le chemin absolu du système de fichiers où les données pour cette session sont enregistrées ur le disque. Retourne null dans le cas des sessions en mémoire.

ses.cookies Readonly

Un objet Cookies pour cette session.

ses.serviceWorkers Readonly

Un objet ServiceWorkers pour cette session.

ses.webRequest Readonly

Un objet WebRequest pour cette session.

ses.protocol Readonly

Un objet Protocole pour cette session.

const { app, session } = require('electron')
const path = require('path')

app.whenReady().then(() => {
  const protocol = session.fromPartition('some-partition').protocol
  if (!protocol.registerFileProtocol('atom', (request, callback) => {
    const url = request.url.substr(7)
    callback({ path: path.normalize(`${__dirname}/${url}`) })
  })) {
    console.error('Failed to register protocol')
  }
})

ses.netLog Readonly

Un objet NetLog pour cette session.

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

app.whenReady().then(async () => {
  const netLog = session.fromPartition('some-partition').netLog
  netLog.startLogging('/path/to/net-log')
  // After some network events
  const path = await netLog.stopLogging()
  console.log('Net-logs written to', path)
})