Zum Inhalt springen

Anwendungen aktualisieren

There are several ways to provide automatic updates to your Electron application. The easiest and officially supported one is taking advantage of the built-in Squirrel framework and Electron's autoUpdater module.

Using update.electronjs.org

The Electron team maintains update.electronjs.org, a free and open-source webservice that Electron apps can use to self-update. Der Service ist für Electron-Apps, die die folgenden Kriterien erfüllen ausgelegt:

  • App läuft unter Mac OS oder Windows
  • App hat ein öffentliches GitHub Repository
  • Builds are published to GitHub Releases
  • Builds are code-signed

Am einfachsten können Sie diesen Service nutzen, indem Sie update-electron-app installieren, ein Node.js-Modul, das für die Verwendung mit update.electronjs.org vorkonfiguriert ist.

Install the module using your Node.js package manager of choice:

npm install update-electron-app

Then, invoke the updater from your app's main process file:

main.js
require('update-electron-app')()

By default, this module will check for updates at app startup, then every ten minutes. When an update is found, it will automatically be downloaded in the background. When the download completes, a dialog is displayed allowing the user to restart the app.

If you need to customize your configuration, you can pass options to update-electron-app or use the update service directly.

Using other update services

Wenn Sie eine private Electron-Anwendung entwickeln oder wenn Sie sie nicht auf GitHub Releases veröffentlichen, könnte notwendig sein, Ihren eigenen Update-Server bereitzustellen.

Step 1: Deploying an update server

Abhängig von Ihren Ansprüchen können Sie einen der folgenden Server nutzen:

  • Hazel – Update server for private or open-source apps which can be deployed for free on Vercel. It pulls from GitHub Releases and leverages the power of GitHub's CDN.
  • Nuts – Also uses GitHub Releases, but caches app updates on disk and supports private repositories.
  • electron-release-server – Provides a dashboard for handling releases and does not require releases to originate on GitHub.
  • Nucleus – A complete update server for Electron apps maintained by Atlassian. Supports multiple applications and channels; uses a static file store to minify server cost.

Once you've deployed your update server, you can instrument your app code to receive and apply the updates with Electron's [autoUpdater] module.

Step 2: Receiving updates in your app

First, import the required modules in your main process code. The following code might vary for different server software, but it works like described when using Hazel.

Check your execution environment!

Please ensure that the code below will only be executed in your packaged app, and not in development. You can use the app.isPackaged API to check the environment.

main.js
const { app, autoUpdater, dialog } = require('electron')

Next, construct the URL of the update server feed and tell autoUpdater about it:

main.js
const server = 'https://your-deployment-url.com'
const url = `${server}/update/${process.platform}/${app.getVersion()}`

autoUpdater.setFeedURL({ url })

As the final step, check for updates. The example below will check every minute:

main.js
setInterval(() => {
autoUpdater.checkForUpdates()
}, 60000)

Once your application is packaged, it will receive an update for each new GitHub Release that you publish.

Step 3: Notifying users when updates are available

Nun, da Sie den grundlegenden Update-Mechanismus konfiguriert haben, müssen Sie sicherstellen, dass die Nutzer benachrichtigt werden, wenn es ein Update gibt. This can be achieved using the autoUpdater API events:

main.js
autoUpdater.on('update-downloaded', (event, releaseNotes, releaseName) => {
const dialogOpts = {
type: 'info',
buttons: ['Restart', 'Later'],
title: 'Application Update',
message: process.platform === 'win32' ? releaseNotes : releaseName,
detail:
'A new version has been downloaded. Restart the application to apply the updates.',
}

dialog.showMessageBox(dialogOpts).then((returnValue) => {
if (returnValue.response === 0) autoUpdater.quitAndInstall()
})
})

Also make sure that errors are being handled. Here's an example for logging them to stderr:

main.js
autoUpdater.on('error', (message) => {
console.error('There was a problem updating the application')
console.error(message)
})
Handling updates manually

Because the requests made by autoUpdate aren't under your direct control, you may find situations that are difficult to handle (such as if the update server is behind authentication). The url field supports the file:// protocol, which means that with some effort, you can sidestep the server-communication aspect of the process by loading your update from a local directory. Here's an example of how this could work.