Electron Updater API Referenz

Diese Seite dokumentiert alle verfügbaren Methoden, Ereignisse und Konfigurationsoptionen für den Electron Updater.

Kernmethoden

notifyAppReady()

Muss auf jedem Anwendungsstart aufgerufen werden. Bestätigt, dass das Bundle erfolgreich geladen wurde und verhindert automatische Rückschritte.

await updater.notifyAppReady();

Vorsicht

Wenn nicht innerhalb von appReadyTimeout (default 10 Sekunden), die Aktualisierung wird als fehlgeschlagen betrachtet und die App rollt zurück auf die vorherige Version.

herunterladen(options)

Laden Sie ein Bundle von einer URL herunter.

const bundle = await updater.download({
  url: 'https://example.com/bundle.zip',
  version: '1.0.1',
  checksum: 'sha256-hash', // Optional but recommended
  sessionKey: '...', // For encrypted bundles
});

Parameter:

Einstellung	Typ	Required	erforderlich
url	Beschreibung	Yes	URL zur Herunterladung des Bundles
version	Beschreibung	Yes	Versionsidentifikator für das Bundle
checksum	Beschreibung	No	SHA256-Prüfsumme für die Überprüfung
sessionKey	Zeichenfolge	Nein	Sitzungschlüssel für verschlüsselte Pakete

Rückgabewerte: BundleInfo Objekt mit id, version, status

next(options)

Eine Pakete wird auf das nächste Anwendungsstart geladen.

await updater.next({ id: 'bundle-id' });

Parameter:

Option	Typ	erforderlich	Beschreibung
id	Zeichenfolge	Ja	Bundle-ID zum Warten

set(options)

Zum Bundle wechseln und die App neu laden.

await updater.set({ id: 'bundle-id' });

Parameter:

Option	Typ	erforderlich	Beschreibung
id	Zeichenfolge	Ja	Bundle-ID zum Aktivieren

reload()

Die App mit der aktuellen Bundle neu laden.

await updater.reload();

löschen(options)

Ein Bundle aus dem Speicher löschen.

await updater.delete({ id: 'bundle-id' });

Parameter:

Option	Typ	Pflichtfeld	Beschreibung
id	Zeichenfolge	Ja	Bundle-ID zum Löschen

reset(options)

Reset to builtin version or last successful bundle.

// Reset to builtin
await updater.reset({ toLastSuccessful: false });

// Reset to last successful bundle
await updater.reset({ toLastSuccessful: true });

Parameter:

Option	Typ	Erforderlich	Beschreibung
toLastSuccessful	boolean	Nein	Wenn wahr, zurücksetzen auf letzte erfolgreiche Bundle anstatt auf eingebauten.

Paketinformationen

aktuell()

Ermitteln Sie Informationen über die aktuelle Anwendung und die native Version.

const info = await updater.current();
// { bundle: { id, version, status }, native: '1.0.0' }

list(options)

Liste aller heruntergeladenen Anwendungen.

const bundles = await updater.list();
// [{ id, version, status, downloaded, checksum }, ...]

getNextBundle()

Laden Sie das Bundle für den nächsten Neustart an.

const next = await updater.getNextBundle();
// { id, version, status } or null

getFailedUpdate()

Ermitteln Sie Informationen über das letzte fehlgeschlagene Update (nützlich für Debugging von Rollover-Updates).

const failed = await updater.getFailedUpdate();
// { id, version, reason } or null

getBuiltinVersion()

Ermitteln Sie die mit der Anwendungs-EXE-Datei gelieferte Version.

const version = await updater.getBuiltinVersion();
// '1.0.0'

Aktualisierungsprüfung

getLatest(options)

Überprüfen Sie den Server auf die neueste verfügbare Version.

const latest = await updater.getLatest();

if (latest.url && !latest.error) {
  // Update available
  console.log('New version:', latest.version);
  console.log('Download URL:', latest.url);
} else if (latest.error) {
  console.error('Error checking updates:', latest.error);
}

Rückgabewerte:

Eigenschaft	Typ	Beschreibung
url	string	Herunterladelink (leer, wenn kein Update)
version	string	Verfügbare Version
checksum	string	SHA256-Prüfsumme
sessionKey	string	Verschlüsselungssitzungsschlüssel
error	string	Fehlermeldung bei fehlgeschlagener Überprüfung
message	string	Servernachricht

Kanalverwaltung

setChannel(options)

Zuweisen Sie das Gerät einem bestimmten Kanal.

await updater.setChannel({ channel: 'beta' });

setzeKanal(options)

Entferne Kanalzuweisung und verwende Standard.

await updater.unsetChannel();

getChannel()

Ermitteln Sie die derzeitige Kanalzuweisung.

const channel = await updater.getChannel();
// { channel: 'production', status: 'set' }

listChannels()

Liste aller verfügbaren Kanäle für diese App.

const channels = await updater.listChannels();
// ['production', 'beta', 'staging']

Verzögerungsbedingungen

Bestimmen Sie, wann heruntergeladene Updates angewendet werden.

setMultiDelay(options)

Legen Sie Bedingungen fest, die vor der Anwendung eines Updates erfüllt sein müssen.

// Wait for app to be backgrounded
await updater.setMultiDelay({
  delayConditions: [{ kind: 'background' }]
});

// Wait until specific date
await updater.setMultiDelay({
  delayConditions: [{ kind: 'date', value: '2024-12-25T00:00:00Z' }]
});

// Wait for app to be killed and restarted
await updater.setMultiDelay({
  delayConditions: [{ kind: 'kill' }]
});

// Multiple conditions (all must be met)
await updater.setMultiDelay({
  delayConditions: [
    { kind: 'background' },
    { kind: 'date', value: '2024-12-25T00:00:00Z' }
  ]
});

Verzögerungsbedingungstypen:

Typ	Wert	Beschreibung
background	Optionale Dauer (ms)	Warten auf das Hintergrunden der App
kill	-	Warten, bis die App beendet und neu gestartet wird
date	ISO-Datumszeichenfolge	Warten, bis eine bestimmte Uhrzeit erreicht ist
nativeVersion	Versionszeichenfolge	Warten auf eine native App-Update

cancelDelay()

Alle Verzögerungsbedingungen löschen und das Update sofort auf die nächste Überprüfung anwenden.

await updater.cancelDelay();

Geräteidentifikation

getDeviceId()

Erhalte die eindeutige Gerätekennung.

const deviceId = await updater.getDeviceId();
// 'uuid-xxxx-xxxx-xxxx'

setCustomId(options)

Setze eine benutzerdefinierte Gerätekennung (nützlich für Analysen).

await updater.setCustomId({ customId: 'user-123' });

Einstellungen

setUpdateUrl(options)

Die Update-Server-URL ändern, während das System läuft.

await updater.setUpdateUrl({ url: 'https://my-server.com/updates' });

Hinweis

erforderlich allowModifyUrl: true im Konstruktor-Optionen.

setStatsUrl(options)

Ändern Sie die URL für die Statistikberichterstattung.

await updater.setStatsUrl({ url: 'https://my-server.com/stats' });

setChannelUrl(options)

Ändern Sie die URL für die Kanalverwaltung.

await updater.setChannelUrl({ url: 'https://my-server.com/channel' });

setAppId(options)

Ändern Sie die App-ID während der Laufzeit.

await updater.setAppId({ appId: 'com.example.newapp' });

Hinweis

Benötigt allowModifyAppId: true in den Konstruktor-Optionen.

getAppId()

Ermitteln Sie die aktuelle App-ID.

const appId = await updater.getAppId();

Debug

setDebugMenu(options)

Aktivieren oder deaktivieren Sie das Debug-Menü.

await updater.setDebugMenu({ enabled: true });

isDebugMenuEnabled()

Überprüfen Sie, ob das Debug-Menü aktiviert ist.

const enabled = await updater.isDebugMenuEnabled();

Events

Hören Sie sich die Ereignisse für Updates an addListener:

updater.addListener('eventName', (event) => {
  // Handle event
});

Verfügbare Ereignisse

Ereignis	Payload	Beschreibung
download	{ percent, status }	Herunterladungsfortschrittsmeldungen
updateAvailable	{ bundle }	Ein Update ist verfügbar
noNeedUpdate	{ message }	Aktuell auf dem neuesten Stand
downloadComplete	{ bundle }	Herunterladen erfolgreich abgeschlossen
downloadFailed	{ bundle, error }	Herunterladen fehlgeschlagen
breakingAvailable	{ bundle }	Inkompatibles Update verfügbar (erfordert native Update)
updateFailed	{ bundle, reason }	Update-Installation fehlgeschlagen
appReloaded	{}	App wurde neu geladen
appReady	{}	notifyAppReady() wurde aufgerufen

Beispiel: Vollständige Ereignis-Handling

// Progress tracking
updater.addListener('download', (event) => {
  updateProgressBar(event.percent);
});

// Update available notification
updater.addListener('updateAvailable', (event) => {
  showNotification(`Update ${event.bundle.version} available!`);
});

// Handle completion
updater.addListener('downloadComplete', async (event) => {
  // Queue for next restart
  await updater.next({ id: event.bundle.id });
  showNotification('Update will apply on next restart');
});

// Handle failures
updater.addListener('updateFailed', (event) => {
  console.error('Update failed:', event.reason);
  reportError(event);
});

Konstruktor-Optionen

Vollständige Konfigurationsoptionen für ElectronUpdater:

const updater = new ElectronUpdater({
  // Required
  appId: 'com.example.app',

  // Version override
  version: '1.0.0', // Override builtin version detection

  // Server URLs
  updateUrl: 'https://plugin.capgo.app/updates',
  channelUrl: 'https://plugin.capgo.app/channel_self',
  statsUrl: 'https://plugin.capgo.app/stats',

  // Behavior
  autoUpdate: true,           // Enable automatic update checks
  appReadyTimeout: 10000,     // Milliseconds before rollback (default: 10000)
  autoDeleteFailed: true,     // Auto-delete failed bundles
  autoDeletePrevious: true,   // Auto-delete old bundles
  resetWhenUpdate: true,      // Reset to builtin on native update

  // Channels
  defaultChannel: 'production',

  // Direct Update Mode
  directUpdate: false,        // 'atInstall' | 'onLaunch' | 'always' | false

  // Security
  publicKey: '...',           // RSA public key for E2E encryption

  // Dynamic Configuration
  allowModifyUrl: false,      // Allow runtime URL changes
  allowModifyAppId: false,    // Allow runtime App ID changes
  persistCustomId: false,     // Persist custom ID across updates
  persistModifyUrl: false,    // Persist URL changes

  // Debug
  debugMenu: false,           // Enable debug menu (Ctrl+Shift+D)
  disableJSLogging: false,    // Disable console logs

  // Periodic Updates
  periodCheckDelay: 0,        // Seconds between auto-checks (0 = disabled, min 600)
});

Weiter von Electron Updater Referenz API

Wenn Sie “__CAPGO_KEEP_0__” verwenden Elektron Updater Referenz API um das Planungsdashboard und die API-Operationen zu verbinden Mit @capgo/electron-updater für die native Fähigkeit in Mit @capgo/electron-updater, API Übersicht für die Implementierungsdetails in API Übersicht, Einführung für die Implementierungsdetails in Einführung, API Schlüssel für die Implementierungsdetails in API Schlüssel, und Geräte für die Implementierungsdetails in Geräte.