This is the full developer documentation for capgo
# Willkommen zur Capgo-Dokumentation
> Meistern Sie Capgo Cloud für sofortige App-Updates und erkunden Sie unsere umfassende Sammlung von Capacitor-Plugins zur Verbesserung Ihrer mobilen Entwicklung
## 🚀 Capgo Cloud - Live-Updates leicht gemacht
[Section titled “🚀 Capgo Cloud - Live-Updates leicht gemacht”](#-capgo-cloud---live-updates-leicht-gemacht)
Sofortige Updates
Stellen Sie JavaScript-, HTML- und CSS-Updates direkt an Benutzer bereit, ohne App-Store-Verzögerungen. Beheben Sie Fehler und liefern Sie Funktionen in Minuten statt Tagen.
3-Schritte-Integration
Starten Sie mit nur `npx @capgo/cli@latest init [APIKEY]` und beginnen Sie sofort mit dem Pushen von Updates dank unserer einfachen Integration.
Erweiterte Funktionen
Kanäle für A/B-Tests, automatische Rollbacks, Update-Analysen, verschlüsselte Bundles und Enterprise-Sicherheitsfunktionen.
Vollständiger Leitfaden
Lernen Sie alles von der [Schnelleinrichtung](/docs/getting-started/quickstart/) bis zu fortgeschrittenen Bereitstellungsstrategien in unserer umfassenden Dokumentation.
## 📚 Was ist in dieser Dokumentation enthalten
[Section titled “📚 Was ist in dieser Dokumentation enthalten”](#-was-ist-in-dieser-dokumentation-enthalten)
[Capgo Cloud-Einrichtung ](/docs/getting-started/quickstart/)Vollständige Anleitungen zur Integration von Live-Updates, Verwaltung von Kanälen, CI/CD-Integration und Überwachung Ihrer Bereitstellungen.
[20+ Capacitor-Plugins ](/docs/plugins/)Erkunden Sie unsere Sammlung produktionsbereiter Plugins für Biometrie, Käufe, Kamera, Speicher und weitere native Funktionen.
[CLI & Öffentliche API ](/docs/cli/overview/)Automatisieren Sie Ihren Workflow mit unseren CLI-Tools und integrieren Sie Capgo in Ihre bestehenden Systeme mit unserer REST-API.
[Enterprise-Lösungen ](/enterprise/)Dedizierter Support, SLAs, benutzerdefinierte Funktionen und erweiterte Sicherheitsoptionen für Teams, die mehr benötigen.
## 🎯 Schnellzugriff
[Section titled “🎯 Schnellzugriff”](#-schnellzugriff)
* **Erstes Mal?** Beginnen Sie mit dem [5-Minuten-Schnellstart](/docs/getting-started/quickstart/)
* **Brauchen Sie ein Plugin?** Durchsuchen Sie unsere [Plugin-Sammlung](/docs/plugins/) oder fordern Sie [individuelle Entwicklung](/consulting/) an
* **Haben Sie Probleme?** Schauen Sie in die [FAQ](/docs/faq/) oder treten Sie unserem [Discord](https://discord.capgo.app) bei
* **Enterprise-Bedürfnisse?** Sehen Sie sich unsere [Enterprise-Lösungen](/enterprise/) an oder [kontaktieren Sie uns](mailto:support@capgo.app)
# Android Builds
> Android-Apps mit Capgo Cloud Build konfigurieren und erstellen
Erstellen und übermitteln Sie Android-Apps an den Google Play Store mithilfe der sicheren Cloud-Infrastruktur von Capgo.
## Bevor Sie erstellen
[Section titled “Bevor Sie erstellen”](#bevor-sie-erstellen)
⚠️ Richten Sie zuerst Android-Zugangsdaten ein
**Erforderlich:** Sie müssen Ihre Android-Zugangsdaten speichern, bevor Sie Release-Apps erstellen.
[Android-Zugangsdaten einrichten →](/docs/cli/cloud-build/credentials/#saving-android-credentials)
## Wie Android Builds funktionieren
[Section titled “Wie Android Builds funktionieren”](#wie-android-builds-funktionieren)
Android-Builds laufen in sicheren Cloudflare-Sandboxen:
* **Infrastruktur**: Cloudflare Workers mit containerisiertem Android SDK
* **Build-Tool**: Gradle mit Android Build Tools
* **Ausführung**: Isolierte Sandbox-Umgebung pro Build
* **Bereinigung**: Sofortige Löschung nach Build-Abschluss
* **Sicherheit**: Kein persistenter Speicher, vollständige Isolation zwischen Builds
## Voraussetzungen
[Section titled “Voraussetzungen”](#voraussetzungen)
Bevor Sie für Android erstellen, benötigen Sie:
### 1. Entwicklungsumgebung (Lokales Testen)
[Section titled “1. Entwicklungsumgebung (Lokales Testen)”](#1-entwicklungsumgebung-lokales-testen)
* Android Studio lokal installiert (für die anfängliche Keystore-Einrichtung)
* Ihre App erstellt erfolgreich mit `npx cap open android`
* Java JDK 17 oder höher
### 2. Signatur-Keystore
[Section titled “2. Signatur-Keystore”](#2-signatur-keystore)
Für Release-Builds benötigen Sie einen Signatur-Keystore:
| Build-Typ | Keystore erforderlich | Zweck |
| ----------- | --------------------- | ------------------------------------ |
| **Debug** | Nein | Nur für Tests, automatisch generiert |
| **Release** | Ja | Play Store-Übermittlung |
## Einen Keystore erstellen
[Section titled “Einen Keystore erstellen”](#einen-keystore-erstellen)
Tip
Für detaillierte Schritt-für-Schritt-Anleitungen mit Screenshots besuchen Sie:
* [Android-Zertifikate-Anleitung](https://capgo.app/cloud/native-builds/certificates/android/)
* [Blog: Automatische Android-Builds mit GitHub Actions](https://capgo.app/blog/automatic-capacitor-android-build-github-action/)
Wenn Sie noch keinen Keystore haben, erstellen Sie einen:
```bash
keytool -genkey -v \
-keystore my-release-key.keystore \
-alias my-key-alias \
-keyalg RSA \
-keysize 2048 \
-validity 10000
```
Beantworten Sie die Aufforderungen:
* **Passwort**: Wählen Sie ein starkes Passwort (sicher aufbewahren!)
* **Name**: Ihr Name oder Firmenname
* **Organisation**: Ihr Firmenname
* **Standort**: Ihre Stadt, Bundesland, Land
Caution
**Wichtig**: Bewahren Sie Ihre Keystore-Datei und Passwörter sicher auf! Wenn Sie diese verlieren, können Sie Ihre App im Play Store nicht aktualisieren.
### Keystore-Komponenten verstehen
[Section titled “Keystore-Komponenten verstehen”](#keystore-komponenten-verstehen)
Beim Erstellen eines Keystores müssen Sie sich Folgendes merken:
1. **Keystore-Passwort** (`KEYSTORE_STORE_PASSWORD`): Das Passwort für die Keystore-Datei selbst
2. **Key-Alias** (`KEYSTORE_KEY_ALIAS`): Der Name/Bezeichner für Ihren Signaturschlüssel innerhalb des Keystores
3. **Key-Passwort** (`KEYSTORE_KEY_PASSWORD`): Das Passwort für den spezifischen Schlüssel (kann identisch mit dem Store-Passwort sein)
**Beispiel-Workflow:**
```bash
# Aliase in Ihrem Keystore auflisten, um zu überprüfen
keytool -list -keystore my-release-key.keystore
# Detaillierte Informationen über Ihren Schlüssel anzeigen
keytool -list -v -keystore my-release-key.keystore -alias my-key-alias
```
## Build-Konfiguration
[Section titled “Build-Konfiguration”](#build-konfiguration)
### Erforderliche Umgebungsvariablen
[Section titled “Erforderliche Umgebungsvariablen”](#erforderliche-umgebungsvariablen)
Für **Release-Builds** legen Sie diese Zugangsdaten fest:
```bash
# Android-Signatur (Erforderlich für Release)
ANDROID_KEYSTORE_FILE=""
KEYSTORE_KEY_ALIAS="my-key-alias"
KEYSTORE_KEY_PASSWORD=""
KEYSTORE_STORE_PASSWORD=""
# Play Store-Veröffentlichung (Optional, für automatische Übermittlung)
PLAY_CONFIG_JSON=""
```
### Base64-Zugangsdaten generieren
[Section titled “Base64-Zugangsdaten generieren”](#base64-zugangsdaten-generieren)
**Keystore-Datei:**
```bash
base64 -i my-release-key.keystore | pbcopy
```
**Play Store Service Account JSON:**
```bash
base64 -i play-store-service-account.json | pbcopy
```
Die Base64-Zeichenfolge befindet sich jetzt in Ihrer Zwischenablage.
### Play Store Service Account einrichten
[Section titled “Play Store Service Account einrichten”](#play-store-service-account-einrichten)
Um automatische Play Store-Uploads zu ermöglichen, müssen Sie ein Google Cloud Service Account mit entsprechenden Berechtigungen erstellen.
Tip
Für detaillierte Anweisungen mit Screenshots siehe die [Android-Zertifikate-Anleitung](https://capgo.app/cloud/native-builds/certificates/android/).
1. **Service Account in Google Cloud erstellen**
* Gehen Sie zu [Google Play Console](https://play.google.com/console) → Einrichtung → API-Zugriff
* Klicken Sie auf “Neues Service Account erstellen”
* Folgen Sie dem Link zur Google Cloud Console
* Klicken Sie auf “Service Account erstellen”
* Geben Sie einen Namen ein (z. B. “Capgo CI/CD”)
* Erteilen Sie die Rolle “Service Account User”
* Klicken Sie auf “Fertig”
2. **JSON-Schlüssel erstellen**
* Finden Sie in der Google Cloud Console Ihr Service Account
* Klicken Sie auf die Service Account-E-Mail
* Gehen Sie zum Tab “Schlüssel”
* Klicken Sie auf “Schlüssel hinzufügen” → “Neuen Schlüssel erstellen”
* Wählen Sie das Format “JSON”
* Laden Sie die JSON-Datei herunter (sicher aufbewahren!)
3. **Berechtigungen in der Play Console erteilen**
* Gehen Sie zurück zur Google Play Console → Einrichtung → API-Zugriff
* Finden Sie Ihr Service Account in der Liste
* Klicken Sie auf “Zugriff gewähren”
* Wählen Sie unter “App-Berechtigungen” Ihre App aus
* Erteilen Sie unter “Kontoberechtigungen”:
* **Releases**: “App-Informationen anzeigen und Massenberichte herunterladen (schreibgeschützt)”
* **Releases**: “Entwurfsreleases erstellen, bearbeiten und löschen”
* **Releases**: “In Produktion veröffentlichen, Geräte ausschließen und Play App Signing verwenden”
* Klicken Sie auf “Benutzer einladen”
4. **Einladung annehmen**
* Das Service Account erhält eine Einladungs-E-Mail
* Akzeptieren Sie die Einladung, um die Berechtigungen zu aktivieren
Caution
Die Service Account JSON-Datei enthält vertrauliche Zugangsdaten. Committen Sie sie niemals in die Versionskontrolle oder teilen Sie sie öffentlich.
## Für Android erstellen
[Section titled “Für Android erstellen”](#für-android-erstellen)
### Debug-Build
[Section titled “Debug-Build”](#debug-build)
Perfekt zum Testen ohne Signatur:
```bash
npx @capgo/cli@latest build com.example.app \
--platform android \
--build-mode debug
```
Dies erstellt ein Debug-APK, das auf jedem Gerät zum Testen installiert werden kann.
### Release-Build
[Section titled “Release-Build”](#release-build)
Für Play Store-Übermittlung:
```bash
npx @capgo/cli@latest build com.example.app \
--platform android \
--build-mode release
```
Erfordert, dass Signaturzugangsdaten als Umgebungsvariablen konfiguriert sind.
## CI/CD-Integration
[Section titled “CI/CD-Integration”](#cicd-integration)
### GitHub Actions-Beispiel
[Section titled “GitHub Actions-Beispiel”](#github-actions-beispiel)
```yaml
name: Build Android App
on:
push:
branches: [main]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6
- name: Setup Node.js
uses: actions/setup-node@v6
with:
node-version: '24'
- name: Install dependencies
run: npm ci
- name: Build web assets
run: npm run build
- name: Sync Capacitor
run: npx cap sync android
- name: Build Android app
env:
CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}
ANDROID_KEYSTORE_FILE: ${{ secrets.ANDROID_KEYSTORE }}
KEYSTORE_KEY_ALIAS: ${{ secrets.KEYSTORE_ALIAS }}
KEYSTORE_KEY_PASSWORD: ${{ secrets.KEYSTORE_KEY_PASSWORD }}
KEYSTORE_STORE_PASSWORD: ${{ secrets.KEYSTORE_STORE_PASSWORD }}
PLAY_CONFIG_JSON: ${{ secrets.PLAY_STORE_CONFIG }}
run: |
npx @capgo/cli@latest build ${{ secrets.APP_ID }} \
--platform android \
--build-mode release
```
## Details zum Build-Prozess
[Section titled “Details zum Build-Prozess”](#details-zum-build-prozess)
### Was passiert während eines Android-Builds
[Section titled “Was passiert während eines Android-Builds”](#was-passiert-während-eines-android-builds)
1. **Sandbox-Initialisierung** (\~5 Sekunden)
* Sicherer Container wird gestartet
* Android SDK und Gradle geladen
* Isoliertes Dateisystem erstellt
2. **Projekt-Setup** (\~20 Sekunden)
* Projekt-Zip von R2 heruntergeladen
* In Build-Verzeichnis extrahiert
* Signaturzugangsdaten eingefügt
3. **Gradle-Build** (2-4 Minuten)
* Abhängigkeiten heruntergeladen
* APK/AAB-Kompilierung
* ProGuard/R8-Optimierung (Release-Modus)
* Code-Signatur angewendet
4. **Play Store-Upload** (30 Sekunden, falls konfiguriert)
* AAB zur Play Console hochgeladen
* Release-Track konfiguriert
* Übermittlung initiiert
5. **Bereinigung** (sofort)
* Alle Dateien gelöscht
* Container zerstört
* Keine Artefakte gespeichert
### Build-Stack
[Section titled “Build-Stack”](#build-stack)
Unsere Android-Build-Umgebung umfasst:
* **Java**: OpenJDK 17
* **Android SDK**: Neueste stabile Version
* **Gradle**: 8.x
* **Build Tools**: 34.x
* **Node.js**: 18.x (LTS)
* **NPM**: Neueste stabile Version
## Build-Ausgabe
[Section titled “Build-Ausgabe”](#build-ausgabe)
### APK vs AAB
[Section titled “APK vs AAB”](#apk-vs-aab)
* **APK** (Android Package): Installierbare Datei für direkte Installation
* **AAB** (Android App Bundle): Von Google Play empfohlenes Format (kleinere Downloads für Benutzer)
Standardmäßig erstellen Capgo-Builds:
* **Debug-Modus**: APK
* **Release-Modus**: AAB (optimiert für Play Store)
## Build-Zeiten
[Section titled “Build-Zeiten”](#build-zeiten)
Typische Android-Build-Zeiten:
| Build-Typ | Durchschnittliche Zeit |
| ----------------------- | ---------------------- |
| Debug | 2-3 Minuten |
| Release (ohne ProGuard) | 3-4 Minuten |
| Release (mit ProGuard) | 4-6 Minuten |
Note
Android-Builds kosten **1× den Basistarif** (halb so viel wie iOS-Builds).
## Build-Varianten
[Section titled “Build-Varianten”](#build-varianten)
### Benutzerdefinierte Build-Varianten
[Section titled “Benutzerdefinierte Build-Varianten”](#benutzerdefinierte-build-varianten)
Wenn Ihre App benutzerdefinierte Build-Varianten hat (z. B. `staging`, `production`), verwenden Sie `build-config`:
```bash
npx @capgo/cli@latest build com.example.app \
--platform android \
--build-mode release \
--build-config '{"variant":"staging"}'
```
Dies erstellt die Variante `stagingRelease`.
### Flavor-Dimensionen
[Section titled “Flavor-Dimensionen”](#flavor-dimensionen)
Für Apps mit Flavor-Dimensionen:
```bash
--build-config '{"flavor":"premium","variant":"production"}'
```
Dies erstellt die Variante `premiumProductionRelease`.
## Fehlerbehebung
[Section titled “Fehlerbehebung”](#fehlerbehebung)
### Häufige Probleme
[Section titled “Häufige Probleme”](#häufige-probleme)
**“Keystore password incorrect”**
* Überprüfen Sie, ob KEYSTORE\_STORE\_PASSWORD mit Ihrem Keystore übereinstimmt
* Stellen Sie sicher, dass KEYSTORE\_KEY\_PASSWORD mit Ihrem Key-Alias-Passwort übereinstimmt
* Prüfen Sie auf zusätzliche Leerzeichen oder Sonderzeichen
**“Key alias not found”**
* Überprüfen Sie, ob KEYSTORE\_KEY\_ALIAS genau übereinstimmt (Groß-/Kleinschreibung beachten)
* Aliase auflisten: `keytool -list -keystore my-release-key.keystore`
**“Gradle build failed”**
* Überprüfen Sie die Build-Protokolle auf den spezifischen Fehler
* Stellen Sie sicher, dass Ihre App lokal mit `./gradlew assembleRelease` erstellt wird
* Überprüfen Sie, ob alle nativen Abhängigkeiten in `build.gradle` sind
**“Play Store upload failed”**
* Überprüfen Sie, ob die Service Account JSON gültig ist
* Stellen Sie sicher, dass das Service Account korrekte Berechtigungen in der Play Console hat
* Prüfen Sie, ob die App ordnungsgemäß in der Play Console eingerichtet ist
**“Build timeout”**
* Große Apps benötigen möglicherweise Optimierung
* Prüfen Sie, ob unnötige Abhängigkeiten entfernt werden können
* Kontaktieren Sie den Support, wenn Builds ständig ein Timeout erreichen
### Debug-Protokolle
[Section titled “Debug-Protokolle”](#debug-protokolle)
Achten Sie auf diese wichtigen Phasen in den Build-Protokollen:
```plaintext
→ Downloading dependencies...
→ Running Gradle assembleRelease...
→ Signing APK/AAB...
→ Uploading to Play Store...
✔ Build succeeded
```
Wenn ein Build fehlschlägt, wird der spezifische Gradle-Fehler in den Protokollen angezeigt.
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
### 1. Zuerst lokal testen
[Section titled “1. Zuerst lokal testen”](#1-zuerst-lokal-testen)
Stellen Sie immer sicher, dass Ihr Android-Build lokal funktioniert:
```bash
cd android
./gradlew assembleRelease
# oder
./gradlew bundleRelease
```
### 2. Sichern Sie Ihren Keystore
[Section titled “2. Sichern Sie Ihren Keystore”](#2-sichern-sie-ihren-keystore)
* Committen Sie niemals Keystores in die Versionskontrolle
* Speichern Sie in sicherer Secrets-Verwaltung (1Password, AWS Secrets Manager usw.)
* Bewahren Sie Backup-Kopien an mehreren sicheren Orten auf
* Dokumentieren Sie Passwörter in einem sicheren Passwort-Manager
### 3. Versionsverwaltung
[Section titled “3. Versionsverwaltung”](#3-versionsverwaltung)
Capgo liest die Version aus Ihrer `capacitor.config.json`:
```json
{
"appId": "com.example.app",
"appName": "My App",
"version": "1.0.0",
"build": "1"
}
```
Erhöhen Sie die `build`-Nummer für jedes Release.
### 4. ProGuard-Konfiguration
[Section titled “4. ProGuard-Konfiguration”](#4-proguard-konfiguration)
Für Release-Builds stellen Sie sicher, dass ProGuard-Regeln ordnungsgemäß konfiguriert sind:
android/app/proguard-rules.pro
```plaintext
-keep class com.getcapacitor.** { *; }
-keep @com.getcapacitor.annotation.CapacitorPlugin public class * {
@com.getcapacitor.annotation.PluginMethod public ;
}
```
### 5. Build-Größe überwachen
[Section titled “5. Build-Größe überwachen”](#5-build-größe-überwachen)
Behalten Sie die APK/AAB-Größe im Auge, um sicherzustellen, dass sie optimiert ist:
```plaintext
Die CLI zeigt die endgültige Größe an:
→ APK size: 12.4 MB
```
Wenn Ihre App groß ist (>50 MB), erwägen Sie:
* ProGuard/R8 aktivieren
* AAB-Format verwenden (dynamische Bereitstellung)
* Bilder und Assets optimieren
## Play Store-Übermittlung
[Section titled “Play Store-Übermittlung”](#play-store-übermittlung)
### Automatische Übermittlung
[Section titled “Automatische Übermittlung”](#automatische-übermittlung)
Mit konfiguriertem PLAY\_CONFIG\_JSON werden Builds automatisch zum internen Test-Track der Play Console hochgeladen.
### Manuelle Übermittlung
[Section titled “Manuelle Übermittlung”](#manuelle-übermittlung)
Wenn Sie manuelle Übermittlung bevorzugen:
1. Führen Sie den Build ohne PLAY\_CONFIG\_JSON aus
2. Laden Sie das AAB von Build-Artefakten herunter (falls konfiguriert)
3. Laden Sie es manuell zur Play Console hoch
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
* [iOS Builds](/docs/cli/cloud-build/ios/) - iOS-Builds konfigurieren
* [Fehlerbehebung](/docs/cli/cloud-build/troubleshooting/) - Häufige Build-Probleme
* [CLI-Referenz](/docs/cli/reference/build/) - Vollständige Befehlsdokumentation
## Brauchen Sie Hilfe?
[Section titled “Brauchen Sie Hilfe?”](#brauchen-sie-hilfe)
* [Fehlerbehebungsanleitung](/docs/cli/cloud-build/troubleshooting/)
* [Discord-Community](https://discord.com/invite/VnYRvBfgA6)
* E-Mail:
# Verwaltung von Zugangsdaten
> Speichern und verwalten Sie Build-Zugangsdaten lokal für iOS- und Android-Builds
Verwalten Sie Ihre iOS- und Android-Build-Zugangsdaten lokal für bequeme Cloud-Builds.
## Übersicht
[Section titled “Übersicht”](#übersicht)
Die Capgo CLI ermöglicht es Ihnen, Build-Zugangsdaten lokal auf Ihrem Computer im Ordner `.capgo-credentials` zu speichern. Wenn Sie einen Build ausführen, werden diese Zugangsdaten automatisch verwendet und sicher an die Build-Server von Capgo gesendet.
Benötigen Sie Hilfe beim Erhalt von Zugangsdaten?
Wenn Sie Ihre Zertifikate und Zugangsdaten noch nicht haben, lesen Sie diese umfassenden Anleitungen:
**iOS:**
* [So erhalten Sie iOS-Zertifikate](/docs/cli/cloud-build/ios/#how-to-get-ios-certificates-and-provisioning-profiles) - Schritt-für-Schritt-Anleitung
* [iOS-Zertifikate-Anleitung (Capgo)](https://capgo.app/cloud/native-builds/certificates/ios/) - Detailliertes Tutorial mit Screenshots
* [Blog: Automatische iOS-Builds](https://capgo.app/blog/automatic-capacitor-ios-build-github-action/) - Vollständige CI/CD-Einrichtung
**Android:**
* [Einen Keystore erstellen](/docs/cli/cloud-build/android/#creating-a-keystore) - Schritt-für-Schritt-Anleitung
* [Android-Zertifikate-Anleitung (Capgo)](https://capgo.app/cloud/native-builds/certificates/android/) - Detailliertes Tutorial mit Screenshots
* [Blog: Automatische Android-Builds](https://capgo.app/blog/automatic-capacitor-android-build-github-action/) - Vollständige CI/CD-Einrichtung
Sicherheitsgarantie
**Ihre Zugangsdaten werden NIEMALS dauerhaft auf Capgo-Servern gespeichert:**
* ✅ Werden NUR während des aktiven Build-Prozesses verwendet
* ✅ Automatisch nach Build-Abschluss gelöscht
* ✅ Maximale Aufbewahrung: 24 Stunden (auch bei fehlgeschlagenem Build)
* ✅ Apps werden direkt an App Store/Play Store gesendet - wir speichern NICHTS
* ✅ Sicher über HTTPS übertragen
## Befehle
[Section titled “Befehle”](#befehle)
### Zugangsdaten speichern
[Section titled “Zugangsdaten speichern”](#zugangsdaten-speichern)
Speichern Sie Ihre Build-Zugangsdaten lokal zur automatischen Verwendung:
```bash
npx @capgo/cli build credentials save --platform [optionen]
```
### Zugangsdaten auflisten
[Section titled “Zugangsdaten auflisten”](#zugangsdaten-auflisten)
Zeigen Sie derzeit gespeicherte Zugangsdaten an (Passwörter sind maskiert):
```bash
npx @capgo/cli build credentials list
```
### Zugangsdaten löschen
[Section titled “Zugangsdaten löschen”](#zugangsdaten-löschen)
Entfernen Sie gespeicherte Zugangsdaten von Ihrem lokalen Computer:
```bash
# Alle Zugangsdaten löschen
npx @capgo/cli build credentials clear
# Nur iOS-Zugangsdaten löschen
npx @capgo/cli build credentials clear --platform ios
# Nur Android-Zugangsdaten löschen
npx @capgo/cli build credentials clear --platform android
```
## iOS-Zugangsdaten speichern
[Section titled “iOS-Zugangsdaten speichern”](#ios-zugangsdaten-speichern)
Note
**Haben Sie noch keine iOS-Zertifikate?** Siehe die [iOS Builds-Anleitung](/docs/cli/cloud-build/ios/#how-to-get-ios-certificates-and-provisioning-profiles) für Anweisungen zum Erstellen von Zertifikaten und Bereitstellungsprofilen.
### Vollständiges Beispiel
[Section titled “Vollständiges Beispiel”](#vollständiges-beispiel)
```bash
npx @capgo/cli build credentials save \
--platform ios \
--certificate ./cert.p12 \
--p12-password "YourP12Password" \
--provisioning-profile ./profile.mobileprovision \
--apple-key ./AuthKey_ABC1234567.p8 \
--apple-key-id "ABC1234567" \
--apple-issuer-id "00000000-0000-0000-0000-000000000000" \
--apple-team-id "TEAM123456"
```
### iOS-Optionen
[Section titled “iOS-Optionen”](#ios-optionen)
| Option | Beschreibung | Erforderlich |
| ------------------------------------ | --------------------------------------------------------- | ----------------- |
| `--certificate ` | Pfad zur .p12-Zertifikatsdatei | Ja (Release) |
| `--p12-password ` | Passwort für das .p12-Zertifikat | Ja (Release) |
| `--provisioning-profile ` | Pfad zur .mobileprovision-Datei | Ja (Release) |
| `--provisioning-profile-prod ` | Produktions-Bereitstellungsprofil (optional) | Nein |
| `--apple-key ` | Pfad zum App Store Connect API .p8-Schlüssel | Ja (Übermittlung) |
| `--apple-key-id ` | App Store Connect API Key ID | Ja (Übermittlung) |
| `--apple-issuer-id ` | App Store Connect API Issuer ID (UUID) | Ja (Übermittlung) |
| `--apple-team-id ` | App Store Connect Team ID | Ja (Übermittlung) |
| `--apple-id ` | Apple ID E-Mail (alternative Authentifizierung) | Nein |
| `--apple-app-password ` | App-spezifisches Passwort (alternative Authentifizierung) | Nein |
### Was wird gespeichert
[Section titled “Was wird gespeichert”](#was-wird-gespeichert)
Wenn Sie iOS-Zugangsdaten speichern, führt die CLI folgende Schritte aus:
1. Liest die Zertifikats- und Bereitstellungsprofildateien
2. Konvertiert sie in Base64-Kodierung
3. Speichert die Zugangsdaten im Ordner `.capgo-credentials`
4. Speichert Passwörter und IDs als Klartext (nur lokale Dateien)
Die gespeicherte Dateistruktur:
```json
{
"ios": {
"BUILD_CERTIFICATE_BASE64": "...",
"BUILD_PROVISION_PROFILE_BASE64": "...",
"APPLE_KEY_CONTENT": "...",
"P12_PASSWORD": "...",
"APPLE_KEY_ID": "ABC1234567",
"APPLE_ISSUER_ID": "...",
"APP_STORE_CONNECT_TEAM_ID": "TEAM123456"
}
}
```
## Android-Zugangsdaten speichern
[Section titled “Android-Zugangsdaten speichern”](#android-zugangsdaten-speichern)
Note
**Haben Sie noch keinen Keystore?** Siehe die [Android Builds-Anleitung](/docs/cli/cloud-build/android/#creating-a-keystore) für Anweisungen zum Erstellen eines Keystores und Einrichten von Play Store-Zugangsdaten.
### Vollständiges Beispiel
[Section titled “Vollständiges Beispiel”](#vollständiges-beispiel-1)
```bash
npx @capgo/cli build credentials save \
--platform android \
--keystore ./release.keystore \
--keystore-alias "my-key-alias" \
--keystore-key-password "KeyPassword123" \
--keystore-store-password "StorePassword123" \
--play-config ./play-store-service-account.json
```
### Android-Optionen
[Section titled “Android-Optionen”](#android-optionen)
| Option | Beschreibung | Erforderlich |
| -------------------------------------- | ---------------------------------------- | ----------------- |
| `--keystore ` | Pfad zur .keystore- oder .jks-Datei | Ja (Release) |
| `--keystore-alias ` | Key-Alias im Keystore | Ja (Release) |
| `--keystore-key-password ` | Passwort für den Key-Alias | Ja (Release) |
| `--keystore-store-password ` | Passwort für den Keystore | Ja (Release) |
| `--play-config ` | Pfad zur Play Store Service Account JSON | Ja (Übermittlung) |
### Was wird gespeichert
[Section titled “Was wird gespeichert”](#was-wird-gespeichert-1)
Wenn Sie Android-Zugangsdaten speichern, führt die CLI folgende Schritte aus:
1. Liest den Keystore und die Service Account JSON-Dateien
2. Konvertiert sie in Base64-Kodierung
3. Speichert die Zugangsdaten im Ordner `.capgo-credentials`
4. Speichert Passwörter und Alias als Klartext (nur lokale Dateien)
Die gespeicherte Dateistruktur:
```json
{
"android": {
"ANDROID_KEYSTORE_FILE": "...",
"PLAY_CONFIG_JSON": "...",
"KEYSTORE_KEY_ALIAS": "my-key-alias",
"KEYSTORE_KEY_PASSWORD": "...",
"KEYSTORE_STORE_PASSWORD": "..."
}
}
```
## Gespeicherte Zugangsdaten verwenden
[Section titled “Gespeicherte Zugangsdaten verwenden”](#gespeicherte-zugangsdaten-verwenden)
Sobald Sie Zugangsdaten gespeichert haben, werden sie beim Build automatisch verwendet:
```bash
# Zugangsdaten werden automatisch aus dem .capgo-credentials-Ordner geladen
npx @capgo/cli build com.example.app --platform ios
```
Sie können gespeicherte Zugangsdaten auch mithilfe von Umgebungsvariablen überschreiben:
```bash
# Umgebungsvariablen haben Vorrang vor gespeicherten Zugangsdaten
BUILD_CERTIFICATE_BASE64="..." \
P12_PASSWORD="different-password" \
npx @capgo/cli build com.example.app --platform ios
```
**Rangfolge:**
1. Umgebungsvariablen (höchste Priorität)
2. Gespeicherte Zugangsdaten im Ordner `.capgo-credentials`
3. Keine Zugangsdaten (niedrigste Priorität)
## Gespeicherte Zugangsdaten anzeigen
[Section titled “Gespeicherte Zugangsdaten anzeigen”](#gespeicherte-zugangsdaten-anzeigen)
Listen Sie auf, welche Zugangsdaten Sie gespeichert haben:
```bash
npx @capgo/cli build credentials list
```
Beispielausgabe:
```plaintext
📋 Gespeicherte Build-Zugangsdaten:
iOS-Zugangsdaten:
✓ Zertifikat (base64)
✓ Bereitstellungsprofil (base64)
✓ Apple Key Content (base64)
✓ P12-Passwort: ********
✓ Apple Key ID: ABC1234567
✓ Apple Issuer ID: 00000000-0000-0000-0000-000000000000
✓ Team ID: TEAM123456
Android-Zugangsdaten:
✓ Keystore (base64)
✓ Play Store Config (base64)
✓ Keystore-Alias: my-key-alias
✓ Key-Passwort: ********
✓ Store-Passwort: ********
Speicherort: .capgo-credentials/
🔒 Diese Zugangsdaten werden nur lokal auf Ihrem Computer gespeichert.
Beim Erstellen werden sie an Capgo gesendet, aber NIEMALS dort gespeichert.
Sie werden nach Build-Abschluss automatisch gelöscht (max. 24 Stunden).
```
## Bewährte Methoden für Sicherheit
[Section titled “Bewährte Methoden für Sicherheit”](#bewährte-methoden-für-sicherheit)
### Sicherheit bei lokaler Speicherung
[Section titled “Sicherheit bei lokaler Speicherung”](#sicherheit-bei-lokaler-speicherung)
1. **Dateiberechtigungen**
```bash
# Stellen Sie sicher, dass der Zugangsdatenordner nicht von anderen lesbar ist
chmod 700 .capgo-credentials
chmod 600 .capgo-credentials/*
```
2. **Niemals Zugangsdaten committen**
```bash
# Zu .gitignore hinzufügen
echo ".capgo-credentials/" >> .gitignore
```
3. **Zugangsdaten trennen**
* Verwenden Sie unterschiedliche Zugangsdaten für lokale Entwicklung vs. CI/CD
* Rotieren Sie Zugangsdaten regelmäßig
* Teilen Sie keine Zugangsdaten zwischen Teammitgliedern
### CI/CD-Verwendung
[Section titled “CI/CD-Verwendung”](#cicd-verwendung)
Für CI/CD-Umgebungen **bevorzugen Sie Umgebungsvariablen** gegenüber gespeicherten Zugangsdaten:
```yaml
# GitHub Actions
env:
BUILD_CERTIFICATE_BASE64: ${{ secrets.IOS_CERTIFICATE }}
P12_PASSWORD: ${{ secrets.P12_PASSWORD }}
# ... weitere Secrets
```
Dies ist sicherer, weil:
* Secrets von Ihrer CI/CD-Plattform verwaltet werden
* Keine Zugangsdatendateien auf Runnern
* Einfache Rotation und Zugriffskontrolle
* Audit-Trails für Secret-Verwendung
### Zugangsdaten-Rotation
[Section titled “Zugangsdaten-Rotation”](#zugangsdaten-rotation)
Rotieren Sie Ihre Zugangsdaten regelmäßig:
1. **iOS**: Generieren Sie jährlich neue Zertifikate und API-Schlüssel
2. **Android**: Ändern Sie Keystore-Passwörter jährlich
3. **Nach Teamänderungen**: Rotieren Sie, wenn Teammitglieder ausscheiden
Gespeicherte Zugangsdaten aktualisieren:
```bash
# Führen Sie den save-Befehl mit neuen Zugangsdaten erneut aus
npx @capgo/cli build credentials save --platform ios --certificate ./new-cert.p12 ...
```
## Fehlerbehebung
[Section titled “Fehlerbehebung”](#fehlerbehebung)
### ”No credentials found”
[Section titled “”No credentials found””](#no-credentials-found)
Wenn der Build sagt, dass keine Zugangsdaten gefunden wurden:
1. **Prüfen Sie, ob Zugangsdaten gespeichert sind**:
```bash
npx @capgo/cli build credentials list
```
2. **Zugangsdaten speichern, falls fehlend**:
```bash
npx @capgo/cli build credentials save --platform ios ...
```
3. **Überprüfen Sie, ob der Zugangsdatenordner existiert**:
```bash
ls -la .capgo-credentials/
```
### “Permission denied” beim Lesen von Zugangsdaten
[Section titled ““Permission denied” beim Lesen von Zugangsdaten”](#permission-denied-beim-lesen-von-zugangsdaten)
Dateiberechtigungen korrigieren:
```bash
chmod 700 .capgo-credentials
chmod 600 .capgo-credentials/*
```
### Zugangsdaten werden nicht verwendet
[Section titled “Zugangsdaten werden nicht verwendet”](#zugangsdaten-werden-nicht-verwendet)
Überprüfen Sie, dass die korrekte Plattform angegeben ist:
```bash
# Stellen Sie sicher, dass --platform mit gespeicherten Zugangsdaten übereinstimmt
npx @capgo/cli build com.example.app --platform ios # Verwendet iOS-Zugangsdaten
npx @capgo/cli build com.example.app --platform android # Verwendet Android-Zugangsdaten
```
### Zugangsdaten löschen und erneut speichern
[Section titled “Zugangsdaten löschen und erneut speichern”](#zugangsdaten-löschen-und-erneut-speichern)
Wenn Zugangsdaten beschädigt zu sein scheinen:
```bash
# Alle Zugangsdaten löschen
npx @capgo/cli build credentials clear
# Erneut speichern
npx @capgo/cli build credentials save --platform ios ...
```
## Migration von Umgebungsvariablen
[Section titled “Migration von Umgebungsvariablen”](#migration-von-umgebungsvariablen)
Wenn Sie derzeit Umgebungsvariablen verwenden, können Sie zu gespeicherten Zugangsdaten migrieren:
1. **Extrahieren Sie Ihre aktuellen Umgebungsvariablen**
```bash
echo $BUILD_CERTIFICATE_BASE64 # Überprüfen Sie, ob sie existieren
```
2. **Dekodieren Sie Base64-Dateien zurück zu Originaldateien** (falls erforderlich)
```bash
echo "$BUILD_CERTIFICATE_BASE64" | base64 -d > cert.p12
echo "$BUILD_PROVISION_PROFILE_BASE64" | base64 -d > profile.mobileprovision
```
3. **Speichern Sie mithilfe der CLI**
```bash
npx @capgo/cli build credentials save \
--platform ios \
--certificate ./cert.p12 \
--provisioning-profile ./profile.mobileprovision \
--p12-password "$P12_PASSWORD" \
--apple-key-id "$APPLE_KEY_ID" \
--apple-issuer-id "$APPLE_ISSUER_ID" \
--apple-team-id "$APP_STORE_CONNECT_TEAM_ID"
```
4. **Testen Sie den Build**
```bash
npx @capgo/cli build com.example.app --platform ios
```
5. **Entfernen Sie Umgebungsvariablen** (optional)
```bash
unset BUILD_CERTIFICATE_BASE64 BUILD_PROVISION_PROFILE_BASE64
```
## Dateispeicherort
[Section titled “Dateispeicherort”](#dateispeicherort)
Zugangsdaten werden im Ordner `.capgo-credentials` gespeichert:
* **macOS/Linux**: `.capgo-credentials/` (in Ihrem Projektverzeichnis oder Home-Verzeichnis)
* **Windows**: `.capgo-credentials\` (in Ihrem Projektverzeichnis oder Home-Verzeichnis)
Der Ordner wird automatisch erstellt, wenn Sie zum ersten Mal Zugangsdaten speichern.
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
* [Erste Schritte](/docs/cli/cloud-build/getting-started/) - Erstellen Sie Ihren ersten Build
* [iOS Builds](/docs/cli/cloud-build/ios/) - iOS-spezifische Build-Konfiguration
* [Android Builds](/docs/cli/cloud-build/android/) - Android-spezifische Build-Konfiguration
* [Fehlerbehebung](/docs/cli/cloud-build/troubleshooting/) - Häufige Probleme und Lösungen
## Brauchen Sie Hilfe?
[Section titled “Brauchen Sie Hilfe?”](#brauchen-sie-hilfe)
* 📚 [Fehlerbehebungsanleitung](/docs/cli/cloud-build/troubleshooting/)
* 💬 [Discord-Community](https://discord.com/invite/VnYRvBfgA6)
* 📧 E-Mail:
# Erste Schritte
> Erstellen Sie Ihren ersten nativen Build mit Capgo Cloud Build
Beginnen Sie mit Capgo Cloud Build und erstellen Sie Ihren ersten iOS- oder Android-nativen Build in Minuten.
## Was Sie benötigen
[Section titled “Was Sie benötigen”](#was-sie-benötigen)
Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:
* Eine Capacitor-App, die lokal erfolgreich erstellt wird
* Node.js 20 oder höher installiert
* Ein Capgo-Konto mit aktivem Abonnement
* Ihre App bereits in Capgo registriert (führen Sie `npx @capgo/cli@latest app add` aus, falls nicht)
* **Build-Zugangsdaten konfiguriert** (Zertifikate, Keystores) - siehe unten
## Vor Ihrem ersten Build
[Section titled “Vor Ihrem ersten Build”](#vor-ihrem-ersten-build)
⚠️ Richten Sie zuerst Zugangsdaten ein
**Erforderlich vor dem Erstellen:** Sie müssen Ihre Build-Zugangsdaten konfigurieren (Zertifikate für iOS, Keystores für Android).
[Zugangsdaten einrichten →](/docs/cli/cloud-build/credentials/)
## Schnellstart
[Section titled “Schnellstart”](#schnellstart)
1. **Build-Zugangsdaten einrichten**
Bevor Sie erstellen können, müssen Sie Ihre Zugangsdaten lokal speichern:
**Für iOS:**
```bash
npx @capgo/cli build credentials save \
--platform ios \
--certificate ./cert.p12 \
--p12-password "password" \
--provisioning-profile ./profile.mobileprovision \
--apple-key ./AuthKey.p8 \
--apple-key-id "KEY123" \
--apple-issuer-id "issuer-uuid" \
--apple-team-id "team-id"
```
**Für Android:**
```bash
npx @capgo/cli build credentials save \
--platform android \
--keystore ./release.keystore \
--keystore-alias "my-key" \
--keystore-key-password "key-pass" \
--keystore-store-password "store-pass"
```
Siehe die [vollständige Zugangsdatenanleitung](/docs/cli/cloud-build/credentials/) für Details.
2. **Lokalen Build überprüfen**
Stellen Sie zunächst sicher, dass Ihre App lokal ohne Fehler erstellt wird:
```bash
# Erstellen Sie Ihre Web-Assets
npm run build
# Mit Capacitor synchronisieren
npx cap sync
# Lokalen Build testen (optional, aber empfohlen)
npx cap open ios # Für iOS
npx cap open android # Für Android
```
3. **Bei Capgo authentifizieren**
Legen Sie Ihren Capgo API-Schlüssel fest (falls noch nicht konfiguriert):
```bash
npx @capgo/cli@latest login
```
Oder setzen Sie die Umgebungsvariable:
```bash
export CAPGO_TOKEN=your_api_key_here
```
4. **Führen Sie Ihren ersten Build aus**
Beginnen Sie mit einem Android-Debug-Build (am schnellsten zum Testen):
```bash
npx @capgo/cli@latest build com.example.app \
--platform android \
--build-mode debug
```
Sie sehen Echtzeit-Protokolle, während Ihr Build fortschreitet:
```plaintext
✔ Creating build job...
✔ Uploading project (15.2 MB)...
✔ Build started
📝 Build logs:
→ Installing dependencies...
→ Running Gradle build...
→ Signing APK...
✔ Build succeeded in 3m 42s
```
5. **Build-Status überprüfen**
Die CLI fragt automatisch ab und zeigt den Build-Status an. Sobald abgeschlossen, sehen Sie:
* Build-Zeit
* Erfolgs-/Fehlerstatus
* App an App Store/Play Store übermittelt (falls Zugangsdaten konfiguriert)
## Den Build-Prozess verstehen
[Section titled “Den Build-Prozess verstehen”](#den-build-prozess-verstehen)
Wenn Sie den Build-Befehl ausführen, passiert Folgendes:
```mermaid
graph LR
A[Ihr Computer] -->|1. Projekt zippen| B[Lokaler Temp]
B -->|2. Hochladen| C[Capgo Cloud]
C -->|3. Erstellen| D[Build-Server]
D -->|4. Protokolle streamen| A
D -->|5. Bereinigung| E[Automatisches Löschen]
```
1. **Lokale Vorbereitung** - Ihr Projekt wird gezippt (ohne `node_modules` und Dotfiles)
2. **Upload** - Das Zip wird zu sicherem Cloud-Speicher hochgeladen (Cloudflare R2)
3. **Build-Ausführung** - Ihre App wird auf dedizierter Infrastruktur erstellt
4. **Protokoll-Streaming** - Echtzeit-Protokolle werden über Server-Sent Events zu Ihrem Terminal gestreamt
5. **Automatische Bereinigung** - Build-Artefakte werden gelöscht (Android: sofort, iOS: 24 Stunden)
## Ihr erster Produktions-Build
[Section titled “Ihr erster Produktions-Build”](#ihr-erster-produktions-build)
Sobald Sie überprüft haben, dass der Prozess funktioniert, erstellen Sie einen Produktions-Build:
### Android
[Section titled “Android”](#android)
```bash
npx @capgo/cli@latest build com.example.app \
--platform android \
--build-mode release
```
Sie müssen zuerst Signaturzugangsdaten konfigurieren. Siehe [Android Build-Konfiguration](/docs/cli/cloud-build/android/).
### iOS
[Section titled “iOS”](#ios)
```bash
npx @capgo/cli@latest build com.example.app \
--platform ios \
--build-mode release
```
iOS-Builds erfordern Signaturzertifikate und Bereitstellungsprofile. Siehe [iOS Build-Konfiguration](/docs/cli/cloud-build/ios/).
## Was wird erstellt
[Section titled “Was wird erstellt”](#was-wird-erstellt)
**Wichtig:** Capgo Cloud Build erstellt nur die **nativen Teile** Ihrer App (nativer iOS- und Android-Code).
Sie sind verantwortlich für:
* Erstellen Ihrer Web-Assets (`npm run build`)
* Ausführen von `npx cap sync` vor dem Build
* Sicherstellen, dass alle Abhängigkeiten in `package.json` sind
Wir kümmern uns um:
* Native iOS-Kompilierung (Xcode, Fastlane)
* Native Android-Kompilierung (Gradle)
* Code-Signatur
* App Store-Übermittlung (falls konfiguriert)
## Build-Zeit & Kosten
[Section titled “Build-Zeit & Kosten”](#build-zeit--kosten)
Die Build-Zeit wird vom Start bis zur Fertigstellung gemessen:
* **Android**: Typischerweise 3-5 Minuten (1× Abrechnungsmultiplikator)
* **iOS**: Typischerweise 5-10 Minuten (2× Abrechnungsmultiplikator aufgrund von Mac-Hardwarekosten)
Sie zahlen nur für die tatsächlich genutzte Build-Zeit. Keine versteckten Gebühren.
## Häufige Anwendungsfälle
[Section titled “Häufige Anwendungsfälle”](#häufige-anwendungsfälle)
### CI/CD-Integration
[Section titled “CI/CD-Integration”](#cicd-integration)
Zu Ihrem GitHub Actions-Workflow hinzufügen:
```yaml
- name: Build native app
env:
CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}
run: |
npm run build
npx cap sync
npx @capgo/cli@latest build ${{ secrets.APP_ID }} \
--platform both \
--build-mode release
```
### Lokale Entwicklung
[Section titled “Lokale Entwicklung”](#lokale-entwicklung)
Builds lokal testen, bevor Sie committen:
```bash
# Schneller Debug-Build zum Testen
npm run build && npx cap sync
npx @capgo/cli@latest build com.example.app \
--platform android \
--build-mode debug
```
### Multi-Plattform-Builds
[Section titled “Multi-Plattform-Builds”](#multi-plattform-builds)
Gleichzeitig für beide Plattformen erstellen:
```bash
npx @capgo/cli@latest build com.example.app \
--platform both \
--build-mode release
```
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
Nachdem Sie Ihren ersten Build erstellt haben:
* [iOS-Builds konfigurieren](/docs/cli/cloud-build/ios/) - Zertifikate und Profile einrichten
* [Android-Builds konfigurieren](/docs/cli/cloud-build/android/) - Keystores und Play Store einrichten
* [Fehlerbehebung](/docs/cli/cloud-build/troubleshooting/) - Häufige Probleme und Lösungen
* [CLI-Referenz](/docs/cli/reference/build/) - Vollständige Befehlsdokumentation
## Brauchen Sie Hilfe?
[Section titled “Brauchen Sie Hilfe?”](#brauchen-sie-hilfe)
* Lesen Sie die [Fehlerbehebungsanleitung](/docs/cli/cloud-build/troubleshooting/)
* Treten Sie unserer [Discord-Community](https://discord.com/invite/VnYRvBfgA6) bei
* E-Mail-Support unter
# iOS Builds
> iOS-Apps mit Capgo Cloud Build konfigurieren und erstellen
Erstellen und übermitteln Sie iOS-Apps an TestFlight und den App Store mithilfe der dedizierten Mac-Infrastruktur von Capgo.
## Bevor Sie erstellen
[Section titled “Bevor Sie erstellen”](#bevor-sie-erstellen)
⚠️ Richten Sie zuerst iOS-Zugangsdaten ein
**Erforderlich:** Sie müssen Ihre iOS-Zugangsdaten speichern, bevor Sie erstellen.
[iOS-Zugangsdaten einrichten →](/docs/cli/cloud-build/credentials/#saving-ios-credentials)
## Wie iOS Builds funktionieren
[Section titled “Wie iOS Builds funktionieren”](#wie-ios-builds-funktionieren)
iOS-Builds laufen auf dedizierten Mac-Maschinen (Scaleway Mac minis M4), die bei Bedarf bereitgestellt werden:
* **Hardware**: Apple Silicon Mac minis mit macOS 15
* **Build-Tool**: Xcode mit Fastlane (benutzerdefinierte Capgo-Konfiguration)
* **Isolation**: Jeder Build läuft als separates macOS-Benutzerkonto
* **Lebensdauer**: Maschinen haben 24-Stunden-Leases und werden automatisch bereinigt
* **Sicherheit**: Alle Dateien und Benutzerkonten werden gelöscht, nachdem die Maschine freigegeben wurde
## Voraussetzungen
[Section titled “Voraussetzungen”](#voraussetzungen)
Bevor Sie für iOS erstellen, benötigen Sie:
### 1. Entwicklungsumgebung
[Section titled “1. Entwicklungsumgebung”](#1-entwicklungsumgebung)
* Mac-Computer mit installiertem Xcode (für anfängliche Zertifikatseinrichtung)
* Gültiges Apple Developer-Konto ($99/Jahr)
* Ihre App erstellt erfolgreich lokal mit `npx cap open ios`
### 2. Code-Signatur-Zertifikate
[Section titled “2. Code-Signatur-Zertifikate”](#2-code-signatur-zertifikate)
Sie benötigen einen dieser Zertifikatstypen je nach Build:
| Build-Typ | Erforderliches Zertifikat | Bereitstellungsprofil |
| --------------- | ------------------------- | --------------------- |
| **Development** | Apple Development | Development Profile |
| **Ad Hoc** | Apple Distribution | Ad Hoc Profile |
| **App Store** | Apple Distribution | App Store Profile |
#### So erhalten Sie iOS-Zertifikate und Bereitstellungsprofile
[Section titled “So erhalten Sie iOS-Zertifikate und Bereitstellungsprofile”](#so-erhalten-sie-ios-zertifikate-und-bereitstellungsprofile)
Tip
Für detaillierte Schritt-für-Schritt-Anleitungen mit Screenshots besuchen Sie:
* [iOS-Zertifikate-Anleitung](https://capgo.app/cloud/native-builds/certificates/ios/)
* [Blog: Automatische iOS-Builds mit GitHub Actions](https://capgo.app/blog/automatic-capacitor-ios-build-github-action/)
**Schnellübersicht:**
1. **Certificate Signing Request (CSR) erstellen**
* Öffnen Sie Schlüsselbundverwaltung auf Ihrem Mac
* Gehen Sie zu Schlüsselbundverwaltung → Zertifikatsassistent → Zertifikat einer Zertifizierungsinstanz anfordern
* Geben Sie Ihre E-Mail und Ihren Namen ein, wählen Sie “Auf Festplatte gesichert”
* Speichern Sie die `.certSigningRequest`-Datei
2. **Zertifikat im Apple Developer Portal generieren**
* Gehen Sie zu [Apple Developer Certificates](https://developer.apple.com/account/resources/certificates)
* Klicken Sie auf ”+”, um ein neues Zertifikat zu erstellen
* Wählen Sie den Zertifikatstyp (iOS Distribution für App Store-Builds)
* Laden Sie Ihre CSR-Datei hoch
* Laden Sie das Zertifikat (`.cer`-Datei) herunter
3. **Zertifikat als .p12 exportieren**
* Doppelklicken Sie auf die heruntergeladene `.cer`-Datei, um sie zum Schlüsselbund hinzuzufügen
* Suchen Sie in der Schlüsselbundverwaltung Ihr Zertifikat unter “Meine Zertifikate”
* Rechtsklick → “Apple Distribution…” exportieren
* Speichern Sie im `.p12`-Format und legen Sie ein Passwort fest (dieses Passwort speichern!)
4. **Bereitstellungsprofil erstellen**
* Gehen Sie zu [Apple Developer Profiles](https://developer.apple.com/account/resources/profiles)
* Klicken Sie auf ”+”, um ein neues Profil zu erstellen
* Wählen Sie den Profiltyp (App Store für Produktions-Builds)
* Wählen Sie Ihre App ID aus
* Wählen Sie das gerade erstellte Zertifikat aus
* Laden Sie die `.mobileprovision`-Datei herunter
### 3. App Store Connect API-Schlüssel (Empfohlen)
[Section titled “3. App Store Connect API-Schlüssel (Empfohlen)”](#3-app-store-connect-api-schlüssel-empfohlen)
Für automatische TestFlight-Übermittlung erstellen Sie einen API-Schlüssel:
1. Gehen Sie zu [App Store Connect](https://appstoreconnect.apple.com/) → Benutzer und Zugriff → Schlüssel
2. Klicken Sie auf die Schaltfläche ”+”, um einen neuen Schlüssel zu erstellen
3. Geben Sie ihm einen Namen (z. B. “Capgo CI”) und wählen Sie die Rolle “Developer”
4. Laden Sie die `.p8`-Datei herunter (Sie können sie nur einmal herunterladen!)
5. Notieren Sie die **Key ID** und **Issuer ID**
Note
Sie finden Ihre **Team ID** auch in Ihrem Apple Developer-Konto unter Mitgliedschaftsdetails.
## Build-Konfiguration
[Section titled “Build-Konfiguration”](#build-konfiguration)
### Erforderliche Umgebungsvariablen
[Section titled “Erforderliche Umgebungsvariablen”](#erforderliche-umgebungsvariablen)
Legen Sie diese Zugangsdaten vor dem Erstellen fest:
```bash
# iOS-Signatur (Erforderlich)
BUILD_CERTIFICATE_BASE64=""
BUILD_PROVISION_PROFILE_BASE64=""
P12_PASSWORD=""
# App Store Connect API (für Übermittlung)
APPLE_KEY_ID="ABC1234567"
APPLE_ISSUER_ID="00000000-0000-0000-0000-000000000000"
APPLE_KEY_CONTENT=""
# Zusätzliche Konfiguration
APP_STORE_CONNECT_TEAM_ID="1234567890"
APPLE_PROFILE_NAME="App Store com.example.app"
```
### Base64-Zugangsdaten generieren
[Section titled “Base64-Zugangsdaten generieren”](#base64-zugangsdaten-generieren)
Tip
Verwenden Sie diese Befehle, um Ihre Zertifikate für Capgo zu kodieren:
**Zertifikat (.p12):**
```bash
base64 -i YourCertificate.p12 | pbcopy
```
**Bereitstellungsprofil (.mobileprovision):**
```bash
base64 -i YourProfile.mobileprovision | pbcopy
```
**App Store Connect Schlüssel (.p8):**
```bash
base64 -i AuthKey_ABC1234567.p8 | pbcopy
```
Die Base64-Zeichenfolge befindet sich jetzt in Ihrer Zwischenablage - fügen Sie sie in Ihre Umgebungsvariable oder CI/CD-Secrets ein.
## Für iOS erstellen
[Section titled “Für iOS erstellen”](#für-ios-erstellen)
### Debug-Build (Development)
[Section titled “Debug-Build (Development)”](#debug-build-development)
```bash
npx @capgo/cli@latest build com.example.app \
--platform ios \
--build-mode debug
```
Dies erstellt einen Development-Build, der auf registrierten Geräten installiert werden kann.
### Release-Build (App Store)
[Section titled “Release-Build (App Store)”](#release-build-app-store)
```bash
npx @capgo/cli@latest build com.example.app \
--platform ios \
--build-mode release
```
Dies erstellt einen App Store-Build und übermittelt ihn automatisch an TestFlight, wenn Sie die App Store Connect API-Zugangsdaten konfiguriert haben.
## CI/CD-Integration
[Section titled “CI/CD-Integration”](#cicd-integration)
### GitHub Actions-Beispiel
[Section titled “GitHub Actions-Beispiel”](#github-actions-beispiel)
```yaml
name: Build iOS App
on:
push:
branches: [main]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6
- name: Setup Node.js
uses: actions/setup-node@v6
with:
node-version: '24'
- name: Install dependencies
run: npm ci
- name: Build web assets
run: npm run build
- name: Sync Capacitor
run: npx cap sync ios
- name: Build iOS app
env:
CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}
BUILD_CERTIFICATE_BASE64: ${{ secrets.IOS_CERTIFICATE }}
BUILD_PROVISION_PROFILE_BASE64: ${{ secrets.IOS_PROVISION_PROFILE }}
P12_PASSWORD: ${{ secrets.P12_PASSWORD }}
APPLE_KEY_ID: ${{ secrets.APPLE_KEY_ID }}
APPLE_ISSUER_ID: ${{ secrets.APPLE_ISSUER_ID }}
APPLE_KEY_CONTENT: ${{ secrets.APPLE_KEY_CONTENT }}
APP_STORE_CONNECT_TEAM_ID: ${{ secrets.TEAM_ID }}
run: |
npx @capgo/cli@latest build ${{ secrets.APP_ID }} \
--platform ios \
--build-mode release
```
## Details zum Build-Prozess
[Section titled “Details zum Build-Prozess”](#details-zum-build-prozess)
### Was passiert während eines iOS-Builds
[Section titled “Was passiert während eines iOS-Builds”](#was-passiert-während-eines-ios-builds)
1. **Maschinenbereitstellung** (1-2 Minuten)
* Scaleway Mac mini wird bereitgestellt oder zugewiesen
* macOS 15 mit vorinstalliertem Xcode
* Bootstrap-Skripte laufen (bei erster Verwendung)
2. **Benutzerisolation** (\~10 Sekunden)
* Eindeutiger macOS-Benutzer erstellt: `job-`
* Dediziertes Home-Verzeichnis: `/Users/job-`
* Isolierter Workspace erstellt
3. **Projekt-Setup** (\~30 Sekunden)
* Projekt-Zip von R2 heruntergeladen
* In Workspace extrahiert
* Zugangsdaten als Umgebungsvariablen eingefügt
4. **Fastlane-Build** (3-8 Minuten)
* Schlüsselbund mit Signaturzertifikat erstellt
* Bereitstellungsprofil installiert
* Xcode-Build-Befehl ausgeführt
* IPA-Datei generiert
5. **App Store-Übermittlung** (1-2 Minuten, falls konfiguriert)
* IPA zu App Store Connect hochgeladen
* An TestFlight übermittelt
* Verarbeitung auf Apple-Seite beginnt
6. **Bereinigung** (sofort)
* Benutzerkonto beendet und gelöscht
* Workspace-Dateien entfernt
* Temporäre Dateien gelöscht
7. **Maschinenfreigabe** (nach 24 Stunden)
* Mac-Maschine wird zerstört
* Alle Daten werden dauerhaft gelöscht
### Build-Stack
[Section titled “Build-Stack”](#build-stack)
Unsere iOS-Build-Umgebung umfasst:
* **macOS**: 15 (neueste stabile Version)
* **Xcode**: Neueste stabile Version
* **Fastlane**: Neueste stabile Version
* **CocoaPods**: Neueste stabile Version
* **Node.js**: 18.x (LTS)
* **Ruby**: System-Ruby mit Bundler
## Build-Zeiten
[Section titled “Build-Zeiten”](#build-zeiten)
Typische iOS-Build-Zeiten:
| Build-Typ | Erster Build | Nachfolgende Builds\* |
| --------- | ------------ | --------------------- |
| Debug | 5-7 Minuten | 4-6 Minuten |
| Release | 7-10 Minuten | 5-8 Minuten |
\*Nachfolgende Builds können schneller sein, wenn dieselbe Maschine innerhalb des 24-Stunden-Fensters wiederverwendet wird.
Note
iOS-Builds kosten **2× den Basistarif** aufgrund dedizierter Mac-Hardwareanforderungen.
## Fehlerbehebung
[Section titled “Fehlerbehebung”](#fehlerbehebung)
### Häufige Probleme
[Section titled “Häufige Probleme”](#häufige-probleme)
**“Code signing failed”**
* Überprüfen Sie, ob Ihr Zertifikat für den korrekten Distributionstyp ist
* Stellen Sie sicher, dass das Bereitstellungsprofil zu Ihrer App ID passt
* Prüfen Sie, ob P12\_PASSWORD korrekt ist
**“Provisioning profile doesn’t include signing certificate”**
* Generieren Sie Ihr Bereitstellungsprofil neu, einschließlich des Zertifikats
* Laden Sie das Profil erneut herunter und kodieren Sie es neu
**“App Store Connect authentication failed”**
* Überprüfen Sie APPLE\_KEY\_ID, APPLE\_ISSUER\_ID und APPLE\_KEY\_CONTENT
* Stellen Sie sicher, dass der API-Schlüssel nicht widerrufen wurde
* Prüfen Sie, ob der Schlüssel die Rolle “Developer” oder höher hat
**“Build timeout after 10 minutes”**
* Prüfen Sie, ob Ihre App große native Abhängigkeiten hat
* Erwägen Sie, Ihr Podfile zu optimieren
* Kontaktieren Sie den Support, wenn Builds ständig ein Timeout erreichen
### Debug-Protokolle
[Section titled “Debug-Protokolle”](#debug-protokolle)
Alle Build-Protokolle werden in Echtzeit gestreamt. Achten Sie auf diese wichtigen Phasen:
```plaintext
✔ Machine assigned: m-abc123
→ Creating user: job-abc123
→ Installing CocoaPods dependencies...
→ Building iOS app...
→ Code signing with certificate...
→ Uploading to App Store Connect...
✔ Build succeeded
```
Wenn ein Build fehlschlägt, wird der Fehler in den Protokollen mit der spezifischen Fastlane/Xcode-Fehlermeldung klar angezeigt.
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
### 1. Zuerst lokal testen
[Section titled “1. Zuerst lokal testen”](#1-zuerst-lokal-testen)
Stellen Sie immer sicher, dass Ihr iOS-Build lokal funktioniert, bevor Sie Cloud Build verwenden:
```bash
npx cap open ios
# In Xcode erstellen
```
### 2. Umgebungsvariablen verwenden
[Section titled “2. Umgebungsvariablen verwenden”](#2-umgebungsvariablen-verwenden)
Committen Sie niemals Zertifikate oder Schlüssel in Ihr Repository. Verwenden Sie immer:
* CI/CD-Secrets (GitHub, GitLab)
* Umgebungsvariablen
* Sichere Secret-Verwaltung
### 3. Abhängigkeiten zwischenspeichern
[Section titled “3. Abhängigkeiten zwischenspeichern”](#3-abhängigkeiten-zwischenspeichern)
Für schnellere Builds stellen Sie sicher, dass Ihre `package.json` und `Podfile.lock` in die Versionskontrolle committed sind.
### 4. Build-Zeit überwachen
[Section titled “4. Build-Zeit überwachen”](#4-build-zeit-überwachen)
Behalten Sie die Build-Dauer im Auge, um Kosten zu optimieren:
```bash
# Die CLI zeigt die Build-Zeit am Ende an
Build succeeded in 6m 42s (13.4 billing minutes at 2× rate)
```
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
* [Android Builds](/docs/cli/cloud-build/android/) - Android-Builds konfigurieren
* [Fehlerbehebung](/docs/cli/cloud-build/troubleshooting/) - Häufige Build-Probleme
* [CLI-Referenz](/docs/cli/reference/build/) - Vollständige Befehlsdokumentation
## Brauchen Sie Hilfe?
[Section titled “Brauchen Sie Hilfe?”](#brauchen-sie-hilfe)
* [Fehlerbehebungsanleitung](/docs/cli/cloud-build/troubleshooting/)
* [Discord-Community](https://discord.com/invite/VnYRvBfgA6)
* E-Mail:
# Fehlerbehebung
> Häufige Probleme und Lösungen für Capgo Cloud Build
Lösungen für häufige Probleme beim Erstellen nativer Apps mit Capgo Cloud Build.
## Build-Fehler
[Section titled “Build-Fehler”](#build-fehler)
### ”Upload failed” oder “Connection timeout”
[Section titled “”Upload failed” oder “Connection timeout””](#upload-failed-oder-connection-timeout)
**Symptome:**
* Build schlägt während des Projekt-Uploads fehl
* Timeout-Fehler nach 60 Sekunden
**Lösungen:**
1. **Überprüfen Sie Ihre Internetverbindung**
```bash
# Verbindung zu Capgo testen
curl -I https://api.capgo.app
```
2. **Projektgröße reduzieren**
* Stellen Sie sicher, dass `node_modules/` nicht hochgeladen wird (sollte automatisch ausgeschlossen werden)
* Überprüfen Sie auf große Dateien in Ihrem Projekt:
```bash
find . -type f -size +10M
```
3. **Upload-URL-Ablauf überprüfen**
* Upload-URLs laufen nach 1 Stunde ab
* Wenn Sie einen Fehler wegen abgelaufener URL erhalten, führen Sie den Build-Befehl erneut aus
Tip
Große Projekte (>200MB) können Timeout-Limits erreichen. Kontaktieren Sie den Support für Enterprise-Optionen.
### ”Build timeout after 10 minutes”
[Section titled “”Build timeout after 10 minutes””](#build-timeout-after-10-minutes)
**Symptome:**
* Build überschreitet die maximal zulässige Zeit
* Status zeigt `timeout`
**Lösungen:**
1. **Abhängigkeiten optimieren**
* Entfernen Sie nicht verwendete npm-Pakete
* Verwenden Sie `npm prune --production` vor dem Erstellen
2. **Auf Netzwerkprobleme im Build prüfen**
* Einige Abhängigkeiten laden möglicherweise große Dateien während des Builds herunter
* Erwägen Sie Vor-Caching mit einer Lock-Datei
3. **Native Abhängigkeiten überprüfen**
```bash
# iOS - Podfile auf schwere Abhängigkeiten prüfen
cat ios/App/Podfile
# Android - build.gradle prüfen
cat android/app/build.gradle
```
4. **Support kontaktieren**
* Wenn Ihre App wirklich mehr Zeit benötigt
* Wir können Limits für spezifische Anwendungsfälle anpassen
## Authentifizierungsprobleme
[Section titled “Authentifizierungsprobleme”](#authentifizierungsprobleme)
### ”API key invalid” oder “Unauthorized”
[Section titled “”API key invalid” oder “Unauthorized””](#api-key-invalid-oder-unauthorized)
**Symptome:**
* Build schlägt sofort mit Authentifizierungsfehler fehl
* 401 oder 403 Fehler
**Lösungen:**
1. **API-Schlüssel überprüfen**
```bash
# Mit einem einfachen Befehl testen
npx @capgo/cli@latest app list
```
2. **API-Schlüssel-Berechtigungen prüfen**
* Schlüssel muss `write`- oder `all`-Berechtigungen haben
* Im Capgo-Dashboard unter API-Schlüssel überprüfen
3. **Sicherstellen, dass API-Schlüssel gelesen wird**
```bash
# Umgebungsvariable überprüfen
echo $CAPGO_TOKEN
# Oder lokale .capgo-Datei überprüfen
cat .capgo
```
4. **Erneut authentifizieren**
```bash
npx @capgo/cli@latest login
```
### ”App not found” oder “No permission for this app”
[Section titled “”App not found” oder “No permission for this app””](#app-not-found-oder-no-permission-for-this-app)
**Symptome:**
* Authentifizierung funktioniert, aber App-spezifischer Fehler
**Lösungen:**
1. **App-Registrierung überprüfen**
```bash
npx @capgo/cli@latest app list
```
2. **App ID-Übereinstimmung prüfen**
* `capacitor.config.json` appId überprüfen
* Sicherstellen, dass Befehl korrekte App ID verwendet
3. **Organisationszugriff überprüfen**
* Überprüfen Sie, dass Sie in der richtigen Organisation sind
* API-Schlüssel muss Zugriff auf die Organisation der App haben
## iOS Build-Probleme
[Section titled “iOS Build-Probleme”](#ios-build-probleme)
### ”Code signing failed”
[Section titled “”Code signing failed””](#code-signing-failed)
**Symptome:**
* Build schlägt während der Code-Signaturphase fehl
* Xcode-Fehler über Zertifikate oder Profile
**Lösungen:**
1. **Zertifikatstyp mit Build-Typ abgleichen**
* Development-Builds benötigen Development-Zertifikate
* App Store-Builds benötigen Distribution-Zertifikate
2. **Zertifikat und Profil auf Übereinstimmung prüfen**
```bash
# Zertifikat dekodieren und inspizieren
echo $BUILD_CERTIFICATE_BASE64 | base64 -d > cert.p12
openssl pkcs12 -in cert.p12 -nokeys -passin pass:$P12_PASSWORD | openssl x509 -noout -subject
```
3. **Bereitstellungsprofil auf Gültigkeit prüfen**
* Ablaufdatum überprüfen
* Überprüfen, dass es Ihre App ID enthält
* Bestätigen, dass es das Zertifikat enthält
4. **Zugangsdaten neu generieren**
* Altes Zertifikat/Profil löschen
* Neue im Apple Developer Portal erstellen
* Neu kodieren und Umgebungsvariablen aktualisieren
### ”Provisioning profile doesn’t include signing certificate”
[Section titled “”Provisioning profile doesn’t include signing certificate””](#provisioning-profile-doesnt-include-signing-certificate)
**Symptome:**
* Xcode kann Zertifikat im Profil nicht finden
**Lösungen:**
1. **Neuestes Profil von Apple herunterladen**
* Zu Apple Developer → Zertifikate, IDs & Profile gehen
* Bereitstellungsprofil herunterladen
* Sicherstellen, dass es Ihr Zertifikat enthält
2. **Zertifikat im Profil überprüfen**
```bash
# Profil extrahieren
echo $BUILD_PROVISION_PROFILE_BASE64 | base64 -d > profile.mobileprovision
# Profilinhalte anzeigen
security cms -D -i profile.mobileprovision
```
3. **Profil mit korrektem Zertifikat neu erstellen**
* Im Apple Developer Portal Profil bearbeiten
* Sicherstellen, dass Ihr Distribution-Zertifikat ausgewählt ist
* Herunterladen und neu kodieren
### ”App Store Connect authentication failed”
[Section titled “”App Store Connect authentication failed””](#app-store-connect-authentication-failed)
**Symptome:**
* Upload zu TestFlight schlägt fehl
* API-Schlüssel-Fehler
**Lösungen:**
1. **API-Schlüssel-Zugangsdaten überprüfen**
* APPLE\_KEY\_ID prüfen (sollte 10 Zeichen sein)
* APPLE\_ISSUER\_ID prüfen (sollte UUID-Format sein)
* Überprüfen, dass APPLE\_KEY\_CONTENT korrekt base64-kodiert ist
2. **API-Schlüssel lokal testen**
```bash
# Schlüssel dekodieren
echo $APPLE_KEY_CONTENT | base64 -d > AuthKey.p8
# Mit fastlane testen (falls installiert)
fastlane pilot list
```
3. **API-Schlüssel-Berechtigungen prüfen**
* Schlüssel benötigt “Developer”-Rolle oder höher
* In App Store Connect → Benutzer und Zugriff → Schlüssel überprüfen
4. **Sicherstellen, dass Schlüssel nicht widerrufen wurde**
* In App Store Connect prüfen
* Neuen Schlüssel generieren, falls erforderlich
### ”Pod install failed”
[Section titled “”Pod install failed””](#pod-install-failed)
**Symptome:**
* Build schlägt während CocoaPods-Installation fehl
* Podfile-Fehler
**Lösungen:**
1. **Podfile.lock ist committed überprüfen**
```bash
git status ios/App/Podfile.lock
```
2. **Pod install lokal testen**
```bash
cd ios/App
pod install
```
3. **Auf inkompatible Pods prüfen**
* Podfile auf Versionskonflikte überprüfen
* Sicherstellen, dass alle Pods Ihr iOS-Deployment-Ziel unterstützen
4. **Pod-Cache löschen**
```bash
cd ios/App
rm -rf Pods
rm Podfile.lock
pod install
# Dann neuen Podfile.lock committen
```
## Android Build-Probleme
[Section titled “Android Build-Probleme”](#android-build-probleme)
### ”Keystore password incorrect”
[Section titled “”Keystore password incorrect””](#keystore-password-incorrect)
**Symptome:**
* Build schlägt während der Signatur fehl
* Gradle-Fehler über Keystore
**Lösungen:**
1. **Keystore-Passwort überprüfen**
```bash
# Keystore lokal testen
keytool -list -keystore my-release-key.keystore
# Passwort bei Aufforderung eingeben
```
2. **Umgebungsvariablen prüfen**
```bash
# Sicherstellen, dass keine zusätzlichen Leerzeichen oder Sonderzeichen vorhanden sind
echo "$KEYSTORE_STORE_PASSWORD" | cat -A
echo "$KEYSTORE_KEY_PASSWORD" | cat -A
```
3. **Base64-Kodierung überprüfen**
```bash
# Dekodieren und testen
echo $ANDROID_KEYSTORE_FILE | base64 -d > test.keystore
keytool -list -keystore test.keystore
```
### ”Key alias not found”
[Section titled “”Key alias not found””](#key-alias-not-found)
**Symptome:**
* Signatur schlägt mit Alias-Fehler fehl
**Lösungen:**
1. **Keystore-Aliase auflisten**
```bash
keytool -list -keystore my-release-key.keystore
```
2. **Alias stimmt genau überein überprüfen**
* Alias beachtet Groß-/Kleinschreibung
* Auf Tippfehler in KEYSTORE\_KEY\_ALIAS prüfen
3. **Korrekten Alias aus Keystore verwenden**
```bash
# Umgebungsvariable aktualisieren, um zu übereinstimmen
export KEYSTORE_KEY_ALIAS="the-exact-alias-name"
```
### ”Gradle build failed”
[Section titled “”Gradle build failed””](#gradle-build-failed)
**Symptome:**
* Allgemeine Gradle-Fehler
* Kompilierungs- oder Abhängigkeitsprobleme
**Lösungen:**
1. **Build zuerst lokal testen**
```bash
cd android
./gradlew clean
./gradlew assembleRelease
```
2. **Auf fehlende Abhängigkeiten prüfen**
* build.gradle-Dateien überprüfen
* Sicherstellen, dass alle Plugins in Abhängigkeiten aufgelistet sind
3. **Gradle-Versionskompatibilität überprüfen**
```bash
# Gradle-Version prüfen
cat android/gradle/wrapper/gradle-wrapper.properties
```
4. **Gradle-Cache löschen**
```bash
cd android
./gradlew clean
rm -rf .gradle build
```
### ”Play Store upload failed”
[Section titled “”Play Store upload failed””](#play-store-upload-failed)
**Symptome:**
* Build erfolgreich, aber Upload schlägt fehl
* Service Account-Fehler
**Lösungen:**
1. **Service Account JSON überprüfen**
```bash
# Dekodieren und Format prüfen
echo $PLAY_CONFIG_JSON | base64 -d | jq .
```
2. **Service Account-Berechtigungen prüfen**
* Zu Play Console → Einrichtung → API-Zugriff gehen
* Sicherstellen, dass Service Account Zugriff auf Ihre App hat
* Berechtigung “Release to testing tracks” erteilen
3. **App in Play Console eingerichtet überprüfen**
* App muss zuerst in Play Console erstellt werden
* Mindestens ein APK muss anfangs manuell hochgeladen werden
4. **API ist aktiviert prüfen**
* Google Play Developer API muss aktiviert sein
* In Google Cloud Console prüfen
## Allgemeine Probleme
[Section titled “Allgemeine Probleme”](#allgemeine-probleme)
### ”Job not found” oder “Build status unavailable”
[Section titled “”Job not found” oder “Build status unavailable””](#job-not-found-oder-build-status-unavailable)
**Symptome:**
* Build-Status kann nicht überprüft werden
* Job-ID-Fehler
**Lösungen:**
1. **Kurz warten und erneut versuchen**
* Build-Jobs benötigen möglicherweise einige Sekunden zur Initialisierung
2. **Job-ID ist korrekt prüfen**
* Job-ID aus der anfänglichen Build-Antwort überprüfen
3. **Build ist nicht abgelaufen prüfen**
* Build-Daten sind 24 Stunden verfügbar
### ”Project sync failed”
[Section titled “”Project sync failed””](#project-sync-failed)
**Symptome:**
* Build schlägt vor Kompilierung fehl
* Fehlende Dateien-Fehler
**Lösungen:**
1. **Capacitor-Sync lokal ausführen**
```bash
npx cap sync
```
2. **Alle nativen Dateien sind committed sicherstellen**
```bash
git status ios/ android/
```
3. **Auf gitignorierte native Dateien prüfen**
* .gitignore überprüfen
* Sicherstellen, dass wichtige Config-Dateien nicht ignoriert werden
### ”Build succeeded but I don’t see output”
[Section titled “”Build succeeded but I don’t see output””](#build-succeeded-but-i-dont-see-output)
**Symptome:**
* Build zeigt Erfolg, aber kein Download-Link
**Lösungen:**
1. **Build-Konfiguration prüfen**
* Artefaktspeicher ist möglicherweise nicht konfiguriert
* Für öffentliche Beta, Support wegen Artefaktzugriff kontaktieren
2. **Für iOS TestFlight-Übermittlung**
* App Store Connect prüfen
* Verarbeitung kann 5-30 Minuten nach Upload dauern
3. **Für Android Play Store**
* Play Console → Testing → Internes Testing prüfen
* Verarbeitung kann einige Minuten dauern
## CI/CD-spezifische Probleme
[Section titled “CI/CD-spezifische Probleme”](#cicd-spezifische-probleme)
### GitHub Actions: “Command not found”
[Section titled “GitHub Actions: “Command not found””](#github-actions-command-not-found)
**Symptome:**
* `npx @capgo/cli` schlägt in CI fehl
**Lösungen:**
1. **Node.js ist installiert sicherstellen**
```yaml
- uses: actions/setup-node@v6
with:
node-version: '24'
```
2. **CLI explizit installieren**
```yaml
- run: npm install -g @capgo/cli
```
### GitHub Actions: “Secrets not found”
[Section titled “GitHub Actions: “Secrets not found””](#github-actions-secrets-not-found)
**Symptome:**
* Umgebungsvariablen im Build leer
**Lösungen:**
1. **Secrets sind gesetzt überprüfen**
* Zu Repo Settings → Secrets and variables → Actions gehen
* Alle erforderlichen Secrets hinzufügen
2. **Korrekte Syntax verwenden**
```yaml
env:
CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}
```
3. **Secret-Namen stimmen überein prüfen**
* Namen beachten Groß-/Kleinschreibung
* Keine Tippfehler in Secret-Referenzen
## Mehr Hilfe erhalten
[Section titled “Mehr Hilfe erhalten”](#mehr-hilfe-erhalten)
### Ausführliche Protokollierung aktivieren
[Section titled “Ausführliche Protokollierung aktivieren”](#ausführliche-protokollierung-aktivieren)
```bash
# Debug-Flag hinzufügen (falls verfügbar)
npx @capgo/cli@latest build com.example.app --verbose
```
### Build-Informationen sammeln
[Section titled “Build-Informationen sammeln”](#build-informationen-sammeln)
Beim Kontaktieren des Supports folgendes einschließen:
1. **Verwendeter Build-Befehl**
```bash
npx @capgo/cli@latest build com.example.app --platform ios
```
2. **Fehlermeldung** (vollständige Ausgabe)
3. **Job-ID** (aus Build-Ausgabe)
4. **Build-Protokolle** (vollständige Terminal-Ausgabe kopieren)
5. **Umgebungsinformationen**
```bash
node --version
npm --version
npx @capgo/cli --version
```
### Support kontaktieren
[Section titled “Support kontaktieren”](#support-kontaktieren)
* **Discord**: [Unserer Community beitreten](https://discord.com/invite/VnYRvBfgA6)
* **E-Mail**:
* **Dokumentation**: [Capgo Docs](/docs/)
### Bekannte Einschränkungen
[Section titled “Bekannte Einschränkungen”](#bekannte-einschränkungen)
Aktuelle Einschränkungen während der öffentlichen Beta:
* Maximale Build-Zeit: 10 Minuten
* Maximale Upload-Größe: \~500MB
* iOS-Builds erfordern 24-Stunden-Mac-Leases, Build auf Mac wird in die Warteschlange gestellt, um optimale Nutzung sicherzustellen
* Build-Artefakt-Download ist möglicherweise nicht verfügbar
Diese Einschränkungen können basierend auf Feedback angepasst werden.
## Zusätzliche Ressourcen
[Section titled “Zusätzliche Ressourcen”](#zusätzliche-ressourcen)
* [Erste Schritte](/docs/cli/cloud-build/getting-started/) - Anfängliche Einrichtungsanleitung
* [iOS Builds](/docs/cli/cloud-build/ios/) - iOS-spezifische Konfiguration
* [Android Builds](/docs/cli/cloud-build/android/) - Android-spezifische Konfiguration
* [CLI-Referenz](/docs/cli/reference/build/) - Vollständige Befehlsdokumentation
# Befehle
> Capgo CLI-Dokumentation
### Verwendung
[Section titled “Verwendung”](#verwendung)
Alle Befehle sollten in Ihrem App-Ordner mit ordnungsgemäß initialisiertem Capacitor-Projekt ausgeführt werden
[Capacitor plattformübergreifende native Laufzeit für Web-Apps ](https://capacitorjs.com/docs/getting-started/)
### **Init**
[Section titled “Init”](#init)
`npx @capgo/cli@latest init [apikey]`
Diese Methode führt Sie Schritt für Schritt durch den Onboarding-Prozess
Sie fügt Ihre App zu Capgo hinzu Sie fügt den Code zur Validierung des Updates in Ihre App ein Ebenso wird sie Ihre App erstellen Außerdem wird sie Ihre App zu Capgo hochladen Und sie hilft Ihnen zu überprüfen, ob das Update funktioniert
### **Login**
[Section titled “Login”](#login)
`npx @capgo/cli login [apikey]`
Diese Methode speichert den `apikey` für Sie
Note
verwenden Sie `--apikey=********` in jedem Befehl, um ihn zu überschreiben
**Optional können Sie angeben:**
`--local` Dies speichert Ihren **apikey** im lokalen Repository und ignoriert ihn in Git
## **Doctor**
[Section titled “Doctor”](#doctor)
`npx @capgo/cli doctor`
Befehl zur Überprüfung, ob Sie mit den Capgo-Paketen auf dem neuesten Stand sind
Dieser Befehl ist auch für Fehlerberichte nützlich
## App
[Section titled “App”](#app)
### **Add**
[Section titled “Add”](#add)
`npx @capgo/cli app add [appId]`
`[appId]` Ihre App-ID, das Format `comtestapp` wird [hier](https://capacitorjs.com/docs/cli/commands/init/) erklärt
> 💡 Alle Optionen werden aus Ihrer Konfiguration erraten, wenn nicht angegeben
Optional können Sie angeben:
* `--icon [/path/to/my/icon]` für ein benutzerdefiniertes Icon in der Capgo Web-App
* `--name [test]` für einen benutzerdefinierten Namen in der Liste
* `--apikey [key]` API-Schlüssel zur Verknüpfung mit Ihrem Konto
* `--retention [retention]` Aufbewahrungszeitraum des App-Bundles in Tagen, 0 standardmäßig = unendlich
Beispiel einer `capacitorconfigjson` für appId und AppName, das Icon wird im resources-Ordner gesucht
```json
{
"appId": "eeforgrcapacitor_go",
"appName": "Capgo",
"webDir": "dist"
}
```
### **Set**
[Section titled “Set”](#set)
`npx @capgo/cli app set [appId]`
`[appId]` ist Ihre App-ID, das Format wird [hier](https://capacitorjs.com/docs/cli/commands/init/) erklärt
Optional können Sie angeben:
* `--icon [/path/to/my/icon]` für ein benutzerdefiniertes Icon in der Capgo Web-App
* `--name [test]` für einen benutzerdefinierten Namen in der Liste
* `--retention [retention]` Aufbewahrungszeitraum des App-Bundles in Tagen, 0 standardmäßig = unendlich
* `--apikey [key]` API-Schlüssel zur Verknüpfung mit Ihrem Konto
### **List**
[Section titled “List”](#list)
`npx @capgo/cli app list [appId]`
`[appId]` Ihre App-ID, das Format `comtestapp` wird [hier](https://capacitorjs.com/docs/cli/commands/init/) erklärt
Optional können Sie angeben:
* `--apikey [key]` API-Schlüssel zur Verknüpfung mit Ihrem Konto
### **Delete**
[Section titled “Delete”](#delete)
`npx @capgo/cli app delete [appId]`
`[appId]` Ihre App-ID, das Format `comtestapp` wird [hier](https://capacitorjs.com/docs/cli/commands/init/) erklärt
Optional können Sie angeben:
* `--apikey [key]` API-Schlüssel zur Verknüpfung mit Ihrem Konto
* `--bundle` mit der Versionsnummer löscht nur diese Version
### Debug
[Section titled “Debug”](#debug)
`npx @capgo/cli app debug [appId]`
`[appId]` Ihre App-ID, das Format `comtestapp` wird [hier](https://capacitorjs.com/docs/cli/commands/init/) erklärt
Optional können Sie angeben:
* `--apikey [key]` API-Schlüssel zur Verknüpfung mit Ihrem Konto
* `--device` mit dem spezifischen Gerät, das Sie debuggen möchten
### Setting
[Section titled “Setting”](#setting)
`npx @capgo/cli app setting [path]`
Bearbeiten der Capacitor-Konfiguration
`[path]` - Pfad der Einstellung, die Sie ändern möchten Zum Beispiel, um die `appId` zu ändern, geben Sie `appId` an Wenn Sie das automatische Update in `capacitor-updater` deaktivieren möchten, geben Sie `pluginsCapacitorUpdaterautoUpdate` an
Sie MÜSSEN entweder `--string` oder `--bool` angeben!
Optionen:
* `--string ` - setzt die Einstellung auf einen String
* `--bool ` - setzt die Einstellung auf einen Boolean
## Bundle
[Section titled “Bundle”](#bundle)
### Upload
[Section titled “Upload”](#upload)
`npx @capgo/cli bundle upload [appId]`
`[appId]` ist Ihre App-ID, das Format wird [hier](https://capacitorjs.com/docs/cli/commands/init/) erklärt
Optional können Sie angeben:
* `--apikey ` API-Schlüssel zur Verknüpfung mit Ihrem Konto
* `--path ` Pfad des hochzuladenden Ordners
* `--channel ` Zu verknüpfender Kanal
* `--external ` Link zu externer URL anstelle des Uploads zur Capgo Cloud
* `--iv-session-key ` IV und Sitzungsschlüssel für externe Bundle-URL festlegen
* `--s3-endpoint ` URL des S3-Endpunkts Funktioniert nicht mit partiellem Upload oder externer Option
* `--s3-region ` Region für Ihren S3-Bucket
* `--s3-apikey ` API-Schlüssel für Ihren S3-Endpunkt
* `--s3-apisecret ` API-Geheimnis für Ihren S3-Endpunkt
* `--s3-bucket-name ` Name für Ihren AWS S3-Bucket
* `--s3-port ` Port für Ihren S3-Endpunkt
* `--no-s3-ssl` SSL für S3-Upload deaktivieren
* `--key ` Benutzerdefinierter Pfad für öffentlichen Signierungsschlüssel (v1-System)
* `--key-data ` Öffentlicher Signierungsschlüssel (v1-System)
* `--key-v2 ` Benutzerdefinierter Pfad für privaten Signierungsschlüssel (v2-System)
* `--key-data-v2 ` Privater Signierungsschlüssel (v2-System)
* `--bundle-url` Gibt Bundle-URL in stdout aus
* `--no-key` Signierungsschlüssel ignorieren und klares Update senden
* `--no-code-check` Überprüfung ignorieren, ob notifyAppReady() im Quellcode aufgerufen wird und Index im Stammverzeichnis vorhanden ist
* `--display-iv-session` IV und Sitzungsschlüssel in der Konsole anzeigen, die zur Verschlüsselung des Updates verwendet werden
* `--bundle ` Bundleversion der hochzuladenden Version
* `--min-update-version ` Minimale Version, die für ein Update auf diese Version erforderlich ist Wird nur verwendet, wenn auto update auf metadata im Kanal gesetzt ist
* `--auto-min-update-version` Minimale Update-Version basierend auf nativen Paketen festlegen
* `--ignore-metadata-check` Ignoriert die Metadaten-Prüfung (node\_modules) beim Hochladen
* `--ignore-checksum-check` Ignoriert die Prüfsummen-Prüfung beim Hochladen
* `--timeout ` Timeout für den Upload-Prozess in Sekunden
* `--partial` Lädt keine partiellen Dateien zur Capgo-Cloud hoch
* `--tus` Lädt das Bundle mit dem tus-Protokoll hoch
* `--multipart` Verwendet das Multipart-Protokoll zum Hochladen von Daten zu S3, Veraltet, verwenden Sie stattdessen TUS
* `--encrypted-checksum ` Eine verschlüsselte Prüfsumme (Signatur) Wird nur beim Hochladen eines externen Bundles verwendet
* `--package-json ` Ein Pfad zu packagejson Nützlich für Monorepos
* `--auto-set-bundle` Bundle in capacitorconfigjson setzen
* `--node-modules ` Eine Liste von Pfaden zu node\_modules Nützlich für Monorepos (kommagetrennt z.B.: //node\_modules,/node\_modules)
> ⭐️ Die externe Option hilft zwei Fälle zu lösen: Unternehmen mit Datenschutzbedenken, die keinen Code an Dritte senden möchten und Apps größer als 200 MB Mit dieser Einstellung speichert Capgo nur den Link zur ZIP-Datei und sendet den Link an alle Apps
> 👀 Capgo Cloud schaut nie, was sich im Link (für externe Option) oder im Code befindet, wenn gespeichert
> 🔑 Sie können eine zweite Sicherheitsebene durch Verschlüsselung hinzufügen, dann kann Capgo nichts einsehen oder modifizieren, es wird “vertrauenslos”
Beispiel einer `packagejson` für Version
```json
{
"version": "102"
}
```
> ⛔ Version sollte größer als “000” sein
> 💡 Vergessen Sie nicht, die Versionsnummer bei jedem Senden zu aktualisieren, Versionsnummern können aus Sicherheitsgründen nicht überschrieben oder nach dem Löschen wiederverwendet werden
### **List**
[Section titled “List”](#list-1)
`npx @capgo/cli bundle list [appId]`
`[appId]` Ihre App-ID, das Format `comtestapp` wird [hier](https://capacitorjs.com/docs/cli/commands/init/) erklärt
Optional können Sie angeben:
* `--apikey [key]` API-Schlüssel zur Verknüpfung mit Ihrem Konto
### **Delete**
[Section titled “Delete”](#delete-1)
`npx @capgo/cli bundle delete [appId]`
`[appId]` Ihre App-ID, das Format `comtestapp` wird [hier](https://capacitorjs.com/docs/cli/commands/init/) erklärt
Optional können Sie angeben:
* `--apikey [key]` API-Schlüssel zur Verknüpfung mit Ihrem Konto
* `--bundle` mit der Versionsnummer löscht nur diese Version
### Cleanup
[Section titled “Cleanup”](#cleanup)
in einem SemVer-Bereich für eine Hauptversion in der Cloud
`npx @capgo/cli bundle cleanup [appId] --bundle=[majorVersion] --keep=[numberToKeep]`
`[appId]` Ihre App-ID, das Format `comtestapp` wird [hier](https://capacitorjs.com/docs/cli/commands/init/) erklärt
Optional können Sie angeben:
* `--apikey [key]` API-Schlüssel zur Verknüpfung mit Ihrem Konto
* `--bundle [majorVersion]` eine Version, für die Sie vorherige Pakete entfernen möchten, es wird die letzte Version + `numberToKeep` behalten\* `--keep [numberToKeep]` die Anzahl der Pakete, die Sie behalten möchten (Standard 4)
Zum Beispiel: Wenn Sie 10 Versionen von 1001 bis 10011 haben und Sie `npx @capgo/cli cleanup [appId] --bundle=1000` verwenden, werden 1001 bis 1006 entfernt, 1007 bis 10011 werden behalten
Wenn Sie insgesamt 20 Versionen haben und keine Bundlenummer angeben, wie hier: `npx @capgo/cli cleanup [appId] --keep=2`, werden 18 Versionen entfernt und die letzten 2 behalten
> Dieser Befehl wird um Bestätigung bitten und zeigt eine Tabelle mit den zu behaltenden und zu entfernenden Versionen
Note
Dieser Befehl ignoriert Bundles, die derzeit in einem Kanal verwendet werden
### **Encrypt**
[Section titled “Encrypt”](#encrypt)
> **Warnung**: Dieser Befehl ist veraltet und wird in der nächsten Hauptversion entfernt. Bitte verwenden Sie das neue Verschlüsselungssystem `npx @capgo/cli bundle encrypt [path/to/zip]`
Dieser Befehl wird verwendet, wenn Sie externe Quellen zum Speichern Ihres Codes verwenden oder zu Testzwecken
Optional können Sie angeben:
`--key [/path/to/my/private_key]` der Pfad zu Ihrem privaten Schlüssel `--key-data [privateKey]` die privaten Schlüsseldaten, wenn Sie sie inline verwenden möchten Der Befehl gibt Ihren `ivSessionKey` aus und generiert eine verschlüsselte ZIP-Datei zur Verwendung mit dem Upload- oder Decrypt-Befehl
### **Encrypt V2**
[Section titled “Encrypt V2”](#encrypt-v2)
`npx @capgo/cli bundle encryptV2 [path/to/zip] [checksum]`
Dieser Befehl wird verwendet, wenn Sie externe Quellen zum Speichern Ihres Codes verwenden oder zu Testzwecken Die Prüfsumme ist der SHA256-Hash des Bundles (generiert durch —key-v2) und wird verwendet, um die Integrität der Datei nach der Entschlüsselung zu überprüfen Sie wird mit dem privaten Schlüssel verschlüsselt und zusammen mit dem Bundle gesendet In Verschlüsselung v2 wird die Prüfsumme zu einer “Signatur” des Bundles aufgewertet
Optional können Sie angeben:
`--key [/path/to/my/private_key]` der Pfad zu Ihrem privaten Schlüssel `--key-data [privateKey]` die privaten Schlüsseldaten, wenn Sie sie inline verwenden möchten `--json` um Informationen als JSON auszugeben Der Befehl gibt Ihren `ivSessionKey` aus und generiert eine verschlüsselte ZIP-Datei zur Verwendung mit dem Upload- oder Decrypt-Befehl
### **Decrypt**
[Section titled “Decrypt”](#decrypt)
`npx @capgo/cli bundle decrypt [path/to/zip] [ivSessionKey]`
Optional können Sie angeben:
`--key [/path/to/my/private_key]` der Pfad zu Ihrem privaten Schlüssel
`--key-data [privateKey]` die privaten Schlüsseldaten, wenn Sie sie inline verwenden möchten Dieser Befehl wird hauptsächlich zu Testzwecken verwendet, er entschlüsselt die ZIP-Datei und gibt den base64-decodierten Sitzungsschlüssel in der Konsole aus
### **Decrypt V2**
[Section titled “Decrypt V2”](#decrypt-v2)
`npx @capgo/cli bundle decryptV2 [path/to/zip] [ivSessionKey]`
Optional können Sie angeben:
`--key [/path/to/my/private_key]` der Pfad zu Ihrem privaten Schlüssel `--key-data [privateKey]` die privaten Schlüsseldaten, wenn Sie sie inline verwenden möchten Dieser Befehl wird hauptsächlich zu Testzwecken verwendet, er entschlüsselt die ZIP-Datei und gibt den base64-decodierten Sitzungsschlüssel in der Konsole aus `--checksum [checksum]` die Prüfsumme der Datei, sie wird nach der Entschlüsselung überprüft
### **Zip**
[Section titled “Zip”](#zip)
`npx @capgo/cli bundle zip [appId]`
`[appId]` ist Ihre App-ID, das Format wird [hier](https://capacitorjs.com/docs/cli/commands/init/) erklärt
Optional können Sie angeben:
* `--path [/path/to/my/bundle]` um einen bestimmten Ordner hochzuladen
* `--bundle [100]` um die Bundle-Versionsnummer des Dateinamens festzulegen
* `--name [myapp]` um den Dateinamen zu überschreiben
* `--json` um Informationen als JSON auszugeben
* `--no-code-check` um die Code-Prüfung zu ignorieren und das Bundle trotzdem zu senden
* `--key-v2` um das neue Verschlüsselungssystem zu verwenden Dies ist erforderlich, da das neue Verschlüsselungssystem bessere Prüfsummen zur Überprüfung der Dateiintegrität verwendet
### **Compatibility**
[Section titled “Compatibility”](#compatibility)
`npx @capgo/cli bundle compatibility [appId] -c [channelId]`
`[appId]` ist Ihre App-ID, das Format wird [hier](https://capacitorjs.com/docs/cli/commands/init/) erklärt `[channelId]` der Name Ihres neuen Kanals
Optional können Sie angeben:
* `--apikey [key]` API-Schlüssel zur Verknüpfung mit Ihrem Konto
* `--text` Text statt Emojis in der Tabelle verwenden
* `--channel [channel]` der Kanal, dessen Kompatibilität überprüft werden soll
* `--package-json ` Ein Pfad zur package.json Nützlich für Monorepos
* `--node-modules ` Eine Liste von Pfaden zu node\_modules Nützlich für Monorepos (kommagetrennt z.B.: //node\_modules,/node\_modules)
## Channel
[Section titled “Channel”](#channel)
### **Add**
[Section titled “Add”](#add-1)
`npx @capgo/cli channel add [channelId] [appId]`
`[channelId]` der Name Ihres neuen Kanals `[appId]` Ihre App-ID, das Format `comtestapp` wird [hier](https://capacitorjs.com/docs/cli/commands/init/) erklärt
### **Delete**
[Section titled “Delete”](#delete-2)
`npx @capgo/cli channel delete [channelId] [appId]`
`[channelId]` der Name des Kanals, den Sie löschen möchten `[appId]` Ihre App-ID, das Format `comtestapp` wird [hier](https://capacitorjs.com/docs/cli/commands/init/) erklärt
### **List**
[Section titled “List”](#list-2)
`npx @capgo/cli channel list [appId]`
`[appId]` Ihre App-ID, das Format `comtestapp` wird [hier](https://capacitorjs.com/docs/cli/commands/init/) erklärt
Optional können Sie angeben:
* `--apikey [key]` API-Schlüssel zur Verknüpfung mit Ihrem Konto
### **Set**
[Section titled “Set”](#set-1)
`npx @capgo/cli channel set [channelId] [appId]`
`[appId]` ist Ihre App-ID, das Format wird [hier](https://capacitorjs.com/docs/cli/commands/init/) erklärt
Optional können Sie angeben:
* `--bundle [123]` Ihr bereits in die Cloud gesendetes App-Bundle, um es mit einem Kanal zu verknüpfen
* `--latest` holt die Bundle-Version aus `packagejson:version`, kann nicht mit `--bundle` verwendet werden
* `--state [ normal | default ]` setzt den Kanalstatus, kann `normal` oder `default` sein Ein Kanal muss `default` sein
* `--downgrade` erlaubt dem Kanal, Downgrade-Versionen an Geräte zu senden
* `--no-downgrade` verbietet dem Kanal, Downgrade-Versionen an Geräte zu senden
* `--upgrade` erlaubt dem Kanal, Upgrade (Major) Versionen an Geräte zu senden
* `--no-upgrade` verbietet dem Kanal, Upgrade (Major) Versionen an Geräte zu senden
* `--ios` erlaubt dem Kanal, Versionen an iOS-Geräte zu senden
* `--no-ios` verbietet dem Kanal, Versionen an iOS-Geräte zu senden
* `--android` erlaubt dem Kanal, Versionen an Android-Geräte zu senden
* `--no-android` verbietet dem Kanal, Versionen an Android-Geräte zu senden
* `--self-assign` erlaubt Geräten, sich selbst diesem Kanal zuzuweisen
* `--no-self-assign` verbietet Geräten, sich selbst diesem Kanal zuzuweisen
* `--disable-auto-update STRATEGY` Deaktiviert die Auto-Update-Strategie für diesen Kanal Die möglichen Optionen sind: major, minor, metadata, none
* `--apikey [key]` API-Schlüssel zur Verknüpfung mit Ihrem Konto
## Deaktivieren der Update-Strategien
[Section titled “Deaktivieren der Update-Strategien”](#deaktivieren-der-update-strategien)
Es gibt mehrere Möglichkeiten, Updates für zu alte Versionen zu deaktivieren\
Capgo kann nativen Code nicht aktualisieren, daher sollte ein Update von einer Version mit altem nativen Code auf eine Version mit aktualisiertem nativen Code nicht möglich sein Es gibt mehrere Möglichkeiten, dies zu erreichen
Erstens die `major` Strategie Sie verhindert ein Update von `000` -> `100` Die Hauptversion ist die hervorgehobene Nummer (**1**00 und **0**00)\
Zweitens die `minor` Strategie Sie verhindert ein Update von `000` -> `110` oder ein Update von `110` auf `120` **ACHTUNG** diese Strategie verhindert nicht ein Update von `010` -> `110`
Drittens die `patch` Strategie Sie wurde als sehr strenger Modus in Capgo eingeführt Es wird nicht empfohlen, sie zu verwenden, es sei denn, Sie verstehen vollständig, wie sie funktioniert Damit ein Update akzeptiert wird, müssen folgende Bedingungen erfüllt sein:
* Die Hauptversion ist zwischen der neuen und alten Version gleich
* Die Nebenversion ist zwischen der neuen und alten Version gleich
* Die Patch-Version der neuen Version ist größer als die Patch-Version der alten Version
Hier ein Beispiel, welche Szenarien für Updates erlaubt oder abgelehnt werden:
* 00311 -> 00314 ✅
* 000 -> 00314 ✅
* 00316 -> 00314 ❌
* 01312 -> 00314 ❌
* 10312 -> 00314 ❌
Zuletzt die komplizierteste Strategie Die `metadata` Strategie\
Zuerst müssen Sie wissen, dass die Updates anfangs **FEHLSCHLAGEN** werden, da dem Kanal die erforderlichen Metadaten fehlen\
Wenn dem Kanal Metadaten fehlen, sehen Sie eine Nachricht wie diese:
Wenn Sie so etwas sehen, wissen Sie, dass Sie zum aktuellen Bundle für den fehlschlagenden Kanal gehen und die Metadaten setzen müssen\
Ermitteln Sie zunächst, welcher Kanal fehlschlägt Sie können das in der Spalte `misconfigured` sehen
Gehen Sie dann zum fehlerhaften Kanal und klicken Sie auf `Bundle number`. Dies sollte Sie zur Bundle-Seite führen.
Füllen Sie dort das Feld `Minimal update version` aus. Dies sollte ein [semver](https://devhints.io/semver/) sein.\
Wenn der eingegebene Wert kein semver ist, erhalten Sie eine Fehlermeldung. Bei korrekter Eingabe sollten Sie etwa Folgendes sehen:
Sie möchten diese Daten wahrscheinlich nicht bei jedem Update manuell festlegen. Glücklicherweise verhindert die CLI das Senden eines Updates ohne diese Metadaten.
Um ein Bundle mit der Option `metadata` korrekt hochzuladen, müssen Sie `--min-update-version` mit einem gültigen semver übergeben. Etwa so:
Die `--min-update-version` ist nicht der EINZIGE Weg für Kompatibilität. Es gibt auch `--auto-min-update-version`. So funktioniert es:
1. Es prüft die aktuell im Kanal hochgeladene Version und überprüft die Kompatibilität wie der Befehl `bundle compatibility`.
2. Wenn die neue Version 100% kompatibel ist, wird die `min_update_version` der neuesten Version im Kanal wiederverwendet. Wenn nicht, wird die `min_update_version` auf die Bundle-Nummer der neu hochgeladenen Version gesetzt.
Sie erhalten bei Verwendung dieser Option immer eine Information über die `min_update_version`. Es wird etwa so aussehen:
Wenn die neue Version nicht kompatibel ist, sollte es etwa so aussehen:
## Ende-zu-Ende-Verschlüsselung (Trustless)
[Section titled “Ende-zu-Ende-Verschlüsselung (Trustless)”](#ende-zu-ende-verschlüsselung-trustless)
Capgo unterstützt Ende-zu-Ende-Verschlüsselung, das bedeutet, dass Ihr Bundle (Code) vor dem Senden in die Cloud verschlüsselt und auf dem Gerät entschlüsselt wird. Dafür müssen Sie ein RSA-Schlüsselpaar generieren, Sie können den folgenden Befehl verwenden, um es zu generieren.
Das Verschlüsselungssystem ist eine Kombination aus RSA und AES, der RSA-Schlüssel wird verwendet, um den AES-Schlüssel zu verschlüsseln, und der AES-Schlüssel wird verwendet, um die Datei zu verschlüsseln.
Weitere Informationen zum Verschlüsselungssystem finden Sie unten
Verschlüsselungsschema
### Schlüssel für Ihre App erstellen
[Section titled “Schlüssel für Ihre App erstellen”](#schlüssel-für-ihre-app-erstellen)
`npx @capgo/cli key create`
Optional können Sie `--force` verwenden, um den vorhandenen Schlüssel zu überschreiben. Dieser Befehl erstellt ein Schlüsselpaar in Ihrer App und fordert Sie auf, den privaten Schlüssel an einem sicheren Ort zu speichern. Es wird empfohlen, den privaten Schlüssel nicht in Git zu committen und mit niemandem zu teilen.
> Nach Ihrem lokalen Test entfernen Sie den Schlüssel aus der Konfigurationsdatei und fügen Sie ihn im CI-Schritt mit `key save` hinzu.
### Schlüssel in Ihrer App-Konfiguration speichern
[Section titled “Schlüssel in Ihrer App-Konfiguration speichern”](#schlüssel-in-ihrer-app-konfiguration-speichern)
`npx @capgo/cli key save`
Optional können Sie angeben:
`--key [/path/to/my/private_key]` der Pfad zu Ihrem privaten Schlüssel
`--key-data [privateKey]` die privaten Schlüsseldaten, wenn Sie sie inline verwenden möchten. Dieser Befehl ist nützlich, wenn Sie der Empfehlung gefolgt sind und den Schlüssel nicht in Ihrer App und in der Konfiguration committet haben.
## CI-Integration
[Section titled “CI-Integration”](#ci-integration)
Um Ihre Arbeit zu automatisieren, empfehle ich Ihnen, GitHub Actions die Aufgabe des Pushens zu unserem Server zu überlassen.
[GitHub Action Tutorial](https://capgo.app/blog/automatic-build-and-release-with-github-actions/)
## Unsere Demo-App
[Section titled “Unsere Demo-App”](#unsere-demo-app)
[GitHub - Cap-go/demo-app](https://github.com/Cap-go/demo-app/)
Vergessen Sie nicht, die CI-Umgebungsvariable mit Ihrem API-Schlüssel zu konfigurieren.
# CLI de 0.x a 1.x
> Upgrade-Anleitung von 0.x auf 1.x
Es gibt keine wesentlichen Änderungen in der CLI
Die wichtigste Änderung ist die Umbenennung des Arguments `--version` zu `--bundle`, um Konflikte zu vermeiden und der neuen Namensgebung überall zu folgen
# Verschlüsselung
> So verschlüsseln Sie Ihre Daten mit neuer Verschlüsselung
Diese Dokumentation erklärt, wie Sie Ihre Daten mit dem neuen Verschlüsselungssystem verschlüsseln und das alte entfernen können
Erfahren Sie mehr über das neue Verschlüsselungssystem im [Blog-Beitrag](/blog/introducing-end-to-end-security-to-capacitor-updater-with-code-signing)
***
Erstellen Sie zunächst ein neues Schlüsselpaar mit folgendem Befehl:
```bash
npx @capgo/cli key create
```
Dieser Befehl erstellt ein neues Schlüsselpaar in Ihrer App; es ist zwingend erforderlich, den privaten Schlüssel an einem sicheren Ort aufzubewahren. Der private Schlüssel darf niemals in die Versionskontrolle übernommen oder mit nicht vertrauenswürdigen Parteien geteilt werden
Dieser Befehl entfernt auch den alten Schlüssel aus Ihrer Capacitor-Konfiguration, entfernt jedoch nicht die alten Schlüsseldateien. Die CLI behält diese bei, damit Sie weiterhin Live-Updates für Apps senden können, die noch kein App-Store-Update erhalten haben und das alte Plugin verwenden. Dies erleichtert die Migration
Wenn Sie bei der Migration gefragt werden: “Möchten Sie die Verschlüsselung mit dem neuen Kanal einrichten, um alte Apps zu unterstützen und die Migration zu erleichtern?”, stimmen Sie bitte zu. Dies fügt eine neue “defaultChannel”-Option zu Ihrer Capacitor-Konfiguration hinzu. Dadurch verwendet Ihre App den Kanal “encryption\_v2”. Dies stellt sicher, dass die neue Verschlüsselung nur von Apps verwendet wird, die sie unterstützen. Apps, die noch kein App-Store-Update erhalten haben, verwenden weiterhin den vorherigen Standardkanal
***
Nun müssen Sie Ihr JS-Bundle erstellen und es in den neuen Kanal hochladen. Führen Sie dazu folgenden Befehl aus:
```bash
npx @capgo/cli bundle upload --channel encryption_v2
```
***
Führen Sie dann diesen Befehl aus, um Apps zu erlauben, sich selbst dem Kanal “encryption\_v2” zuzuweisen:
Caution
Dies ist notwendig, damit die neue “defaultChannel”-Option funktioniert
```bash
npx @capgo/cli channel set encryption_v2 --self-assign
```
***
Sie können die App jetzt ausführen; sie wird das neue Verschlüsselungssystem verwenden
Um das neue JS-Bundle in den alten Kanal hochzuladen, müssen Sie nur folgenden Befehl ausführen:
```bash
npx @capgo/cli bundle upload --channel production
```
***
Sie müssen sich keine Sorgen um die Capacitor-Konfiguration machen, sie wird nie zu Capgo hochgeladen
Wenn alle Benutzer ihre Apps aktualisiert haben (dies kann bis zu 3/4 Monate dauern), können Sie “defaultChannel” aus Ihrer Capacitor-Konfiguration entfernen
Dann können Sie den alten Kanal mit folgendem Befehl entfernen:
```bash
npx @capgo/cli channel delete encryption_v2
```
***
Nach dem Löschen des “encryption\_v2”-Kanals werden alle Apps, die ihn als Standard verwenden, beginnen, den “production”-Kanal zu verwenden
# Übersicht
> Dieses Dokument bietet einen umfassenden Überblick über die Capgo CLI und wie sie genutzt werden kann, um Ihren App-Entwicklungsprozess durch nahtlose Live-Updates zu verbessern
Nutzen Sie Capgos Live-Updates-Funktion, um die JavaScript-Bundles Ihrer App aus der Ferne in Echtzeit zu aktualisieren. Senden Sie JS-Updates direkt an Ihre Nutzer, ohne den App-Store-Überprüfungsprozess zu durchlaufen, um sofort Fehler zu beheben und neue Funktionen bereitzustellen.
Note
Live-Updates sind auf JavaScript-Bundle-Änderungen beschränkt. Wenn Sie nativen Code aktualisieren müssen, wie das Hinzufügen oder Entfernen eines Plugins oder das Ändern der nativen Projektkonfiguration, müssen Sie einen neuen nativen Binary-Build an die App Stores übermitteln.
## Wie Live-Updates funktionieren
[Section titled “Wie Live-Updates funktionieren”](#wie-live-updates-funktionieren)
Das Live-Update-System von Capgo hat zwei Schlüsselkomponenten:
1. Das Capgo SDK, das Sie in Ihrer App installieren. Das SDK prüft auf verfügbare Updates und lädt sie im Hintergrund herunter.
2. Kanäle, mit denen Sie Updates für bestimmte Benutzergruppen bereitstellen können. Sie können Kanäle verwenden, um verschiedene Release-Tracks wie `Production`, `Staging` und `Dev` zu verwalten.
Wenn Sie ein neues JS-Bundle auf Capgo hochladen und einem Kanal zuweisen, erkennt das Capgo SDK in Apps, die für diesen Kanal konfiguriert sind, das Update und lädt es herunter. Beim nächsten Neustart der App wird das neue Bundle geladen.
## Erste Schritte
[Section titled “Erste Schritte”](#erste-schritte)
Folgen Sie diesen Schritten, um mit Live-Updates zu beginnen:
1. Schließen Sie den [Capgo Quickstart](/docs/getting-started/quickstart) ab, um Ihre App in Capgo einzurichten und das Capgo SDK zu installieren.
2. Rufen Sie in Ihrem App-Code `CapacitorUpdater.notifyAppReady()` auf, nachdem Ihre App initialisiert wurde. Dies teilt dem Capgo SDK mit, dass Ihre App bereit ist, Updates zu empfangen.
3. Erstellen Sie Ihr JS-Bundle und laden Sie es auf Capgo hoch:
```shell
npm run build
npx @capgo/cli@latest bundle upload --channel=production
```
4. Öffnen Sie Ihre App und warten Sie, bis das Update heruntergeladen ist. Sie können den Status überprüfen mit:
```shell
npx @capgo/cli@latest app debug
```
5. Sobald das Update heruntergeladen ist, schließen und öffnen Sie Ihre App erneut, um das neue Bundle zu laden.
Weitere Details finden Sie im [Leitfaden für Live-Updates-Bereitstellung](/docs/getting-started/deploy).
## Die Capgo CLI
[Section titled “Die Capgo CLI”](#die-capgo-cli)
Die Capgo CLI ist ein leistungsstarkes Tool, das Entwicklern ermöglicht, mit Capgos Diensten aus ihren eigenen CI/CD-Pipelines zu interagieren. Mit der CLI haben Sie detaillierte Kontrolle darüber, wann Builds erstellt und bereitgestellt werden, sodass Sie Capgo in Ihre bestehenden Enterprise-Workflows integrieren können.
### Wofür ist die Capgo CLI gedacht?
[Section titled “Wofür ist die Capgo CLI gedacht?”](#wofür-ist-die-capgo-cli-gedacht)
Die Capgo CLI ist für Entwickler und Teams konzipiert, die mehr Kontrolle und Flexibilität in ihren Live-Update-Workflows benötigen. Durch die Verwendung der CLI in Ihren CI/CD-Pipelines können Sie:
* Genau festlegen, wann Updates erstellt und bereitgestellt werden sollen, anstatt sich auf Capgos integrierte Automatisierung zu verlassen
* Eigene Prozesse wie Code-Signierung, QA-Tests oder Manager-Genehmigungen zwischen den Build- und Bereitstellungsschritten einfügen
* Capgo in Ihre bestehenden DevOps-Tools und -Workflows integrieren
### Authentifizierung
[Section titled “Authentifizierung”](#authentifizierung)
Um die Capgo CLI zu nutzen, müssen Sie sich mit Ihrem API-Schlüssel authentifizieren. Sie können einen API-Schlüssel in Ihren Capgo-Kontoeinstellungen generieren.
Um sich anzumelden und Ihren API-Schlüssel sicher zu speichern, führen Sie aus:
```shell
npx @capgo/cli@latest login [API_KEY]
```
Dieser Befehl wird dann für zukünftige Verwendungen gespeichert. Nach der Anmeldung müssen Sie Ihren API-Schlüssel nicht bei jedem Befehl erneut angeben.
### Wichtige Unterschiede zu anderen CLI-Tools
[Section titled “Wichtige Unterschiede zu anderen CLI-Tools”](#wichtige-unterschiede-zu-anderen-cli-tools)
Wenn Sie mit anderen Live-Update-CLI-Tools vertraut sind, gibt es einige wichtige Besonderheiten der Capgo CLI zu beachten:
* Capgo verwendet eine einzige CLI sowohl für Entwicklungs- als auch für CI/CD-Anwendungsfälle, da Capgo sich ausschließlich auf Live-Update-Funktionen konzentriert
* Die Capgo CLI erfordert keinen separaten Installationsschritt. Sie ist im `@capgo/cli`-Paket enthalten und kann direkt mit `npx` ausgeführt werden
* Die Capgo CLI ist speziell für den Live-Update-Workflow konzipiert und enthält möglicherweise nicht alle Funktionen oder Befehle, die in allgemeineren CLI-Tools zu finden sind.
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
[ Kanäle](/docs/live-updates/channels/)
[Erfahren Sie, wie Sie Kanäle verwenden, um verschiedene Release-Tracks zu verwalten und Updates für bestimmte Benutzer bereitzustellen.](/docs/live-updates/channels/)
[ Rollbacks](/docs/live-updates/rollbacks/)
[Entdecken Sie, wie Sie zu einer vorherigen JS-Bundle-Version zurückkehren können, wenn ein Update Probleme verursacht.](/docs/live-updates/rollbacks/)
[ Update-Verhalten](/docs/live-updates/update-behavior/)
[Passen Sie an, wie und wann Updates in Ihrer App heruntergeladen und angewendet werden.](/docs/live-updates/update-behavior/)
[ Schnelle Updates](/docs/live-updates/differentials/)
[Erfahren Sie, wie Sie schnelle Updates verwenden können, um den Update-Prozess zu beschleunigen.](/docs/live-updates/differentials/)
# Übersicht
> Detaillierte Dokumentation für Capgo CLI-Befehle
Die Capgo CLI stellt eine Reihe von Befehlen zur Verwaltung Ihrer Capgo-Apps und Deployments bereit. Diese Referenz bietet detaillierte Informationen zu jedem verfügbaren Befehl, einschließlich seiner Optionen und Anwendungsbeispiele.
## Befehle
[Section titled “Befehle”](#befehle)
[ init](/docs/cli/reference/init/)
[Eine neue Capgo-App initialisieren](/docs/cli/reference/init/)
[ login](./login/)
[Mit dem Capgo-Service authentifizieren](./login/)
[ doctor](/docs/cli/reference/doctor/)
[Überprüfen Sie Ihre Capgo-Einrichtung auf mögliche Probleme](/docs/cli/reference/doctor/)
[ app](./app/)
[Verwalten Sie Ihre Capgo-Apps](./app/)
[ bundle](/docs/cli/reference/bundle/)
[Verwalten Sie Ihre App-Bundles](/docs/cli/reference/bundle/)
[ channel](/docs/cli/reference/channel/)
[Verwalten Sie Ihre Release-Kanäle](/docs/cli/reference/channel/)
[ key](/docs/cli/reference/key/)
[Verwalten Sie Ihre App-Signierungsschlüssel](/docs/cli/reference/key/)
## CI-Integration
[Section titled “CI-Integration”](#ci-integration)
Um Ihre Arbeit zu automatisieren, empfehlen wir die Verwendung von GitHub Actions, um Ihre Updates an Capgo zu übertragen. Weitere Informationen finden Sie in unserem [GitHub Actions Tutorial](https://capgo.app/blog/automatic-build-and-release-with-github-actions/)
Vergessen Sie nicht, Ihre CI-Umgebungsvariablen mit Ihrem Capgo API-Schlüssel zu konfigurieren.
## Demo-App
[Section titled “Demo-App”](#demo-app)
Ein vollständiges Beispiel einer Capgo-App mit CI-Integration finden Sie in unserer [Demo-App auf GitHub](https://github.com/Cap-go/demo-app/)
# Konto
Der `account`-Befehl ermöglicht die Verwaltung Ihres Capgo-Kontos
### id
[Section titled “id”](#id)
`npx @capgo/cli account id`
Ruft Ihre Konto-ID ab
Optionen:
* `-a, --apikey `: API-Schlüssel zur Verknüpfung mit Ihrem Konto
# App
Der `app`-Befehl ermöglicht die Verwaltung Ihrer Capgo-Apps
### add
[Section titled “add”](#add)
`npx @capgo/cli app add [appId]`
Fügt eine neue App zu Ihrem Capgo-Konto hinzu
`[appId]` ist Ihre App-ID im Format `com.example.app`. Weitere Informationen finden Sie in der [Capacitor-Dokumentation](https://capacitorjs.com/docs/cli/commands/init/)
> 💡 Alle Optionen werden aus Ihrer `capacitor.config.json` ermittelt, wenn sie nicht angegeben werden
Optionen:
* `--icon [path]`: Pfad zu einem benutzerdefinierten Symbol, das in der Capgo-Webanwendung angezeigt wird
* `--name [name]`: Benutzerdefinierter Name, der in der App-Liste angezeigt wird
* `--apikey [key]`: API-Schlüssel zur Verknüpfung mit Ihrem Konto
* `--retention [days]`: Aufbewahrungszeitraum für App-Bundles in Tagen (Standard: 0 = unbegrenzt)
### set
[Section titled “set”](#set)
`npx @capgo/cli app set [appId]`
Aktualisiert eine bestehende App in Ihrem Capgo-Konto
Optionen:
* `--icon [path]`: Pfad zu einem benutzerdefinierten Symbol, das in der Capgo-Webanwendung angezeigt wird
* `--name [name]`: Benutzerdefinierter Name, der in der App-Liste angezeigt wird
* `--retention [days]`: Aufbewahrungszeitraum für App-Bundles in Tagen (Standard: 0 = unbegrenzt)
* `--apikey [key]`: API-Schlüssel zur Verknüpfung mit Ihrem Konto
### list
[Section titled “list”](#list)
`npx @capgo/cli app list [appId]`
Listet alle Apps in Ihrem Capgo-Konto auf
Optionen:
* `--apikey [key]`: API-Schlüssel zur Verknüpfung mit Ihrem Konto
### delete
[Section titled “delete”](#delete)
`npx @capgo/cli app delete [appId]`
Löscht eine App aus Ihrem Capgo-Konto
Optionen:
* `--apikey [key]`: API-Schlüssel zur Verknüpfung mit Ihrem Konto
* `--bundle`: Löscht nur eine bestimmte Bundle-Version
### debug
[Section titled “debug”](#debug)
`npx @capgo/cli app debug [appId]`
Zeigt Debug-Informationen für eine App an
Optionen:
* `--apikey [key]`: API-Schlüssel zur Verknüpfung mit Ihrem Konto
* `--device`: Debug eines bestimmten Geräts
### setting
[Section titled “setting”](#setting)
`npx @capgo/cli app setting [path]`
Bearbeitet die Capacitor-Konfiguration für eine App
`[path]` ist der Pfad zur Einstellung, die Sie ändern möchten (z.B. `appId` oder `plugins.CapacitorUpdater.autoUpdate`)
Sie müssen entweder `--string` oder `--bool` angeben:
* `--string `: Setzt die Einstellung auf einen String-Wert
* `--bool `: Setzt die Einstellung auf einen Boolean-Wert
# 🏗️ build
> Erstellen Sie native Mobile Apps in der Cloud und übermitteln Sie sie direkt über Ihre CLI an App Store und Play Store.
🏗️ Erstellen Sie native Mobile Apps in der Cloud und übermitteln Sie sie automatisch an den App Store und Play Store.
## Übersicht
[Section titled “Übersicht”](#übersicht)
Der `build`-Befehl ermöglicht es Ihnen, Ihre Capacitor-App für iOS und Android in der Cloud-Infrastruktur von Capgo zu erstellen, ähnlich wie Expo Builds handhabt. Ihre App wird auf dedizierter Infrastruktur erstellt und kann automatisch an die App Stores übermittelt werden.
**Aktueller Status:** Öffentliche Beta
## Warum Cloud Build verwenden?
[Section titled “Warum Cloud Build verwenden?”](#warum-cloud-build-verwenden)
Das traditionelle Erstellen nativer mobiler Apps erfordert:
* **Mac-Hardware** für iOS-Builds ($1000+ oder teure CI-Minuten)
* **Komplexe CI/CD**-Einrichtung mit Caching und Zugangsdaten
* **Wartungsaufwand** für Xcode, Android Studio und SDKs
Mit Capgo Cloud Build erhalten Sie:
* ✅ **Kein Mac erforderlich** - Erstellen Sie iOS-Apps von jedem Gerät aus
* ✅ **Keine Einrichtung** - Keine CI/CD-Konfiguration erforderlich
* ✅ **Kampferprobt** - Basiert auf 3 Jahren interner Produktionsnutzung
* ✅ **Sicher** - Keine Protokollspeicherung, automatische Bereinigung
* ✅ **Nur nativ** - Ihr JavaScript bleibt privat
## Schnellstart
[Section titled “Schnellstart”](#schnellstart)
```bash
npx @capgo/cli@latest build com.example.app
```
Das ist alles! Ihre App wird in der Cloud erstellt und Sie sehen Echtzeit-Protokolle.
## Dokumentationsabschnitte
[Section titled “Dokumentationsabschnitte”](#dokumentationsabschnitte)
⚠️ Richten Sie ZUERST Zugangsdaten ein
**Erforderlich vor dem Erstellen:** Speichern Sie Ihre iOS/Android-Zugangsdaten lokal.
[Zugangsdaten einrichten →](/docs/cli/cloud-build/credentials/)
Erste Schritte
Erstellen Sie Ihren ersten nativen Build in Minuten.
[Anleitung lesen →](/docs/cli/cloud-build/getting-started/)
iOS Builds
Konfigurieren Sie Zertifikate und erstellen Sie für den App Store.
[iOS konfigurieren →](/docs/cli/cloud-build/ios/)
Android Builds
Richten Sie Keystores ein und erstellen Sie für den Play Store.
[Android konfigurieren →](/docs/cli/cloud-build/android/)
Fehlerbehebung
Lösungen für häufige Build-Probleme.
[Hilfe erhalten →](/docs/cli/cloud-build/troubleshooting/)
## Befehlsreferenz
[Section titled “Befehlsreferenz”](#befehlsreferenz)
### Grundlegende Verwendung
[Section titled “Grundlegende Verwendung”](#grundlegende-verwendung)
```bash
npx @capgo/cli@latest build [appId] [optionen]
```
### Beispiele
[Section titled “Beispiele”](#beispiele)
Für beide Plattformen erstellen:
```bash
npx @capgo/cli@latest build com.example.app
```
Nur für iOS erstellen:
```bash
npx @capgo/cli@latest build com.example.app --platform ios
```
Für Android im Debug-Modus erstellen:
```bash
npx @capgo/cli@latest build com.example.app --platform android --build-mode debug
```
Aus einem bestimmten Verzeichnis erstellen:
```bash
npx @capgo/cli@latest build com.example.app --path ./my-app
```
### Optionen
[Section titled “Optionen”](#optionen)
| Option | Typ | Standard | Beschreibung |
| ------------------------- | ------ | ----------------------- | -------------------------------------------------------------- |
| `appId` | string | capacitor.config | Anwendungs-ID (z. B. com.example.app) |
| `--path ` | string | Aktuelles Verzeichnis | Pfad zu Ihrem Projektverzeichnis |
| `--platform ` | string | both | Zielplattform: `ios`, `android` oder `both` |
| `--build-mode ` | string | release | Build-Modus: `debug` oder `release` |
| `--build-config ` | string | - | Zusätzliche Build-Konfiguration als JSON-String |
| `-a, --apikey ` | string | - | API-Schlüssel (oder `CAPGO_TOKEN` Umgebungsvariable verwenden) |
| `--supa-host ` | string | | Benutzerdefinierte Supabase-Host-URL |
| `--supa-anon ` | string | - | Benutzerdefinierter Supabase-Anon-Schlüssel |
## Wie es funktioniert
[Section titled “Wie es funktioniert”](#wie-es-funktioniert)
```mermaid
sequenceDiagram
participant Dev as Entwickler
participant CLI as Capgo CLI
participant Cloud as Capgo Cloud
participant iOS as Mac Builder
participant Android as Android Builder
Dev->>CLI: build com.example.app
CLI->>CLI: Projekt lokal zippen
CLI->>Cloud: Zu R2 hochladen
Cloud->>iOS: Mac bereitstellen (iOS)
Cloud->>Android: Sandbox starten (Android)
iOS-->>CLI: Protokolle streamen (SSE)
Android-->>CLI: Protokolle streamen (SSE)
iOS->>Cloud: Build abgeschlossen
Android->>Cloud: Build abgeschlossen
Cloud->>iOS: Bereinigung (24h später)
Cloud->>Android: Bereinigung (sofort)
CLI->>Dev: Build erfolgreich
```
### Build-Prozess
[Section titled “Build-Prozess”](#build-prozess)
1. **Lokale Vorbereitung** - Ihr Projekt wird lokal gezippt (ohne `node_modules`, Dotfiles)
2. **Upload** - Zip-Datei wird zu sicherem Cloud-Speicher hochgeladen (Cloudflare R2)
3. **Build-Ausführung**:
* **iOS**: Dedizierte Mac-Maschine bereitgestellt, Fastlane erstellt und signiert
* **Android**: Sichere Sandbox erstellt, Gradle kompiliert und signiert
4. **Protokoll-Streaming** - Echtzeit-Protokolle über Server-Sent Events (nicht gespeichert!)
5. **Automatische Bereinigung**:
* **iOS**: Dateien nach 24 Stunden gelöscht, wenn Maschine freigegeben wird
* **Android**: Alles sofort nach Build gelöscht
## Unsere Expertise
[Section titled “Unsere Expertise”](#unsere-expertise)
Capgo Cloud Build ist keine neue Infrastruktur - wir nutzen sie seit **3 Jahren** intern:
* ✅ **Benutzerdefiniertes Fastlane** - Speziell für Capacitor-Apps entwickelt
* ✅ **Tausende von Builds** - Kampferprobt in Produktion
* ✅ **Capacitor-Experten** - Tiefes Wissen über das Wesentliche
* ✅ **Nur-nativ-Fokus** - Ihr JavaScript berührt nie unsere Server
## Sicherheit & Datenschutz
[Section titled “Sicherheit & Datenschutz”](#sicherheit--datenschutz)
* **Keine Protokollspeicherung** - Protokolle streamen nur zu Ihrem Terminal, werden niemals gespeichert
* **Keine Artefaktspeicherung** - Apps werden direkt an App Store/Play Store gesendet, wir behalten nichts
* **Zugangsdaten automatisch gelöscht** - Nur während Build verwendet, danach gelöscht (max. 24h)
* **Isolierte Builds** - Jeder Build läuft isoliert
* **Ihr Code bleibt Ihrer** - Wir erstellen nur native Teile, JavaScript bleibt lokal
## CI/CD-Integration
[Section titled “CI/CD-Integration”](#cicd-integration)
Funktioniert überall - GitHub Actions, GitLab CI oder jede CI/CD-Plattform:
```yaml
- name: Build native app
env:
CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}
run: |
npm run build
npx cap sync
npx @capgo/cli@latest build com.example.app \
--platform both \
--build-mode release
```
Nicht erforderlich:
* Mac-Runner
* Android SDK-Installation
* Xcode-Installation
* Komplexes Caching
* Zugangsdatenverwaltung
## Preisgestaltung
[Section titled “Preisgestaltung”](#preisgestaltung)
Build-Zeit wird basierend auf tatsächlicher Nutzung abgerechnet:
* **Android**: 1× Multiplikator (\~$0.XX pro Minute)
* **iOS**: 2× Multiplikator (\~$0.XX pro Minute, aufgrund von Mac-Hardware)
**Typische Kosten:**
* Android Debug: 3 min × 1× = \~$X.XX
* iOS Release: 7 min × 2× = \~$X.XX
Zahlen Sie nur für das, was Sie nutzen. Keine Mindestbeträge, keine Überraschungen.
## Vergleich mit anderen Lösungen
[Section titled “Vergleich mit anderen Lösungen”](#vergleich-mit-anderen-lösungen)
| Funktion | Capgo Cloud Build | GitHub Actions (Mac) | Expo EAS |
| --------------------------- | --------------------- | -------------------- | ----------------- |
| **Mac lokal erforderlich** | ❌ Nein | ✅ Ja | ❌ Nein |
| **Einrichtungskomplexität** | ⭐ Einzelner Befehl | ⭐⭐⭐ Komplexes YAML | ⭐⭐ Config-Dateien |
| **Capacitor nativ** | ✅ Optimiert | ⚠️ Generisch | ❌ Nur Expo |
| **Ihr Code-Datenschutz** | ✅ Niemals gespeichert | ⚠️ In Runnern | ⚠️ Hochgeladen |
| **Kosten (iOS)** | 💰 2× Basis | 💰💰💰 10× teuer | 💰💰 Premium |
## Was wird erstellt
[Section titled “Was wird erstellt”](#was-wird-erstellt)
**Wichtig:** Capgo erstellt **nur native Teile**.
✅ **Wir erstellen:**
* iOS-nativer Code (Swift, Objective-C, Xcode-Projekte)
* Android-nativer Code (Java, Kotlin, Gradle-Projekte)
* Code-Signatur und App Store-Übermittlung
❌ **Sie erstellen (lokal):**
* JavaScript, HTML, CSS (`npm run build`)
* Capacitor-Sync (`npx cap sync`)
* Ihre Web-Assets
Diese Trennung gewährleistet:
* **Bessere Sicherheit** - Ihre App-Logik bleibt privat
* **Schnellere Builds** - Keine doppelten Web-Builds
* **Klare Verantwortung** - Sie kontrollieren Ihren Code
## Einschränkungen
[Section titled “Einschränkungen”](#einschränkungen)
Aktuelle Einschränkungen während der öffentlichen Beta:
* **Build-Timeout**: 10 Minuten maximal
* **Upload-Timeout**: 1 Stunde für Upload-URL
* **iOS-Maschine**: 24-Stunden-Lease-Anforderung, Build auf Mac wird in Warteschlange gestellt, um optimale Nutzung sicherzustellen
* **Zugriff**: Nur öffentliche Beta
## Erste Schritte
[Section titled “Erste Schritte”](#erste-schritte)
Bereit, ohne Aufwand zu erstellen?
Erstellen Sie Ihren ersten Build
Schritt-für-Schritt-Anleitung für Ihren ersten Cloud-Build.
[Jetzt starten →](/docs/cli/cloud-build/getting-started/)
An öffentlicher Beta teilnehmen
Cloud Build ist in der öffentlichen Beta. Treten Sie unserer Community bei, um Zugriff zu erhalten.
[Discord beitreten →](https://discord.com/invite/VnYRvBfgA6)
## Mehr erfahren
[Section titled “Mehr erfahren”](#mehr-erfahren)
* [Erste-Schritte-Anleitung](/docs/cli/cloud-build/getting-started/) - Erstellen Sie Ihren ersten Build
* [iOS-Konfiguration](/docs/cli/cloud-build/ios/) - iOS-Builds einrichten
* [Android-Konfiguration](/docs/cli/cloud-build/android/) - Android-Builds einrichten
* [Fehlerbehebung](/docs/cli/cloud-build/troubleshooting/) - Häufige Probleme und Lösungen
* [Blog: Cloud Build vorstellen](/blog/introducing-capgo-cloud-build/) - Feature-Ankündigung
## Brauchen Sie Hilfe?
[Section titled “Brauchen Sie Hilfe?”](#brauchen-sie-hilfe)
* 📚 [Fehlerbehebungsanleitung](/docs/cli/cloud-build/troubleshooting/)
* 💬 [Discord-Community](https://discord.com/invite/VnYRvBfgA6)
* 📧 E-Mail:
# Bündel
Der `bundle`-Befehl ermöglicht die Verwaltung Ihrer App-Bundles
### upload
[Section titled “upload”](#upload)
`npx @capgo/cli bundle upload [appId]`
Lädt ein neues Bundle für eine App hoch
Optionen:
* `-a, --apikey `: API-Schlüssel zur Verknüpfung mit Ihrem Konto
* `-p, --path `: Pfad zum hochzuladenden Ordner (standardmäßig das `webDir` in `capacitorconfig`)
* `-c, --channel `: Channel, mit dem das Bundle verknüpft werden soll
* `-e, --external `: Link zu einer externen URL statt Upload zu Capgo Cloud
* `--iv-session-key `: IV und Session-Schlüssel für externe Bundle-URL festlegen
* `--s3-region `: Region für Ihren S3-Bucket
* `--s3-apikey `: API-Schlüssel für Ihren S3-Endpunkt
* `--s3-apisecret `: API-Secret für Ihren S3-Endpunkt
* `--s3-endpoint `: URL des S3-Endpunkts
* `--s3-bucket-name `: Name Ihres S3-Buckets
* `--s3-port `: Port für Ihren S3-Endpunkt
* `--no-s3-ssl`: SSL für S3-Uploads deaktivieren
* `--key `: Benutzerdefinierter Pfad für den öffentlichen Signaturschlüssel (v1-System)
* `--key-data `: Öffentliche Signaturschlüsseldaten (v1-System)
* `--key-v2 `: Benutzerdefinierter Pfad für den privaten Signaturschlüssel (v2-System)
* `--key-data-v2 `: Private Signaturschlüsseldaten (v2-System)
* `--bundle-url`: Bundle-URL in stdout ausgeben
* `--no-key`: Signaturschlüssel ignorieren und unsigniertes Update senden
* `--no-code-check`: Überprüfung auf `notifyAppReady()` im Quellcode und `indexhtml` im Root-Verzeichnis überspringen
* `--display-iv-session`: IV und Session-Schlüssel zur Verschlüsselung des Updates anzeigen
* `-b, --bundle `: Hochzuladende Bundle-Versionsnummer
* `--min-update-version `: Mindestversion der App für dieses Update (nur verwendet wenn Auto-Update über Metadaten deaktiviert ist)
* `--auto-min-update-version`: Automatische Festlegung der Mindest-Update-Version basierend auf nativen Paketversionen
* `--ignore-metadata-check`: Metadaten-Prüfung (node\_modules) beim Hochladen ignorieren
* `--ignore-checksum-check`: Prüfsummen-Prüfung beim Hochladen ignorieren
* `--timeout `: Timeout für den Upload-Prozess in Sekunden
* `--multipart`: Multipart-Protokoll für S3-Upload verwenden (veraltet, nutzen Sie stattdessen `--tus`)
* `--tus`: Bundle mit dem tus-Protokoll hochladen
* `--tus-chunk-size `: Chunk-Größe für den tus-Upload
* `--partial`: Nur geänderte Dateien zu Capgo Cloud hochladen
* `--partial-only`: Nur partielle Dateien zu Capgo Cloud hochladen, ZIP-Datei überspringen (nützlich für große Bundles)
* `--encrypted-checksum `: Verschlüsselte Prüfsumme (Signatur) für externes Bundle
* `--auto-set-bundle`: Bundle-Version automatisch in `capacitorconfigjson` setzen
* `--dry-upload`: Testlauf des Upload-Prozesses ohne tatsächlichen Upload (nützlich zum Testen)
* `--package-json `: Kommagetrennte Liste von Pfaden zu `packagejson`-Dateien (nützlich für Monorepos)
* `--node-modules `: Kommagetrennte Liste von Pfaden zu `node_modules`-Verzeichnissen (nützlich für Monorepos)
* `--encrypt-partial`: Partielle Update-Dateien verschlüsseln
* `--delete-linked-bundle-on-upload`: Aktuell verknüpftes Bundle im Ziel-Channel vor dem Upload löschen
### compatibility
[Section titled “compatibility”](#compatibility)
`npx @capgo/cli bundle compatibility [appId]`
Prüft die Kompatibilität eines Bundles mit einem bestimmten Channel
Optionen:
* `-a, --apikey `: API-Schlüssel zur Verknüpfung mit Ihrem Konto
* `-c, --channel `: Zu prüfender Channel
* `--text`: Ergebnisse als Text statt Emoji ausgeben
* `--package-json `: Kommagetrennte Liste von Pfaden zu `packagejson`-Dateien (nützlich für Monorepos)
* `--node-modules `: Kommagetrennte Liste von Pfaden zu `node_modules`-Verzeichnissen (nützlich für Monorepos)
### delete
[Section titled “delete”](#delete)
`npx @capgo/cli bundle delete [bundleId] [appId]`
Löscht ein Bundle aus einer App
Optionen:
* `-a, --apikey `: API-Schlüssel zur Verknüpfung mit Ihrem Konto
### list
[Section titled “list”](#list)
`npx @capgo/cli bundle list [appId]`
Listet alle Bundles einer App auf
Optionen:
* `-a, --apikey `: API-Schlüssel zur Verknüpfung mit Ihrem Konto
### cleanup
[Section titled “cleanup”](#cleanup)
`npx @capgo/cli bundle cleanup [appId]`
Bereinigt alte Bundles einer Hauptversion und behält die angegebene Anzahl der neuesten Bundles
Optionen:
* `-b, --bundle `: Zu bereinigende Hauptversionsnummer
* `-a, --apikey `: API-Schlüssel zur Verknüpfung mit Ihrem Konto
* `-k, --keep `: Anzahl der zu behaltenden Bundles (Standard: 4)
* `-f, --force`: Erzwungenes Entfernen ohne Bestätigung
### decrypt
[Section titled “decrypt”](#decrypt)
`npx @capgo/cli bundle decrypt [zipPath] [sessionKey]`
Entschlüsselt ein signiertes ZIP-Bundle
Optionen:
* `--key `: Benutzerdefinierter Pfad für den privaten Signaturschlüssel
* `--key-data `: Private Signaturschlüsseldaten
### encrypt
[Section titled “encrypt”](#encrypt)
`npx @capgo/cli bundle encrypt [zipPath]`
Verschlüsselt ein ZIP-Bundle
Optionen:
* `--key `: Benutzerdefinierter Pfad für den privaten Signaturschlüssel
* `--key-data `: Private Signaturschlüsseldaten
### encryptV2
[Section titled “encryptV2”](#encryptv2)
`npx @capgo/cli bundle encryptV2 [zipPath] [checksum]`
Verschlüsselt ein ZIP-Bundle mit der neuen Verschlüsselungsmethode
Optionen:
* `--key `: Benutzerdefinierter Pfad für den privaten Signaturschlüssel
* `--key-data `: Private Signaturschlüsseldaten
* `-j, --json`: Ergebnisse als JSON ausgeben
### decryptV2
[Section titled “decryptV2”](#decryptv2)
`npx @capgo/cli bundle decryptV2 [zipPath] [checksum]`
Entschlüsselt ein ZIP-Bundle mit der neuen Verschlüsselungsmethode
Optionen:
* `--key `: Benutzerdefinierter Pfad für den privaten Signaturschlüssel
* `--key-data `: Private Signaturschlüsseldaten
* `--checksum `: Prüfsumme des Bundles zur Integritätsprüfung
### zip
[Section titled “zip”](#zip)
`npx @capgo/cli bundle zip [appId]`
Erstellt eine ZIP-Datei für ein Bundle
Optionen:
* `-p, --path `: Pfad zum zu zippenden Ordner (standardmäßig das `webDir` in `capacitorconfig`)
* `-b, --bundle `: Bundle-Versionsnummer für den Dateinamen
* `-n, --name `: Benutzerdefinierter Dateiname für die ZIP-Datei
* `-j, --json`: Ergebnisse als JSON ausgeben
* `--no-code-check`: Überprüfung auf `notifyAppReady()` im Quellcode und `indexhtml` im Root-Verzeichnis überspringen
* `--key-v2`: Neue Verschlüsselungsmethode (v2) verwenden
* `--package-json `: Kommagetrennte Liste von Pfaden zu `packagejson`-Dateien (nützlich für Monorepos)
# Kanal
Der `channel`-Befehl ermöglicht die Verwaltung Ihrer Release-Kanäle
### add
[Section titled “add”](#add)
`npx @capgo/cli channel add [channelId] [appId]`
Erstellt einen neuen Kanal für eine App
Optionen:
* `-d, --default`: Setzt den neuen Kanal als Standardkanal
* `-a, --apikey `: API-Schlüssel zur Verknüpfung mit Ihrem Konto
### delete
[Section titled “delete”](#delete)
`npx @capgo/cli channel delete [channelId] [appId]`
Löscht einen Kanal aus einer App
Optionen:
* `-a, --apikey `: API-Schlüssel zur Verknüpfung mit Ihrem Konto
* `--delete-bundle`: Löscht das mit dem Kanal verbundene Bundle
### list
[Section titled “list”](#list)
`npx @capgo/cli channel list [appId]`
Listet alle Kanäle einer App auf
Optionen:
* `-a, --apikey `: API-Schlüssel zur Verknüpfung mit Ihrem Konto
### currentBundle
[Section titled “currentBundle”](#currentbundle)
`npx @capgo/cli channel currentBundle [channel] [appId]`
Ruft das aktuelle Bundle für einen bestimmten Kanal ab
Optionen:
* `-c, --channel `: Kanal, von dem das aktuelle Bundle abgerufen werden soll
* `-a, --apikey `: API-Schlüssel zur Verknüpfung mit Ihrem Konto
* `--quiet`: Gibt nur die Bundle-Version aus
### set
[Section titled “set”](#set)
`npx @capgo/cli channel set [channelId] [appId]`
Legt die Eigenschaften eines Kanals fest
Optionen:
* `-a, --apikey `: API-Schlüssel zur Verknüpfung mit Ihrem Konto
* `-b, --bundle `: Bundle-Versionsnummer für den Kanal festlegen
* `-s, --state `: Setzt den Status des Kanals (`default` oder `normal`)
* `--latest`: Verwendet die neueste Version aus `packagejson` als Bundle-Version
* `--downgrade`: Erlaubt Downgrades auf Versionen unter der nativen Version
* `--no-downgrade`: Deaktiviert Downgrades auf Versionen unter der nativen Version
* `--upgrade`: Erlaubt Upgrades auf Versionen über der nativen Version
* `--no-upgrade`: Deaktiviert Upgrades auf Versionen über der nativen Version
* `--ios`: Erlaubt das Senden von Updates an iOS-Geräte
* `--no-ios`: Deaktiviert das Senden von Updates an iOS-Geräte
* `--android`: Erlaubt das Senden von Updates an Android-Geräte
* `--no-android`: Deaktiviert das Senden von Updates an Android-Geräte
* `--self-assign`: Erlaubt Geräten die Selbstzuweisung zu diesem Kanal
* `--no-self-assign`: Deaktiviert die Selbstzuweisung von Geräten zu diesem Kanal
* `--disable-auto-update `: Deaktiviert die Auto-Update-Strategie für diesen Kanal (Optionen: `major`, `minor`, `metadata`, `patch`, `none`)
* `--dev`: Erlaubt das Senden von Updates an Entwicklungsgeräte
* `--no-dev`: Deaktiviert das Senden von Updates an Entwicklungsgeräte
* `--emulator`: Erlaubt das Senden von Updates an Emulator-Geräte
* `--no-emulator`: Deaktiviert das Senden von Updates an Emulator-Geräte
* `--package-json `: Kommagetrennte Liste von Pfaden zu `packagejson`-Dateien (nützlich für Monorepos)
# Arzt
`npx @capgo/cli doctor`
Dieser Befehl überprüft, ob Sie die neueste Version der Capgo-Pakete verwenden
Er ist auch nützlich für die Meldung von Fehlern
# initialisieren
`npx @capgo/cli@latest init [apikey]`
Dieser Befehl führt Sie Schritt für Schritt durch:
* Hinzufügen Ihrer App zu Capgo
* Hinzufügen des Codes zu Ihrer App zur Validierung des Updates
* Erstellen Ihrer App
* Hochladen Ihrer App zu Capgo
* Hilft Ihnen zu überprüfen, ob das Update funktioniert
# Schlüssel
Mit dem Befehl `key` können Sie Ihre App-Signierungsschlüssel verwalten
### save
[Section titled “save”](#save)
`npx @capgo/cli key save`
Speichert einen Base64-codierten Verschlüsselungsschlüssel in der Capacitor-Konfiguration (nützlich für CI)
Options:
* `-f, --force`: Erzwingt die Generierung eines neuen Schlüssels
* `--key`: Pfad zur Schlüsseldatei, die in der Capacitor-Konfiguration gespeichert werden soll
* `--key-data`: Schlüsseldaten, die direkt in der Capacitor-Konfiguration gespeichert werden sollen
### create
[Section titled “create”](#create)
`npx @capgo/cli key create`
Erstellt einen neuen Verschlüsselungsschlüssel
Options:
* `-f, --force`: Erzwingt die Generierung eines neuen Schlüssels
### delete\_old
[Section titled “delete\_old”](#delete_old)
`npx @capgo/cli key delete_old`
Löscht den alten Verschlüsselungsschlüssel
# Login
`npx @capgo/cli login [apikey]`
Dieser Befehl speichert Ihren Capgo API-Schlüssel für die zukünftige Verwendung
Note
Sie können den gespeicherten API-Schlüssel überschreiben, indem Sie `--apikey=` zu einem beliebigen Befehl hinzufügen
Optionen:
* `--local`: Speichert den API-Schlüssel im lokalen Repository und fügt ihn zur `gitignore` hinzu
# 🔹 organisation
> 🏢 Verwalten Sie Ihre Organisationen in Capgo Cloud für Teamzusammenarbeit und App-Verwaltung.
🏢 Verwalten Sie Ihre Organisationen in Capgo Cloud für Teamzusammenarbeit und App-Verwaltung.
### []()📋 **List**
[Section titled “ 📋 List”](#--list)
**Alias:** `l`
```bash
npx @capgo/cli@latest organisation list
```
📋 Auflisten aller Organisationen, auf die Sie in Capgo Cloud Zugriff haben.
**Beispiel:**
```bash
npx @capgo/cli@latest organisation list
```
**Optionen:**
| Parameter | Typ | Beschreibung |
| -------------- | -------- | ------------------------------------------------------------------------------ |
| **-a,** | `string` | API-Schlüssel, um mit Ihrem Konto zu verknüpfen |
| **—supa-host** | `string` | Benutzerdefinierte Supabase-Host-URL (für Self-Hosting oder Capgo-Entwicklung) |
| **—supa-anon** | `string` | Benutzerdefinierter Supabase-Anon-Schlüssel (für Self-Hosting) |
### []()➕ **Add**
[Section titled “ ➕ Add”](#--add)
**Alias:** `a`
```bash
npx @capgo/cli@latest organisation add
```
➕ Erstellen Sie eine neue Organisation in Capgo Cloud für Teamzusammenarbeit.
**Beispiel:**
```bash
npx @capgo/cli@latest organisation add --name "My Company" --email admin@mycompany.com
```
**Optionen:**
| Parameter | Typ | Beschreibung |
| -------------- | -------- | ------------------------------------------------------------------------------ |
| **-n,** | `string` | Organisationsname |
| **-e,** | `string` | Verwaltungs-E-Mail für die Organisation |
| **-a,** | `string` | API-Schlüssel, um mit Ihrem Konto zu verknüpfen |
| **—supa-host** | `string` | Benutzerdefinierte Supabase-Host-URL (für Self-Hosting oder Capgo-Entwicklung) |
| **—supa-anon** | `string` | Benutzerdefinierter Supabase-Anon-Schlüssel (für Self-Hosting) |
### []()⚙️ **Set**
[Section titled “ ⚙️ Set”](#-️-set)
**Alias:** `s`
```bash
npx @capgo/cli@latest organisation set
```
⚙️ Aktualisieren Sie Organisationseinstellungen wie Name und Verwaltungs-E-Mail.
**Beispiel:**
```bash
npx @capgo/cli@latest organisation set ORG_ID --name "Updated Company Name"
```
**Optionen:**
| Parameter | Typ | Beschreibung |
| -------------- | -------- | ------------------------------------------------------------------------------ |
| **-n,** | `string` | Organisationsname |
| **-e,** | `string` | Verwaltungs-E-Mail für die Organisation |
| **-a,** | `string` | API-Schlüssel, um mit Ihrem Konto zu verknüpfen |
| **—supa-host** | `string` | Benutzerdefinierte Supabase-Host-URL (für Self-Hosting oder Capgo-Entwicklung) |
| **—supa-anon** | `string` | Benutzerdefinierter Supabase-Anon-Schlüssel (für Self-Hosting) |
### []()🗑️ **Delete**
[Section titled “ 🗑️ Delete”](#-️-delete)
**Alias:** `d`
```bash
npx @capgo/cli@latest organisation delete
```
🗑️ Löschen Sie eine Organisation aus Capgo Cloud. Diese Aktion kann nicht rückgängig gemacht werden. Nur Organisationsinhaber können Organisationen löschen.
**Beispiel:**
```bash
npx @capgo/cli@latest organisation delete ORG_ID
```
**Optionen:**
| Parameter | Typ | Beschreibung |
| -------------- | -------- | ------------------------------------------------------------------------------ |
| **-a,** | `string` | API-Schlüssel, um mit Ihrem Konto zu verknüpfen |
| **—supa-host** | `string` | Benutzerdefinierte Supabase-Host-URL (für Self-Hosting oder Capgo-Entwicklung) |
| **—supa-anon** | `string` | Benutzerdefinierter Supabase-Anon-Schlüssel (für Self-Hosting) |
# Plugins hinzufügen oder aktualisieren
> Vollständige Anleitung für Mitwirkende und Agenten zum Hinzufügen neuer Plugins oder Aktualisieren bestehender Plugins in der Capgo-Dokumentation.
Dieser Leitfaden erklärt, wie Sie neue Capacitor-Plugins zur Capgo-Website hinzufügen oder bestehende Plugin-Dokumentation aktualisieren. Dies ist nützlich für Mitwirkende, Wartungspersonen und KI-Agenten, die bei der Pflege der Dokumentation helfen.
## Übersicht
[Section titled “Übersicht”](#übersicht)
Beim Hinzufügen eines neuen Plugins zum Capgo-Ökosystem müssen Sie mehrere Dateien und Stellen auf der Website aktualisieren, um sicherzustellen, dass das Plugin an allen relevanten Stellen korrekt angezeigt wird:
1. **Plugin-Listen-Konfiguration** - Plugin-Metadaten zur Masterliste hinzufügen
2. **Plugin-Indexseite** - Plugin zur kategorisierten Plugin-Listenseite hinzufügen
3. **Seitenleisten-Navigation** - Plugin zur Dokumentations-Seitenleiste hinzufügen
4. **Plugin-Dokumentation** - Übersichts- und Erste-Schritte-Seiten erstellen
5. **Plugin-Tutorial** - Ein umfassendes Tutorial erstellen
## Dateispeicherorte
[Section titled “Dateispeicherorte”](#dateispeicherorte)
### Wichtige zu aktualisierende Dateien
[Section titled “Wichtige zu aktualisierende Dateien”](#wichtige-zu-aktualisierende-dateien)
| Datei | Zweck |
| ----------------------------------------------- | -------------------------------------- |
| `/src/config/plugins.ts` | Master-Plugin-Liste mit Metadaten |
| `/src/content/docs/docs/plugins/index.mdx` | Plugin-Indexseite mit Kategorien |
| `/astro.config.mjs` | Seitenleisten-Navigationskonfiguration |
| `/src/content/docs/docs/plugins/[plugin-name]/` | Plugin-Dokumentationsverzeichnis |
| `/src/content/plugins-tutorials/en/` | Englische Tutorial-Dateien |
## Schritt-für-Schritt-Anleitung
[Section titled “Schritt-für-Schritt-Anleitung”](#schritt-für-schritt-anleitung)
1. ### Plugin zur Masterliste hinzufügen
[Section titled “Plugin zur Masterliste hinzufügen”](#plugin-zur-masterliste-hinzufügen)
Öffnen Sie `/src/config/plugins.ts` und fügen Sie Ihr Plugin zum `actions`-Array hinzu:
```typescript
// Zuerst ein passendes Heroicon importieren
import YourIconName from 'astro-heroicons/mini/IconName.astro'
// Dann zum actions-Array hinzufügen
{
name: '@capgo/your-plugin-name',
author: 'github.com/Cap-go',
description: 'Kurze Beschreibung, was das Plugin tut',
href: 'https://github.com/Cap-go/your-plugin-name/',
title: 'Anzeigename',
icon: YourIconName,
}
```
**Verfügbare Icons**: Prüfen Sie `/node_modules/astro-heroicons/mini/` für verfügbare Icons.
2. ### Plugin zur Indexseite hinzufügen
[Section titled “Plugin zur Indexseite hinzufügen”](#plugin-zur-indexseite-hinzufügen)
Öffnen Sie `/src/content/docs/docs/plugins/index.mdx` und fügen Sie Ihr Plugin unter der entsprechenden Kategorie hinzu:
```mdx
```
**Kategorien**:
* ⭐ Featured Plugins
* 📱 Device & System Plugins
* 🎥 Media & Camera Plugins
* 🛠️ Utility Plugins
* 🤖 AI & Advanced Media
* 📍 Location & Background Services
* 📞 Communication & Analytics
* 🔐 Security & System
* 📊 Android-Specific Features
* 📥 Download & Navigation
3. ### Zur Seitenleisten-Navigation hinzufügen
[Section titled “Zur Seitenleisten-Navigation hinzufügen”](#zur-seitenleisten-navigation-hinzufügen)
Öffnen Sie `/astro.config.mjs` und fügen Sie Ihr Plugin zur Seitenleisten-Konfiguration hinzu (um Zeile 540):
```javascript
{
label: 'Ihr Plugin-Name',
items: [
{ label: 'Übersicht', link: '/docs/plugins/your-plugin-name/' },
{ label: 'Erste Schritte', link: '/docs/plugins/your-plugin-name/getting-started' },
],
collapsed: true,
}
```
Plugins sind alphabetisch in der Seitenleiste aufgelistet.
4. ### Plugin-Dokumentationsverzeichnis erstellen
[Section titled “Plugin-Dokumentationsverzeichnis erstellen”](#plugin-dokumentationsverzeichnis-erstellen)
Erstellen Sie ein neues Verzeichnis für Ihre Plugin-Dokumentation:
```bash
mkdir -p /src/content/docs/docs/plugins/your-plugin-name/
```
5. ### Plugin-Übersichtsseite erstellen
[Section titled “Plugin-Übersichtsseite erstellen”](#plugin-übersichtsseite-erstellen)
Erstellen Sie `/src/content/docs/docs/plugins/your-plugin-name/index.mdx`:
```mdx
---
title: "@capgo/your-plugin-name"
description: Kurze Beschreibung des Plugin-Zwecks
tableOfContents: false
next: false
prev: false
sidebar:
order: 1
label: "Einführung"
hero:
tagline: Detaillierte Tagline, die erklärt, was das Plugin macht
image:
file: ~public/your-plugin-icon.svg
actions:
- text: Erste Schritte
link: /docs/plugins/your-plugin-name/getting-started/
icon: right-arrow
variant: primary
- text: Github
link: https://github.com/Cap-go/your-plugin-name/
icon: external
variant: minimal
---
import { Card, CardGrid } from '@astrojs/starlight/components';
Beschreibung des ersten Hauptfeatures
Beschreibung des zweiten Hauptfeatures
Funktioniert sowohl auf iOS als auch auf Android 📱
Schauen Sie sich die [Dokumentation](/docs/plugins/your-plugin-name/getting-started/) an, um das Plugin zu meistern.
```
6. ### Erste-Schritte-Anleitung erstellen
[Section titled “Erste-Schritte-Anleitung erstellen”](#erste-schritte-anleitung-erstellen)
Erstellen Sie `/src/content/docs/docs/plugins/your-plugin-name/getting-started.mdx`:
```mdx
---
title: Erste Schritte
description: Erfahren Sie, wie Sie das Plugin in Ihrer Capacitor-App installieren und verwenden.
sidebar:
order: 2
---
import { Steps } from '@astrojs/starlight/components';
import { PackageManagers } from 'starlight-package-managers'
1. **Paket installieren**
2. **Mit nativen Projekten synchronisieren**
## Konfiguration
### iOS-Konfiguration
[iOS-spezifische Einrichtungsanweisungen]
### Android-Konfiguration
[Android-spezifische Einrichtungsanweisungen]
## Verwendung
[Grundlegende Verwendungsbeispiele]
## API-Referenz
[Detaillierte API-Dokumentation]
## Vollständiges Beispiel
[Vollständiges funktionierendes Beispiel]
## Best Practices
[Empfohlene Praktiken und Tipps]
## Plattformhinweise
[Plattformspezifische Hinweise und Einschränkungen]
```
7. ### Tutorial-Datei erstellen
[Section titled “Tutorial-Datei erstellen”](#tutorial-datei-erstellen)
Erstellen Sie `/src/content/plugins-tutorials/en/your-plugin-name.md`:
```markdown
---
locale: en
---
# Verwendung des @capgo/your-plugin-name Pakets
Das `@capgo/your-plugin-name` Paket [kurze Beschreibung]. In diesem Tutorial führen wir Sie durch Installation, Konfiguration und Verwendung dieses Pakets in Ihrer Ionic Capacitor App.
## Installation
[Installationsschritte]
## Konfiguration
[Konfigurationsschritte für iOS und Android]
## API-Verwendung
[Detaillierte API-Verwendungsbeispiele]
## Vollständiges Beispiel
[Vollständiges funktionierendes Beispiel]
## Best Practices
[Tipps und Best Practices]
## Fehlerbehebung
[Häufige Probleme und Lösungen]
## Fazit
[Zusammenfassung und Links zu zusätzlichen Ressourcen]
```
## Plugin-Dokumentationsstruktur
[Section titled “Plugin-Dokumentationsstruktur”](#plugin-dokumentationsstruktur)
### Erforderliche Dateien
[Section titled “Erforderliche Dateien”](#erforderliche-dateien)
```plaintext
src/content/docs/docs/plugins/your-plugin-name/
├── index.mdx # Übersichtsseite mit Hero und Feature-Karten
└── getting-started.mdx # Installations- und Verwendungsanleitung
src/content/plugins-tutorials/en/
└── your-plugin-name.md # Umfassendes Tutorial
```
### Optionale Dateien
[Section titled “Optionale Dateien”](#optionale-dateien)
Für komplexe Plugins können Sie zusätzliche Dokumentationsseiten hinzufügen:
```plaintext
src/content/docs/docs/plugins/your-plugin-name/
├── index.mdx
├── getting-started.mdx
├── api-reference.mdx # Detaillierte API-Dokumentation
├── examples.mdx # Zusätzliche Beispiele
├── troubleshooting.mdx # Fehlerbehebungsanleitung
└── migrations.mdx # Migrationsanleitungen
```
## Inhaltsrichtlinien
[Section titled “Inhaltsrichtlinien”](#inhaltsrichtlinien)
### Plugin-Beschreibungen schreiben
[Section titled “Plugin-Beschreibungen schreiben”](#plugin-beschreibungen-schreiben)
* **Seien Sie prägnant**: Halten Sie Beschreibungen unter 100 Zeichen
* **Seien Sie spezifisch**: Erklären Sie, was das Plugin tut, nicht was es ist
* **Verwenden Sie Aktionswörter**: Beginnen Sie mit Verben wie “Steuern”, “Integrieren”, “Aktivieren”
**Gute Beispiele**:
* “Steuern Sie Geräte-Taschenlampe und Fackel mit einfachem Ein/Aus-Schalter”
* “Integrieren Sie Crisp Live-Chat und Kundensupport in Ihre App”
* “Aktivieren Sie sichere Authentifizierung mit Face ID und Touch ID”
**Schlechte Beispiele**:
* “Ein Plugin für Blitz”
* “Dies ist ein Crisp-Plugin”
* “Biometrisches Plugin”
### Dokumentation schreiben
[Section titled “Dokumentation schreiben”](#dokumentation-schreiben)
1. **Beginnen Sie mit Installation**: Beginnen Sie immer mit klaren Installationsschritten
2. **Konfiguration bereitstellen**: Plattformspezifische Einrichtungsanforderungen einschließen
3. **Verwendungsbeispiele zeigen**: Funktionierende Code-Beispiele bereitstellen
4. **API-Referenz einschließen**: Alle Methoden und Parameter dokumentieren
5. **Vollständige Beispiele hinzufügen**: Reale Verwendungsmuster zeigen
6. **Bewährte Methoden auflisten**: Tipps für optimale Nutzung teilen
7. **Plattformunterschiede dokumentieren**: iOS vs. Android-Verhalten klären
8. **Fehlerbehebung hinzufügen**: Häufige Probleme ansprechen
### Code-Beispiele
[Section titled “Code-Beispiele”](#code-beispiele)
* TypeScript für alle Code-Beispiele verwenden
* Imports oben einschließen
* Kommentare hinzufügen, die Schlüsselschritte erklären
* Fehlerbehandlung zeigen
* Sowohl grundlegende als auch fortgeschrittene Verwendung demonstrieren
## Checkliste
[Section titled “Checkliste”](#checkliste)
Verwenden Sie diese Checkliste beim Hinzufügen eines neuen Plugins:
* [ ] Plugin zu `/src/config/plugins.ts` hinzugefügt
* [ ] Passendes Icon aus Heroicons ausgewählt
* [ ] Plugin zu `/src/content/docs/docs/plugins/index.mdx` unter korrekter Kategorie hinzugefügt
* [ ] Seitenleisteneintrag in `/astro.config.mjs` hinzugefügt
* [ ] Plugin-Dokumentationsverzeichnis erstellt
* [ ] `index.mdx` Übersichtsseite erstellt
* [ ] `getting-started.mdx` Anleitung erstellt
* [ ] Tutorial in `/src/content/plugins-tutorials/en/` erstellt
* [ ] Installationsanweisungen eingeschlossen
* [ ] iOS-Konfiguration dokumentiert
* [ ] Android-Konfiguration dokumentiert
* [ ] Verwendungsbeispiele bereitgestellt
* [ ] API-Referenz hinzugefügt
* [ ] Vollständiges funktionierendes Beispiel eingeschlossen
* [ ] Bewährte Methoden aufgelistet
* [ ] Plattformspezifische Hinweise hinzugefügt
* [ ] Getestet, dass alle Links korrekt funktionieren
## Icon-Referenz
[Section titled “Icon-Referenz”](#icon-referenz)
Häufig verwendete Icons für Plugins (aus `astro-heroicons/mini/`):
| Icon | Anwendungsfall |
| ------------------------ | ------------------------------------------ |
| `BoltIcon` | Blitz, Energie, Strom |
| `CameraIcon` | Kamera, Foto, Video |
| `ChatBubbleLeftIcon` | Chat, Messaging, Kommunikation |
| `FingerPrintIcon` | Biometrisch, Sicherheit, Authentifizierung |
| `MapPinIcon` | Standort, Geolokation, Karten |
| `SpeakerWaveIcon` | Audio, Ton, Musik |
| `VideoCameraIcon` | Video, Aufnahme, Streaming |
| `CreditCardIcon` | Zahlungen, Käufe |
| `PlayCircleIcon` | Mediaplayer, Videoplayer |
| `SignalIcon` | Konnektivität, Netzwerk, Beacon |
| `RadioIcon` | Beacon, Broadcast, Wireless |
| `ChatBubbleOvalLeftIcon` | Soziale Medien, WeChat |
## Bestehende Plugins aktualisieren
[Section titled “Bestehende Plugins aktualisieren”](#bestehende-plugins-aktualisieren)
Beim Aktualisieren eines bestehenden Plugins:
1. **Versionsnummern aktualisieren** in der Dokumentation
2. **Migrationsanleitungen hinzufügen**, falls Breaking Changes existieren
3. **API-Referenz aktualisieren** mit neuen Methoden
4. **Neue Beispiele hinzufügen** für neue Features
5. **Plattformanforderungen aktualisieren**, falls geändert
6. **Bewährte Methoden überarbeiten** basierend auf neuen Features
7. **Tutorial aktuell halten** mit neuester API
## Mehrsprachige Unterstützung
[Section titled “Mehrsprachige Unterstützung”](#mehrsprachige-unterstützung)
Die Website unterstützt mehrere Sprachen. Nach Erstellung der englischen Dokumentation:
1. Übersetzungsskript ausführen:
```bash
bun run plugins:translate_all
```
2. Generierte Übersetzungen überprüfen in:
* `/src/content/plugins-tutorials/de/` (Deutsch)
* `/src/content/plugins-tutorials/es/` (Spanisch)
* `/src/content/plugins-tutorials/fr/` (Französisch)
* `/src/content/plugins-tutorials/it/` (Italienisch)
* `/src/content/plugins-tutorials/ja/` (Japanisch)
* `/src/content/plugins-tutorials/ko/` (Koreanisch)
* `/src/content/plugins-tutorials/id/` (Indonesisch)
## Ihre Änderungen testen
[Section titled “Ihre Änderungen testen”](#ihre-änderungen-testen)
Nach dem Hinzufügen oder Aktualisieren von Plugin-Dokumentation:
1. **Website lokal erstellen**:
```bash
npm run build
```
2. **Auf Fehler prüfen**:
* Überprüfen, ob alle Links funktionieren
* Sicherstellen, dass Bilder korrekt geladen werden
* Code-Beispiele auf Gültigkeit überprüfen
* Navigation testen
3. **Website-Vorschau**:
```bash
npm run dev
```
4. **Ihr Plugin erscheint überprüfen**:
* Plugin-Listenseite prüfen
* Seitenleisten-Navigation überprüfen
* Alle Dokumentationsseiten testen
* Tutorial-Seite bestätigen
## Häufige Fehler
[Section titled “Häufige Fehler”](#häufige-fehler)
Caution
**Vermeiden Sie diese häufigen Fehler:**
1. **Sync vergessen**: Führen Sie in Beispielen immer `npx cap sync` aus
2. **Inkonsistente Benennung**: Verwenden Sie überall denselben Plugin-Namen
3. **Fehlende Plattform-Konfiguration**: Sowohl iOS- als auch Android-Setup dokumentieren
4. **Fehlerhafte Links**: Relative Links verwenden und Funktionalität überprüfen
5. **Keine Fehlerbehandlung**: Immer try-catch in Beispielen zeigen
6. **Fehlende Imports**: Alle notwendigen Imports in Beispiele einschließen
7. **Unklare Beschreibungen**: Spezifisch sein, was das Plugin tut
## Hilfe erhalten
[Section titled “Hilfe erhalten”](#hilfe-erhalten)
Wenn Sie Hilfe beim Hinzufügen oder Aktualisieren von Plugin-Dokumentation benötigen:
* **Discord**: Treten Sie unserer [Discord-Community](https://discord.capgo.app) bei
* **GitHub**: Öffnen Sie ein Issue im [Website-Repository](https://github.com/Cap-go/website)
* **E-Mail**: Kontaktieren Sie das Team unter
## Beispiele
[Section titled “Beispiele”](#beispiele)
Zur Referenz schauen Sie sich diese gut dokumentierten Plugins an:
* **Updater**: `/src/content/docs/docs/plugins/updater/` (komplexes Plugin mit mehreren Seiten)
* **Flash**: `/src/content/docs/docs/plugins/flash/` (einfaches Plugin, gutes Starter-Beispiel)
* **Social Login**: `/src/content/docs/docs/plugins/social-login/` (Plugin mit Unterseiten)
## Zusammenfassung
[Section titled “Zusammenfassung”](#zusammenfassung)
Das Hinzufügen eines Plugins zur Capgo-Dokumentation umfasst:
1. Metadaten zur Master-Konfiguration hinzufügen
2. Plugin zur kategorisierten Indexseite hinzufügen
3. Seitenleisten-Navigation konfigurieren
4. Umfassende Dokumentationsseiten erstellen
5. Detailliertes Tutorial schreiben
6. Alle Änderungen lokal testen
Durch Befolgung dieses Leitfadens stellen Sie sicher, dass Plugins konsistent dokumentiert und von Benutzern leicht auffindbar sind.
# Häufig gestellte Fragen
> Häufig gestellte Fragen zu Capgo
Wenn Sie hier nicht beantwortete Fragen haben, fragen Sie bitte! Sowohl das Erstellen eines Issues als auch das Fragen auf [Discord](https://discordcom/invite/VnYRvBfgA6) funktionieren.
### Was ist “Code Push”?
[Section titled “Was ist “Code Push”?”](#was-ist-code-push)
Code Push, auch bekannt als “Over the Air Updates” (OTA), ist ein Cloud-Service, der es Capacitor-Entwicklern ermöglicht, Updates für ihre Apps in der Produktion bereitzustellen. Capgo funktioniert derzeit auf Android und iOS und wird letztendlich überall dort funktionieren, wo Capacitor funktioniert.
“Code Push” ist eine Referenz auf den Namen einer Deploy-Funktion, die von der React Native Community von [Microsoft](https://appcenterms/) und [Expo](https://expodev/) verwendet wird, die beide Capacitor nicht unterstützen.
### Was ist der Unterschied zwischen einem Bundle und einem Release?
[Section titled “Was ist der Unterschied zwischen einem Bundle und einem Release?”](#was-ist-der-unterschied-zwischen-einem-bundle-und-einem-release)
Wir verwenden den Begriff “Release” für die Vorbereitung einer Binärdatei für die App Stores. Um später ein Bundle generieren zu können, muss Capgo die exakte Binärdatei kennen, die an die App Stores gesendet wurde.
Wir verwenden den Begriff “Bundle” für ein Patch, das auf ein Release angewendet werden kann, um es mit neuem Code zu aktualisieren. Der Befehl `npx @capgo/cli app update` wird verwendet, um aus Ihrem neuen lokalen Code ein Bundle zu generieren, das dann an Ihre Nutzer ausgeliefert wird.
### Wie sieht die Roadmap aus?
[Section titled “Wie sieht die Roadmap aus?”](#wie-sieht-die-roadmap-aus)
Unsere Projekt-Boards sind öffentlich und zu finden unter: [https://github.com/orgs/Cap-go/projects](https://github.com/orgs/Cap-go/projects/)
Unser Team arbeitet auch öffentlich, sodass Sie jederzeit sehen können, woran wir arbeiten. Wir beantworten gerne Ihre Fragen zu unserer Roadmap oder Prioritäten über Github Issues oder [Discord](https://discordcom/invite/VnYRvBfgA6).
### Kann ich Capgo mit meinem Team nutzen?
[Section titled “Kann ich Capgo mit meinem Team nutzen?”](#kann-ich-capgo-mit-meinem-team-nutzen)
Ja! Alle Pläne unterstützen unbegrenzte Entwickler. Wir beschränken nur App-Metriken (MAU, Speicher und Bandbreite) für jede Organisation.
Weitere Informationen finden Sie unter [Teams](https://capgo.app/pricing/).
### Speichert Capgo meinen Quellcode?
[Section titled “Speichert Capgo meinen Quellcode?”](#speichert-capgo-meinen-quellcode)
Nein. Capgo-Server sehen niemals Ihren Quellcode. Wenn Sie `npx @capgo/cli app update` ausführen, lädt das `npx @capgo/cli`-Tool nur den kompilierten Code hoch, den Sie auch an die App Stores senden. Wenn Sie zusätzliche Sicherheit wünschen, können Sie Ende-zu-Ende-Verschlüsselung verwenden, um Ihr Bundle vor dem Upload auf Capgo-Server zu verschlüsseln.
Siehe auch unsere Datenschutzrichtlinie: [https://capgo.app/privacy](https://capgo.app/privacy/)
### Kann ich Capgo von meinem CI-System aus nutzen?
[Section titled “Kann ich Capgo von meinem CI-System aus nutzen?”](#kann-ich-capgo-von-meinem-ci-system-aus-nutzen)
Ja. Capgo ist für die Verwendung in CI-Systemen gedacht. Wir haben eine Anleitung für [Android und Github Actions](https://capgo.app/blog/automatic-capacitor-android-build-github-action/) und [IOS](https://capgo.app/blog/automatic-capacitor-ios-build-github-action/) sowie für [Gitlab](https://capgo.app/blog/setup-ci-and-cd-gitlab/) veröffentlicht, andere CI-Systeme sollten ähnlich sein.
Zögern Sie nicht, sich bei Problemen über GitHub Issues oder Discord zu melden.
### Wie verhält sich das zu Firebase Remote Config oder Launch Darkly?
[Section titled “Wie verhält sich das zu Firebase Remote Config oder Launch Darkly?”](#wie-verhält-sich-das-zu-firebase-remote-config-oder-launch-darkly)
Code Push ermöglicht das Hinzufügen neuen Codes/Ersetzen von Code auf dem Gerät. Firebase Remote Config und Launch Darkly sind beides Konfigurationssysteme. Sie ermöglichen es Ihnen, die Konfiguration Ihrer App zu ändern, ohne eine neue Version ausliefern zu müssen. Sie sind nicht dafür gedacht, Code zu ersetzen.
### Wie groß ist der Dependency-Footprint?
[Section titled “Wie groß ist der Dependency-Footprint?”](#wie-groß-ist-der-dependency-footprint)
Ich habe es kürzlich nicht gemessen, aber ich erwarte, dass die Code-Push-Bibliothek weniger als ein Megabyte zu Capacitor-Apps hinzufügt. Wir kennen Möglichkeiten, dies kleiner zu machen, wenn es Priorität wird. Wenn die Größe ein Blocker für Sie ist, lassen Sie es uns wissen!
### Funktioniert Code Push mit großen Anwendungen?
[Section titled “Funktioniert Code Push mit großen Anwendungen?”](#funktioniert-code-push-mit-großen-anwendungen)
Ja. Es gibt keine Begrenzung für die Größe der Anwendung, die mit Code Push aktualisiert werden kann. Wie [unten](https://capgo.app/docs/faq/#what-types-of-changes-does-capgo-code-push-support) erwähnt, kann Capgo jeden JS-Code in Ihrer Anwendung ändern, unabhängig von der Größe.
Zu beachten: Eine größere Größe erschwert es Benutzern, Updates herunterzuladen. Wir empfehlen, Ihre App so klein wie möglich zu halten.
### Wofür kann ich Capgo Code Push verwenden?
[Section titled “Wofür kann ich Capgo Code Push verwenden?”](#wofür-kann-ich-capgo-code-push-verwenden)
Wir haben verschiedene Anwendungsfälle gesehen, darunter:
* Notfall-Fixes für Produktions-Apps
* Auslieferung von Fehlerbehebungen an Benutzer älterer Versionen Ihrer App
* Kontinuierliche Auslieferung (z.B. stündlich)
Beachten Sie, dass die meisten App Stores das Ausliefern von Code verbieten, der das Verhalten der App wesentlich ändert. Weitere Informationen finden Sie [unten](https://capgo.app/docs/faq/#how-does-this-relate-to-the-appplay-store-review-process-or-policies).
### Was zählt als “MAU” für Capgo?
[Section titled “Was zählt als “MAU” für Capgo?”](#was-zählt-als-mau-für-capgo)
Ein MAU ist ein “Monthly Active User”. Wir zählen einen MAU als jedes Gerät, das in den letzten 30 Tagen unsere Server kontaktiert hat. Wir zählen keine Geräte, die unsere Server in den letzten 30 Tagen nicht kontaktiert haben.
**Wichtig**: Ab Plugin-Version **v6.25.0** und **v7.25.0** bleibt die Geräte-ID über App-Neuinstallationen hinweg erhalten. Vor diesen Versionen erzeugte jede App-Neuinstallation eine neue Geräte-ID und zählte als neuer MAU.
Mit den aktuellen Versionen:
* Geräte-ID bleibt über App-Neuinstallationen hinweg erhalten (sicher gespeichert im Keychain auf iOS und EncryptedSharedPreferences auf Android)
* Das Aktualisieren der App erstellt keine neue Geräte-ID
* Während der Entwicklung, wenn Sie eine ältere Plugin-Version (< v6.25.0 / v7.25.0) verwenden, erstellt jede Neuinstallation immer noch einen neuen MAU
Hinweis: TestFlight-Downloads und Kanalwechsel in Android können je nach Konfiguration immer noch neue Geräteregistrierungen erzeugen.
> Wir empfehlen nach dem ersten Setup, Entwicklungsgeräte und Emulatoren zu deaktivieren, um die Anzahl doppelter Geräte zu reduzieren.
### Wofür können wir Capgo Code Push nicht verwenden?
[Section titled “Wofür können wir Capgo Code Push nicht verwenden?”](#wofür-können-wir-capgo-code-push-nicht-verwenden)
Wie oben erwähnt, sollte Capgo nicht verwendet werden, um gegen App Store-Richtlinien zu verstoßen. Weitere Informationen finden Sie [unten](https://capgo.app/docs/faq/#does-capgo-comply-with-play-store-guidelines).
Außerdem unterstützt Capgo keine Änderungen am nativen Code (z.B. Java/Kotlin auf Android oder Objective-C/Swift auf iOS). Das Tool warnt Sie während eines Aktualisierungsversuchs, wenn Sie nativen Code geändert haben.
### Kann ich Änderungen an capacitor.config.ts über Capgo aktualisieren?[](https://capgo.app/docs/faq/#can-i-update-capacitorconfigts-changes-via-capgo "Direct link to Can I update capacitor.config.ts changes via Capgo?")
[Section titled “Kann ich Änderungen an capacitor.config.ts über Capgo aktualisieren?”](#kann-ich-änderungen-an-capacitorconfigts-über-capgo-aktualisieren)
Nein. Änderungen an `capacitor.config.ts` können nicht über Capgo Live-Updates gesendet werden. Die Capacitor-Konfigurationsdatei wird zur nativen Build-Zeit gelesen und in die native App-Binary kompiliert. Das bedeutet, dass Änderungen an `capacitor.config.ts` (wie Plugin-Konfigurationen, App-ID, Server-Einstellungen oder native Plugin-Optionen) eine neue native Version über den App Store oder Google Play erfordern.
Capgo kann nur Web-Assets (HTML, CSS, JavaScript) aktualisieren, die zur Laufzeit geladen werden. Wenn Sie Ihre Capacitor-Konfiguration ändern müssen:
1. Aktualisieren Sie `capacitor.config.ts` lokal
2. Bauen Sie Ihre native App neu (`npx cap sync` gefolgt von einem nativen Build)
3. Reichen Sie die neue Binary bei den App Stores ein
### Reicht Capgo die Apps für mich bei den Stores ein?
[Section titled “Reicht Capgo die Apps für mich bei den Stores ein?”](#reicht-capgo-die-apps-für-mich-bei-den-stores-ein)
Capgo unterstützt derzeit nicht das Einreichen bei den App Stores in Ihrem Namen. Wir planen, dies in Zukunft hinzuzufügen, aber vorerst müssen Sie weiterhin Ihre bestehenden Prozesse für die Einreichung bei den App Stores verwenden.
Sie können unseren [CI-Leitfaden für Android](https://capgo.app/blog/automatic-capacitor-android-build-github-action/) und [CI-Leitfaden für iOS](https://capgo.app/blog/automatic-capacitor-ios-build-github-action/) verwenden, um diesen Prozess zu automatisieren.
### Was speichert Capgo auf der Festplatte und wo?
[Section titled “Was speichert Capgo auf der Festplatte und wo?”](#was-speichert-capgo-auf-der-festplatte-und-wo)
Der Capgo-Updater (der in Ihrer Anwendung enthalten ist, wenn Sie Ihre App erstellen) speichert das zuletzt heruntergeladene Bundle im einzigen Verzeichnis, das Capacitor zum Laden von Code erlaubt. Auf Android befindet sich dies in `/data/user/0/comexampleapp/code_cache/capgo_updater`, wobei der Basispfad vom Android-System bereitgestellt wird und sich zur Laufzeit dynamisch ändern kann. Auf iOS-Geräten werden Daten unter `Library/Application Support/capgo` gespeichert.
Die Capgo-Kommandozeilentools (z.B.`npx @capgo/cli app update`) werden auf der Festplatte in npm-Caches installiert, Ihre Anmeldedaten werden in Ihrem Home-Verzeichnis in `~/capgo` gespeichert
### Wie verhält sich das zum Capacitor Hot Reload?
[Section titled “Wie verhält sich das zum Capacitor Hot Reload?”](#wie-verhält-sich-das-zum-capacitor-hot-reload)
Capacitor Hot Reload ist ein Feature ausschließlich für die Entwicklungszeit. Code Push ist für die Produktion.
Hot Reload ist eine Funktion von Capacitor, die es ermöglicht, Code während der Entwicklung auf dem Gerät zu ändern. Dies erfordert das Erstellen der Capacitor-App mit einem Proxy zur Verbindung mit Ihrem lokalen Rechner.
Code Push ist eine Funktion, die es ermöglicht, Code auf dem Gerät in der Produktion zu ändern. Wir verwenden verschiedene Techniken, um dies je nach Plattform zu ermöglichen.
### Welche Arten von Änderungen unterstützt Capgo Code Push?
[Section titled “Welche Arten von Änderungen unterstützt Capgo Code Push?”](#welche-arten-von-änderungen-unterstützt-capgo-code-push)
Capgo kann jeden JS-Code in Ihrer Anwendung ändern. Dies umfasst App-Code und generierten Code. Sie können auch Abhängigkeiten in `package.json` aktualisieren, solange diese keine nativen Code-Änderungen erfordern.
Wir haben nicht vor, Änderungen am nativen Code zu unterstützen (z.B. Java/Kotlin auf Android oder Objective-C/Swift auf iOS), und das Tool wird Sie warnen, wenn es erkennt, dass Sie nativen Code geändert haben, da dieser nicht im Bundle enthalten sein wird.
### Unterstützt dies Web?
[Section titled “Unterstützt dies Web?”](#unterstützt-dies-web)
Code Push wird für Web nicht benötigt, da Web bereits so funktioniert. Wenn ein Benutzer eine Web-App öffnet, lädt sie bei Bedarf die neueste Version vom Server herunter.
Wenn Sie einen Anwendungsfall für Code Push mit Web haben, würden wir das gerne wissen!
### Wird dies auf iOS, Android, Mac, Windows, Linux usw. funktionieren?
[Section titled “Wird dies auf iOS, Android, Mac, Windows, Linux usw. funktionieren?”](#wird-dies-auf-ios-android-mac-windows-linux-usw-funktionieren)
Ja.
Bisher haben wir uns auf die Android- und iOS-Unterstützung konzentriert, aber Code Push wird letztendlich überall funktionieren, wo Capacitor funktioniert. Wir stellen sicher, dass wir zuerst die gesamte Infrastruktur aufbauen, die benötigt wird, um Code Push zuverlässig und sicher bereitzustellen, bevor wir auf weitere Plattformen expandieren.
### Welche Betriebssystemversionen unterstützt Capgo?
[Section titled “Welche Betriebssystemversionen unterstützt Capgo?”](#welche-betriebssystemversionen-unterstützt-capgo)
Capgo unterstützt die gleichen Android-Versionen, die auch Capacitor unterstützt.
Capacitor unterstützt derzeit Android API Level 22+ und iOS 13.0+: [https://capacitorjs.com/docs/main/reference/support-policy](https://capacitorjs.com/docs/main/reference/support-policy/)
### Welche Versionen von Capacitor unterstützt Capgo?
[Section titled “Welche Versionen von Capacitor unterstützt Capgo?”](#welche-versionen-von-capacitor-unterstützt-capgo)
Capgo unterstützt derzeit nur aktuelle stabile Versionen von Capacitor. Wir könnten auch ältere Versionen von Capacitor unterstützen, haben aber noch nicht die nötige Infrastruktur aufgebaut, um diese über die Zeit zu pflegen. Wir beabsichtigen, in Zukunft mehr Versionen von Capacitor zu unterstützen, einschließlich jeder Version für unsere Enterprise-Kunden [https://github.com/Cap-go/capgo/issues/1100](https://github.com/Cap-go/capgo/issues/1100/)
Capgo verfolgt die stabilen Versionen und aktualisiert in der Regel innerhalb weniger Stunden nach einer stabilen Veröffentlichung. Unser System für diese Aktualisierungen ist automatisiert und benötigt nur wenige Minuten. Danach führen wir einen zusätzlichen manuellen Verifizierungsschritt durch, bevor wir auf unsere Server veröffentlichen.
### Wie verhält sich dies zum App/Play Store Überprüfungsprozess oder deren Richtlinien?
[Section titled “Wie verhält sich dies zum App/Play Store Überprüfungsprozess oder deren Richtlinien?”](#wie-verhält-sich-dies-zum-appplay-store-überprüfungsprozess-oder-deren-richtlinien)
Entwickler sind an ihre Vereinbarungen mit Store-Anbietern gebunden, wenn sie diese Stores nutzen. Code Push ist so konzipiert, dass Entwickler ihre Apps aktualisieren und dabei die Store-Richtlinien auf iOS und Android einhalten können. Ähnlich wie bei den verschiedenen kommerziellen Produkten, die für React Native verfügbar sind (z.B. [Microsoft](https://appcenter.ms/), [Expo](https://expo.dev/))
Microsoft veröffentlicht auch einen Leitfaden darüber, wie ihre Lösung die App Store-Richtlinien erfüllt: [https://github.com/microsoft/react-native-code-push#store-guideline-compliance](https://github.com/microsoft/react-native-code-push/#store-guideline-compliance)
Code Push ist eine weit verbreitete Technik in den App Stores. Alle großen Apps, die ich kenne, verwenden Code Push. Die wichtigste Richtlinie ist, das Verhalten der App nicht wesentlich zu ändern. Weitere Informationen finden Sie [unten](https://capgo.app/docs/faq/#does-capgo-comply-with-play-store-guidelines).
### Erfüllt Capgo die Play Store-Richtlinien?
[Section titled “Erfüllt Capgo die Play Store-Richtlinien?”](#erfüllt-capgo-die-play-store-richtlinien)
Ja.
Der Play Store bietet zwei Einschränkungen in Bezug auf Update-Tools:
1. Updates müssen einen Interpreter oder eine virtuelle Maschine verwenden (Capgo verwendet die Dart Virtual Machine) [https://support.google.com/googleplay/android-developer/answer/9888379?hl=en](https://support.google.com/googleplay/android-developer/answer/9888379/?hl=en)
```plaintext
Eine über Google Play verteilte App darf sich nicht selbst modifizieren, ersetzen oder aktualisieren
mit anderen Methoden als dem Update-Mechanismus von Google Play. Ebenso darf eine App
keinen ausführbaren Code (wie dex-, JAR-, .so-Dateien) von einer
anderen Quelle als Google Play herunterladen. *Diese Einschränkung gilt nicht für Code,
der in einer virtuellen Maschine oder einem Interpreter läuft*, wo entweder
indirekten Zugriff auf Android-APIs bietet (wie JavaScript in einer WebView oder
Browser)
Apps oder Drittanbieter-Code, wie SDKs, mit interpretierten Sprachen (JavaScript,
Python, Lua, etc.), die zur Laufzeit geladen werden (zum Beispiel nicht mit der
App gebündelt), dürfen keine potenziellen Verstöße gegen Google Play-Richtlinien ermöglichen
```
2. Änderungen an der App dürfen nicht täuschend sein (z.B. Ändern des Zwecks der App durch ein Update) [https://support.google.com/googleplay/android-developer/answer/9888077](https://support.google.com/googleplay/android-developer/answer/9888077/) Bitte seien Sie transparent gegenüber Ihren Benutzern bezüglich dessen, was Sie mit Ihrer Anwendung bereitstellen, und verletzen Sie nicht ihre Erwartungen durch wesentliche Verhaltensänderungen durch die Verwendung von Capgo.
Capgo ist so konzipiert, dass es mit den Play Store-Richtlinien kompatibel ist. Allerdings ist Capgo ein Werkzeug und kann wie jedes Werkzeug missbraucht werden. Die absichtliche missbräuchliche Verwendung von Capgo zur Verletzung der Play Store-Richtlinien verstößt gegen die Capgo [Nutzungsbedingungen](https://capgo.app/tos/) und kann zur Kündigung Ihres Kontos führen.
Schließlich werden Code Push-Dienste in der Branche weit verbreitet eingesetzt (alle großen Apps, die ich kenne, verwenden sie) und es gibt mehrere andere öffentlich verfügbare Code Push-Dienste (z.B. expo.dev & appcenter.ms). Dies ist ein gut ausgetretener Pfad.
Microsoft veröffentlicht auch einen Leitfaden darüber, wie ihre React Native “codepush”-Bibliothek die App Store-Richtlinien erfüllt: [https://github.com/microsoft/react-native-code-push#store-guideline-compliance](https://github.com/microsoft/react-native-code-push/#store-guideline-compliance)
### Erfüllt Capgo die App Store-Richtlinien?
[Section titled “Erfüllt Capgo die App Store-Richtlinien?”](#erfüllt-capgo-die-app-store-richtlinien)
Ja.
Ähnlich wie der Play Store bietet der App Store sowohl technische als auch Richtlinien-Einschränkungen.
```plaintext
3.2.2
interpretierter Code kann in eine Anwendung heruntergeladen werden, jedoch nur solange
dieser Code:
(a) den primären Zweck der Anwendung nicht durch Bereitstellung von
Funktionen oder Funktionalität ändert, die nicht mit dem beabsichtigten und
beworbenen Zweck der Anwendung, wie sie im App Store eingereicht wurde, übereinstimmen,
(b) keinen Store oder Storefront für anderen Code oder Anwendungen erstellt, und
(c) keine Signierung, Sandbox oder andere Sicherheitsfunktionen des Betriebssystems umgeht
```
Capgo verwendet einen benutzerdefinierten Dart-Interpreter, um die Interpreter-Only-Beschränkung für Updates auf iOS einzuhalten. Solange Ihre Anwendung kein täuschendes Verhalten durch Updates zeigt (z.B. Änderung des App-Zwecks durch Update), ist das Aktualisieren über Capgo (oder eine andere Code-Push-Lösung) gängige Branchenpraxis und entspricht den App Store-Richtlinien.
Der absichtliche Missbrauch von Capgo zur Verletzung der App Store-Richtlinien verstößt gegen die [Nutzungsbedingungen](https://capgo.app/tos/) von Capgo und kann zur Kündigung Ihres Kontos führen.
Microsoft veröffentlicht auch einen Leitfaden, wie ihre React Native “CodePush”-Bibliothek die App Store-Richtlinien einhält: [https://github.com/microsoft/react-native-code-push#store-guideline-compliance](https://github.com/microsoft/react-native-code-push/#store-guideline-compliance)
### Kann ich Capgo in meinem Land nutzen?[](https://capgo.app/docs/faq/#can-i-use-capgo-in-my-country "Direct link to Can I use Capgo in my country?")
[Section titled “Kann ich Capgo in meinem Land nutzen?”](#kann-ich-capgo-in-meinem-land-nutzen)
Wir haben den Zugriff auf Capgo aus keinem Land eingeschränkt.
Wir erkennen an, dass einige Länder Einschränkungen haben, welche URLs innerhalb des Landes aufgerufen werden können. Capgo verwendet derzeit Cloudflare Cloud für das Hosting, einschließlich R2 Storage und Cloudflare Workers.
Folgende URLs werden von Capgo verwendet:
* [https://apicapgo.app](https://apicapgo.app/) — verwendet von den `npx @capgo/cli` Command Line Tools für die Interaktion mit den Capgo-Servern sowie vom Capgo-Updater auf den Geräten der Benutzer zur Überprüfung von Updates
* [https://\*r2cloudflarestoragecom](https://*r2cloudflarestoragecom/) — verwendet vom `npx @capgo/cli` Command Line Tool zum Hoch- und Herunterladen von Bundles
Wenn all diese URLs aus Ihrem Land erreichbar sind, sollte Capgo funktionieren.
Wenn Ihre Region den Zugriff auf eine dieser URLs blockieren muss, lassen Sie es uns wissen und wir können mit Ihnen an einer Lösung arbeiten. Proxy-Server sind eine Option.
### Kann ich Capgo selbst hosten?[](https://capgo.app/docs/faq/#can-i-self-host-capgo "Direct link to Can I self-host Capgo?")
[Section titled “Kann ich Capgo selbst hosten?”](#kann-ich-capgo-selbst-hosten)
Ja, Sie können Capgo selbst hosten. Die Anleitung ist noch nicht geschrieben, aber der Code ist Open Source und verfügbar unter [https://github.com/cap-go/capgo](https://github.com/cap-go/capgo/)
### Benötigt Code Push Internet zum Funktionieren?[](https://capgo.app/docs/faq/#does-code-push-require-the-internet-to-work "Direct link to Does code push require the internet to work?")
[Section titled “Benötigt Code Push Internet zum Funktionieren?”](#benötigt-code-push-internet-zum-funktionieren)
Ja. Man könnte sich vorstellen, einen Server zu betreiben, um die Updates getrennt vom allgemeinen Internet zu verteilen, aber irgendeine Form von Netzwerkverbindung ist erforderlich, um Updates auf die Geräte zu übertragen.
### Wie wird Capgo von fehlender Netzwerkverbindung beeinflusst?[](https://capgo.app/docs/faq/#how-is-capgo-affected-by-lack-of-network-connectivity "Direct link to How is Capgo affected by lack of network connectivity?")
[Section titled “Wie wird Capgo von fehlender Netzwerkverbindung beeinflusst?”](#wie-wird-capgo-von-fehlender-netzwerkverbindung-beeinflusst)
Der Capgo-Updater (der in Ihrer Anwendung enthalten ist, wenn Sie Ihre App mit Capgo erstellen) ist darauf ausgelegt, resistent gegen Netzwerkverbindungsprobleme zu sein.
Im Standard-Update-Verhalten benachrichtigt die Anwendung beim Start den Capgo-Updater, der einen separaten Thread startet, um eine Netzwerkanfrage an die Capgo-Server zu stellen und nach einem Update zu fragen. Wir verwenden absichtlich einen separaten Thread, um andere Aktivitäten der Anwendung nicht zu blockieren. Wenn die Netzwerkanfrage fehlschlägt oder eine Zeitüberschreitung auftritt, wird der Updater beim nächsten Start der Anwendung erneut prüfen.
Capgo Command Line Tools (z.B. `npx @capgo/cli app update`) benötigen eine Netzwerkverbindung zum Funktionieren. Wenn Sie Capgo zur Verteilung Ihrer App verwenden, sollten Sie sicherstellen, dass Ihr CI-System eine Netzwerkverbindung hat.
### Was passiert, wenn ein Benutzer lange Zeit nicht aktualisiert und ein Update verpasst?[](https://capgo.app/docs/faq/#what-happens-if-a-user-doesnt-update-for-a-long-time-and-misses-an-update "Direct link to What happens if a user doesn't update for a long time and misses an update?")
[Section titled “Was passiert, wenn ein Benutzer lange Zeit nicht aktualisiert und ein Update verpasst?”](#was-passiert-wenn-ein-benutzer-lange-zeit-nicht-aktualisiert-und-ein-update-verpasst)
Unsere Implementierung sendet immer ein speziell auf das anfragende Gerät zugeschnittenes Update, das den Anfrager immer auf die neueste verfügbare Version aktualisiert. Wenn ein Benutzer also eine Weile nicht aktualisiert, wird er Zwischenupdates “verpassen”.
Der Update-Server könnte geändert werden, um je nach Bedarf Ihrer Anwendung entweder die nächste inkrementelle Version oder die neueste Version zu unterstützen. Bitte lassen Sie uns wissen, wenn alternative Update-Verhaltensweisen für Sie wichtig sind.
### Wie verhält sich Capgo zu Capacitor?[](https://capgo.app/docs/faq/#how-does-capgo-relate-to-capacitor "Direct link to How does Capgo relate to Capacitor?")
[Section titled “Wie verhält sich Capgo zu Capacitor?”](#wie-verhält-sich-capgo-zu-capacitor)
Capgo ist ein Plugin für Capacitor, das Code Push hinzufügt. Capgo ist kein Ersatz für Capacitor. Sie können weiterhin die Capacitor-Tools verwenden, die Sie bereits kennen und schätzen.
Wir verfolgen die neueste stabile Version von Capacitor und aktualisieren unser Code Push Plugin entsprechend.
### Wann finden Updates statt?[](https://capgo.app/docs/faq/#when-do-updates-happen "Direct link to When do updates happen?")
[Section titled “Wann finden Updates statt?”](#wann-finden-updates-statt)
Standardmäßig prüft der Capgo-Updater beim App-Start auf Updates. Er läuft in einem Hintergrund-Thread und blockiert nicht den UI-Thread. Updates werden installiert, während der Benutzer die App verwendet, und beim nächsten Neustart der App angewendet.
Es ist auch möglich, den Capgo-Updater manuell mit [package:capgo\_code\_push](https://pubdev/packages/capgo_code_push/) auszuführen, wodurch Updates jederzeit ausgelöst werden können, auch über Push-Benachrichtigungen.
Der Capgo-Updater ist so konzipiert, dass die App normal weiterläuft, wenn das Netzwerk nicht verfügbar ist oder der Server nicht erreichbar ist. Sollten Sie sich jemals entscheiden, ein Update von unseren Servern zu löschen, werden alle Ihre Clients normal weiterlaufen.
Wir haben die Möglichkeit hinzugefügt, Patches zurückzurollen. Am einfachsten ist es, einfach ein vorheriges Bundle an Ihren Kanal anzuhängen, um dies rückgängig zu machen.
### Muss ich meine app\_id geheim halten?[](https://capgo.app/docs/faq/#do-i-need-to-keep-my-app_id-secret "Direct link to Do I need to keep my app_id secret?")
[Section titled “Muss ich meine app\_id geheim halten?”](#muss-ich-meine-app_id-geheim-halten)
Nein. Die `app_id` ist in Ihrer App enthalten und kann öffentlich sein. Sie können sie in die Versionskontrolle einchecken (auch öffentlich) und müssen sich keine Sorgen machen, dass jemand anderes darauf zugreift.
Jemand mit Ihrer `app_id` kann die neueste Version Ihrer App von Capgo-Servern abrufen, kann aber keine Updates für Ihre App pushen oder auf andere Aspekte Ihres Capgo-Kontos zugreifen.
### Welche Informationen werden an Capgo-Server gesendet?[](https://capgo.app/docs/faq/#what-information-is-sent-to-capgo-servers "Direct link to What information is sent to Capgo servers?")
[Section titled “Welche Informationen werden an Capgo-Server gesendet?”](#welche-informationen-werden-an-capgo-server-gesendet)
Obwohl Capgo sich mit dem Netzwerk verbindet, werden keine personenbezogenen Daten gesendet. Das Einbinden von Capgo sollte Ihre Erklärungen für den Play Store oder App Store nicht beeinflussen.
Anfragen, die von der App an Capgo-Server gesendet werden, enthalten:
* app\_id (angegeben in `capacitorconfigjson`)
* channel (optional in `capacitorconfigjson`)
* release\_version (versionName aus AndroidManifestxml oder CFBundleShortVersionString aus Infoplist oder `capacitorconfigjson` wenn in [`CapacitorUpdaterversion`](/docs/plugin/settings/#version) gesetzt)
* version\_number (generiert als Teil von `npx @capgo/cli app update`)
* os\_version (z.B. ‘1121’)
* platform (z.B. ‘android’, notwendig um den richtigen Patch zu senden) Das wars. Der Code dafür ist in `updater/library/src/networkrs`
* device\_id (beim ersten Start auf dem Gerät generiert, wird verwendet um Geräte-spezifische Installationen zu deduplizieren und ermöglicht uns die Abrechnung basierend auf installierten Benutzern)monatlich aktive Nutzer), anstatt der Gesamtanzahl der Patches oder Patch-Installationen)
* custom\_id (optional, zur Laufzeit vom Entwickler festgelegt, um ein Gerät mit einem Benutzer in Ihrem System zu verknüpfen)
### Welche Plattformen unterstützt Capgo?[](https://capgo.app/docs/faq/#what-platforms-does-capgo-support "Direct link to What platforms does Capgo support?")
[Section titled “Welche Plattformen unterstützt Capgo?”](#welche-plattformen-unterstützt-capgo)
Derzeit unterstützt Capgo iOS und Android. Beide sind produktionsreif.
Die Nutzung von Capgo für iOS oder Android kann unabhängig voneinander entschieden werden. Sie können in Ihrem Kanal festlegen, ob Sie an Android oder eine in den App Store gebaute IPA ausliefern möchten oder umgekehrt.
Capgo kann (relativ einfach) für Desktop- oder Embedded-Ziele erweitert werden. Wenn diese für Sie wichtig sind, lassen Sie es uns bitte wissen.
### Wie interagiert Capgo mit Play Testing Tracks oder Apple TestFlight?[](https://capgo.app/docs/faq/#how-does-capgo-interact-with-play-testing-tracks-or-apple-testflight "Direct link to How does Capgo interact with Play Testing Tracks or Apple TestFlight?")
[Section titled “Wie interagiert Capgo mit Play Testing Tracks oder Apple TestFlight?”](#wie-interagiert-capgo-mit-play-testing-tracks-oder-apple-testflight)
Jeder App Store hat eigene Mechanismen zur Verteilung von Apps an begrenzte Benutzergruppen (z.B. “internes Testen”, “geschlossene Beta” usw.). Dies sind alles Mechanismen zur Segmentierung Ihrer Benutzer in Gruppen und zur Verteilung spezifischer App-Versionen.
Leider erlauben nicht alle diese Mechanismen Drittanbietern zu erkennen, wenn Apps in einem bestimmten Test Track oder über TestFlight installiert sind. Daher haben wir keine zuverlässige Einsicht in die Zusammensetzung dieser Gruppen und können den Zugriff auf Capgo-Patches nicht zuverlässig auf Basis dieser Gruppen steuern. [https://stackoverflow.com/questions/53291007/can-an-android-application-identify-the-test-track-within-google-play](https://stackoverflow.com/questions/53291007/can-an-android-application-identify-the-test-track-within-google-play/) [https://stackoverflow.com/questions/26081543/how-to-tell-at-runtime-whether-an-ios-app-is-running-through-a-testflight-beta-i](https://stackoverflow.com/questions/26081543/how-to-tell-at-runtime-whether-an-ios-app-is-running-through-a-testflight-beta-i/)
Wenn Sie die Verfügbarkeit von Capgo-Bundles segmentieren möchten, gibt es 4 mögliche Optionen:
1. Verwenden Sie separate Kanäle für jede Gruppe. Dies ist der einfachste Ansatz, erfordert aber die Verwaltung mehrerer Kanäle. Möglicherweise haben Sie bereits Dev-Kanäle und Prod-Kanäle mit unterschiedlicher Verfügbarkeit. Sie können also Ihre Dev-Kanäle aktualisieren, überprüfen und dann separat Ihre Prod-Kanäle aktualisieren. Wir empfehlen die Verwendung von Branches/Tags in Ihrer Versionskontrolle, um den Überblick über die Quellen der einzelnen Releases zu behalten.
2. Verfolgen Sie Ihre eigene Liste von Opt-in-Benutzern, deaktivieren Sie automatische Updates und lösen Sie Updates nur für bestimmte Benutzer über package:capgo\_code\_push aus. Dies funktioniert heute, erfordert aber die Verwaltung Ihrer eigenen Opt-in-Liste.
3. Capgo ermöglicht einen eigenen Opt-in-Mechanismus auf Geräteebene (ähnlich wie Test Tracks oder TestFlight, nur plattformunabhängig). Dies ermöglicht Ihrem QA-Team, sich für Bundles anzumelden, bevor sie der Öffentlichkeit zur Verfügung gestellt werden.
4. Capgo hat prozentbasierte Rollouts. Dies lässt Sie zwar nicht auswählen, an welche Geräte gesendet wird, kann aber helfen, inkrementell auszurollen und bei Problemen zurückzurollen.
## Abrechnung[](https://capgo.app/docs/faq/#billing "Direct link to Billing")
[Section titled “Abrechnung”](#abrechnung)
### Wie kann ich meinen Plan upgraden oder downgraden?[](https://capgo.app/docs/faq/#how-do-i-upgrade-or-downgrade-my-plan "Direct link to How do I upgrade or downgrade my plan?")
[Section titled “Wie kann ich meinen Plan upgraden oder downgraden?”](#wie-kann-ich-meinen-plan-upgraden-oder-downgraden)
Sie können Ihren Plan jederzeit in Ihrem Dashboard upgraden oder downgraden: [https://console.capgo.app/settings/organization/plans](https://console.capgo.app/settings/organization/plans/)
### Wann wird meine Abrechnungsperiode zurückgesetzt?[](https://capgo.app/docs/faq/#when-does-my-billing-period-reset "Direct link to When does my billing period reset?")
[Section titled “Wann wird meine Abrechnungsperiode zurückgesetzt?”](#wann-wird-meine-abrechnungsperiode-zurückgesetzt)
Abrechnungsperioden werden automatisch jeden Monat am Tag Ihrer ersten Capgo-Anmeldung zurückgesetzt. Wenn Sie sich zum Beispiel am 15. des Monats angemeldet haben, wird Ihre Abrechnungsperiode am 15. jedes Monats zurückgesetzt.
### Wie kann ich mein Abonnement kündigen?[](https://capgo.app/docs/faq/#how-do-i-cancel-my-subscription "Direct link to How do I cancel my subscription?")
[Section titled “Wie kann ich mein Abonnement kündigen?”](#wie-kann-ich-mein-abonnement-kündigen)
Sie können Ihr Abonnement jederzeit in Ihrem Dashboard kündigen: [https://console.capgo.app/settings/organization/plans](https://console.capgo.app/settings/organization/plans/)
### Kann ich für ein Jahr im Voraus bezahlen?[](https://capgo.app/docs/faq/#can-i-pay-for-a-year-in-advance "Direct link to Can I pay for a year in advance?")
[Section titled “Kann ich für ein Jahr im Voraus bezahlen?”](#kann-ich-für-ein-jahr-im-voraus-bezahlen)
Ja, Sie können jederzeit in Ihrem Dashboard für ein Jahr im Voraus bezahlen: [https://console.capgo.app/settings/organization/plans](https://console.capgo.app/settings/organization/plans/)
### Statistiken und Analysen[](https://capgo.app/docs/faq/#stats-and-analytics "Direct link to Stats and analytics")
[Section titled “Statistiken und Analysen”](#statistiken-und-analysen)
Die Statistiken in Ihrem Dashboard werden jeden Tag um Mitternacht UTC aktualisiert. Die Statistiken basieren auf der Anzahl der [MAU](https://capgo.app/docs/faq/#what-is-the-difference-between-a-bundle-and-a-release "Direct link to What is the difference between a bundle and a release?"), die auf Ihren Geräten installiert wurden.
# Wie wird die Geräte-ID generiert[](https://capgo.app/docs/faq/#how-device-id-is-generated "Direct link to How device ID is generated")
[Section titled “Wie wird die Geräte-ID generiert”](#wie-wird-die-geräte-id-generiert)
Die Geräte-ID wird beim ersten Start auf dem Gerät generiert und wird verwendet, um Installationen pro Gerät zu deduplizieren und uns zu ermöglichen, basierend auf installierten Benutzern (z.B. monatlich aktive Nutzer) abzurechnen, anstatt der Gesamtanzahl der Patches oder Patch-Installationen.
MAU ist eine bessere Lösung als die Anzahl der Installationen für die Preisgestaltung von Capgo, da es genauer ist und die tatsächlichen Kosten von Capgo pro Gerät widerspiegelt.
**Persistenz der Geräte-ID (Aktualisiert in v6.25.0 und v7.25.0)**:
* **Aktuelles Verhalten**: Die Geräte-ID bleibt nun über App-Neuinstallationen hinweg erhalten. Sie wird sicher im Keychain des Geräts (iOS) oder EncryptedSharedPreferences (Android) gespeichert, sodass wir dasselbe Gerät auch nach Deinstallation/Neuinstallation verfolgen können.
* **Vorheriges Verhalten** (vor v6.25.0/v7.25.0): Aus Datenschutzgründen im Zusammenhang mit Apple- und Google Store-Richtlinien wurde die Geräte-ID bei jeder App-Neuinstallation zurückgesetzt, was es unmöglich machte, dasselbe Gerät über Neuinstallationen hinweg zu verfolgen.
Die Datenschutzregeln werden von Apple und Google durchgesetzt, und die Implementierung von Capgo entspricht deren Bewährte Methoden für die Geräteidentifikation.
Geräte-IDs werden erst in Ihrer Geräteliste angezeigt, wenn sie ihren ersten Patch installiert haben.
# Warum unterscheidet sich meine Geräteanzahl von meinen MAU?[](https://capgo.app/docs/faq/#why-my-device-number-is-different-than-my-mau "Direct link to Why my device number is different than my MAU?")
[Section titled “Warum unterscheidet sich meine Geräteanzahl von meinen MAU?”](#warum-unterscheidet-sich-meine-geräteanzahl-von-meinen-mau)
Derzeit wird die Geräteliste nicht so häufig aktualisiert wie die MAU.
Die Geräteliste wird nur aktualisiert, wenn ein Gerät ein Update installiert.
Die MAU wird bei jedem App-Start aktualisiert. Dies ist eine aktuelle Einschränkung der Plattform. Unsere Analyseplattform unterstützt keine Raw-Updates, daher verwenden wir konventionelle Datenbanken für die Geräteliste.
Um die Anzahl der Datenbankabfragen zu begrenzen, aktualisieren wir Zeilen nur bei App-Updates.
Diese Einschränkung wird in Zukunft behoben.
# Wie kann ich verschiedene Updates pro Plattform haben?[](https://capgo.app/docs/faq/#how-to-have-different-update-by-platform "Direct link to How to have different update by platform?")
[Section titled “Wie kann ich verschiedene Updates pro Plattform haben?”](#wie-kann-ich-verschiedene-updates-pro-plattform-haben)
Sie können einen Kanal für jede Plattform erstellen und plattformspezifische Updates in jedem Kanal deaktivieren.
Im iOS-Kanal Android-Updates deaktivieren und im Android-Kanal iOS-Updates deaktivieren.
Dann laden Sie ein Bundle in jeden Kanal hoch, um verschiedene Updates für jede Plattform zu haben.
Wenn Sie dasselbe Update für beide Plattformen benötigen, können Sie ein Bundle mit mehreren Kanälen verknüpfen. Das Bundle muss nicht dupliziert werden.
# Tech Support für Capgo
> So erhalten Sie Tech Support für Capgo und unseren Updater. Bitte folgen Sie dieser Anleitung, um Hilfe zu erhalten, wenn die Dokumentation und unsere Artikel nicht ausreichen
## Support über Discord
[Section titled “Support über Discord”](#support-über-discord)
Capgo hat einen offiziellen [Discord Server](https://discord.capgo.app). Dort technischen Support zu erhalten ist wahrscheinlich einer der schnellsten Wege, eine Antwort zu bekommen.
Hier ist eine Kurzanleitung:
Schritt 1 - Gehe zum `questions` Kanal
Schritt 2 - Erstelle deinen Thread
Schritt 3 - Beschreibe dein Problem und wähle die relevanten Tags aus
Schritt 4 - Teile deine sichere Konto-ID (optional)
Dies ermöglicht es dem Capgo-Team, einen Blick auf dein Konto zu werfen. Das Teilen dieser ID ist sicher, da sie dafür entwickelt wurde, öffentlich geteilt zu werden.
Um dies zu teilen, gehe bitte zu den [Capgo-Einstellungen](https://console.capgo.app/dashboard/settings/account/). Klicke dort bitte auf `copy account id`.
Dies kopiert die sichere Konto-ID in die Zwischenablage. Bitte füge diese in deinen Discord-Beitrag ein.
## Support per E-Mail
[Section titled “Support per E-Mail”](#support-per-e-mail)
Dies ist der langsamste Weg, Support zu erhalten. Bitte nutze zuerst den Discord-Server.
Wenn du uns per E-Mail kontaktieren musst, sende bitte eine E-Mail an .
# App hinzufügen
> Fügen Sie eine App zu Ihrem Capgo-Konto hinzu und installieren Sie das Plugin in Ihrer App
## Voraussetzungen
[Section titled “Voraussetzungen”](#voraussetzungen)
Bevor Sie mit Capgo beginnen, stellen Sie sicher, dass Sie:
* Eine Capacitor-App installiert und konfiguriert haben. [Erfahren Sie, wie Sie Capacitor einrichten](https://capacitorjs.com/docs/getting-started/)
* Node.js 20 oder neuer installiert haben
* Eine der folgenden Entwicklungsumgebungen:
* **macOS** mit Xcode (für iOS-Entwicklung) und/oder Android Studio (für Android-Entwicklung)
* **Linux** mit Android Studio (für Android-Entwicklung)
* **Windows** mit Android Studio (für Android-Entwicklung)
## Einführung in Capgo
[Section titled “Einführung in Capgo”](#einführung-in-capgo)
[Play](https://youtube.com/watch?v=NzXXKoyhTIo)
## Live-Updates sind 3 Schritte entfernt
[Section titled “Live-Updates sind 3 Schritte entfernt”](#live-updates-sind-3-schritte-entfernt)
### Geführtes Setup
[Section titled “Geführtes Setup”](#geführtes-setup)
1. Erstellen Sie Ihr Konto unter . 
2. Verwenden Sie die Init-Befehle, um zu beginnen
```bash
npx @capgo/cli@latest init [APIKEY]
```
Es werden Ihnen eine Reihe von Fragen gestellt. Beantworten Sie diese, um das automatische Setup abzuschließen.
3. Stellen Sie ein Live-Update bereit
Tip
Wenn Sie diese Schritte befolgen, sind Sie in kürzester Zeit einsatzbereit. Falls Sie während des Prozesses weitere Unterstützung benötigen, ist unser Support-Team [hier um zu helfen](https://support.capgo.app). Viel Spaß beim Onboarding!
[Detaillierter Onboarding-Leitfaden ](/docs/getting-started/onboarding/)Sehen Sie den vollständigen Schritt-für-Schritt-Leitfaden für den CLI-Onboarding-Prozess
[Stellen Sie ein Live-Update bereit ](/docs/getting-started/deploy/)Erfahren Sie, wie Sie ein Live-Update für Ihre App bereitstellen
### Manuelles Setup
[Section titled “Manuelles Setup”](#manuelles-setup)
Falls der Init-Befehl für Sie nicht funktioniert, können Sie eine App manuell hinzufügen.
1. Verbinden Sie die CLI mit Ihrem Konto:
```bash
npx @capgo/cli@latest login [APIKEY]
```
2. Fügen Sie die App mit diesem Befehl zu Ihrem Konto hinzu:
```bash
npx @capgo/cli@latest app add [APP_NAME]
```
3. Installieren Sie das Plugin in Ihrer App:
```bash
npm i @capgo/capacitor-updater
```
4. Konfigurieren Sie das Plugin in Ihrer `capacitor.config`
```json
{
"plugins": {
CapacitorUpdater: {
"appId": "Your appID",
"autoUpdate": true,
"version": "1.0.0"
}
}
}
```
[Siehe alle verfügbaren Optionen](/docs/plugin/settings/). Diese Informationen werden abgeleitet, wenn sie nicht bereitgestellt werden.
5. Rufen Sie die Init-Methode so früh wie möglich in Ihrer App auf:
```typescript
import { CapacitorUpdater } from '@capgo/capacitor-updater';
CapacitorUpdater.notifyAppReady();
```
6. Stellen Sie ein Live-Update bereit
Installation für ältere Capacitor-Versionen
Der obige Befehl installiert die neueste Version (v8.x) für Capacitor 8. Für ältere Capacitor-Versionen verwenden Sie den entsprechenden npm-Tag:
```bash
# Capacitor 7
npm i @capgo/capacitor-updater@lts-v7
# Capacitor 6
npm i @capgo/capacitor-updater@lts-v6
# Capacitor 5
npm i @capgo/capacitor-updater@lts-v5
```
Jede Plugin-Hauptversion entspricht der Capacitor-Hauptversion (v8 → Capacitor 8, v7 → Capacitor 7, v6 → Capacitor 6, v5 → Capacitor 5). Minor-Versionen teilen denselben Funktionsumfang über alle Hauptversionen (z.B. 5.34.0, 6.34.0, 7.34.0 und 8.34.0 enthalten dieselben Funktionen).
# CI/CD-Integration
> Die Integration von Capgo in Ihre CI/CD-Pipeline ermöglicht es Ihnen, den Prozess des Erstellens und Bereitstellens von Updates für Ihre App vollständig zu automatisieren. Durch die Nutzung der Capgo CLI und semantic-release können Sie konsistente, zuverlässige Bereitstellungen sicherstellen und schnelle Iterationen ermöglichen.
Die Integration von Capgo in Ihre CI/CD-Pipeline ermöglicht es Ihnen, den Prozess des Erstellens und Bereitstellens von Updates für Ihre App vollständig zu automatisieren. Durch die Nutzung der Capgo CLI und semantic-release können Sie konsistente, zuverlässige Bereitstellungen sicherstellen und schnelle Iterationen ermöglichen.
## Vorteile der CI/CD-Integration
[Section titled “Vorteile der CI/CD-Integration”](#vorteile-der-cicd-integration)
* **Automatisierung**: Keine manuellen Schritte mehr oder Raum für menschliche Fehler. Ihr gesamter Build-, Test- und Bereitstellungsprozess kann von Anfang bis Ende automatisiert werden.
* **Konsistenz**: Jede Bereitstellung folgt den gleichen Schritten und gewährleistet einen vorhersehbaren und wiederholbaren Prozess. Dies ist besonders wertvoll, wenn mehrere Teammitglieder Code beisteuern.
* **Schnellere Iterationen**: Mit automatisierten Bereitstellungen können Sie Updates häufiger und mit Zuversicht ausliefern. Kein Warten mehr auf manuelle QA oder Freigabegenehmigungen.
## Capgo CLI
[Section titled “Capgo CLI”](#capgo-cli)
Die Capgo CLI ist der Schlüssel zur Integration von Capgo in Ihren CI/CD-Workflow. Sie bietet Befehle zum Pushen neuer Bundle-Versionen, Verwalten von Kanälen und mehr.
Der wichtigste Befehl für die CI/CD-Integration ist `bundle upload`:
```shell
npx @capgo/cli@latest bundle upload --channel Production --apikey YOUR_API_KEY
```
Wenn Sie Verschlüsselung verwenden, sollten Sie diese auf eine der folgenden Arten bereitstellen:
**Verwendung eines privaten Schlüsseldateipfads:**
```shell
npx @capgo/cli@latest bundle upload --channel Production --apikey YOUR_API_KEY --key-v2 PRIVATE_KEY_PATH
```
**Direktes Verwenden des privaten Schlüsselinhalts (empfohlen für CI/CD):**
```shell
npx @capgo/cli@latest bundle upload --channel Production --apikey YOUR_API_KEY --key-data-v2 PRIVATE_KEY_CONTENT
```
**Verwendung von Umgebungsvariablen (Best Practice für CI/CD):**
```shell
npx @capgo/cli@latest bundle upload --channel Production --apikey YOUR_API_KEY --key-data-v2 "$CAPGO_PRIVATE_KEY"
```
### Einrichten von Umgebungsvariablen für Verschlüsselung
[Section titled “Einrichten von Umgebungsvariablen für Verschlüsselung”](#einrichten-von-umgebungsvariablen-für-verschlüsselung)
Für CI/CD-Umgebungen wird empfohlen, Ihren privaten Schlüssel als Umgebungsvariable statt als Datei zu speichern. So richten Sie es ein:
1. **Holen Sie sich den Inhalt Ihres privaten Schlüssels:**
```shell
cat .capgo_key_v2 | pbcopy
```
Dies kopiert den Schlüsselinhalt in Ihre Zwischenablage.
2. **Fügen Sie ihn zu Ihrer CI/CD-Umgebung hinzu:**
* **GitHub Actions**: Fügen Sie `CAPGO_PRIVATE_KEY` zu Ihren Repository-Secrets hinzu
* **GitLab CI**: Fügen Sie ihn als maskierte Variable in Ihren Projekteinstellungen hinzu
* **CircleCI**: Fügen Sie ihn als Umgebungsvariable in Ihren Projekteinstellungen hinzu
* **Jenkins**: Fügen Sie ihn als Secret-Text-Credential hinzu
3. **Verwenden Sie ihn in Ihrer Pipeline:**
```yaml
- run: npx @capgo/cli@latest bundle upload --channel=production --apikey=${{ secrets.CAPGO_API_KEY }} --key-data-v2 "${{ secrets.CAPGO_PRIVATE_KEY }}"
```
**Hinweis**: Das `--key-data-v2` Flag ermöglicht es Ihnen, den Inhalt des privaten Schlüssels direkt als String zu übergeben, was perfekt für Umgebungsvariablen in CI/CD-Pipelines ist, wo Sie keine temporären Dateien erstellen möchten.
Dieser Befehl lädt den aktuellen Web-Build in den angegebenen Kanal hoch. Sie führen dies typischerweise als letzten Schritt in Ihrer CI/CD-Pipeline aus, nachdem Ihr Web-Build erfolgreich abgeschlossen wurde.
## Einrichtung von Capgo in Ihrer CI/CD-Pipeline
[Section titled “Einrichtung von Capgo in Ihrer CI/CD-Pipeline”](#einrichtung-von-capgo-in-ihrer-cicd-pipeline)
Während die genauen Schritte je nach gewähltem CI/CD-Tool variieren, sieht der allgemeine Prozess zur Integration von Capgo wie folgt aus:
1. **API-Schlüssel generieren**: Melden Sie sich beim Capgo-Dashboard an und erstellen Sie einen neuen API-Schlüssel. Dieser Schlüssel wird zur Authentifizierung der CLI in Ihrer CI/CD-Umgebung verwendet. Halten Sie ihn geheim und committen Sie ihn niemals in Ihr Repository!
2. **Konfigurieren Sie den `bundle upload` Befehl**: Fügen Sie Ihrer CI/CD-Konfiguration einen Schritt hinzu, der den `bundle upload` Befehl mit den entsprechenden Argumenten ausführt:
upload.yml
```yaml
- run: npx @capgo/cli@latest bundle upload --channel=production --apikey=${{ secrets.CAPGO_API_KEY }}
```
\n Ersetzen Sie `Production` mit dem Kanal, in den Sie deployen möchten, `${{ secrets.CAPGO_API_KEY }}` mit der Umgebungsvariable, die Ihren API-Schlüssel enthält, und fügen Sie `--key-data-v2 "${{ secrets.CAPGO_PRIVATE_KEY }}"` hinzu, wenn Sie Verschlüsselung verwenden.
3. **Fügen Sie den `upload` Schritt nach Ihrem Web-Build hinzu**: Stellen Sie sicher, dass der `upload` Schritt nach erfolgreichem Abschluss Ihres Web-Builds erfolgt. Dies stellt sicher, dass Sie immer Ihren neuesten Code bereitstellen.\n Hier ist ein Beispiel für die Konfiguration für GitHub Actions:\n
upload.yml
```yaml
name: Deploy to Capgo
on:
push:
branches: [main]
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6
- uses: actions/setup-node@v6
with:
node-version: '24'
- run: npm ci
- run: npm run build
- run: npm install -g @capgo/cli
- run: npx @capgo/cli@latest bundle upload --channel=production --apikey=${{ secrets.CAPGO_API_KEY }} --key-data-v2 "${{ secrets.CAPGO_PRIVATE_KEY }}"
```
## Versionsverwaltung mit Semantic-release
[Section titled “Versionsverwaltung mit Semantic-release”](#versionsverwaltung-mit-semantic-release)
Der empfohlene Weg zur Handhabung der Versionierung mit Capgo ist, die Version in Ihrer `capacitor.config.ts` Datei durch Import aus `package.json` zu setzen:
```ts
import pkg from './package.json'
const config: CapacitorConfig = {
// ... andere Konfigurationen
plugins: {
CapacitorUpdater: {
version: pkg.version,
}
}
}
```
Dieser Ansatz ermöglicht es Ihnen:
1. Semantic-release (oder ein anderes Tool) zu verwenden, um die `package.json` Version zu aktualisieren
2. Ihre App mit der automatisch enthaltenen aktualisierten Version zu bauen
3. Das Bundle mit der korrekten Version hochzuladen
Ihr CI/CD-Workflow würde so aussehen:
```yaml
- run: npm ci
- run: npx semantic-release # Aktualisiert package.json Version
- run: npm run build # Baut mit neuer Version aus capacitor.config
- run: npx @capgo/cli@latest bundle upload --channel=production --apikey=${{ secrets.CAPGO_API_KEY }}
```
Hier ist eine Beispiel-`.releaserc` Konfigurationsdatei für semantic-release:
```json
{
"branches": [
"main",
{
"name": "beta",
"prerelease": true
}
],
"plugins": [
"@semantic-release/commit-analyzer",
"@semantic-release/release-notes-generator",
"@semantic-release/changelog",
[
"@semantic-release/git",
{
"assets": ["CHANGELOG.md", "package.json"],
"message": "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
}
]
]
}
```
Diese Konfiguration führt Folgendes aus:
1. Analysiert Commit-Nachrichten, um die nächste Versionsnummer nach der Conventional Commits-Spezifikation zu bestimmen.
2. Generiert Release Notes basierend auf den Commits seit dem letzten Release.
3. Aktualisiert die `CHANGELOG.md` Datei mit den neuen Release Notes.
4. Aktualisiert die `package.json` Version, die von Ihrer capacitor.config übernommen wird.
5. Committet die aktualisierte `CHANGELOG.md`, `package.json` und alle anderen geänderten Dateien zurück ins Repository.
Stellen Sie sicher, dass Sie semantic-release vor dem Build Ihrer App ausführen, damit die aktualisierte Version aus `package.json` durch die capacitor.config in Ihren Build aufgenommen wird.
## Fehlerbehebung
[Section titled “Fehlerbehebung”](#fehlerbehebung)
Wenn Sie Probleme mit Ihrer Capgo CI/CD-Integration haben, hier einige Dinge, die Sie überprüfen sollten:
* **API-Schlüssel**: Stellen Sie sicher, dass Ihr API-Schlüssel gültig ist und die erforderlichen Berechtigungen hat. Wenn Sie eine Umgebungsvariable verwenden, überprüfen Sie, ob sie korrekt gesetzt ist.
* **CLI-Version**: Stellen Sie sicher, dass Sie die neueste Version der Capgo CLI verwenden. Ältere Versionen können Kompatibilitätsprobleme haben oder bestimmte Funktionen fehlen.
* **Build-Artefakte**: Bestätigen Sie, dass Ihr Web-Build die erwarteten Ausgabedateien generiert. Die Capgo CLI benötigt einen gültigen Web-Build, um ein Bundle zu erstellen.
* **Netzwerkverbindung**: Überprüfen Sie, ob Ihre CI/CD-Umgebung Netzwerkzugriff auf die Capgo-Server hat. Firewall- oder Proxy-Probleme können manchmal den `upload` Befehl stören.
Wenn Sie immer noch Probleme haben, wenden Sie sich an den Capgo-Support. Sie können bei der Fehlerbehebung für Ihre spezifische Einrichtung helfen.
## Fazit
[Section titled “Fazit”](#fazit)
Die Integration von Capgo in Ihre CI/CD-Pipeline mit ordnungsgemäßer Versionsverwaltung kann Ihren Entwicklungsworkflow erheblich vereinfachen. Durch die Automatisierung Ihrer Bereitstellungen und Versionierung durch den capacitor.config-Ansatz können Sie Updates schneller und mit mehr Zuversicht ausliefern.
Der empfohlene Ansatz, die Version in Ihrer `capacitor.config.ts` Datei zu setzen und semantic-release zur Aktualisierung von `package.json` zu verwenden, bietet einen robusten und zuverlässigen Bereitstellungsprozess, der es Ihnen ermöglicht, sich auf das Entwickeln großartiger Funktionen zu konzentrieren, anstatt sich über manuelle Release-Schritte Gedanken zu machen.
Weitere Details zu den Capgo CLI-Befehlen und Optionen finden Sie in der [CLI-Referenz](/docs/cli/overview). Und für einen tieferen Einblick in die semantic-release-Konfiguration, siehe die [semantic-release Dokumentation](https://github.com/semantic-release/semantic-release).
Viel Spaß beim Bereitstellen!
# Live-Update bereitstellen
> Erfahren Sie, wie Sie ein Live-Update für Ihre App mit der Live-Updates-Funktion von Capgo bereitstellen, die Echtzeit-UI- und Logik-Updates ohne erneute Einreichung im App Store ermöglicht.
Nutzen Sie die Live-Updates-Funktion von Capgo, um die Benutzeroberfläche und Geschäftslogik Ihrer App aus der Ferne in Echtzeit zu aktualisieren. Übertragen Sie JS-Bundle-Updates direkt an Ihre Nutzer, ohne den App Store zu durchlaufen, um sofort Fehler zu beheben und neue Funktionen bereitzustellen.
Diese Anleitung setzt voraus, dass Sie den [Capgo Quickstart](/docs/getting-started/quickstart) abgeschlossen haben und bereits:
1. Das `@capgo/capacitor-updater` SDK in Ihrer Capacitor-App installiert haben
2. Ihre App-ID und den Update-Kanal in `capacitor.config.ts` konfiguriert haben
3. Die `CapacitorUpdater.notifyAppReady()` Methode in Ihren Code eingefügt haben
Wenn Sie diese Schritte noch nicht ausgeführt haben, gehen Sie bitte zurück und schließen Sie zuerst den Quickstart ab.
[App hinzufügen ](/docs/getting-started/add-an-app/)Fügen Sie eine App zu Ihrem Capgo-Konto hinzu und installieren Sie das Plugin in Ihrer App
## Bundle hochladen
[Section titled “Bundle hochladen”](#bundle-hochladen)
Mit dem installierten und konfigurierten Capgo SDK können Sie Ihr erstes Live-Update-Bundle hochladen:
1. Web-Assets erstellen:
```shell
npm run build
```
2. Bundle zu Capgo hochladen:
* Console
```shell
npx @capgo/cli@latest bundle upload --channel=production
```
* Github Actions
.github/workflows/build\_and\_deploy.yml
```yml
name: Build source code and send to Capgo
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
on:
push:
branches:
- main
jobs:
deploy_to_capgo:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v6
- uses: actions/setup-node@v6
with:
node-version: '24'
- name: Install dependencies
run: npm install
- name: Build
run: npm run build
- name: Deploy to Capgo
run: npx @capgo/cli@latest bundle upload -a ${{ secrets.CAPGO_TOKEN }} --channel ${{ env.CHANNEL }}
env:
CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}
```
* Gitlab
.gitlab-ci.yml
```yml
stages:
- build
build:
stage: build
image: node:18
cache:
- key:
files:
- package-lock.json
paths:
- .node_modules/
script:
- npm install
- npm run build
- npx @capgo/cli@latest bundle upload -a $CAPGO_TOKEN --channel $CAPGO_CHANNEL
artifacts:
paths:
- node_modules/
- dist/
only:
- master
```
Dies lädt eine neue Bundle-Version in den im Befehl angegebenen Kanal hoch
### Fehlerbehebung beim Hochladen
[Section titled “Fehlerbehebung beim Hochladen”](#fehlerbehebung-beim-hochladen)
Wenn das Hochladen fehlschlägt, überprüfen Sie:
* Ihre App-ID in `capacitor.config.ts` stimmt mit Ihrer App im Capgo-Dashboard überein
* Sie führen den Upload-Befehl vom Root-Verzeichnis Ihres Capacitor-Projekts aus
* Ihre Web-Assets sind erstellt und aktuell
Wenn Sie immer noch Probleme haben, gehen Sie zum Abschnitt [Fehlerbehebung](/docs/getting-started/troubleshooting/)
## Update auf einem Gerät empfangen
[Section titled “Update auf einem Gerät empfangen”](#update-auf-einem-gerät-empfangen)
Sobald Ihr Bundle hochgeladen ist, können Sie das Live-Update auf einem Gerät testen:
1. Synchronisieren Sie Ihre App mit dem Gerät:
```shell
npx cap sync ios
```
2. Öffnen Sie ein weiteres Terminal und führen Sie den folgenden Befehl aus, um den Update-Status zu überprüfen:
```shell
npx @capgo/cli@latest app debug
```
3. Führen Sie Ihre App lokal aus:
```shell
npx cap run ios
```
Oder öffnen Sie das iOS/Android-Projekt in Xcode/Android Studio und führen Sie einen nativen Start durch
4. Lassen Sie die App etwa 30 Sekunden geöffnet, damit das Update im Hintergrund heruntergeladen werden kann
5. Die Logs brauchen einige Sekunden, um sich zu aktualisieren und den Update-Status anzuzeigen
6. Schließen und öffnen Sie die App erneut. Sie sollten Ihr Live-Update angewendet sehen!
Schauen Sie im [Capgo Quickstart](/docs/getting-started/quickstart#receiving-a-live-update-on-a-device) nach, um weitere Details zum Testen von Live-Updates zu erhalten
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
Herzlichen Glückwunsch zum Bereitstellen Ihres ersten Live-Updates mit Capgo! 🎉
Um mehr zu erfahren, lesen Sie den Rest der [Capgo Live-Updates-Dokumentation](/docs/live-updates). Einige wichtige Themen, die Sie als Nächstes überprüfen sollten:
* [Updates mit Kanälen zielgerichtet einsetzen](/docs/live-updates/channels)
* [Update-Verhalten anpassen](/docs/live-updates/update-behavior)
* [Live-Update-Rollbacks](/docs/live-updates/rollbacks)
# CLI Onboarding-Anleitung
> Vollständige Schritt-für-Schritt-Anleitung zum Onboarding Ihrer App mit Capgo über die interaktive CLI
## Schnellübersicht
[Section titled “Schnellübersicht”](#schnellübersicht)
Die Capgo CLI bietet ein interaktives Onboarding, das Live-Updates für Ihre Capacitor-App einrichtet. Sie werden:
1. ✅ Ihre App in Capgo registrieren
2. 🔌 Das Updater-Plugin installieren und konfigurieren
3. 🚀 Ihr erstes Live-Update bereitstellen
4. 📱 Das Update auf Ihrem Gerät testen
**Geschätzte Zeit:** 10-20 Minuten (variiert je nach Internetgeschwindigkeit und Build-Zeit)
Tip
Das Onboarding ist vollständig fortsetzbar - beenden Sie jederzeit und fahren Sie später fort, wo Sie aufgehört haben.
## Onboarding starten
[Section titled “Onboarding starten”](#onboarding-starten)
Führen Sie den Onboarding-Befehl mit Ihrem API-Schlüssel aus:
```bash
npx @capgo/cli@latest init [APIKEY]
```
Sie sehen die Willkommensnachricht:
```plaintext
Capgo onboarding 🛫
```
## Was während des Onboardings passiert
[Section titled “Was während des Onboardings passiert”](#was-während-des-onboardings-passiert)
Die CLI führt Sie durch 13 interaktive Schritte:
**Setup-Phase (Schritte 1-6):**
* Überprüfen Sie Ihre Entwicklungsumgebung (Xcode/Android Studio)
* Fügen Sie Ihre App zu Capgo hinzu und erstellen Sie einen Produktionskanal
* Installieren Sie das `@capgo/capacitor-updater` Plugin
* Fügen Sie den erforderlichen Code in Ihre App ein
* Optional: End-to-End-Verschlüsselung aktivieren
* Wählen Sie eine Plattform zum Testen (iOS oder Android)
**Testphase (Schritte 7-12):**
* Erstellen Sie Ihre App und führen Sie sie auf einem Gerät/Simulator aus
* Nehmen Sie eine sichtbare Codeänderung vor (automatisch oder manuell)
* Laden Sie das aktualisierte Bundle zu Capgo hoch
* Sehen Sie das Live-Update in Echtzeit auf Ihrem Gerät erscheinen
**Abschluss (Schritt 13):**
* Ihre App ist bereit für Live-Updates! 🎉
## Der 13-Schritte-Onboarding-Prozess
[Section titled “Der 13-Schritte-Onboarding-Prozess”](#der-13-schritte-onboarding-prozess)
### Schritt 1: Voraussetzungen prüfen
[Section titled “Schritt 1: Voraussetzungen prüfen”](#schritt-1-voraussetzungen-prüfen)
Die CLI überprüft Ihre Entwicklungsumgebung, um sicherzustellen, dass Sie die erforderlichen Tools installiert haben.
**Was wird überprüft:**
* **Xcode** (nur macOS) - für iOS-Entwicklung
* **Android SDK** - für Android-Entwicklung
**Mögliche Ergebnisse:**
✅ **Beide Umgebungen gefunden:**
```plaintext
✅ Xcode detected - iOS development ready
✅ Android SDK detected - Android development ready
```
⚠️ **Keine Umgebung gefunden:**
```plaintext
⚠️ Xcode not found
⚠️ Android SDK not found
❌ No development environment detected
📱 To develop mobile apps with Capacitor, you need:
• For iOS: Xcode (macOS only) - https://developer.apple.com/xcode/
• For Android: Android Studio - https://developer.android.com/studio
```
Caution
Wenn keine Entwicklungsumgebung erkannt wird, werden Sie gefragt, ob Sie fortfahren möchten. Es wird empfohlen, mindestens eine Plattform zu installieren, bevor Sie fortfahren.
### Schritt 2: Ihre App hinzufügen
[Section titled “Schritt 2: Ihre App hinzufügen”](#schritt-2-ihre-app-hinzufügen)
Die CLI meldet Sie bei Capgo an und fügt Ihre App zu Ihrem Konto hinzu.
```plaintext
(spinner) Running: npm @capgo/cli@latest login ***
Login Done ✅
❓ Add {appId} in Capgo?
```
**Wenn Ihre App-ID bereits vergeben ist:**
Die CLI schlägt Alternativen vor:
```plaintext
❌ App ID "com.example.app" is already taken
💡 Here are some suggestions:
1. com.example.app2
2. com.example.app3
3. com.example.app.new
4. com.example.app.app
❓ What would you like to do?
```
Sie können einen Vorschlag wählen oder eine benutzerdefinierte App-ID eingeben.
Note
App-IDs müssen der Reverse-Domain-Notation folgen (z.B. `com.example.myapp`)
### Schritt 3: Produktionskanal erstellen
[Section titled “Schritt 3: Produktionskanal erstellen”](#schritt-3-produktionskanal-erstellen)
Kanäle ermöglichen es Ihnen, verschiedene Update-Streams für Ihre App zu verwalten.
```plaintext
❓ Create default channel production for {appId} in Capgo?
```
Tip
**Keine Sorge!** Dies ist nur für lokale Tests während des Onboardings. Das Erstellen eines “Produktions”-Kanals bedeutet nicht, dass Ihre Updates sofort an Kunden gesendet werden. Sie haben die volle Kontrolle darüber, wann Updates bereitgestellt werden. Wählen Sie **Ja**, es sei denn, Sie haben spezifische Kanalanforderungen.
**Wenn Sie Ja wählen:**
```plaintext
(spinner) Running: npm @capgo/cli@latest channel add production {appId} --default
Channel add Done ✅ (or "Channel already added ✅")
```
Ein Produktionskanal wird erstellt und als Standard festgelegt. Dies ist die empfohlene Option für die meisten Benutzer.
**Wenn Sie Nein wählen:**
```plaintext
If you change your mind, run it for yourself with: "npm @capgo/cli@latest channel add production {appId} --default"
```
Sie müssen Kanäle später manuell erstellen und konfigurieren. Alternativ können Sie:
* Den Kanal in Ihrer `capacitor.config.ts` Datei festlegen
* Die JavaScript `setChannel()` Methode verwenden, um den Kanal dynamisch festzulegen
* Kanäle später über die Capgo-Webkonsole konfigurieren
### Schritt 4: Updater-Plugin installieren
[Section titled “Schritt 4: Updater-Plugin installieren”](#schritt-4-updater-plugin-installieren)
Die CLI installiert das `@capgo/capacitor-updater` Plugin, das mit Ihrer Capacitor-Version kompatibel ist.
```plaintext
❓ Automatic Install "@capgo/capacitor-updater" dependency in {appId}?
```
**Versionskompatibilität:**
* **Capacitor 5**: Installiert `@capgo/capacitor-updater` v5
* **Capacitor 6**: Installiert `@capgo/capacitor-updater` v6
* **Capacitor 7**: Installiert `@capgo/capacitor-updater` v7
* **Capacitor 8+**: Installiert die neueste Version
Caution
Capgo unterstützt nur Capacitor v5 und höher. Wenn Sie eine ältere Version verwenden, müssen Sie zuerst aktualisieren.
**Sofortige Updates-Option:**
Nach der Installation werden Sie gefragt:
```plaintext
❓ Do you want to set instant updates in {appId}?
Read more: https://capgo.app/docs/live-updates/update-behavior/#applying-updates-immediately
```
Tip
**Was sind sofortige Updates?** Mit aktivierten sofortigen Updates wendet Ihre App Updates sofort an, wenn sie in den Hintergrund verschoben und wieder geöffnet wird. Dies funktioniert nahtlos, da Capgo Updates weltweit in unter 300ms verteilen kann. Ohne diese Option (Standardmodus) werden Updates im Hintergrund heruntergeladen und beim nächsten App-Neustart angewendet. Sofortige Updates sind ideal für schnellere Iteration während der Entwicklung und kritische Fehlerbehebungen in der Produktion.
**Wenn Sie Ja wählen:**
* Updates werden so konfiguriert, dass sie sofort angewendet werden, wenn die App in den Hintergrund verschoben und wieder geöffnet wird
* `directUpdate: 'always'` und `autoSplashscreen: true` werden zu Ihrer Konfiguration hinzugefügt
* Ihre `capacitor.config.ts` wird automatisch aktualisiert
* **Delta-Updates** werden automatisch aktiviert - dies sendet nur die Dateien, die sich zwischen Updates geändert haben, anstelle des vollständigen Bundles, was Updates viel schneller macht
**Wenn Sie Nein wählen:**
* Updates verwenden das Standardverhalten (Download im Hintergrund, Anwendung beim nächsten Neustart)
* Sie können sofortige Updates später jederzeit aktivieren, indem Sie Ihre `capacitor.config.ts` ändern
### Schritt 5: Integrationscode hinzufügen
[Section titled “Schritt 5: Integrationscode hinzufügen”](#schritt-5-integrationscode-hinzufügen)
Die CLI fügt automatisch den erforderlichen Code in Ihre Hauptanwendungsdatei ein.
```plaintext
❓ Automatic Add "CapacitorUpdater.notifyAppReady()" code and import in {appId}?
```
**Was hinzugefügt wird:**
```typescript
import { CapacitorUpdater } from '@capgo/capacitor-updater'
CapacitorUpdater.notifyAppReady()
```
**Projekttypenerkennung:**
* **Nuxt.js**: Erstellt `plugins/capacitorUpdater.client.ts`
* **Andere Frameworks**: Fügt zu Ihrer Haupteingabedatei hinzu
Tip
**Wenn die automatische Injektion fehlschlägt**, können Sie den Code manuell zu Ihrer Hauptanwendungsdatei hinzufügen:
**Für Nuxt.js:** Erstellen Sie `plugins/capacitorUpdater.client.ts`:
```typescript
import { CapacitorUpdater } from '@capgo/capacitor-updater'
export default defineNuxtPlugin(() => {
CapacitorUpdater.notifyAppReady()
})
```
**Für andere Frameworks:** Fügen Sie zu Ihrer Haupteingabedatei hinzu (z.B. `main.ts`, `index.js`, `App.tsx`):
```typescript
import { CapacitorUpdater } from '@capgo/capacitor-updater'
CapacitorUpdater.notifyAppReady()
```
Platzieren Sie diesen Code nach Ihren Imports und vor Ihrer App-Initialisierung. Weitere Details finden Sie im [App hinzufügen Leitfaden](/docs/getting-started/add-an-app/).
### Schritt 6: Verschlüsselung einrichten (Optional)
[Section titled “Schritt 6: Verschlüsselung einrichten (Optional)”](#schritt-6-verschlüsselung-einrichten-optional)
End-to-End-Verschlüsselung fügt eine zusätzliche Sicherheitsebene für Ihre Updates hinzu.
```plaintext
🔐 End-to-end encryption
✅ Use this for: Banking, healthcare, or apps with legal encryption requirements
⚠️ Note: Makes debugging harder - skip if you don't need it
❓ Enable end-to-end encryption for {appId} updates?
```
Note
Verschlüsselung ist nur für Capacitor v6 und höher verfügbar.
Wenn Sie Verschlüsselung aktivieren, wird die CLI:
1. Verschlüsselungsschlüssel generieren
2. Anbieten, Ihre Capacitor-Konfiguration zu synchronisieren
### Schritt 7: Plattform auswählen
[Section titled “Schritt 7: Plattform auswählen”](#schritt-7-plattform-auswählen)
Wählen Sie aus, mit welcher Plattform Sie während des Onboardings testen möchten.
```plaintext
📱 Platform selection for onboarding
This is just for testing during onboarding - your app will work on all platforms
❓ Which platform do you want to test with during this onboarding?
Options:
- iOS
- Android
```
Tip
Dies betrifft nur den Onboarding-Prozess. Ihre endgültige App unterstützt alle Plattformen.
### Schritt 8: Ihr Projekt erstellen
[Section titled “Schritt 8: Ihr Projekt erstellen”](#schritt-8-ihr-projekt-erstellen)
Die CLI erstellt Ihre App und synchronisiert sie mit Capacitor.
```plaintext
❓ Automatic build {appId} with "npm run build"?
```
**Was passiert:**
1. Erkennt Ihren Projekttyp
2. Führt Ihr Build-Skript aus
3. Führt `npx cap sync {platform}` aus
**Wenn das Build-Skript fehlt:**
Sie werden gefragt, ob Sie den Build überspringen oder ein Build-Skript zu Ihrer `package.json` hinzufügen möchten.
### Schritt 9: Auf Gerät ausführen
[Section titled “Schritt 9: Auf Gerät ausführen”](#schritt-9-auf-gerät-ausführen)
Testen Sie die Anfangsversion Ihrer App auf einem Gerät oder Simulator.
```plaintext
❓ Run {appId} on {PLATFORM} device now to test the initial version?
```
Wenn Sie **Ja** wählen:
```plaintext
(spinner) Running: npx cap run {platform}
(device picker appears)
App started ✅
📱 Your app should now be running on your {platform} device with Capgo integrated
🔄 This is your baseline version - we'll create an update next
```
### Schritt 10: Teständerung vornehmen
[Section titled “Schritt 10: Teständerung vornehmen”](#schritt-10-teständerung-vornehmen)
Jetzt ist es Zeit, das Update-System von Capgo zu testen, indem Sie eine sichtbare Änderung vornehmen.
```plaintext
🎯 Now let's test Capgo by making a visible change and deploying an update!
❓ How would you like to test the update?
Options:
- Auto: Let Capgo CLI make a visible change for you
- Manual: I'll make changes myself
```
**Auto-Modus:** Die CLI ändert automatisch Ihre Dateien, um ein sichtbares Test-Banner oder eine Änderung hinzuzufügen.
**Manueller Modus:** Sie nehmen Ihre eigenen Änderungen vor (z.B. Text ändern, Farben oder Elemente hinzufügen).
**Versionsverwaltung:**
```plaintext
❓ How do you want to handle the version for this update?
Options:
- Auto: Bump patch version ({currentVersion} → {nextVersion})
- Manual: I'll provide the version number
```
**Mit Änderungen erstellen:**
```plaintext
❓ Build {appId} with changes before uploading?
```
Tip
Wenn Sie manuell in einem anderen Terminal erstellen müssen, wählen Sie “Nein” und erstellen Sie selbst, dann fahren Sie fort.
### Schritt 11: Bundle hochladen
[Section titled “Schritt 11: Bundle hochladen”](#schritt-11-bundle-hochladen)
Laden Sie Ihr aktualisiertes App-Bundle zu Capgo hoch.
```plaintext
❓ Upload the updated {appId} bundle (v{version}) to Capgo?
```
Die CLI führt aus:
```bash
npx @capgo/cli@latest bundle upload
```
Tip
**Delta-Updates mit Direct Update:** Wenn Sie sofortige Updates (Direct Update) in Schritt 4 aktiviert haben, fragt die CLI automatisch, ob Sie Delta-Updates aktivieren möchten. Delta-Updates senden nur die Dateien, die sich zwischen Versionen geändert haben, anstelle des gesamten Bundles. Da sich normalerweise nur wenige Dateien zwischen Updates ändern, macht dies Downloads viel schneller. Wählen Sie **Ja** für die beste Erfahrung mit sofortigen Updates.
**Delta-Updates-Eingabeaufforderung (wenn Direct Update aktiviert ist):**
```plaintext
💡 Direct Update (instant updates) is enabled in your config
Delta updates send only changed files instead of the full bundle
❓ Enable delta updates for this upload? (Recommended with Direct Update)
```
Caution
Für Monorepos müssen Sie möglicherweise zusätzliche Pfade zu Ihrer `package.json` und `node_modules` angeben.
**Erfolg:**
```plaintext
✅ Update v{version} uploaded successfully!
🎉 Your updated bundle is now available on Capgo
```
### Schritt 12: Update auf Gerät testen
[Section titled “Schritt 12: Update auf Gerät testen”](#schritt-12-update-auf-gerät-testen)
Zeit, das Update in Aktion zu sehen!
```plaintext
🧪 Time to test the Capgo update system!
📱 Go to your device where the app is running
```
**Für sofortige Updates:**
```plaintext
🔄 IMPORTANT: Background your app (swipe up/press home button) and then reopen it
⏱️ The update should be downloaded and applied automatically
```
**Für Standard-Updates:**
```plaintext
📱 With standard updates, you will need to:
1. Background the app (swipe up/press home button) to start download
2. Wait a few seconds for download to complete
3. Background and foreground again to see the update
```
**Protokolle überwachen:**
```plaintext
❓ Monitor Capgo logs to verify the update worked?
```
Wenn Sie **Ja** wählen, sehen Sie Live-Protokolle von Ihrem Gerät, die den Update-Prozess zeigen.
### Schritt 13: Abschluss
[Section titled “Schritt 13: Abschluss”](#schritt-13-abschluss)
```plaintext
Welcome onboard ✈️!
```
Herzlichen Glückwunsch! Sie haben erfolgreich Capgo Live-Updates für Ihre App eingerichtet.
## Was Sie erreicht haben
[Section titled “Was Sie erreicht haben”](#was-sie-erreicht-haben)
Nach Abschluss des Onboardings haben Sie:
✅ App registriert
Ihre App ist in Capgo mit einem Produktionskanal registriert
✅ Plugin installiert
Das Capacitor Updater Plugin ist installiert und konfiguriert
✅ Code integriert
Integrationscode ist zu Ihrer App hinzugefügt
✅ Update getestet
Sie haben erfolgreich ein Live-Update bereitgestellt und empfangen
## Täglicher Workflow
[Section titled “Täglicher Workflow”](#täglicher-workflow)
Für spätere Updates verwenden Sie:
```bash
npm run build
npx @capgo/cli@latest bundle upload --channel=production
```
Weitere Bereitstellungsoptionen finden Sie unter [Live-Update bereitstellen](/docs/getting-started/deploy/).
## Onboarding fortsetzen
[Section titled “Onboarding fortsetzen”](#onboarding-fortsetzen)
Wenn Sie den Onboarding-Prozess beenden, können Sie jederzeit fortfahren:
```bash
npx @capgo/cli@latest init [APIKEY]
```
Sie sehen:
```plaintext
You have already got to the step {stepNumber}/13 in the previous session
❓ Would you like to continue from where you left off?
```
Tip
Der Fortschritt wird lokal gespeichert, sodass Sie den Onboarding-Prozess sicher beenden und fortsetzen können.
## Fehlerbehebung
[Section titled “Fehlerbehebung”](#fehlerbehebung)
### Keine Entwicklungsumgebung
[Section titled “Keine Entwicklungsumgebung”](#keine-entwicklungsumgebung)
**Problem:** Weder Xcode noch Android SDK wird erkannt.
**Lösung:**
* **Für iOS**: Installieren Sie [Xcode](https://developer.apple.com/xcode/) (nur macOS)
* **Für Android**: Installieren Sie [Android Studio](https://developer.android.com/studio)
### App-ID bereits vergeben
[Section titled “App-ID bereits vergeben”](#app-id-bereits-vergeben)
**Problem:** Ihre App-ID ist bereits registriert.
**Lösung:** Wählen Sie eine der vorgeschlagenen Alternativen oder geben Sie eine benutzerdefinierte App-ID in Reverse-Domain-Notation ein.
### Build-Skript fehlt
[Section titled “Build-Skript fehlt”](#build-skript-fehlt)
**Problem:** Kein Build-Skript in `package.json` gefunden.
**Lösung:** Fügen Sie ein Build-Skript zu Ihrer `package.json` hinzu:
```json
{
"scripts": {
"build": "your-build-command"
}
}
```
### Auto-Injektion fehlgeschlagen
[Section titled “Auto-Injektion fehlgeschlagen”](#auto-injektion-fehlgeschlagen)
**Problem:** Die CLI kann den Integrationscode nicht automatisch einfügen.
**Lösung:** Fügen Sie den Code manuell zu Ihrer Hauptdatei hinzu:
```typescript
import { CapacitorUpdater } from '@capgo/capacitor-updater'
CapacitorUpdater.notifyAppReady()
```
### Capacitor-Version zu alt
[Section titled “Capacitor-Version zu alt”](#capacitor-version-zu-alt)
**Problem:** Ihre Capacitor-Version ist unter v5.
**Lösung:** Aktualisieren Sie Capacitor auf v5 oder höher:
* [Upgrade auf Capacitor 5](https://capacitorjs.com/docs/updating/5-0)
* [Upgrade auf Capacitor 6](https://capacitorjs.com/docs/updating/6-0)
* [Upgrade auf Capacitor 7](https://capacitorjs.com/docs/updating/7-0)
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
Nachdem Sie das Onboarding abgeschlossen haben, erkunden Sie diese Themen:
[ Updates bereitstellen](/docs/getting-started/deploy/)
[Erfahren Sie, wie Sie Updates vom Capgo-Dashboard bereitstellen](/docs/getting-started/deploy/)
[ Update-Typen](/docs/live-updates/update-types/)
[Referenz aller OTA-Update-Typen: Anwendungszeitpunkt, Verzögerungsbedingungen, Versionsblockierung und Bereitstellung](/docs/live-updates/update-types/)
[ CI/CD-Integration](/docs/getting-started/cicd-integration/)
[Automatisieren Sie Ihre Update-Bereitstellungen mit CI/CD](/docs/getting-started/cicd-integration/)
[ Kanäle](/docs/live-updates/channels/)
[Verwalten Sie mehrere Update-Streams mit Kanälen](/docs/live-updates/channels/)
[ Verschlüsselung](/docs/live-updates/encryption/)
[Sichern Sie Ihre Updates mit End-to-End-Verschlüsselung](/docs/live-updates/encryption/)
[ Update-Verhalten](/docs/live-updates/update-behavior/)
[Passen Sie an, wann und wie Updates angewendet werden (direct, delta, etc.)](/docs/live-updates/update-behavior/)
## Hilfe erhalten
[Section titled “Hilfe erhalten”](#hilfe-erhalten)
Wenn Sie während des Onboardings auf Probleme stoßen:
* Überprüfen Sie den [Fehlerbehebungsleitfaden](/docs/getting-started/troubleshooting/)
* Treten Sie der [Discord-Community](https://discord.capgo.app) bei
* Überprüfen Sie die [FAQ](/docs/faq/)
* Kontaktieren Sie den [Support](/docs/getting-help/)
# Überblick
> Erste Schritte mit Capgo durch Erlernen der wichtigsten Konzepte und Schritte zur Integration und Bereitstellung von Live-Updates für Ihre App.
Das Quickstart-Tutorial führt Sie durch die wichtigsten Konzepte von Capgo! Zu den behandelten Konzepten gehören:
1. Hinzufügen einer App zu Ihrem Capgo-Konto
2. Integration von Capgo in Ihre CI/CD
3. Auslösen des Bundle-Uploads auf Capgo durch Pushen von Commits
4. Konfiguration und Anpassung der Capgo Bundle-Veröffentlichung
5. Einrichten Ihrer App für Live-Updates über Capgo
6. Bereitstellung von Live-Updates für Ihre App von Capgo aus
Folgen Sie einfach der Anleitung Schritt für Schritt oder navigieren Sie direkt zur Dokumentation der Komponente, die Sie interessiert.
[ Tutorial starten](/docs/getting-started/add-an-app/)
[Folgen Sie dem Quickstart-Tutorial und nutzen Sie Capgo in kürzester Zeit!](/docs/getting-started/add-an-app/)
[ CLI Onboarding-Leitfaden](/docs/getting-started/onboarding/)
[Vollständiger Schritt-für-Schritt-Leitfaden für den interaktiven CLI-Onboarding-Prozess.](/docs/getting-started/onboarding/)
[ Updates ausliefern](/docs/getting-started/deploy/)
[Liefern Sie Updates für Ihre App über das Capgo-Dashboard aus.](/docs/getting-started/deploy/)
[ Updates automatisieren](/docs/getting-started/cicd-integration/)
[Integrieren Sie Capgo in Ihre CI/CD und lösen Sie Bundle-Uploads auf Capgo durch Pushen von Commits aus.](/docs/getting-started/cicd-integration/)
[ Fehlerbehebung](/docs/getting-started/troubleshooting/)
[Häufige Probleme und deren Lösungen.](/docs/getting-started/troubleshooting/)
[ Zusammenfassung](/docs/getting-started/wrapping-up/)
[Schließen Sie das Tutorial ab und erhalten Sie einen schnellen Überblick über das Gelernte.](/docs/getting-started/wrapping-up/)
Tip
Die Over-the-Air (OTA) Update-Funktion gilt nur für Änderungen an HTML-, CSS- und JavaScript-Dateien.
Wenn Sie Änderungen am nativen Code vornehmen, wie z.B. Updates von Capacitor-Plugins, müssen Sie die Anwendung erneut zur Genehmigung im App Store einreichen.
## Discord Community beitreten
[Section titled “Discord Community beitreten”](#discord-community-beitreten)
[Treten Sie dem Capgo Discord Server bei!](https://discord.capgo.app)
## Wartung
[Section titled “Wartung”](#wartung)
| Plugin-Version | Capacitor-Kompatibilität | Gewartet |
| ------------------ | ------------------------ | ---------------------------------------------------------------------- |
| v7.\*.\* (≥7.25.0) | v7.\*.\* | ✅ Vollständig unterstützt |
| v6.\*.\* (≥6.25.0) | v6.\*.\* | ✅ Vollständig unterstützt |
| v5.\*.\* (≥5.10.0) | v5.\*.\* | ✅ Vollständig unterstützt |
| v5.\*.\* (<5.10.0) | v5.\*.\* | ⚠️ Veraltet |
| v4.\*.\* | v4.\*.\* | ❌ Nicht mehr unterstützt |
| v3.\*.\* | v3.\*.\* | ❌ Nicht mehr unterstützt |
| >= 8 | v4.\*.\* | ⚠️ Veraltet aufgrund von Versionierungsproblemen in unserem CI-Prozess |
## Einhaltung der Store-Richtlinien
[Section titled “Einhaltung der Store-Richtlinien”](#einhaltung-der-store-richtlinien)
Der Android Google Play und der iOS App Store haben entsprechende Richtlinien mit Regeln, die Sie kennen sollten, bevor Sie die Capacitor-updater-Lösung in Ihre Anwendung integrieren
### Google Play
[Section titled “Google Play”](#google-play)
Der dritte Absatz zum Thema [Geräte- und Netzwerkmissbrauch](https://supportgooglecom/googleplay/android-developer/answer/9888379/?hl=en) beschreibt, dass die Aktualisierung von Quellcode durch andere Methoden als den Update-Mechanismus von Google Play eingeschränkt ist. Diese Einschränkung gilt jedoch nicht für die Aktualisierung von JavaScript-Bundles
> Diese Einschränkung gilt nicht für Code, der in einer virtuellen Maschine ausgeführt wird und eingeschränkten Zugriff auf Android-APIs hat (wie JavaScript in einer Webview oder einem Browser)
Das erlaubt Capacitor-updater vollständig, da es nur die JS-Bundles aktualisiert und keinen nativen Code ändert
### App Store
[Section titled “App Store”](#app-store)
Absatz **332** des [Apple Developer Program License Agreement](https://developer.apple.com/programs/ios/information/) erlaubt seit 2015 vollständig Over-the-Air-Updates von JavaScript und Assets - und in der neuesten Version (20170605) [hier herunterladbar](https://developer.apple.com/terms/) ist diese Regelung sogar noch umfassender:
> Interpretierter Code kann in eine Anwendung heruntergeladen werden, solange dieser Code: (a) den primären Zweck der Anwendung nicht durch Funktionen oder Funktionalitäten ändert, die mit dem beabsichtigten und beworbenen Zweck der Anwendung, wie sie im App Store eingereicht wurde, nicht übereinstimmen, (b) keinen Store oder Storefront für anderen Code oder Anwendungen erstellt, und (c) keine Signierung, Sandbox oder andere Sicherheitsfunktionen des Betriebssystems umgeht
Capacitor-updater ermöglicht es Ihnen, diese Regeln vollständig einzuhalten, solange das Update, das Sie pushen, nicht wesentlich von der ursprünglichen, vom App Store genehmigten Absicht Ihres Produkts abweicht
Um weiterhin die Apple-Richtlinien einzuhalten, empfehlen wir, dass im App Store vertriebene Apps das Szenario ‘Erzwungenes Update’ nicht aktivieren, da in den [App Store Review Guidelines](https://developer.apple.com/app-store/review/guidelines/) steht:
> Apps dürfen Benutzer nicht zwingen, die App zu bewerten, die App zu überprüfen, andere Apps herunterzuladen oder ähnliche Aktionen durchzuführen, um auf Funktionen, Inhalte oder die Nutzung der App zugreifen zu können
Dies ist kein Problem für das Standardverhalten des Hintergrund-Updates, da es den Benutzer nicht zwingt, die neue Version anzuwenden, bis er die App das nächste Mal schließt, aber Sie sollten sich dieser Rolle bewusst sein, wenn Sie sich entscheiden, sie anzuzeigen
## Open Source
[Section titled “Open Source”](#open-source)
Das Plugin steht unter der LGPL-3.0 Lizenz und das Backend unter der AGPL-3.0 Lizenz
> 💡 LGPL-3.0 bedeutet, wenn jemand den Code des Plugins modifiziert, ist es verpflichtend, ihn als Open Source mit der gleichen Lizenzierung zu veröffentlichen. Wenn Sie den Code ohne Modifikation verwenden, betrifft Sie das nicht. Weitere Details finden Sie im Issue unten, siehe Link 👇
[Lizenzierung? ](https://github.com/Cap-go/capacitor-updater/issues/7)
[Probieren Sie GPTS Capgo aus, um Hilfe zu erhalten, anstatt die Dokumentation zu lesen ](https://chatopenaicom/g/g-3dMwHbF2w-capgo-doc-gpt)
> Sie können es ohne Bedenken in Ihre App einbinden
## Abschließende Bemerkungen
[Section titled “Abschließende Bemerkungen”](#abschließende-bemerkungen)
Wenn Sie selbst hosten und dieses Tool nützlich finden, erwägen Sie bitte, meine Arbeit zu unterstützen, indem Sie [GitHub Sponsor](https://github.com/sponsors/riderx/) werden
Ich habe mich entschieden, den gesamten Code, den ich hier entwickelt habe, als Open Source zur Verfügung zu stellen, anstatt ihn hinter einer Bezahlschranke zu verstecken. Ich glaube, dass wir durch Öffnung statt Kampf und Verstecken die Welt zu einem besseren Ort machen können
Um dies zu ermöglichen, müssen wir alle unseren Teil beitragen, auch Sie 🥹 Wenn Capgo Cloud Ihre Bedürfnisse nicht erfüllt, können Sie einen bootstrapped Maker [hier](https://github.com/sponsors/riderx/) zu Ihren eigenen Bedingungen unterstützen
## Einfache Rechnung
[Section titled “Einfache Rechnung”](#einfache-rechnung)
Der Preis des Basic-Plans: 14€\*12 = 168€ pro Jahr Während durchschnittliche Entwicklerkosten/Stunde = 60€ Das bedeutet, dass 3 verschwendete Entwicklerstunden beim Self-Hosting es Ihnen ermöglichen, ein ganzes Jahr zu bezahlen. Wenn Sie mehr als 3 Stunden aufwenden, verlieren Sie Geld ^^
# Fehlerbehebung
> Lösen Sie häufige Probleme bei der Verwendung von Capgo mit detaillierten Fehlerbehebungsschritten und erweiterten Optionen für Upload und Debugging.
Hier sind einige häufige Probleme, auf die Sie bei der Verwendung von Capgo stoßen könnten, und wie Sie diese lösen können
🚀 Benötigen Sie Experten-Hilfe?
Stecken Sie bei einem komplexen Problem fest? Unser Expertenteam ist hier, um zu helfen! Erhalten Sie persönlichen Support, Code-Reviews und maßgeschneiderte Lösungen für Ihre spezifischen Bedürfnisse.
[Professionellen Support erhalten](/consulting/)
### Upload-Fehler
[Section titled “Upload-Fehler”](#upload-fehler)
Wenn Ihr Bundle-Upload fehlschlägt, überprüfen Sie:
* Ihre App-ID in `capacitor.config.ts` stimmt mit Ihrer App im Capgo-Dashboard überein
* Sie führen den Upload-Befehl vom Root-Verzeichnis Ihres Capacitor-Projekts aus
* Ihre Web-Assets sind gebaut und aktuell
#### Erweiterte Upload-Optionen
[Section titled “Erweiterte Upload-Optionen”](#erweiterte-upload-optionen)
Die Capgo CLI bietet einige zusätzliche Flags zur Lösung häufiger Upload-Probleme:
* `--tus`: Verwendet das [tus resumable upload protocol](https://tusio/) für zuverlässigere Uploads von großen Bundles oder bei schlechten Netzwerkverbindungen. Wenn Ihr Bundle über 10MB groß ist oder Sie eine instabile Verbindung haben, erwägen Sie die Verwendung von `--tus`:
```shell
npx @capgo/cli@latest bundle upload --tus
```
* `--package-json` und `--node-modules`: Teilt Capgo mit, wo Ihre root `package.json` und `node_modules` zu finden sind, wenn Ihre App eine nicht-standardmäßige Struktur wie ein Monorepo oder npm Workspace verwendet. Übergeben Sie den Pfad zur root `package.json` und den `--node_modules` Pfad:
```shell
npx @capgo/cli@latest bundle upload --package-json=path/to/package.json --node_modules=path/to/node_modules
```
Capgo benötigt diese Informationen, um die Abhängigkeiten Ihrer App korrekt zu bündeln.
Sie können diese Flags mit anderen Optionen wie `--channel` nach Bedarf kombinieren. Siehe die [Capgo CLI Dokumentation](/docs/cli/overview/) für vollständige Details zu den verfügbaren Upload-Optionen.
Wenn Sie immer noch Probleme mit Uploads haben, wenden Sie sich an den [Capgo Support](https://support.capgo.app) für weitere Unterstützung.
### Updates debuggen
[Section titled “Updates debuggen”](#updates-debuggen)
Wenn Sie Probleme mit Live-Updates haben, ist der Capgo Debug-Befehl ein hilfreiches Tool zur Fehlerbehebung. So verwenden Sie es:
1. Führen Sie den folgenden Befehl in Ihrem Projektverzeichnis aus:
```shell
npx @capgo/cli@latest app debug
```
2. Starten Sie Ihre App auf einem Gerät oder Emulator und führen Sie die Aktion aus, die ein Update auslösen sollte (z.B. die App nach dem Hochladen eines neuen Bundles neu öffnen)
3. Beobachten Sie die Ausgabe des Debug-Befehls. Er protokolliert Informationen über den Update-Prozess, einschließlich:
* Wann die App nach einem Update sucht
* Ob ein Update gefunden wurde und welche Version es ist
* Download- und Installationsfortschritt für das Update
* Alle Fehler, die während des Update-Prozesses auftreten
4. Verwenden Sie die Debug-Logs, um zu identifizieren, wo das Problem auftritt. Zum Beispiel:
* Wenn kein Update gefunden wird, überprüfen Sie, ob Ihr Bundle erfolgreich hochgeladen wurde und die App für den richtigen Kanal konfiguriert ist
* Wenn das Update heruntergeladen, aber nicht installiert wird, stellen Sie sicher, dass Sie `CapacitorUpdater.notifyAppReady()` aufgerufen haben und die App vollständig geschlossen und neu geöffnet wurde
* Wenn Sie eine Fehlermeldung sehen, suchen Sie nach diesem spezifischen Fehler in der Capgo-Dokumentation oder wenden Sie sich an den Support
Der Debug-Befehl ist besonders nützlich, um Probleme mit dem Update-Download und Installationsprozess zu identifizieren. Wenn die Logs zeigen, dass die erwartete Update-Version gefunden, aber nicht letztendlich angewendet wurde, konzentrieren Sie Ihre Fehlerbehebung auf die Schritte nach dem Download.
### Debugging mit nativen Logs
[Section titled “Debugging mit nativen Logs”](#debugging-mit-nativen-logs)
Zusätzlich zum Capgo Debug-Befehl können die nativen Logs auf Android und iOS wertvolle Fehlerbehebungsinformationen liefern, besonders für Probleme auf der nativen Seite des Update-Prozesses.
#### Android Logs
[Section titled “Android Logs”](#android-logs)
So greifen Sie auf die Android-Logs zu:
1. Verbinden Sie Ihr Gerät oder starten Sie Ihren Emulator
2. Öffnen Sie Android Studio und wählen Sie “View > Tool Windows > Logcat”
3. Im Logcat-Fenster filtern Sie die Logs auf den Prozess Ihrer App, indem Sie ihn aus dem Dropdown-Menü oben auswählen
4. Suchen Sie nach Zeilen, die `Capgo` enthalten, um die SDK-Logs zu finden
Alternativ können Sie den `adb logcat` Befehl verwenden und nach `Capgo` grep’en, um die Logs zu filtern.
Das Capgo SDK protokolliert wichtige Ereignisse während des Update-Prozesses, wie zum Beispiel:
* Wann eine Update-Prüfung initiiert wird
* Ob ein Update gefunden wurde und welche Version es ist
* Wann der Update-Download startet und abgeschlossen ist
* Wann die Update-Installation ausgelöst wird
* Alle Fehler, die während der nativen Update-Schritte auftreten
Häufige Android-spezifische Probleme, die Sie in den Logs sehen könnten, sind:
* Netzwerkverbindungsprobleme, die den Update-Download verhindern
* Dateiberechtigungsfehler beim Speichern oder Lesen des Update-Bundles
* Nicht genügend Speicherplatz für das Update-Bundle
* Fehler beim Neustart der App nach der Update-Installation
#### iOS Logs
[Section titled “iOS Logs”](#ios-logs)
So greifen Sie auf die iOS-Logs zu:
1. Verbinden Sie Ihr Gerät oder starten Sie Ihren Simulator
2. Öffnen Sie Xcode und gehen Sie zu “Window > Devices and Simulators”
3. Wählen Sie Ihr Gerät und klicken Sie auf “Open Console”
4. Suchen Sie in der Konsolenausgabe nach Zeilen, die `Capgo` enthalten, um die SDK-Logs zu finden
Sie können auch den `log stream` Befehl im Terminal verwenden und nach `Capgo` grep’en, um die Logs zu filtern.
Ähnlich wie bei Android protokolliert das Capgo SDK wichtige iOS-seitige Ereignisse:
* Update-Prüfung Initiierung und Ergebnis
* Download-Start, Fortschritt und Abschluss
* Installations-Trigger und Ergebnis
* Alle Fehler während des nativen Update-Prozesses
iOS-spezifische Probleme, die Sie in den Logs identifizieren könnten, sind:
* SSL-Zertifikatsprobleme beim Herunterladen des Updates
* App Transport Security blockiert den Update-Download
* Unzureichender Speicherplatz für das Update-Bundle
* Fehler beim korrekten Extrahieren oder Anwenden des Update-Bundles
Auf beiden Plattformen bieten die nativen Logs einen tieferen Einblick in den Update-Prozess mit mehr Details zur nativen Implementierung. Sie sind besonders nützlich für die Identifizierung von Problemen, die außerhalb der Capgo JavaScript-Schicht auftreten.
Bei der Fehlerbehebung eines kniffligen Live-Update-Problems ist es eine gute Idee, sowohl die Capgo Debug-Logs als auch die nativen Logs für ein umfassendes Bild der Situation zu erfassen. Die beiden Logs zusammen geben Ihnen die beste Chance, das Problem zu identifizieren und zu lösen.
### Updates werden nicht angewendet
[Section titled “Updates werden nicht angewendet”](#updates-werden-nicht-angewendet)
Wenn Sie ein Bundle hochgeladen haben, aber die Änderungen auf Ihrem Gerät nicht sehen:
* Stellen Sie sicher, dass Sie `CapacitorUpdater.notifyAppReady()` in Ihrem App-Code aufgerufen haben, wie im [Quickstart](/docs/getting-started/quickstart) gezeigt
* Prüfen Sie, ob Ihr Gerät mit dem Internet verbunden ist und die Capgo Debug-Logs zeigen, dass das Update heruntergeladen wurde
* Versuchen Sie, die App vollständig zu schließen und neu zu öffnen, da Updates nur bei einem Neustart angewendet werden
* Suchen Sie in den nativen Logs nach Fehlern, die auf ein Problem beim Anwenden des Updates hinweisen könnten
Weitere Details zum Update-Prozess finden Sie im [Live-Updates Deployment Guide](/docs/getting-started/deploy). Wenn Sie immer noch Probleme haben, verwenden Sie den `npx @capgo/cli@latest app debug` Befehl und native Logs, um mehr Einblick in das Geschehen zu bekommen.
## SDK-Installation
[Section titled “SDK-Installation”](#sdk-installation)
Wenn Sie Probleme bei der Installation des Capgo SDK haben, stellen Sie sicher:
* Ihre App verwendet eine unterstützte Version von Capacitor (4.0 oder neuer)
* Sie sind den [Quickstart](/docs/getting-started/quickstart) Schritten in der richtigen Reihenfolge gefolgt, einschließlich der Synchronisierung Ihrer App nach der Installation des SDK
## CI/CD-Integration
[Section titled “CI/CD-Integration”](#cicd-integration)
Bei Problemen mit dem Auslösen von Capgo-Uploads aus Ihrer CI/CD-Pipeline:
* Überprüfen Sie, ob Ihr Capgo-Authentifizierungstoken korrekt eingerichtet ist
* Stellen Sie sicher, dass Sie den Upload-Befehl nach dem Build Ihrer Web-Assets ausführen
* Prüfen Sie, ob der Upload-Befehl den richtigen Kanalnamen für Ihre Zielumgebung verwendet
Weitere Fehlerbehebungstipps finden Sie in der [CI/CD-Integration](/docs/getting-started/cicd-integration/) Dokumentation. Sie können auch den `npx @capgo/cli@latest app debug` Befehl verwenden, um zu bestätigen, ob Ihre CI/CD-ausgelösten Updates von der App empfangen werden.
# Zusammenfassung
> Schließen Sie Ihre Capgo-Reise mit einem prägnanten Überblick über wichtige Konzepte und nächste Schritte ab und stellen Sie eine solide Grundlage für zukünftige Erkundungen und Beherrschung sicher.
Nachdem Sie die Schnellstartanleitung abgeschlossen haben, sollten Sie ein grundlegendes Verständnis der Hauptkonzepte von Capgo haben! Die wichtigsten Konzepte, die Sie in dieser Anleitung gelernt haben, sind:
1. Hinzufügen einer App zu Ihrem Capgo-Konto
2. Integration von Capgo in Ihre CI/CD-Pipeline
3. Auslösen von Bundle-Uploads zu Capgo bei neuen Commits
4. Konfigurieren Ihrer App zur Aktivierung von Live-Updates mit dem Capgo SDK
5. Bereitstellen von Live-Updates für Ihre App über das Capgo-Dashboard
Aber es gibt noch mehr über Capgo zu lernen! Erkunden Sie die Dokumentation weiter oder schauen Sie sich einige dieser wichtigen Themen an:
[ CI/CD-Integration](/docs/getting-started/cicd-integration/)
[Sie haben bereits eine CI/CD-Pipeline? Erfahren Sie, wie Sie Capgo in Ihren bestehenden Workflow integrieren können.](/docs/getting-started/cicd-integration/)
[ Live-Updates](/docs/live-updates/)
[Tauchen Sie tiefer in die Live-Update-Funktionen und Bewährte Methoden von Capgo ein.](/docs/live-updates/)
[ FAQ](/docs/faq/)
[Finden Sie Antworten auf häufige Fragen zu Capgo.](/docs/faq/)
[ Fehlerbehebung](/docs/getting-started/troubleshooting/)
[Erhalten Sie Hilfe bei häufigen Problemen, die bei der Verwendung von Capgo auftreten können.](/docs/getting-started/troubleshooting/)
# Anleitungen
> Ein umfassender Leitfaden für Capgo mit detaillierten Tutorials, hilfreichen Tipps und fortgeschrittenen Techniken zur effektiven Nutzung der Plattform
[Wie Versionierung in Capgo funktioniert ](https://capgo.app/blog/how-version-work-in-capgo/)capgo.app
[Wie man Major Versionen in Capgo veröffentlicht ](https://capgo.app/blog/how-to-release-major-version-in-capgo/)capgo.app
[Wie man spezifische Updates an einen Benutzer oder eine Gruppe sendet ](https://capgo.app/blog/how-to-send-specific-version-to-users/)capgo.app
## CI / CD
[Section titled “CI / CD”](#ci--cd)
[Automatischer Build und Release mit GitHub Actions ](https://capgo.app/blog/automatic-build-and-release-with-github-actions/)capgo.app
[Verwaltung von Entwicklungs- und Produktionsbuilds mit GitHub Actions ](https://capgo.app/blog/automatic-build-and-release-with-github-actions/)capgo.app
## Mitwirken
[Section titled “Mitwirken”](#mitwirken)
[Beitragen zu Capgo Open Source ](https://github.com/Cap-go/capgo/blob/main/CONTRIBUTING.md)github.com
# Übersicht
Nutzen Sie Capgos Live Updates-Funktion, um die JavaScript-Bundles Ihrer App remote in Echtzeit zu aktualisieren. Pushen Sie JS-Updates direkt an Ihre Nutzer, ohne den App Store-Überprüfungsprozess zu durchlaufen, um sofort Fehler zu beheben und neue Funktionen bereitzustellen.
Note
Live Updates sind auf JavaScript-Bundle-Änderungen beschränkt. Wenn Sie nativen Code aktualisieren müssen, wie das Hinzufügen oder Entfernen eines Plugins oder das Ändern der nativen Projektkonfiguration, müssen Sie einen neuen nativen Binary-Build an die App Stores übermitteln.
## Wie Live Updates funktionieren
[Section titled “Wie Live Updates funktionieren”](#wie-live-updates-funktionieren)
Das Live Update-System von Capgo hat zwei Schlüsselkomponenten:
1. Das Capgo SDK, das Sie in Ihrer App installieren. Das SDK prüft auf verfügbare Updates und lädt diese im Hintergrund herunter.
2. Kanäle, mit denen Sie Updates an bestimmte Benutzergruppen richten können. Sie können Kanäle verwenden, um verschiedene Release-Tracks wie `Production`, `Staging` und `Dev` zu verwalten.
Wenn Sie ein neues JS-Bundle zu Capgo hochladen und es einem Kanal zuweisen, erkennt das Capgo SDK in Apps, die für diesen Kanal konfiguriert sind, das Update und lädt es herunter. Beim nächsten Neustart der App wird das neue Bundle geladen.
## Erste Schritte
[Section titled “Erste Schritte”](#erste-schritte)
Folgen Sie diesen Schritten, um Live Updates zu verwenden:
1. Schließen Sie den [Capgo Quickstart](/docs/getting-started/quickstart) ab, um Ihre App in Capgo einzurichten und das Capgo SDK zu installieren.
2. Rufen Sie in Ihrem App-Code `CapacitorUpdater.notifyAppReady()` auf, nachdem Ihre App initialisiert wurde. Dies teilt dem Capgo SDK mit, dass Ihre App bereit ist, Updates zu empfangen.
3. Erstellen Sie Ihr JS-Bundle und laden Sie es zu Capgo hoch:
```shell
npm run build
npx @capgo/cli@latest bundle upload --channel=production
```
4. Öffnen Sie Ihre App und warten Sie, bis das Update heruntergeladen ist. Sie können den Status überprüfen mit:
```shell
npx @capgo/cli@latest app debug
```
5. Sobald das Update heruntergeladen wurde, schließen und öffnen Sie die App erneut, um das neue Bundle zu laden.
Weitere Details finden Sie im [Leitfaden zum Bereitstellen von Live Updates](/docs/getting-started/deploy).
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
[ Update-Typen](/docs/live-updates/update-types/)
[Referenz aller OTA-Update-Typen: Anwendungszeitpunkt, Verzögerungsbedingungen, Versionssperrung und Bereitstellung.](/docs/live-updates/update-types/)
[ Kanäle](/docs/live-updates/channels/)
[Erfahren Sie, wie Sie Kanäle verwenden, um verschiedene Release-Tracks zu verwalten und Updates an bestimmte Benutzer zu richten](/docs/live-updates/channels/)
[ Rollbacks](/docs/live-updates/rollbacks/)
[Entdecken Sie, wie Sie zu einer vorherigen JS-Bundle-Version zurückkehren können, wenn ein Update Probleme verursacht](/docs/live-updates/rollbacks/)
[ Update-Verhalten](/docs/live-updates/update-behavior/)
[Passen Sie an, wie und wann Updates in Ihrer App heruntergeladen und angewendet werden](/docs/live-updates/update-behavior/)
[ Schnelle Updates](/docs/live-updates/differentials/)
[Erfahren Sie, wie Sie schnelle Updates verwenden können, um den Update-Prozess zu beschleunigen](/docs/live-updates/differentials/)
# Breaking Changes
> Wie man Breaking Changes mit versionierten Kanälen handhabt
Diese Dokumentation erklärt, wie Sie Breaking Changes in Ihrer App mithilfe von versionierten Kanälen handhaben. Dieser Ansatz ermöglicht es Ihnen, verschiedene Versionen Ihrer App zu pflegen und gleichzeitig sicherzustellen, dass Benutzer kompatible Updates erhalten.
## Beispielszenario
[Section titled “Beispielszenario”](#beispielszenario)
Angenommen, Sie haben:
* App-Version 1.2.3 (alte Version) - verwendet Produktionskanal
* App-Version 2.0.0 (neue Version mit Breaking Changes) - verwendet v2-Kanal
* Live-Update 1.2.4 (kompatibel mit 1.2.3)
* Live-Update 2.0.1 (kompatibel mit 2.0.0)
## Strategie: Immer defaultChannel für Major-Versionen verwenden
[Section titled “Strategie: Immer defaultChannel für Major-Versionen verwenden”](#strategie-immer-defaultchannel-für-major-versionen-verwenden)
**Empfohlener Ansatz:** Legen Sie einen `defaultChannel` für jede Major-Version fest. Dies stellt sicher, dass Sie Updates immer an bestimmte Benutzergruppen pushen können, ohne auf dynamische Kanalzuweisung angewiesen zu sein.
```ts
// Version 1.x Releases
defaultChannel: 'v1'
// Version 2.x Releases
defaultChannel: 'v2'
// Version 3.x Releases (zukünftig)
defaultChannel: 'v3'
```
Tip
**Vorteile dieses Ansatzes:**
* **Immer Kontrolle** darüber, welche Benutzer Updates erhalten
* **Keine dynamische Kanalumschaltung** im App-Code erforderlich
* **Klare Trennung** zwischen verschiedenen App-Versionen
* **Flexibilität**, Updates an jede spezifische Versionsgruppe zu pushen
## 1. Kanal für neue Version erstellen
[Section titled “1. Kanal für neue Version erstellen”](#1-kanal-für-neue-version-erstellen)
```bash
# Kanal für Version 2.x erstellen
npx @capgo/cli channel create v2
```
## 2. Capacitor-Konfiguration für Version 2.0.0 aktualisieren
[Section titled “2. Capacitor-Konfiguration für Version 2.0.0 aktualisieren”](#2-capacitor-konfiguration-für-version-200-aktualisieren)
Aktualisieren Sie Ihre Capacitor-Konfiguration, bevor Sie Version 2.0.0 für den App Store erstellen:
capacitor.config.ts
```ts
import { CapacitorConfig } from '@capacitor/cli';
const config: CapacitorConfig = {
appId: 'com.example.app',
appName: 'Example App',
plugins: {
CapacitorUpdater: {
// ... weitere Optionen
defaultChannel: 'v2' // Alle 2.0.0-Benutzer verwenden v2-Kanal
}
}
};
export default config;
```
Note
**Für Version 1.x:** Wenn Sie anfangs keinen `defaultChannel` festgelegt haben, sind Version 1.x-Benutzer auf dem `production`-Kanal. Für zukünftige Major-Versionen legen Sie immer einen spezifischen Kanal wie `v3`, `v4` usw. fest.
## 3. Separate Code-Branches verwalten
[Section titled “3. Separate Code-Branches verwalten”](#3-separate-code-branches-verwalten)
Erstellen Sie separate Git-Branches, um die Kompatibilität zwischen App-Versionen zu gewährleisten:
```bash
# Branch für Version 1.x-Updates erstellen und pflegen
git checkout -b v1-maintenance
git push origin v1-maintenance
# Ihr Main-Branch setzt Entwicklung von Version 2.x fort
git checkout main
```
**Kritisch:** Pushen Sie niemals JavaScript-Bundles an ältere Apps, die nativen Code/APIs erwarten, die sie nicht haben. Erstellen Sie Updates immer vom entsprechenden Branch:
* **v1-maintenance Branch**: Für Updates an 1.x Apps (Produktionskanal)
* **main Branch**: Für Updates an 2.x Apps (v2-Kanal)
## 4. Bundles an entsprechende Kanäle hochladen
[Section titled “4. Bundles an entsprechende Kanäle hochladen”](#4-bundles-an-entsprechende-kanäle-hochladen)
```bash
# Für 1.x Updates: Vom v1-maintenance Branch erstellen
git checkout v1-maintenance
# Nehmen Sie hier Ihre 1.x-kompatiblen Änderungen vor
npx @capgo/cli bundle upload --channel production
# Für 2.x Updates: Vom Main-Branch erstellen
git checkout main
# Nehmen Sie hier Ihre 2.x-Änderungen vor
npx @capgo/cli bundle upload --channel v2
```
## 5. Selbstzuweisung aktivieren
[Section titled “5. Selbstzuweisung aktivieren”](#5-selbstzuweisung-aktivieren)
```bash
# Apps erlauben, sich selbst dem v2-Kanal zuzuweisen
npx @capgo/cli channel set v2 --self-assign
```
## 6. Im App Store bereitstellen
[Section titled “6. Im App Store bereitstellen”](#6-im-app-store-bereitstellen)
Erstellen und stellen Sie Version 2.0.0 im App Store bereit. Alle Benutzer, die diese Version herunterladen (ob neue Benutzer oder bestehende Benutzer, die aktualisieren), werden automatisch den v2-Kanal verwenden, da dies im App-Bundle konfiguriert ist.
Note
**Keine Code-Änderungen erforderlich!** Da `defaultChannel: 'v2'` mit der App Store-Version gebündelt ist, verwenden alle Benutzer, die Version 2.0.0 herunterladen, automatisch den richtigen Kanal.
## Skalierung auf zukünftige Versionen
[Section titled “Skalierung auf zukünftige Versionen”](#skalierung-auf-zukünftige-versionen)
Wenn Sie Version 3.0.0 mit weiteren Breaking Changes veröffentlichen:
```bash
# Kanal für Version 3.x erstellen
npx @capgo/cli channel create v3
```
```ts
// capacitor.config.ts für Version 3.0.0
const config: CapacitorConfig = {
// ...
plugins: {
CapacitorUpdater: {
defaultChannel: 'v3' // Version 3.x-Benutzer
}
}
};
```
Jetzt können Sie Updates an jede Version pushen:
* `production` Kanal → Version 1.x-Benutzer
* `v2` Kanal → Version 2.x-Benutzer
* `v3` Kanal → Version 3.x-Benutzer
## 7. Bereinigung (Nach Migration)
[Section titled “7. Bereinigung (Nach Migration)”](#7-bereinigung-nach-migration)
Sobald alle Benutzer auf Version 2.x migriert sind (rechnen Sie mit 3-4 Monaten):
1. Entfernen Sie `defaultChannel` aus Ihrer Capacitor-Konfiguration
2. Löschen Sie den v2-Kanal:
```bash
npx @capgo/cli channel delete v2
```
3. Löschen Sie den v1-maintenance Branch:
```bash
git branch -d v1-maintenance
git push origin --delete v1-maintenance
```
Tip
Dieser Ansatz stellt sicher, dass Benutzer nur Updates erhalten, die mit ihrer App-Version kompatibel sind
Testen Sie Updates in jedem Kanal gründlich vor der Bereitstellung
Note
Sie können den v2-Kanal in Capgo sicher löschen, auch wenn einige Benutzer noch die Kanalüberschreibung haben. Sie erhalten stattdessen automatisch Updates vom Produktionskanal.
## Version 1.x-Updates pflegen
[Section titled “Version 1.x-Updates pflegen”](#version-1x-updates-pflegen)
Um Updates zu senden, die mit Version 1.x kompatibel sind:
1. Zum v1-maintenance Branch wechseln:
```bash
git checkout v1-maintenance
```
2. Ihre Änderungen vornehmen und committen:
```bash
# 1.x-kompatible Änderungen vornehmen
git add .
git commit -m "Fix for v1.x"
git push origin v1-maintenance
```
3. Zum Produktionskanal erstellen und hochladen:
```bash
npx @capgo/cli bundle upload --channel production
```
Tip
Halten Sie Ihren v1-maintenance Branch mit Bugfixes auf dem neuesten Stand, die mit Version 1.x kompatibel sind, aber mergen Sie niemals Breaking Changes vom Main-Branch
# Kanäle
> Erfahren Sie, wie Sie Live Update-Kanäle in Capgo verwalten und konfigurieren, um nahtlose App-Updates zu ermöglichen, indem Sie spezifische JS-Bundle-Builds an Geräte weiterleiten, die für diese Kanäle konfiguriert sind.
Ein Live Update-Kanal verweist auf einen bestimmten JS-Bundle-Build Ihrer App, der mit allen Geräten geteilt wird, die für Updates auf diesen Kanal eingestellt sind. Wenn Sie das [Capgo Live Updates SDK](/docs/getting-started/quickstart/) in Ihrer App installieren, prüft jede native Binary, die für diesen Kanal konfiguriert ist, beim App-Start auf verfügbare Updates. Sie können den Build, auf den ein Kanal verweist, jederzeit ändern und bei Bedarf auch auf vorherige Builds zurücksetzen.
## Wie ein Gerät einen Kanal auswählt (Priorität)
[Section titled “Wie ein Gerät einen Kanal auswählt (Priorität)”](#wie-ein-gerät-einen-kanal-auswählt-priorität)
Wenn ein Gerät nach einem Update sucht, entscheidet Capgo in dieser strikten Reihenfolge, welcher Kanal verwendet wird (höchste Priorität zuerst):
1. **Erzwungene Gerätezuordnung (Dashboard)** – Ordnen Sie ein bestimmtes Gerät manuell einem Kanal zu. Verwenden Sie dies für dringendes Debugging oder kontrolliertes Testen mit einem einzelnen echten Benutzer. Dies hat immer Vorrang.
2. **Cloud-Override (pro Gerät) über Dashboard oder API** – Wird erstellt, wenn Sie den Kanal des Geräts im Dashboard oder über die API ändern. Verwenden Sie dies für QA-Benutzer, die zwischen Feature-/PR-Kanälen wechseln, oder um ein Benutzerproblem zu reproduzieren. Eine Neuinstallation der Binary löscht dies nicht; das Löschen des Geräteeintrags schon.
Sofortiger Kanalwechsel mit setChannel()
**Ab Plugin-Version 5.34.0, 6.34.0, 7.34.0 oder 8.0.0** (je nach Ihrer Hauptversion) funktioniert `setChannel()` anders: Es kontaktiert das Backend, um zu **validieren**, dass der Kanal erlaubt ist (prüft, ob Selbstzuweisung für diesen Kanal aktiviert ist), und speichert den Kanal dann **lokal auf dem Gerät** als `defaultChannel`. Das bedeutet, der neue Kanal wird **sofort** für die nächste Update-Prüfung wirksam – kein Warten auf Replikation.
Zuvor speicherte `setChannel()` den Kanal-Override in der Backend-Datenbank (wie Dashboard- oder API-Änderungen), und Geräte mussten auf die Datenreplikation warten (bis zu 2 Minuten), bevor der neue Kanal erkannt wurde. Das neue Verhalten liest nur vom Backend (zur Validierung) und speichert lokal, was Kanalwechsel sofort macht.
**Hinweis:** Selbst wenn ein Kanal nach dem lokalen Setzen nicht mehr erlaubt ist, validiert das Backend den Kanal weiterhin bei Update-Prüfungen, sodass die Sicherheit gewährleistet bleibt.
**Wichtig:** Wenn Kanaländerungen über das Dashboard oder die API vorgenommen werden, gibt es immer noch eine Replikationsverzögerung von bis zu 2 Minuten, bevor alle Edge-Server die Änderung widerspiegeln. Für sofortige Kanalwechsel verwenden Sie `setChannel()` aus Ihrem App-Code – es validiert mit dem Backend und setzt dann den Kanal lokal für sofortige Wirkung.
3. **Capacitor-Konfig `defaultChannel` (Test-Build-Standard)** – Wenn in `capacitor.config.*` vorhanden und kein Force/Override existiert, startet die App auf diesem Kanal (z.B. `beta`, `qa`, `pr-123`). Gedacht für TestFlight-/interne Builds, damit Tester automatisch auf einem Pre-Release-Kanal landen. Produktions-Builds lassen dies normalerweise leer.
4. **Cloud-Standardkanal (Hauptpfad \~99% der Benutzer)** – Wenn Sie im Dashboard einen Standardkanal markieren, werden alle normalen Endbenutzer (kein Force, kein Override, kein Config-defaultChannel) hier angehängt. Ändern Sie ihn, um sofort auszurollen oder zurückzusetzen – keine neue Binary nötig. Wenn Sie plattformspezifische Standards haben (einen nur für iOS, einen nur für Android), landet jedes Gerät auf dem Standard, der seiner Plattform entspricht. Den Cloud-Standard leer zu lassen ist erlaubt; in diesem Fall muss das Gerät über Schritte 1-3 zugeordnet werden, um Updates zu erhalten.
Best Practice:
* Behandeln Sie 1-3 als Ausnahme-/Test-Layer; wenn Sie einen Cloud-Standard setzen, sollten echte Benutzer darüber fließen. Wenn Sie keinen setzen, seien Sie bewusst darüber, wie Benutzer zugeordnet werden (typischerweise über `defaultChannel` in der Konfig oder gerätespezifische Overrides).
* Konfigurieren Sie `defaultChannel` nur in Binaries, die Sie explizit an Tester versenden. Lassen Sie es leer, um die Produktionslogik zentral im Dashboard zu halten.
* Verwenden Sie `setChannel()` sparsam in der Produktion – hauptsächlich für QA oder gezielte Diagnosen.
Wenn ein Kanal für die Plattform deaktiviert ist (iOS/Android-Schalter), wenn er sonst gewählt würde, überspringt der Auswahlprozess ihn und fährt in der Liste fort.
> Zusammenfassung: Force > Override > Config `defaultChannel` > Cloud-Standard.
## Standardkanal-Verhalten
[Section titled “Standardkanal-Verhalten”](#standardkanal-verhalten)
Das Setzen eines Cloud-Standards ist optional, dient aber normalerweise als Auffangpfad für neue Geräte. Ohne einen erhalten nur Geräte Updates, die über erzwungene Zuordnungen, Overrides oder einen `defaultChannel` in der Capacitor-Konfig zugeordnet sind. Wenn Sie Standards markieren möchten, beachten Sie diese Muster:
* **Einzelner Standard (am häufigsten)** – Wenn der Kanal sowohl iOS als auch Android aktiviert hat, wird er zum einzigen Standard; jedes Gerät ohne Overrides wird hier angehängt.
* **Plattformspezifische Standards** – Wenn Sie Kanäle nach Plattform aufteilen (z.B. `ios-production` nur mit iOS aktiviert und `android-production` nur mit Android aktiviert), markieren Sie jeden als Standard für seine Plattform. iOS-Geräte gehen zum iOS-Standard, Android-Geräte zum Android-Standard.
Denken Sie daran, dass der Cloud-Standard und `defaultChannel` in `capacitor.config.*` beide dieselbe Entscheidungsebene belegen. Wenn Sie einen Cloud-Standard setzen, müssen Sie den Wert nicht in Ihrer Capacitor-Konfig duplizieren – lassen Sie `defaultChannel` für Produktions-Builds leer. Reservieren Sie `defaultChannel` für Binaries, die Sie absichtlich an Tester oder QA versenden, wenn sie auf einem Nicht-Produktionskanal starten sollen, auch wenn der Cloud-Standard anders ist.
Sie können Standards jederzeit im Dashboard ändern. Wenn Sie einen Standard wechseln, folgen neue Geräte sofort der neuen Weiterleitung und bestehende Geräte folgen beim nächsten Check-in den normalen Prioritätsregeln.
## Einrichten eines Kanals
[Section titled “Einrichten eines Kanals”](#einrichten-eines-kanals)
Während des Onboardings erstellen Sie den ersten Kanal (die meisten Teams nennen ihn “Production”), aber nichts ist gesperrt – Sie können jeden Kanal jederzeit umbenennen oder löschen. Um später zusätzliche Kanäle hinzuzufügen:
1. Gehen Sie zum Bereich “Channels” im Capgo Dashboard
2. Klicken Sie auf den Button “New Channel”
3. Geben Sie einen Namen für den Kanal ein und klicken Sie auf “Create”
Kanalnamen können frei gewählt werden. Eine gängige Strategie ist es, Kanäle Ihren Entwicklungsphasen zuzuordnen, zum Beispiel:
* `Development` - zum Testen von Live-Updates auf lokalen Geräten oder Emulatoren
* `QA` - für Ihr QA-Team zur Überprüfung von Updates vor der breiten Veröffentlichung
* `Staging` - für finale Tests in einer produktionsähnlichen Umgebung
* `Production` - für die Version Ihrer App, die Endbenutzer aus den App Stores erhalten
## Konfigurieren des Kanals in Ihrer App
[Section titled “Konfigurieren des Kanals in Ihrer App”](#konfigurieren-des-kanals-in-ihrer-app)
Nachdem Sie Ihre Kanäle erstellt haben, müssen Sie Ihre App so konfigurieren, dass sie auf den entsprechenden Kanal hört. In diesem Beispiel verwenden wir den `Development`-Kanal.
Öffnen Sie Ihre `capacitor.config.ts` (oder `capacitor.config.json`) Datei. Setzen Sie unter dem `plugins`-Abschnitt optional `defaultChannel` für **Test-Builds** (intern / QA). Für Produktions-Builds bevorzugen Sie, es wegzulassen, damit Geräte den Cloud-Standard verwenden, es sei denn, sie werden explizit überschrieben.
```ts
import { CapacitorConfig } from '@capacitor/cli';
const config: CapacitorConfig = {
plugins: {
CapacitorUpdater: {
// Für einen QA/TestFlight-Build – Tester starten automatisch auf dem Development-Kanal.
defaultChannel: 'Development',
// Produktions-Builds lassen dies normalerweise weg, damit Benutzer sich an den Cloud-Standardkanal anhängen.
},
},
};
```
Bauen Sie anschließend Ihre Web-App und führen Sie `npx cap sync` aus, um die aktualisierte Konfigurationsdatei in Ihre iOS- und Android-Projekte zu kopieren. Wenn Sie diesen Sync-Schritt überspringen, verwenden Ihre nativen Projekte weiterhin den Kanal, für den sie zuvor konfiguriert waren.
Caution
Kanalauswahlreihenfolge: Force > Override (`setChannel` / Dashboard) > Config `defaultChannel` > Cloud-Standard.
Verwenden Sie `defaultChannel` nur in Test-/internen Builds; lassen Sie es für die Produktion weg, damit Benutzer dem Cloud-Standard folgen (wenn gesetzt), anstatt die Weiterleitung in der nativen Konfig zu duplizieren.
Sie können ein Gerät später noch erzwingen (pinnen) oder einen Override anwenden – diese überschreiben sofort den Konfig-Wert.
> Kanalnamen unterscheiden Groß- und Kleinschreibung.
## Kanaloptionen und Strategien
[Section titled “Kanaloptionen und Strategien”](#kanaloptionen-und-strategien)
Kanäle haben mehrere Optionen, die steuern, wer Updates erhalten kann und wie Updates geliefert werden. Die wichtigsten sind unten aufgeführt. Sie können diese über die Web-App, die CLI oder die Public API konfigurieren.
* Standardkanal: Markieren Sie optional den Kanal oder plattformspezifische Kanäle, an die sich neue Geräte anhängen. Siehe “Standardkanal-Verhalten” für Weiterleitungsszenarien.
* Plattformfilter: Aktivieren oder deaktivieren Sie die Zustellung an `iOS`- und/oder `Android`-Geräte pro Kanal.
* Auto-Downgrade unter Native deaktivieren: Verhindert das Senden eines Updates, wenn die native App-Version des Geräts neuer ist als das Bundle des Kanals (z.B. Gerät auf 1.2.3, während der Kanal 1.2.2 hat).
* Development-Builds erlauben: Ermöglicht Updates für Development-Builds (nützlich zum Testen).
* Emulator-Geräte erlauben: Ermöglicht Updates für Emulatoren/Simulatoren (nützlich zum Testen).
* Geräte-Selbstzuweisung erlauben: Ermöglicht der App, zur Laufzeit mit `setChannel` zu diesem Kanal zu wechseln. Wenn deaktiviert, schlägt `setChannel` für diesen Kanal fehl.
### Strategien zum Deaktivieren automatischer Updates
[Section titled “Strategien zum Deaktivieren automatischer Updates”](#strategien-zum-deaktivieren-automatischer-updates)
Verwenden Sie dies, um einzuschränken, welche Arten von Updates der Kanal automatisch liefert. Optionen:
* major: Blockiert kanalübergreifende Major-Updates (0.0.0 → 1.0.0). Minor- und Patch-Updates sind weiterhin erlaubt.
* minor: Blockiert kanalübergreifende Minor-Updates (z.B. 1.1.0 → 1.2.0) und Majors. Patch-Updates sind weiterhin erlaubt. Hinweis: Blockiert nicht 0.1.0 → 1.1.0.
* patch: Sehr strikt. Erlaubt nur steigende Patch-Versionen innerhalb desselben Major und Minor. Beispiele: 0.0.311 → 0.0.314 ✅, 0.1.312 → 0.0.314 ❌, 1.0.312 → 0.0.314 ❌.
* metadata: Erfordert eine minimale Update-Version-Metadaten für jedes Bundle. Konfigurieren Sie über CLI mit `--min-update-version` oder `--auto-min-update-version`. Wenn fehlend, wird der Kanal als fehlkonfiguriert markiert und Updates werden abgelehnt, bis es gesetzt ist.
* none: Erlaubt alle Updates gemäß semver-Kompatibilität.
Erfahren Sie mehr Details und Beispiele unter Strategie zum Deaktivieren von Updates unter /docs/cli/commands/#disable-updates-strategy.
Beispiel (CLI):
```bash
# Major-Updates auf dem Production-Kanal blockieren
npx @capgo/cli@latest channel set production com.example.app \
--disable-auto-update major
# Geräten erlauben, sich selbst dem Beta-Kanal zuzuweisen
npx @capgo/cli@latest channel set beta com.example.app --self-assign
```
### setChannel() aus Ihrer App verwenden
[Section titled “setChannel() aus Ihrer App verwenden”](#setchannel-aus-ihrer-app-verwenden)
Die `setChannel()`-Methode ermöglicht Ihrer App, zur Laufzeit programmatisch den Kanal zu wechseln. Dies ist besonders nützlich für:
* QA/Debug-Menüs, in denen Tester zwischen Kanälen wechseln können
* Beta-Programm-Opt-in-Flows
* Feature-Flag-Implementierungen
* A/B-Test-Szenarien
```typescript
import { CapacitorUpdater } from '@capgo/capacitor-updater';
// Zum Beta-Kanal wechseln
await CapacitorUpdater.setChannel({ channel: 'beta' });
// Optional eine sofortige Update-Prüfung nach dem Wechsel auslösen
await CapacitorUpdater.setChannel({
channel: 'beta',
triggerAutoUpdate: true
});
```
Wie setChannel() funktioniert (v5.34.0+ / v6.34.0+ / v7.34.0+ / v8.0.0+)
Wenn `setChannel()` aufgerufen wird:
1. **Backend-Validierung (nur Lesen)**: Eine Anfrage wird an das Capgo-Backend gesendet, um zu validieren, dass der Kanal erlaubt ist (prüft Selbstzuweisungsberechtigungen)
2. **Lokale Speicheraktualisierung**: Wenn die Validierung erfolgreich ist, wird der Kanal im lokalen Speicher des Geräts als `defaultChannel` gespeichert
3. **Sofortige Wirkung**: Die nächste Update-Prüfung verwendet den neuen Kanal sofort (kein Warten auf Replikation)
**Warum das wichtig ist:** In älteren Versionen speicherte `setChannel()` den Kanal-Override in der Backend-Datenbank (wie Dashboard- oder API-Änderungen). Geräte mussten auf die Backend-Replikation warten (bis zu 2 Minuten), bevor die Kanaländerung wirksam wurde. Jetzt liest `setChannel()` nur vom Backend (zur Validierung) und speichert lokal, was Kanalwechsel sofort macht.
**Sicherheitshinweis:** Selbst wenn sich die Berechtigungen eines Kanals nach dem lokalen Setzen ändern (z.B. Selbstzuweisung wird deaktiviert), validiert das Backend den Kanal weiterhin bei Update-Prüfungen, um die Sicherheit zu gewährleisten.
**Vergleich der Kanaländerungsmethoden:**
| Methode | Wirkungszeit | Wo gespeichert | Anwendungsfall |
| ------------------------- | ------------ | ----------------- | ------------------------------------------------ |
| `setChannel()` vom Plugin | **Sofort** | Nur Gerät (lokal) | Benutzer-initiierter Kanalwechsel in der App |
| Dashboard-Geräte-Override | Bis zu 2 Min | Backend-Datenbank | Admin-initiierte Änderungen für bestimmte Geräte |
| API-Kanalzuweisung | Bis zu 2 Min | Backend-Datenbank | Automatisierte Backend-Integrationen |
Für die beste Benutzererfahrung beim Erstellen von Kanalwechsel-UIs verwenden Sie immer die `setChannel()`-Methode des Plugins.
Mindestversionen für lokalen Kanalwechsel: **5.34.0**, **6.34.0**, **7.34.0** oder **8.0.0** (je nach Ihrer Hauptversion). Jede Minor-Versionsnummer entspricht demselben Funktionsumfang über alle Hauptversionen hinweg (z.B. X.34.0 enthält dieselben Funktionen, ob X 5, 6, 7 oder 8 ist). Siehe [Plugin-Installation](/docs/getting-started/add-an-app/) für Versions-Tags.
## Zuweisen eines Bundles zu einem Kanal
[Section titled “Zuweisen eines Bundles zu einem Kanal”](#zuweisen-eines-bundles-zu-einem-kanal)
Um ein Live-Update bereitzustellen, müssen Sie einen neuen JS-Bundle-Build hochladen und einem Kanal zuweisen. Sie können dies in einem Schritt mit der Capgo CLI tun:
```shell
npx @capgo/cli@latest bundle upload --channel=Development
```
Dies lädt Ihre gebauten Web-Assets hoch und setzt den neuen Bundle als aktiven Build für den `Development`-Kanal. Alle Apps, die für diesen Kanal konfiguriert sind, erhalten das Update beim nächsten Überprüfen.
Sie können Builds auch über den “Bundles”-Bereich des Capgo Dashboards Kanälen zuweisen. Klicken Sie auf das Menü-Symbol neben einem Build und wählen Sie “Assign to Channel”, um den Kanal für diesen Build auszuwählen.
## Bundle-Versionierung und Kanäle
[Section titled “Bundle-Versionierung und Kanäle”](#bundle-versionierung-und-kanäle)
Es ist wichtig zu beachten, dass Bundles in Capgo global für Ihre App sind und nicht spezifisch für einzelne Kanäle. Dasselbe Bundle kann mehreren Kanälen zugewiesen werden.
Bei der Versionierung Ihrer Bundles empfehlen wir die Verwendung von Semantic Versioning [semver](https://semver.org/) mit Pre-Release-Kennungen für kanalspezifische Builds. Ein Beta-Release könnte beispielsweise als `1.2.3-beta.1` versioniert sein.
Dieser Ansatz hat mehrere Vorteile:
* Er kommuniziert die Beziehung zwischen Builds klar: `1.2.3-beta.1` ist offensichtlich eine Vorabversion von `1.2.3`
* Er ermöglicht die Wiederverwendung von Versionsnummern über Kanäle hinweg und reduziert Verwirrung
* Er ermöglicht klare Rollback-Pfade. Wenn Sie von `1.2.3` zurückrollen müssen, wissen Sie, dass `1.2.2` die vorherige stabile Version ist
Hier ist ein Beispiel, wie Sie Ihre Bundle-Versionen mit einem typischen Kanal-Setup abstimmen könnten:
* `Development`-Kanal: `1.2.3-dev.1`, `1.2.3-dev.2`, etc.
* `QA`-Kanal: `1.2.3-qa.1`, `1.2.3-qa.2`, etc.
* `Staging`-Kanal: `1.2.3-rc.1`, `1.2.3-rc.2`, etc.
* `Production`-Kanal: `1.2.3`, `1.2.4`, etc.
Die Verwendung von semver mit Pre-Release-Kennungen ist ein empfohlener Ansatz, aber nicht strikt erforderlich. Der Schlüssel ist, ein Versionierungsschema zu finden, das die Beziehungen zwischen Ihren Builds klar kommuniziert und mit dem Entwicklungsprozess Ihres Teams übereinstimmt.
## Zurücksetzen eines Live-Updates
[Section titled “Zurücksetzen eines Live-Updates”](#zurücksetzen-eines-live-updates)
Wenn Sie ein Live-Update bereitstellen, das einen Fehler einführt oder aus anderen Gründen zurückgesetzt werden muss, können Sie einfach zu einem vorherigen Build zurückkehren. Vom “Channels”-Bereich des Dashboards aus:
1. Klicken Sie auf den Namen des Kanals, den Sie zurücksetzen möchten
2. Finden Sie den Build, zu dem Sie zurückkehren möchten, und klicken Sie auf das Kronen-Symbol 
3. Bestätigen Sie die Aktion
Der ausgewählte Build wird sofort wieder zum aktiven Build für diesen Kanal. Apps erhalten die zurückgesetzte Version beim nächsten Update-Check.
## Automatisierung von Deployments
[Section titled “Automatisierung von Deployments”](#automatisierung-von-deployments)
Für fortgeschrittenere Workflows können Sie Ihre Live-Update-Deployments als Teil Ihrer CI/CD-Pipeline automatisieren. Durch die Integration von Capgo in Ihren Build-Prozess können Sie automatisch neue Bundles hochladen und Kanälen zuweisen, wenn Sie zu bestimmten Branches pushen oder neue Releases erstellen.
Schauen Sie sich die [CI/CD Integration](/docs/getting-started/cicd-integration/) Dokumentation an, um mehr über die Automatisierung von Capgo Live-Updates zu erfahren.
## Bereitstellung auf einem Gerät
[Section titled “Bereitstellung auf einem Gerät”](#bereitstellung-auf-einem-gerät)
Nachdem Sie die Kanäle verstanden haben, können Sie mit der Bereitstellung von Live-Updates auf echten Geräten beginnen. Der grundlegende Prozess ist:
1. Installieren Sie das Capgo SDK in Ihrer App
2. Konfigurieren Sie die App, um auf Ihren gewünschten Kanal zu hören
3. Laden Sie einen Build hoch und weisen Sie ihn diesem Kanal zu
4. Starten Sie die App und warten Sie auf das Update!
Eine detailliertere Anleitung finden Sie im [Deploying Live Updates](/docs/getting-started/deploy/) Guide. Viel Spaß beim Aktualisieren!
## Erweiterte Kanalnutzung: Benutzersegmentierung
[Section titled “Erweiterte Kanalnutzung: Benutzersegmentierung”](#erweiterte-kanalnutzung-benutzersegmentierung)
Kanäle können für mehr als nur Entwicklungsphasen verwendet werden. Sie sind ein leistungsstarkes Werkzeug für die Benutzersegmentierung und ermöglichen Funktionen wie:
* Feature-Flags für verschiedene Benutzerstufen
* A/B-Tests
* Schrittweise Feature-Rollouts
* Beta-Test-Programme
Erfahren Sie, wie Sie diese erweiterten Anwendungsfälle in unserem Leitfaden implementieren: [How to Segment Users by Plan and Channels for Feature Flags and A/B Testing](/blog/how-to-segment-users-by-plan-and-channels/).
# Capgo in China verwenden
> Erfahren Sie, wie Sie Capgo Live Updates für den Betrieb in China konfigurieren, indem Sie regionale OST-URLs für optimale Leistung und Zuverlässigkeit verwenden.
Wenn Sie Ihre App für Benutzer in China bereitstellen, müssen Sie Capgo für die Verwendung regionaler OST-URLs (Object Storage Technology) konfigurieren, um zuverlässige und schnelle Updates sicherzustellen.
## Warum China-spezifische URLs verwenden?
[Section titled “Warum China-spezifische URLs verwenden?”](#warum-china-spezifische-urls-verwenden)
Aufgrund der Netzwerkinfrastruktur und Vorschriften in China (der Great Firewall) können direkte Verbindungen zu internationalen Servern langsam oder unzuverlässig sein. Capgo stellt dedizierte OST-URLs mit Daten in Hongkong bereit, um die Latenz zu minimieren und sicherzustellen, dass Ihre Benutzer Updates so schnell und zuverlässig wie möglich erhalten.
## Konfiguration
[Section titled “Konfiguration”](#konfiguration)
Um Capgo für China zu konfigurieren, müssen Sie drei spezifische URLs in Ihrer Capacitor-Konfigurationsdatei festlegen. Diese URLs verweisen auf die in Hongkong basierende Infrastruktur von Capgo.
1. Öffnen Sie Ihre `capacitor.config.ts`-Datei
2. Fügen Sie die folgende Konfiguration zum `CapacitorUpdater`-Plugin-Abschnitt hinzu:
```typescript
import { CapacitorConfig } from '@capacitor/cli';
const config: CapacitorConfig = {
plugins: {
CapacitorUpdater: {
autoUpdate: true,
updateUrl: 'https://updater.capgo.com.cn/updates',
statsUrl: 'https://updater.capgo.com.cn/stats',
channelUrl: 'https://updater.capgo.com.cn/channel_self',
},
},
};
export default config;
```
3. Bauen Sie Ihre App neu, um die Änderungen anzuwenden:
```shell
npm run build
npx cap sync
```
## Konfigurationsdetails
[Section titled “Konfigurationsdetails”](#konfigurationsdetails)
Hier ist, was jede URL macht:
* **updateUrl**: `https://updater.capgo.com.cn/updates` - Wird verwendet, um verfügbare Updates für Ihre App zu überprüfen und herunterzuladen
* **statsUrl**: `https://updater.capgo.com.cn/stats` - Wird verwendet, um Analysen und Nutzungsstatistiken an Capgo zurückzumelden
* **channelUrl**: `https://updater.capgo.com.cn/channel_self` - Wird verwendet, um Kanalkonfiguration abzurufen und zu bestimmen, welche Updates angewendet werden
Tip
Alle drei URLs müssen zusammen konfiguriert werden, um die volle Funktionalität des Capgo-Updaters in China sicherzustellen.
## Empfohlene Einstellungen für China
[Section titled “Empfohlene Einstellungen für China”](#empfohlene-einstellungen-für-china)
Aufgrund von Netzwerkleistungseinschränkungen durch die Great Firewall of China haben wir spezifische Empfehlungen für Apps, die in Festlandchina bereitgestellt werden:
### Direkte Updates deaktivieren
[Section titled “Direkte Updates deaktivieren”](#direkte-updates-deaktivieren)
Wir **empfehlen dringend, `directUpdate` zu deaktivieren** für Apps in China. Die Netzwerkkonnektivität in China ist weniger leistungsfähig als in anderen Regionen, und direkte Updates (die sofort angewendet werden) können zu einer schlechten Benutzererfahrung führen, wenn Downloads unterbrochen oder langsam sind.
Verwenden Sie stattdessen das Standard-Update-Verhalten, bei dem Updates im Hintergrund heruntergeladen und angewendet werden, wenn die App in den Hintergrund geht oder neu startet. Dies bietet eine zuverlässigere Erfahrung für Ihre Benutzer.
```typescript
const config: CapacitorConfig = {
plugins: {
CapacitorUpdater: {
autoUpdate: true,
directUpdate: false, // Empfohlen für China
updateUrl: 'https://updater.capgo.com.cn/updates',
statsUrl: 'https://updater.capgo.com.cn/stats',
channelUrl: 'https://updater.capgo.com.cn/channel_self',
},
},
};
```
Caution
Obwohl unsere in Hongkong basierende Infrastruktur hilft, die Latenz zu minimieren und die Zuverlässigkeit zu verbessern, kann die Netzwerkleistung nach Festlandchina immer noch von der Great Firewall beeinträchtigt werden. Das Deaktivieren von `directUpdate` hilft sicherzustellen, dass Updates erfolgreich abgeschlossen werden, ohne die Benutzererfahrung zu beeinträchtigen.
## Vollständiges Konfigurationsbeispiel
[Section titled “Vollständiges Konfigurationsbeispiel”](#vollständiges-konfigurationsbeispiel)
Hier ist ein vollständiges Beispiel mit empfohlenen Einstellungen für Apps, die in China bereitgestellt werden:
```typescript
import { CapacitorConfig } from '@capacitor/cli';
const config: CapacitorConfig = {
appId: 'com.example.app',
appName: 'My App',
webDir: 'dist',
plugins: {
CapacitorUpdater: {
autoUpdate: true,
directUpdate: false, // Empfohlen: für bessere Zuverlässigkeit in China deaktivieren
updateUrl: 'https://updater.capgo.com.cn/updates',
statsUrl: 'https://updater.capgo.com.cn/stats',
channelUrl: 'https://updater.capgo.com.cn/channel_self',
},
},
};
export default config;
```
## Ihre Konfiguration testen
[Section titled “Ihre Konfiguration testen”](#ihre-konfiguration-testen)
Nachdem Sie die China-spezifischen URLs konfiguriert haben, können Sie überprüfen, ob Updates korrekt funktionieren:
1. Ein neues Bundle zu Capgo hochladen:
```shell
npx @capgo/cli@latest bundle upload --channel=production
```
2. Ihre App auf einem Testgerät in China installieren
3. Den Update-Prozess überwachen:
```shell
npx @capgo/cli@latest app debug
```
4. Überprüfen, dass Updates von den China OST-URLs heruntergeladen werden
Note
Das Update-Verhalten und Timing bleibt gleich wie bei der Standard-Capgo-Konfiguration. Siehe die [Update-Verhalten](/docs/live-updates/update-behavior/)-Dokumentation für Details darüber, wie und wann Updates angewendet werden.
## Multi-Region-Bereitstellung
[Section titled “Multi-Region-Bereitstellung”](#multi-region-bereitstellung)
Wenn Ihre App Benutzer sowohl innerhalb als auch außerhalb Chinas bedient, können Sie die chinesische Domain-Konfiguration für alle Benutzer weltweit verwenden. Die `updater.capgo.com.cn`-Domain wird dank der Alibaba DNS-Infrastruktur global aufgelöst und ist sowohl in China als auch überall sonst auf der Welt zugänglich.
### Chinesische Domains global verwenden
[Section titled “Chinesische Domains global verwenden”](#chinesische-domains-global-verwenden)
Die chinesischen Domain-URLs funktionieren nahtlos für Multi-Region-Apps:
```typescript
const config: CapacitorConfig = {
plugins: {
CapacitorUpdater: {
autoUpdate: true,
directUpdate: false, // Empfohlen für China-Benutzer
updateUrl: 'https://updater.capgo.com.cn/updates',
statsUrl: 'https://updater.capgo.com.cn/stats',
channelUrl: 'https://updater.capgo.com.cn/channel_self',
},
},
};
```
Diese einzelne Konfiguration funktioniert für:
* Benutzer in Festlandchina (verwenden in Hongkong basierende Infrastruktur)
* Benutzer außerhalb Chinas (greifen auf dieselbe Infrastruktur über Alibaba DNS zu)
**Leistungsüberlegungen:**
Obwohl die `.cn`-Domain global über Alibaba DNS aufgelöst wird und überall funktioniert, ist sie für Benutzer außerhalb Chinas im Vergleich zur Standard-Domain (`api.capgo.app`), die direkt von Cloudflare aufgelöst wird, wo unser Backend gehostet ist, etwas weniger leistungsfähig. Die DNS-Auflösung ist jedoch schnell, sodass der Leistungsunterschied minimal ist und die Benutzererfahrung nicht wesentlich beeinträchtigt.
Tip
Die Verwendung der `.cn`-Domain für alle Benutzer vereinfacht Ihre Bereitstellung und stellt ein konsistentes Update-Verhalten in allen Regionen sicher. Sie benötigen keine separaten Builds oder umgebungsbasierten Konfigurationen. Der kleine Leistungsnachteil außerhalb Chinas ist typischerweise die vereinfachte Bereitstellung wert.
### Alternative: Regionsspezifische Konfigurationen
[Section titled “Alternative: Regionsspezifische Konfigurationen”](#alternative-regionsspezifische-konfigurationen)
Wenn Sie es vorziehen, für jede Region unterschiedlich zu optimieren, können Sie auch in Betracht ziehen:
* Separate App-Varianten mit unterschiedlichen Konfigurationen zu erstellen
* Umgebungsbasierte Konfiguration zu verwenden, um die URLs dynamisch festzulegen
* Verschiedene Release-Kanäle für verschiedene Regionen zu erstellen
Wenn Sie Unterstützung bei Multi-Region-Bereitstellungsstrategien benötigen, kontaktieren Sie uns bitte unter oder treten Sie unserer [Discord-Community](https://discord.capgo.app) bei, um Hilfe zu erhalten.
## Fehlerbehebung
[Section titled “Fehlerbehebung”](#fehlerbehebung)
Wenn Sie Probleme mit Updates in China haben:
1. **Überprüfen Sie Ihre Konfiguration** - Überprüfen Sie doppelt, dass alle drei URLs in Ihrer `capacitor.config.ts` korrekt festgelegt sind
2. **Netzwerkkonnektivität prüfen** - Stellen Sie sicher, dass Ihr Gerät die `updater.capgo.com.cn`-Domain erreichen kann
3. **Protokolle überprüfen** - Verwenden Sie `npx @capgo/cli@latest app debug`, um auf Fehlermeldungen zu prüfen
4. **Updates testen** - Versuchen Sie, ein neues Bundle hochzuladen und den Download-Prozess zu überwachen
5. **Support kontaktieren** - Wenn Probleme bestehen bleiben, wenden Sie sich an uns unter oder treten Sie unserer [Discord-Community](https://discord.capgo.app) bei, um Unterstützung zu erhalten
Caution
Stellen Sie sicher, dass Sie die `.cn`-Domain (`updater.capgo.com.cn`) und nicht die internationale Standard-Domain verwenden, wenn Sie für China konfigurieren.
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
* Erfahren Sie mehr über [Update-Verhalten](/docs/live-updates/update-behavior/), um anzupassen, wann Updates angewendet werden
* Erkunden Sie [Kanäle](/docs/live-updates/channels/), um verschiedene Release-Tracks zu verwalten
* Überprüfen Sie [Verschlüsselung](/docs/live-updates/encryption/), um Ihre Updates zu sichern
# Compliance
> Erfahren Sie mehr über Capgos Datenschutzpraktiken, Datenerfassung, Sicherheitskonformität und wie wir die Informationen Ihrer Benutzer während Live-Updates schützen.
Capgo ist mit Fokus auf Datenschutz, Sicherheit und Compliance konzipiert. Dieses Dokument erklärt, welche Daten erfasst werden, wie sie verwendet werden und welche Maßnahmen zum Schutz der Privatsphäre Ihrer Benutzer und zur Gewährleistung der regulatorischen Compliance bei der Nutzung des Live-Update-Dienstes von Capgo getroffen werden.
## Datenerfassungs-Übersicht
[Section titled “Datenerfassungs-Übersicht”](#datenerfassungs-übersicht)
Capgo erfasst minimale Daten, die zur effektiven Bereitstellung des Live-Update-Dienstes erforderlich sind. Die Datenerfassung konzentriert sich auf betriebliche Anforderungen statt auf Benutzer-Tracking oder Analysen.
### Welche Daten werden erfasst
[Section titled “Welche Daten werden erfasst”](#welche-daten-werden-erfasst)
Capgo erfasst nur die Daten, die zur Bereitstellung der Live-Updates-Funktion erforderlich sind. Wenn Ihre App nach Updates sucht oder neue Bundles herunterlädt, werden folgende Informationen erfasst:
* **App-ID**: Ein eindeutiger Identifikator für Ihre App, der verwendet wird, um die App mit dem richtigen Konto zu verknüpfen
* **App-Versionscode**: Der Versionscode der App, der verwendet wird, um zu bestimmen, welche Updates mit der App kompatibel sind
* **App-Versionsname**: Der Versionsname der App, der für Anzeigezwecke verwendet wird
* **Plattform**: Die Plattform (iOS, Android) der App, die verwendet wird, um zu bestimmen, welche Updates mit der App kompatibel sind
* **Geräte-ID**: Ein eindeutiger Identifikator für das Gerät, der verwendet wird, um Updates an ein bestimmtes Gerät zu liefern und für Abrechnungszwecke. Dieser Identifikator ist eine zufällige Zeichenfolge, die beim ersten Start der App erstellt wird. **Ab Plugin-Version v5.10.0, v6.25.0 und v7.25.0** bleibt die Geräte-ID jetzt über App-Neuinstallationen hinweg bestehen (sicher gespeichert im Keychain auf iOS und EncryptedSharedPreferences auf Android), um eine bessere Geräteverfolgung zu ermöglichen und gleichzeitig die Compliance mit App Store-Richtlinien aufrechtzuerhalten. Vor diesen Versionen wurde die Geräte-ID bei jeder App-Installation zurückgesetzt
* **Bundle-ID**: Der eindeutige Identifikator für das Bundle, das aktuell auf dem Gerät installiert ist
* **Kanalname**: Der Name des Kanals, der ausgewählt wurde, um Updates zu erhalten
* **OS-Version**: Die Version des Betriebssystems, die verwendet wird, um zu bestimmen, welche Updates mit dem Gerät kompatibel sind
* **Plugin-Version**: Die Version des @capgo/capacitor-updater Plugins, das verwendet wird, um Updates an das Gerät zu liefern
**Zusätzliche technische Daten:**
* Update-Prüfungs-Zeitstempel
* Download-Erfolgs-/Fehlerstatus
* Bundle-Installationsstatus
* Rollback-Ereignisse und Gründe
* IP-Adresse (für Geolokalisierung und CDN-Optimierung)
Note
Sie können die erfassten Daten überprüfen, indem Sie den Quellcode des @capgo/capacitor-updater Plugins inspizieren, der Open Source ist und auf [GitHub](https://github.com/Cap-go/capacitor-updater) verfügbar ist. Capgo erfasst keine personenbezogenen Daten (PII) wie Namen, E-Mail-Adressen, Telefonnummern oder persistente Geräte-Identifikatoren, die verwendet werden können, um einzelne Benutzer über Apps hinweg zu verfolgen.
### Welche Daten werden NICHT erfasst
[Section titled “Welche Daten werden NICHT erfasst”](#welche-daten-werden-nicht-erfasst)
Capgo erfasst ausdrücklich nicht:
* Persönliche Benutzerinformationen oder Zugangsdaten
* App-Nutzungsanalysen oder Benutzerverhaltens-Daten
* Inhalte aus Ihrer App oder benutzergenerierte Daten
* Standortdaten über die allgemeine geografische Region hinaus
* Persistente Geräte-Identifikatoren für Tracking
* Biometrische oder sensible persönliche Daten
## Datennutzung und -zweck
[Section titled “Datennutzung und -zweck”](#datennutzung-und--zweck)
Die von Capgo erfassten Daten werden ausschließlich verwendet für:
### Dienstbetrieb
[Section titled “Dienstbetrieb”](#dienstbetrieb)
* Bestimmen, welche Updates für bestimmte App-Versionen verfügbar sind
* Optimierung der Inhaltsbereitstellung durch geografische CDN-Auswahl
* Sicherstellen der Kompatibilität zwischen Updates und Gerätefunktionen
* Verwaltung von Update-Rollouts und Kanalzuweisungen
### Dienstverbesserung
[Section titled “Dienstverbesserung”](#dienstverbesserung)
* Überwachung der Update-Erfolgsraten und Identifizierung von Problemen
* Optimierung der Download-Leistung und Zuverlässigkeit
* Verbesserung des gesamten Update-Liefersystems
* Fehlersuche und Behebung von Update-Fehlern
### Sicherheit und Integrität
[Section titled “Sicherheit und Integrität”](#sicherheit-und-integrität)
* Verhinderung von Missbrauch und Sicherstellung der Dienstverfügbarkeit
* Validierung der Authentizität und Integrität von Updates
* Schutz vor bösartigen oder beschädigten Updates
* Aufrechterhaltung der Dienstsicherheit und Stabilität
## Datenspeicherung und Aufbewahrung
[Section titled “Datenspeicherung und Aufbewahrung”](#datenspeicherung-und-aufbewahrung)
### Speicherort
[Section titled “Speicherort”](#speicherort)
* Update-Bundles und Metadaten werden auf sicherer Cloud-Infrastruktur gespeichert
* Daten werden über mehrere geografische Regionen verteilt für bessere Leistung
* Alle Datenübertragungen werden mit branchenüblichen Protokollen verschlüsselt (HTTPS/TLS)
### Datenaufbewahrung
[Section titled “Datenaufbewahrung”](#datenaufbewahrung)
* Update-Prüfungsprotokolle werden für betriebliche Zwecke aufbewahrt (typischerweise 30-90 Tage)
* Bundle-Dateien werden aufbewahrt, solange sie aktiven Kanälen zugewiesen sind
* Aggregierte, nicht-personenbezogene Metriken können länger für Dienstverbesserungen aufbewahrt werden
* Persönliche Daten, falls vorhanden, werden gemäß geltenden Datenschutzgesetzen gelöscht
### Datensicherheit
[Section titled “Datensicherheit”](#datensicherheit)
* Alle Daten werden während der Übertragung und im Ruhezustand verschlüsselt
* Zugriff auf Daten ist nur autorisiertem Personal vorbehalten
* Regelmäßige Sicherheitsaudits und Überwachung werden durchgeführt
* Branchenübliche Sicherheitspraktiken werden befolgt
* **SOC 2-Zertifizierung**: Capgo ist derzeit SOC 2 Typ II zertifiziert und gewährleistet höchste Standards für Sicherheit, Verfügbarkeit und Vertraulichkeit. Sehen Sie sich unseren Compliance-Status unter [trust.capgo.app](https://trust.capgo.app) an
* **Kontinuierliche Code-Prüfung**: Jeder Commit wird automatisch von [SonarCloud](https://sonarcloud.io/summary/overall?id=Cap-go_capacitor-updater\&branch=main) für das [Plugin](https://sonarcloud.io/summary/overall?id=Cap-go_capgo\&branch=main) und [Backend](https://sonarcloud.io/summary/overall?id=Cap-go_capgo\&branch=main) geprüft, um Codequalität, Erkennung von Sicherheitslücken und Wartbarkeit sicherzustellen
* **Schwachstellen-Scanning**: Zusätzliches Sicherheitsscanning wird von [Snyk](https://snyk.io/test/github/Cap-go/capgo) durchgeführt, um Sicherheitslücken in Abhängigkeiten zu erkennen und zu beheben
* **Infrastruktur-Sicherheit**: Unsere Hosting-Infrastruktur wird kontinuierlich überwacht und durch [Hosting-Sicherheitsprüfungen](https://hosting-checker.net/websites/api.capgo.app) verifiziert
* **KI-gestützte Code-Überprüfung**: Jede Pull-Request wird von CodeRabbit AI überprüft, um potenzielle Probleme, Sicherheitsbedenken zu erkennen und Codequalitätsstandards aufrechtzuerhalten
## Datenschutzkontrollen
[Section titled “Datenschutzkontrollen”](#datenschutzkontrollen)
### Für App-Entwickler
[Section titled “Für App-Entwickler”](#für-app-entwickler)
Als Capgo-Benutzer haben Sie Kontrolle über:
* **Kanalverwaltung**: Steuern Sie, welche Updates an welche Benutzer verteilt werden
* **Datenminimierung**: Konfigurieren Sie, welche Geräteinformationen geteilt werden
* **Geografische Kontrollen**: Verwalten Sie, wo Ihre Updates verteilt werden
* **Aufbewahrungseinstellungen**: Steuern Sie, wie lange Update-Daten aufbewahrt werden
### Für Endbenutzer
[Section titled “Für Endbenutzer”](#für-endbenutzer)
Ihre App-Benutzer profitieren von:
* **Minimale Datenerfassung**: Nur wesentliche Daten für die Update-Bereitstellung werden erfasst
* **Kein Tracking**: Kein App-übergreifendes oder persistentes Benutzer-Tracking
* **Transparenz**: Diese Datenschutzrichtlinie erklärt genau, welche Daten erfasst werden
* **Sicherheit**: Alle Datenübertragungen sind verschlüsselt und sicher
## Compliance und Rechtliches
[Section titled “Compliance und Rechtliches”](#compliance-und-rechtliches)
### Datenschutzvorschriften
[Section titled “Datenschutzvorschriften”](#datenschutzvorschriften)
Capgo ist darauf ausgelegt, wichtige Datenschutzvorschriften einzuhalten, einschließlich:
* **GDPR** (Datenschutz-Grundverordnung)
* **CCPA** (California Consumer Privacy Act)
* **COPPA** (Children’s Online Privacy Protection Act)
* Andere anwendbare regionale Datenschutzgesetze
### App Store Compliance
[Section titled “App Store Compliance”](#app-store-compliance)
Capgo hält sich strikt an App Store-Richtlinien und -Richtlinien:
* **Apple App Store**: Entspricht den [App Store Review Guidelines](https://developer.apple.com/app-store/review/guidelines/) Abschnitt 3.3.2 und stellt sicher, dass Live-Updates nur das Verhalten der App auf eine Weise ändern, die mit der eingereichten App übereinstimmt
* **Google Play Store**: Befolgt die Anforderungen der [Google Play Developer Policy](https://play.google.com/about/developer-content-policy/) für dynamisches Code-Laden und App-Updates
* **Inhaltsbeschränkungen**: Live-Updates können keine Funktionalität einführen, die in der ursprünglichen App-Einreichung nicht vorhanden war oder plattformspezifische Inhaltsrichtlinien verletzt
* **Sicherheitsanforderungen**: Alle Updates behalten die gleiche Sicherheitslage und Berechtigungen wie die ursprüngliche App bei
### Ihre Verantwortlichkeiten
[Section titled “Ihre Verantwortlichkeiten”](#ihre-verantwortlichkeiten)
Als App-Entwickler, der Capgo verwendet, sollten Sie:
* Angemessene Datenschutzerklärungen in die Datenschutzrichtlinie Ihrer App aufnehmen
* Benutzer über die Verwendung von Live-Update-Diensten informieren
* Die Einhaltung geltender Gesetze in Ihrer Gerichtsbarkeit sicherstellen
* Geeignete Einwilligungsmechanismen implementieren, falls erforderlich
Tip
**Keine zusätzliche Datenschutzimplementierung erforderlich**: Capgo ist standardmäßig datenschutzkonform konzipiert. Sie müssen keine zusätzlichen Datenschutzkontrollen oder Datenverarbeitungsmechanismen in Ihrem App-Code implementieren. Der minimale Datenerfassungsansatz und das Privacy-by-Design-Prinzip bedeuten, dass die Integration von Capgo typischerweise keine Änderungen an Ihren bestehenden Datenschutzerklärungen oder Richtlinien erfordert.
## Privacy by Design
[Section titled “Privacy by Design”](#privacy-by-design)
Capgo folgt Privacy-by-Design-Prinzipien:
### Datenminimierung
[Section titled “Datenminimierung”](#datenminimierung)
* Nur Daten erfassen, die absolut notwendig für den Dienstbetrieb sind
* Erfassung persönlicher oder sensibler Informationen vermeiden
* Wo möglich aggregierte und anonymisierte Daten verwenden
### Zweckbindung
[Section titled “Zweckbindung”](#zweckbindung)
* Erfasste Daten nur für die angegebenen Zwecke verwenden
* Daten nicht für unzusammenhängende Aktivitäten umwidmen
* Klare Grenzen für die Datennutzung aufrechterhalten
### Transparenz
[Section titled “Transparenz”](#transparenz)
* Klare Informationen über Datenerfassung und -nutzung bereitstellen
* Datenschutzpraktiken leicht zugänglich und verständlich machen
* Datenschutzdokumentation regelmäßig aktualisieren
## Kontakt und Fragen
[Section titled “Kontakt und Fragen”](#kontakt-und-fragen)
Wenn Sie Fragen zu Capgos Datenschutzpraktiken haben oder ein Datenschutzanliegen melden möchten:
* Überprüfen Sie unsere vollständige Datenschutzrichtlinie unter [capgo.app/privacy](https://capgo.app/privacy)
* Sehen Sie sich unseren Sicherheits- und Compliance-Status unter [capgo.app/trust](https://capgo.app/trust) an
* Kontaktieren Sie unser Datenschutzteam über die Support-Kanäle
* Melden Sie datenschutzbezogene Probleme über unseren Sicherheitskontakt
Tip
Denken Sie daran, die Datenschutzrichtlinie Ihrer eigenen App zu aktualisieren, um die Verwendung des Live-Update-Dienstes von Capgo und jegliche Datenerfassung widerzuspiegeln, die als Teil des Update-Prozesses stattfinden kann.
## Bewährte Methoden für Datenschutz
[Section titled “Bewährte Methoden für Datenschutz”](#bewährte-methoden-für-datenschutz)
Bei der Implementierung von Capgo in Ihrer App:
1. **Seien Sie transparent**: Informieren Sie Benutzer über die Live-Update-Funktionalität
2. **Minimieren Sie Daten**: Aktivieren Sie nur Datenerfassungsfunktionen, die Sie tatsächlich benötigen
3. **Sichere Implementierung**: Befolgen Sie Sicherheits-Bewährte Methoden bei Ihrer Integration
4. **Regelmäßige Überprüfungen**: Überprüfen Sie regelmäßig Ihre Datenschutzpraktiken und aktualisieren Sie Richtlinien
5. **Benutzerkontrolle**: Erwägen Sie, Benutzern Optionen zur Steuerung des Update-Verhaltens anzubieten
Durch die Befolgung dieser Praktiken und das Verständnis von Capgos Datenschutzansatz können Sie Ihren Benutzern eine sichere, datenschutzfreundliche Live-Update-Erfahrung bieten.
# Custom Storage
> Erfahren Sie, wie Sie benutzerdefinierte Speicherlösungen mit Capgo Live Updates verwenden, einschließlich externer URLs, S3-Integration und Bundle-Verschlüsselung für sichere Bereitstellungen.
Capgo unterstützt benutzerdefinierte Speicherlösungen für Ihre App-Bundles, sodass Sie Ihre Updates auf Ihrer eigenen Infrastruktur oder Drittspeicherdiensten hosten können. Dies ist besonders nützlich für Organisationen mit spezifischen Sicherheitsanforderungen, Compliance-Anforderungen oder bestehender Speicherinfrastruktur.
## Übersicht
[Section titled “Übersicht”](#übersicht)
Custom Storage in Capgo funktioniert durch Hochladen Ihres Bundles an einen externen Standort und Bereitstellung der URL für Capgo, um darauf zuzugreifen. Das Capgo SDK lädt dann Updates direkt von Ihrem benutzerdefinierten Speicherort herunter anstelle von Capgos Standard-Cloud-Speicher.
Tip
Custom Storage ist ideal für:
* Organisationen mit strengen Datenresidenzanforderungen
* Teams mit bestehender CDN- oder Speicherinfrastruktur
* Anwendungen, die zusätzliche Sicherheitsebenen erfordern
* Kostenoptimierung für große Bundle-Größen
## Externe URL-Upload
[Section titled “Externe URL-Upload”](#externe-url-upload)
Der einfachste Weg, benutzerdefinierten Speicher zu verwenden, besteht darin, Ihr Bundle auf eine öffentlich zugängliche URL hochzuladen und diese URL Capgo bereitzustellen.
### Basis Externe URL-Upload
[Section titled “Basis Externe URL-Upload”](#basis-externe-url-upload)
```shell
npx @capgo/cli@latest bundle upload --external https://your-domain.com/bundles/v1.2.3.zip
```
Dieser Befehl weist Capgo an, auf das Bundle unter der angegebenen URL zu verweisen, anstatt es in Capgos Cloud-Speicher hochzuladen.
### Mit Verschlüsselung
[Section titled “Mit Verschlüsselung”](#mit-verschlüsselung)
Für sicheren externen Speicher können Sie Ihr Bundle verschlüsseln und die Entschlüsselungsschlüssel bereitstellen:
```shell
npx @capgo/cli@latest bundle upload --external https://your-domain.com/bundles/v1.2.3.zip --iv-session-key YOUR_IV_SESSION_KEY
```
## S3-Integration
[Section titled “S3-Integration”](#s3-integration)
Capgo bietet integrierte Unterstützung für Amazon S3 und S3-kompatible Speicherdienste. Die CLI kann Ihr Bundle automatisch zu S3 hochladen und Capgo konfigurieren, die S3-URL zu verwenden.
### S3 Upload-Optionen
[Section titled “S3 Upload-Optionen”](#s3-upload-optionen)
```shell
npx @capgo/cli@latest bundle upload \
--s3-region us-east-1 \
--s3-apikey YOUR_ACCESS_KEY \
--s3-apisecret YOUR_SECRET_KEY \
--s3-bucket-name your-bucket-name
```
### Vollständige S3-Konfiguration
[Section titled “Vollständige S3-Konfiguration”](#vollständige-s3-konfiguration)
Für S3-kompatible Dienste oder benutzerdefinierte Endpunkte:
```shell
npx @capgo/cli@latest bundle upload \
--s3-region us-east-1 \
--s3-apikey YOUR_ACCESS_KEY \
--s3-apisecret YOUR_SECRET_KEY \
--s3-endpoint https://s3.your-provider.com \
--s3-bucket-name your-bucket-name \
--s3-port 443 \
--no-s3-ssl # Nur wenn Ihr Endpunkt SSL nicht unterstützt
```
### S3-Konfigurationsparameter
[Section titled “S3-Konfigurationsparameter”](#s3-konfigurationsparameter)
| Parameter | Beschreibung | Erforderlich |
| ------------------ | ---------------------------------- | ------------ |
| `--s3-region` | AWS-Region für Ihren S3-Bucket | Ja |
| `--s3-apikey` | S3-Zugriffsschlüssel-ID | Ja |
| `--s3-apisecret` | S3-Geheimzugriffsschlüssel | Ja |
| `--s3-bucket-name` | Name Ihres S3-Buckets | Ja |
| `--s3-endpoint` | Benutzerdefinierte S3-Endpunkt-URL | Nein |
| `--s3-port` | Port für S3-Endpunkt | Nein |
| `--no-s3-ssl` | SSL für S3-Upload deaktivieren | Nein |
## Bundle-Vorbereitung und Verschlüsselung
[Section titled “Bundle-Vorbereitung und Verschlüsselung”](#bundle-vorbereitung-und-verschlüsselung)
Bei Verwendung von benutzerdefiniertem Speicher, insbesondere mit Verschlüsselung, müssen Sie Ihre Bundles ordnungsgemäß vorbereiten. Dies beinhaltet das Erstellen einer Zip-Datei und optional deren Verschlüsselung.
### Schritt 1: Ein Zip-Bundle erstellen
[Section titled “Schritt 1: Ein Zip-Bundle erstellen”](#schritt-1-ein-zip-bundle-erstellen)
Erstellen Sie zunächst eine Zip-Datei Ihres App-Bundles:
```shell
npx @capgo/cli@latest bundle zip com.example.app --path ./dist
```
Der Zip-Befehl gibt die Prüfsumme der Zip-Datei zurück. Sie können diese Prüfsumme verwenden, um die Zip-Datei bei Bedarf zu verschlüsseln. Verwenden Sie die Option `--json`, um strukturierte Ausgabe einschließlich der Prüfsumme zu erhalten.
#### Zip-Befehlsoptionen
[Section titled “Zip-Befehlsoptionen”](#zip-befehlsoptionen)
```shell
npx @capgo/cli@latest bundle zip [appId] \
--path ./dist \
--bundle 1.2.3 \
--name myapp-v1.2.3 \
--json \
--no-code-check \
--key-v2 \
--package-json ../../package.json,./package.json
```
| Option | Beschreibung |
| ----------------- | ----------------------------------------------------------------------- |
| `--path` | Pfad zum zu zippenden Ordner (Standard ist webDir aus capacitor.config) |
| `--bundle` | Bundle-Versionsnummer zur Benennung der Zip-Datei |
| `--name` | Benutzerdefinierter Name für die Zip-Datei |
| `--json` | Ergebnisse im JSON-Format ausgeben (enthält Prüfsumme) |
| `--no-code-check` | Prüfung auf notifyAppReady()-Aufruf und Index-Datei überspringen |
| `--key-v2` | Verschlüsselung v2 verwenden |
| `--package-json` | Pfade zu package.json-Dateien für Monorepos (kommagetrennt) |
### Schritt 2: Bundle verschlüsseln (Optional)
[Section titled “Schritt 2: Bundle verschlüsseln (Optional)”](#schritt-2-bundle-verschlüsseln-optional)
Für erhöhte Sicherheit verschlüsseln Sie Ihr Zip-Bundle vor dem Hochladen:
```shell
# Verwendung des lokalen Standardschlüssels
npx @capgo/cli@latest bundle encrypt ./myapp.zip CHECKSUM
# Verwendung einer benutzerdefinierten Schlüsseldatei
npx @capgo/cli@latest bundle encrypt ./myapp.zip CHECKSUM --key ./path/to/.capgo_key_v2
# Verwendung von Schlüsseldaten direkt
npx @capgo/cli@latest bundle encrypt ./myapp.zip CHECKSUM --key-data "PRIVATE_KEY_CONTENT"
```
Der Parameter `CHECKSUM` ist erforderlich und sollte die Prüfsumme Ihrer Zip-Datei sein. Sie können die Prüfsumme aus der Ausgabe des Zip-Befehls erhalten (verwenden Sie die Option `--json` für strukturierte Ausgabe).
Standardmäßig verwendet der encrypt-Befehl Ihren lokalen privaten Signaturschlüssel. Sie können einen benutzerdefinierten Schlüssel mit den Optionen `--key` oder `--key-data` angeben.
Der encrypt-Befehl gibt den für Upload oder Entschlüsselung benötigten `ivSessionKey` zurück.
#### Verschlüsselungs-Befehlsoptionen
[Section titled “Verschlüsselungs-Befehlsoptionen”](#verschlüsselungs-befehlsoptionen)
| Option | Beschreibung |
| ------------ | ------------------------------------------------------------------------------------------------------------- |
| `zipPath` | Pfad zur zu verschlüsselnden Zip-Datei (erforderlich) |
| `checksum` | Prüfsumme der Zip-Datei (erforderlich) - aus Zip-Befehl erhalten |
| `--key` | Benutzerdefinierter Pfad für privaten Signaturschlüssel (optional, verwendet lokalen Schlüssel standardmäßig) |
| `--key-data` | Private Signaturschlüsseldaten direkt (optional) |
| `--json` | Ergebnisse im JSON-Format ausgeben |
Caution
Der encrypt-Befehl gibt einen `ivSessionKey` aus, den Sie beim Hochladen mit der Option `--iv-session-key` bereitstellen müssen.
## Vollständige Workflow-Beispiele
[Section titled “Vollständige Workflow-Beispiele”](#vollständige-workflow-beispiele)
### Beispiel 1: Externe URL mit Verschlüsselung
[Section titled “Beispiel 1: Externe URL mit Verschlüsselung”](#beispiel-1-externe-url-mit-verschlüsselung)
1. **Erstellen Sie Ihre App:**
```shell
npm run build
```
2. **Erstellen Sie ein Zip-Bundle:**
```shell
npx @capgo/cli@latest bundle zip com.example.app --path ./dist --bundle 1.2.3
```
Notieren Sie sich die von diesem Befehl zurückgegebene Prüfsumme.
3. **Verschlüsseln Sie das Bundle:**
```shell
npx @capgo/cli@latest bundle encrypt ./com.example.app-1.2.3.zip CHECKSUM_FROM_STEP_2
```
Notieren Sie sich den `ivSessionKey` aus der Ausgabe.
4. **In Ihren Speicher hochladen:** Laden Sie die verschlüsselte Zip-Datei zu Ihrem Hosting-Dienst hoch.
5. **Bei Capgo registrieren:**
```shell
npx @capgo/cli@latest bundle upload \
--external https://your-cdn.com/bundles/com.example.app-1.2.3.zip \
--iv-session-key IV_SESSION_KEY_FROM_STEP_3
```
### Beispiel 2: Direkter S3-Upload
[Section titled “Beispiel 2: Direkter S3-Upload”](#beispiel-2-direkter-s3-upload)
1. **Erstellen Sie Ihre App:**
```shell
npm run build
```
2. **Direkt zu S3 hochladen:**
```shell
npx @capgo/cli@latest bundle upload \
--s3-region us-west-2 \
--s3-apikey YOUR_ACCESS_KEY \
--s3-apisecret YOUR_SECRET_KEY \
--s3-bucket-name your-app-bundles \
--channel Production
```
### Beispiel 3: S3 mit Verschlüsselung
[Section titled “Beispiel 3: S3 mit Verschlüsselung”](#beispiel-3-s3-mit-verschlüsselung)
1. **Erstellen und zippen:**
```shell
npm run build
npx @capgo/cli@latest bundle zip com.example.app --path ./dist --key-v2
```
2. **Bundle verschlüsseln:**
```shell
npx @capgo/cli@latest bundle encrypt ./com.example.app.zip CHECKSUM
```
3. **Zu S3 mit Verschlüsselung hochladen:**
```shell
npx @capgo/cli@latest bundle upload \
--s3-region us-west-2 \
--s3-apikey YOUR_ACCESS_KEY \
--s3-apisecret YOUR_SECRET_KEY \
--s3-bucket-name your-app-bundles \
--iv-session-key IV_SESSION_KEY_FROM_STEP_2 \
--channel Production
```
## Sicherheitsüberlegungen
[Section titled “Sicherheitsüberlegungen”](#sicherheitsüberlegungen)
Bei Verwendung von benutzerdefiniertem Speicher sollten Sie diese Sicherheits-Best-Practices beachten:
### Zugriffskontrolle
[Section titled “Zugriffskontrolle”](#zugriffskontrolle)
* Stellen Sie sicher, dass Ihre Speicher-URLs für Ihre App-Benutzer zugänglich, aber nicht öffentlich auffindbar sind
* Verwenden Sie signierte URLs oder tokenbasierte Authentifizierung, wenn möglich
* Implementieren Sie ordnungsgemäße CORS-Header für webbasierte Apps
### Verschlüsselung
[Section titled “Verschlüsselung”](#verschlüsselung)
* Verschlüsseln Sie immer sensible Bundles mit den Capgo-Verschlüsselungstools
* Speichern Sie Verschlüsselungsschlüssel sicher und rotieren Sie sie regelmäßig
* Verwenden Sie HTTPS für alle Bundle-URLs (erforderlich für iOS und Android)
### Überwachung
[Section titled “Überwachung”](#überwachung)
* Überwachen Sie Zugriffsprotokolle, um ungewöhnliche Download-Muster zu erkennen
* Richten Sie Benachrichtigungen für fehlgeschlagene Bundle-Downloads ein
* Überprüfen Sie regelmäßig Ihre Speicherberechtigungen
## Fehlerbehebung
[Section titled “Fehlerbehebung”](#fehlerbehebung)
### Häufige Probleme
[Section titled “Häufige Probleme”](#häufige-probleme)
**Bundle wird nicht heruntergeladen:**
* Überprüfen Sie, ob die URL öffentlich zugänglich ist und HTTPS verwendet (erforderlich für iOS und Android)
* Prüfen Sie CORS-Header für Web-Apps
* Stellen Sie sicher, dass das Bundle-Format korrekt ist
**Verschlüsselungsfehler:**
* Überprüfen Sie, ob der `ivSessionKey` mit dem verschlüsselten Bundle übereinstimmt
* Prüfen Sie, ob das Bundle mit dem richtigen Schlüssel verschlüsselt wurde
* Stellen Sie sicher, dass Verschlüsselung v2 für neue Bundles verwendet wird
**S3-Upload-Fehler:**
* Überprüfen Sie Ihre S3-Anmeldeinformationen und Berechtigungen
* Prüfen Sie Bucket-Richtlinien und CORS-Konfiguration
* Stellen Sie sicher, dass die angegebene Region korrekt ist
### Debug-Befehle
[Section titled “Debug-Befehle”](#debug-befehle)
Bundle-Status überprüfen:
```shell
npx @capgo/cli@latest app debug
```
Bundle-Integrität überprüfen:
```shell
npx @capgo/cli@latest bundle list
```
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
* Erfahren Sie mehr über [Channels](/docs/live-updates/channels/), um verschiedene Bereitstellungsumgebungen zu verwalten
* Erkunden Sie [Update Behavior](/docs/live-updates/update-behavior/), um anzupassen, wie Updates angewendet werden
* Richten Sie [CI/CD Integration](/docs/getting-started/cicd-integration/) ein, um Ihren benutzerdefinierten Speicher-Workflow zu automatisieren
# Schnelle Aktualisierungen
Capgos Live-Update-System kann Updates schneller und effizienter bereitstellen, indem nur die geänderten Dateien und nicht das gesamte JS-Bundle gesendet werden
Dies ist besonders vorteilhaft für Benutzer mit langsameren oder getakteten Netzwerkverbindungen, da die Menge der herunterzuladenden Daten minimiert wird
Ein zweiter Vorteil ist, wenn die App große Assets enthält, die sich selten ändern, wie Bilder oder Videos - im Vergleich zu gezippten JS-Dateien werden diese nur einmal heruntergeladen
## Wie Differenzielle Updates funktionieren
[Section titled “Wie Differenzielle Updates funktionieren”](#wie-differenzielle-updates-funktionieren)
Differenzielle Updates in Capgo werden durch das in Ihrer App installierte Capgo-Plugin verarbeitet. Wenn Sie eine neue Version Ihrer App mit der Flag `--partial` hochladen, führt Capgo Folgendes aus:
1. Jede Datei in Ihrem Build wird einzeln hochgeladen
2. Für jede Datei werden Prüfsummen generiert
3. Ein neues JSON-Manifest wird erstellt, das alle Dateien und ihre Prüfsummen auflistet
4. Dieses Manifest wird in die Capgo-Datenbank hochgeladen
Wenn ein Gerät, auf dem Ihre App läuft, nach Updates sucht, erhält das Capgo-Plugin das neue Manifest vom Server. Es vergleicht dieses Manifest mit dem aktuellen und identifiziert anhand der Prüfsummen und Dateipfade, welche Dateien sich geändert haben
Das Plugin lädt dann nur die geänderten Dateien herunter, anstatt das gesamte JS-Bundle. Es rekonstruiert die neue Version der App, indem es diese heruntergeladenen Dateien mit den unveränderten Dateien kombiniert
Manifest
Bei differenziellen Updates speichert das Gerät alle heruntergeladenen Dateien in einem gemeinsamen Cache. Capgo wird diesen nie bereinigen, aber das Betriebssystem kann dies jederzeit tun
## Aktivierung von Differenziellen Updates
[Section titled “Aktivierung von Differenziellen Updates”](#aktivierung-von-differenziellen-updates)
Um differenzielle Updates für Ihre Capgo-App zu aktivieren, verwenden Sie einfach die Flag `--partial` beim Hochladen einer neuen Version:
## Erzwingen von Differenziellen Updates
[Section titled “Erzwingen von Differenziellen Updates”](#erzwingen-von-differenziellen-updates)
Wenn Sie sicherstellen möchten, dass alle Uploads differenzielle Updates sind und versehentliche vollständige Bundle-Uploads verhindert werden, können Sie die Flag `--partial-only` verwenden:
```shell
npx @capgo/cli@latest bundle upload --partial-only
```
Wenn `--partial-only` verwendet wird, lädt Capgo nur einzelne Dateien hoch und generiert ein Manifest. Geräte, die keine partiellen Updates unterstützen, können das Update nicht herunterladen
Sie möchten `--partial-only` möglicherweise verwenden, wenn:
* Sie immer differenzielle Updates verwenden und nie vollständige Bundle-Uploads zulassen möchten
* Sie eine CI/CD-Pipeline einrichten und sicherstellen möchten, dass alle automatisierten Uploads differenziell sind
* Ihre App groß ist und die Bandbreite begrenzt ist, sodass Sie Upload-/Download-Größen minimieren müssen
Wenn Sie einen vollständigen Bundle-Upload durchführen müssen, während `--partial-only` gesetzt ist, führen Sie den Upload-Befehl einfach ohne `--partial-only` aus. Dies überschreibt die Einstellung für diesen einzelnen Upload und ermöglicht es Ihnen, ein vollständiges Bundle zu pushen, wenn nötig
## Fehlerbehebung
[Section titled “Fehlerbehebung”](#fehlerbehebung)
Wenn differenzielle Updates nicht zu funktionieren scheinen (d.h. Geräte laden immer das vollständige JS-Bundle herunter, auch bei kleinen Änderungen), überprüfen Sie Folgendes:
* Sie verwenden die Flag `--partial` bei jedem Upload einer neuen Version
* Bei Verwendung von `--partial-only` stellen Sie sicher, dass Sie die Flag `--partial` nicht versehentlich weggelassen haben
* Ihr Gerät läuft mit der neuesten Version des Capgo-Plugins
* Ihr Gerät hat eine stabile Netzwerkverbindung und kann die Capgo-Server erreichen
Sie können auch die Capgo-Webapp verwenden, um die Details Ihres letzten Uploads zu überprüfen:
1. Gehen Sie zur [Webapp](https://app.capgo.io)
2. Klicken Sie auf Ihre App
3. Klicken Sie auf die Bundles-Nummer in der Statistikleiste
4. Wählen Sie das letzte Bundle
5. Überprüfen Sie das `Partial`-Feld 
Wenn Sie weiterhin Probleme haben, wenden Sie sich bitte an den Capgo-Support für weitere Unterstützung. Sie können die Server-Logs überprüfen, um zu bestätigen, dass Ihre partiellen Uploads korrekt verarbeitet werden und die Geräte die aktualisierten Manifeste erhalten
Das war’s! Die Flag `--partial` weist Capgo an, die einzelnen Datei-Uploads und Manifest-Generierung durchzuführen, die für differenzielle Updates benötigt werden
Beachten Sie, dass Sie `--partial` jedes Mal verwenden müssen, wenn Sie eine neue Version hochladen, die als differenzielles Update bereitgestellt werden soll. Wenn Sie die Flag weglassen, lädt Capgo das gesamte JS-Bundle als einzelne Datei hoch, und Geräte werden das gesamte Bundle herunterladen, auch wenn sich nur ein kleiner Teil geändert hat
# Encryption
> Erfahren Sie, wie die Ende-zu-Ende-Verschlüsselung von Capgo Ihre App-Bundles während der Übertragung und Speicherung sichert und Ihren Code und Benutzerdaten schützt.
Capgo bietet robuste Ende-zu-Ende-Verschlüsselung für Ihre App-Bundles und stellt sicher, dass Ihr JavaScript-Code und Assets während der Übertragung und Speicherung geschützt sind. Dieses Verschlüsselungssystem ist darauf ausgelegt, Ihnen die vollständige Kontrolle über die Sicherheit Ihrer App zu geben und gleichzeitig den Komfort von Live-Updates beizubehalten.
## Übersicht
[Section titled “Übersicht”](#übersicht)
Das Verschlüsselungssystem von Capgo verwendet branchenübliche kryptografische Methoden, um Ihre Bundles vor unbefugtem Zugriff zu schützen. Wenn die Verschlüsselung aktiviert ist, werden Ihre Bundles verschlüsselt, bevor sie Ihre Entwicklungsumgebung verlassen, und bleiben verschlüsselt, bis sie von Ihrer App auf dem Gerät des Benutzers entschlüsselt werden.
**Echte Ende-zu-Ende-Verschlüsselung**: Im Gegensatz zu anderen OTA-Update-Plattformen, die nur Updates signieren (wobei der Code öffentlich lesbar bleibt), bietet Capgo echte Ende-zu-Ende-Verschlüsselung. Das bedeutet, dass nur Ihre Benutzer Ihre Updates entschlüsseln können - niemand sonst, einschließlich Capgo selbst. Ihr Bundle-Inhalt bleibt während des gesamten Bereitstellungsprozesses vollständig privat und unlesbar.
Tip
Verschlüsselung ist besonders wichtig für:
* Apps, die sensible Daten oder Geschäftslogik verarbeiten
* Unternehmensanwendungen mit Compliance-Anforderungen
* Apps, die in regulierten Branchen eingesetzt werden
* Organisationen mit strengen Sicherheitsrichtlinien
## Wie Verschlüsselung funktioniert
[Section titled “Wie Verschlüsselung funktioniert”](#wie-verschlüsselung-funktioniert)
Capgo verwendet einen hybriden Verschlüsselungsansatz, der RSA- und AES-Verschlüsselung für optimale Sicherheit und Leistung kombiniert:
### 1. Schlüsselerzeugung
[Section titled “1. Schlüsselerzeugung”](#1-schlüsselerzeugung)
* **Privater Schlüssel**: In Ihrer Entwicklungsumgebung generiert und sicher gespeichert (wird für Verschlüsselung verwendet)
* **Öffentlicher Schlüssel**: Von Ihrem privaten Schlüssel abgeleitet und in der Capacitor-Konfiguration Ihrer App gespeichert (wird für Entschlüsselung verwendet)
* **Session-Schlüssel**: Zufällige AES-Schlüssel, die für jedes Bundle-Upload generiert werden
### 2. Verschlüsselungsprozess
[Section titled “2. Verschlüsselungsprozess”](#2-verschlüsselungsprozess)
1. Ein zufälliger AES-Session-Schlüssel wird für jedes Bundle-Upload generiert
2. Ihr Bundle wird mit dem AES-Session-Schlüssel verschlüsselt
3. Die Bundle-Prüfsumme wird berechnet
4. Sowohl der AES-Session-Schlüssel als auch die Prüfsumme werden zusammen mit Ihrem RSA-Privatschlüssel verschlüsselt (wodurch die “Signatur” erstellt wird)
5. Das verschlüsselte Bundle und die verschlüsselte Signatur werden gespeichert
Die Prüfsumme wird zusammen mit dem AES-Schlüssel verschlüsselt, um Manipulationen zu verhindern. Da nur Ihr RSA-Privatschlüssel diese Signatur erstellen kann und nur der entsprechende öffentliche Schlüssel sie entschlüsseln kann, wird sichergestellt, dass sowohl der AES-Session-Schlüssel als auch die erwartete Prüfsumme authentisch sind und nicht von einem Angreifer modifiziert wurden.
### 3. Entschlüsselungsprozess
[Section titled “3. Entschlüsselungsprozess”](#3-entschlüsselungsprozess)
1. Ihre App lädt das verschlüsselte Bundle und die verschlüsselte Signatur herunter
2. Das Capgo SDK verwendet Ihren RSA-öffentlichen Schlüssel (in der App gespeichert), um die Signatur zu entschlüsseln
3. Dies enthüllt den AES-Session-Schlüssel und die ursprüngliche Prüfsumme
4. Der AES-Session-Schlüssel wird verwendet, um das Bundle zu entschlüsseln
5. Eine Prüfsumme des entschlüsselten Bundles wird berechnet und mit der ursprünglichen Prüfsumme zur Integritätsprüfung verglichen
Dieser Prozess stellt sicher, dass selbst wenn ein Angreifer das verschlüsselte Bundle abfängt, er weder den AES-Session-Schlüssel ändern noch eine gefälschte Prüfsumme bereitstellen kann, da er Ihren privaten Schlüssel benötigen würde, um eine gültige Signatur zu erstellen, die der öffentliche Schlüssel entschlüsseln kann.
Tip
RSA kann große Datenmengen nicht effizient verschlüsseln, daher wird AES für die eigentliche Bundle-Verschlüsselung verwendet, während RSA den AES-Schlüssel sichert und Integritätsprüfung durch Prüfsummen-Signierung bietet.
## Capgo vs. andere Plattformen
[Section titled “Capgo vs. andere Plattformen”](#capgo-vs-andere-plattformen)
| Merkmal | Capgo | Andere OTA-Plattformen |
| ---------------------- | --------------------------------------------------------- | --------------------------------------- |
| **Bundle-Inhalt** | Vollständig verschlüsselt (unlesbar) | Öffentlich lesbar |
| **Sicherheitsmethode** | Echte Ende-zu-Ende-Verschlüsselung | Nur Code-Signierung |
| **Datenschutzniveau** | Zero-Knowledge (selbst Capgo kann Ihren Code nicht lesen) | Plattform kann auf Ihren Code zugreifen |
| **Schutz** | Inhalt + Integrität + Authentizität | Nur Integrität + Authentizität |
**Warum das wichtig ist:**
* **Code-Signierung** überprüft nur, dass Updates nicht manipuliert wurden und aus der richtigen Quelle stammen
* **Ende-zu-Ende-Verschlüsselung** stellt sicher, dass Ihr tatsächlicher Code-Inhalt während der Übertragung und Speicherung privat und unlesbar bleibt
* Mit Capgos echter Ende-zu-Ende-Verschlüsselung können nur Ihre Benutzer Updates entschlüsseln - niemand sonst, einschließlich Capgo selbst
## Verschlüsselungsmethoden
[Section titled “Verschlüsselungsmethoden”](#verschlüsselungsmethoden)
Capgo verwendet Verschlüsselung V2 als Standard-Verschlüsselungsmethode:
### Verschlüsselung V2 (Aktueller Standard)
[Section titled “Verschlüsselung V2 (Aktueller Standard)”](#verschlüsselung-v2-aktueller-standard)
* Verwendet RSA-4096 für erhöhte Sicherheit
* AES-256-GCM für authentifizierte Verschlüsselung
* Bietet Integritätsprüfung
* Bessere Leistung und Sicherheit
### Verschlüsselung V1 (Veraltet)
[Section titled “Verschlüsselung V1 (Veraltet)”](#verschlüsselung-v1-veraltet)
* Verwendet RSA-2048 für Schlüsselverschlüsselung
* AES-256-CBC für Bundle-Verschlüsselung
* **In der aktuellen CLI nicht mehr verfügbar**
* Legacy-Apps, die V1 verwenden, müssen auf V2 migrieren
Danger
Verschlüsselung V1 wird in der aktuellen Capgo CLI nicht mehr unterstützt. Wenn Sie V1-Verschlüsselung verwenden, müssen Sie auf V2 migrieren. Siehe den [Migrationsleitfaden](/docs/upgrade/encryption-v1-to-v2/) für detaillierte Anweisungen.
## Verschlüsselung einrichten
[Section titled “Verschlüsselung einrichten”](#verschlüsselung-einrichten)
### Schritt 1: Verschlüsselungsschlüssel generieren
[Section titled “Schritt 1: Verschlüsselungsschlüssel generieren”](#schritt-1-verschlüsselungsschlüssel-generieren)
Generieren Sie zunächst Ihre Verschlüsselungsschlüssel mit der Capgo CLI:
```shell
# Neue Verschlüsselungsschlüssel generieren (erstellt Dateien im aktuellen Verzeichnis)
npx @capgo/cli@latest key create
```
Dies erstellt:
* `.capgo_key_v2`: Ihr privater Schlüssel (halten Sie diesen sicher!)
* `.capgo_key_v2.pub`: Ihr öffentlicher Schlüssel (wird von Ihrer App verwendet)
Diese Dateien werden im aktuellen Verzeichnis erstellt, in dem Sie den Befehl ausführen.
Caution
**Wichtige Speicherhinweise:**
* **Privater Schlüssel (`.capgo_key_v2`)**: Committen Sie diesen niemals in die Versionskontrolle. Diese Datei sollte sicher aufbewahrt und nur für die Verschlüsselung während Bundle-Uploads verwendet werden.
* **Öffentlicher Schlüssel (`.capgo_key_v2.pub`)**: Dies kann sicher in die Versionskontrolle committiert werden, da es eine Sicherung Ihres öffentlichen Schlüssels ist.
* **Dateispeicherort**: Schlüssel werden im aktuellen Verzeichnis erstellt, in dem Sie den Befehl `key create` ausführen.
* **Öffentlicher Schlüssel in Konfiguration**: Sie müssen `key save` ausführen, um den öffentlichen Schlüssel in Ihrer Capacitor-Konfiguration zu speichern, damit die mobile App ihn verwenden kann.
Für die Produktionsnutzung speichern Sie den privaten Schlüssel sicher (Umgebungsvariablen, Schlüsselverwaltungsdienste) und entfernen Sie ihn nach dem Setup aus Ihrem lokalen Projekt.
### Schritt 2: Öffentlichen Schlüssel in Capacitor-Konfiguration speichern (Erforderlich)
[Section titled “Schritt 2: Öffentlichen Schlüssel in Capacitor-Konfiguration speichern (Erforderlich)”](#schritt-2-öffentlichen-schlüssel-in-capacitor-konfiguration-speichern-erforderlich)
Sie **müssen** Ihren öffentlichen Schlüssel in der Capacitor-Konfiguration speichern, damit Ihre mobile App Bundles entschlüsseln kann:
```shell
# Öffentlichen Schlüssel aus Datei in Capacitor-Konfiguration speichern (erforderlich)
npx @capgo/cli@latest key save --key ./.capgo_key_v2.pub
# Oder öffentliche Schlüsseldaten direkt speichern
npx @capgo/cli@latest key save --key-data "$CAPGO_PUBLIC_KEY"
```
### Schritt 3: Capacitor-Plattform synchronisieren (Erforderlich)
[Section titled “Schritt 3: Capacitor-Plattform synchronisieren (Erforderlich)”](#schritt-3-capacitor-plattform-synchronisieren-erforderlich)
Nachdem Sie den öffentlichen Schlüssel gespeichert haben, **müssen** Sie die Capacitor-Plattform synchronisieren, um die aktualisierte Konfiguration auf die native Ebene zu kopieren:
```shell
# Plattform synchronisieren, um Konfiguration auf native Ebene zu kopieren
npx cap sync
```
Caution
**Erforderliche Schritte**:
1. Der Befehl `key save` speichert den öffentlichen Schlüssel in Ihrer Capacitor-Konfiguration
2. `npx cap sync` kopiert diese Konfiguration auf die native Ebene, wo die mobile App darauf zugreifen kann
3. Ohne beide Schritte kann Ihre App verschlüsselte Updates nicht entschlüsseln
## Bundles verschlüsseln
[Section titled “Bundles verschlüsseln”](#bundles-verschlüsseln)
### Methode 1: Während des Uploads verschlüsseln
[Section titled “Methode 1: Während des Uploads verschlüsseln”](#methode-1-während-des-uploads-verschlüsseln)
Der einfachste Weg ist die Verschlüsselung während des Upload-Prozesses:
```shell
# Upload mit automatischer Verschlüsselung
npx @capgo/cli@latest bundle upload --key-v2
# Für externen Speicher müssen Sie zuerst verschlüsseln (siehe Manuelle Verschlüsselungs-Workflow unten)
```
### Methode 2: Manueller Verschlüsselungs-Workflow
[Section titled “Methode 2: Manueller Verschlüsselungs-Workflow”](#methode-2-manueller-verschlüsselungs-workflow)
Für mehr Kontrolle können Sie Bundles manuell verschlüsseln:
1. **Ein Zip-Bundle erstellen:**
```shell
npx @capgo/cli@latest bundle zip com.example.app --path ./dist --key-v2
```
2. **Bundle verschlüsseln:**
```shell
npx @capgo/cli@latest bundle encrypt ./com.example.app.zip CHECKSUM_FROM_STEP_1
```
3. **In Ihren Speicher hochladen (z.B. S3) und bei Capgo registrieren:**
```shell
# Zuerst verschlüsseltes Bundle in Ihren Speicher hochladen (z.B. AWS S3)
aws s3 cp ./encrypted-bundle.zip s3://your-bucket/encrypted-bundle.zip
# Dann bei Capgo mit externer URL registrieren
npx @capgo/cli@latest bundle upload --external https://your-storage.com/encrypted-bundle.zip --iv-session-key IV_SESSION_KEY_FROM_STEP_2
```
## Schlüsselverwaltung
[Section titled “Schlüsselverwaltung”](#schlüsselverwaltung)
### Schlüssel sicher speichern
[Section titled “Schlüssel sicher speichern”](#schlüssel-sicher-speichern)
**Optionen für privaten Schlüssel:**
1. **Dateibasiert (lokale Entwicklung):**
```shell
# Schlüssel als .capgo_key_v2-Datei im Projektstamm gespeichert
npx @capgo/cli@latest bundle upload --key-v2
```
2. **Umgebungsvariable (CI/CD):**
```shell
# In Umgebungsvariable für CI speichern
export CAPGO_PRIVATE_KEY="$(cat .capgo_key_v2)"
npx @capgo/cli@latest bundle upload --key-data-v2 "$CAPGO_PRIVATE_KEY"
```
**Öffentliche Schlüssel-Einrichtung (Erforderlich):**
```shell
# Öffentlichen Schlüssel in Capacitor-Konfiguration für mobile App speichern
npx @capgo/cli@latest key save --key ./.capgo_key_v2.pub
```
**Produktionsumgebung:**
* Speichern Sie private Schlüssel in sicheren Schlüsselverwaltungsdiensten (AWS KMS, Azure Key Vault usw.)
* Verwenden Sie CI/CD-Geheimnisverwaltung für private Schlüssel
* Committen Sie niemals private Schlüssel in die Versionskontrolle
**Schlüsselverwendung:**
* **Privater Schlüssel**: Wird von CLI für Verschlüsselung während Bundle-Upload verwendet (sicher aufbewahren)
* **Öffentlicher Schlüssel**: In App-Konfiguration für Entschlüsselung auf Gerät gespeichert (sicher zu committen)
### Schlüsselrotation
[Section titled “Schlüsselrotation”](#schlüsselrotation)
Rotieren Sie regelmäßig Ihre Verschlüsselungsschlüssel für erhöhte Sicherheit:
1. **Neue Schlüssel generieren:**
```shell
# Navigieren Sie zuerst zum gewünschten Verzeichnis, dann Schlüssel erstellen
mkdir ./new-keys && cd ./new-keys
npx @capgo/cli@latest key create
```
2. **Neuen öffentlichen Schlüssel in Capacitor-Konfiguration speichern:**
```shell
npx @capgo/cli@latest key save --key ./new-keys/.capgo_key_v2.pub
```
3. **Aktualisieren Sie Ihre App-Konfiguration** mit dem neuen öffentlichen Schlüssel
4. **Deployen Sie die aktualisierte App**, bevor Sie verschlüsselte Bundles mit dem neuen Schlüssel hochladen
## Sicherheits-Best-Practices
[Section titled “Sicherheits-Best-Practices”](#sicherheits-best-practices)
### Schlüsselsicherheit
[Section titled “Schlüsselsicherheit”](#schlüsselsicherheit)
* **Teilen Sie niemals private Schlüssel** zwischen Umgebungen oder Teammitgliedern
* **Verwenden Sie unterschiedliche Schlüssel** für verschiedene Umgebungen (dev, staging, production)
* **Rotieren Sie Schlüssel regelmäßig** (empfohlen: alle 6-12 Monate)
* **Speichern Sie Schlüssel sicher** mit geeigneten Schlüsselverwaltungssystemen
### Bundle-Sicherheit
[Section titled “Bundle-Sicherheit”](#bundle-sicherheit)
* **Überprüfen Sie immer** die Bundle-Integrität nach der Entschlüsselung
* **Überwachen Sie** auf ungewöhnliche Download-Muster oder Fehler
* **Verwenden Sie HTTPS** für alle Bundle-URLs (erforderlich für mobile Apps)
* **Implementieren Sie** ordnungsgemäße Fehlerbehandlung für Entschlüsselungsfehler
### Zugriffskontrolle
[Section titled “Zugriffskontrolle”](#zugriffskontrolle)
* **Beschränken Sie den Zugriff** auf Verschlüsselungsschlüssel nur auf autorisiertes Personal
* **Verwenden Sie rollenbasierte Zugriffskontrolle** für Schlüsselverwaltungsoperationen
* **Prüfen Sie** regelmäßig Schlüsselnutzung und -zugriff
* **Implementieren Sie** ordnungsgemäße Backup- und Wiederherstellungsverfahren
## Fehlerbehebung bei Verschlüsselung
[Section titled “Fehlerbehebung bei Verschlüsselung”](#fehlerbehebung-bei-verschlüsselung)
### Häufige Probleme
[Section titled “Häufige Probleme”](#häufige-probleme)
**Entschlüsselungsfehler:**
* Überprüfen Sie, ob der private Schlüssel mit dem für die Verschlüsselung verwendeten öffentlichen Schlüssel übereinstimmt
* Prüfen Sie, ob der `ivSessionKey` korrekt ist
* Stellen Sie sicher, dass Sie Verschlüsselung V2 verwenden (V1 wird nicht mehr unterstützt)
**Schlüsselbezogene Fehler:**
* Bestätigen Sie, dass das Format des privaten Schlüssels korrekt ist (PEM-Format)
* Überprüfen Sie, ob der Schlüssel während der Speicherung/Übertragung nicht beschädigt wurde
* Prüfen Sie, ob der Schlüssel die richtigen Berechtigungen in Ihrer App-Konfiguration hat
**Leistungsprobleme:**
* Große Bundles können länger zum Ver-/Entschlüsseln benötigen
* Erwägen Sie die Verwendung von differenziellen Updates, um Bundle-Größen zu reduzieren
* Überwachen Sie die Geräteleistung während der Entschlüsselung
### Debug-Befehle
[Section titled “Debug-Befehle”](#debug-befehle)
Verschlüsselungsstatus überprüfen:
```shell
npx @capgo/cli@latest app debug
```
Verschlüsselungs-/Entschlüsselungs-Workflow testen:
```shell
# Vollständigen Workflow testen: zip → encrypt → decrypt → unzip
npx @capgo/cli@latest bundle zip com.example.app --key-v2
npx @capgo/cli@latest bundle encrypt ./com.example.app.zip CHECKSUM --json
npx @capgo/cli@latest bundle decrypt ./encrypted-bundle.zip IV_SESSION_KEY
```
## Compliance und Standards
[Section titled “Compliance und Standards”](#compliance-und-standards)
Die Verschlüsselungsimplementierung von Capgo folgt Industriestandards:
* **AES-256**: FIPS 140-2 genehmigter Verschlüsselungsalgorithmus
* **RSA-4096**: Starke asymmetrische Verschlüsselung für Schlüsselschutz
* **GCM-Modus**: Bietet sowohl Vertraulichkeit als auch Authentizität
* **Sichere Zufallszahlen**: Kryptografisch sichere Zufallszahlengenerierung
Dies macht Capgo geeignet für Anwendungen, die Compliance benötigen mit:
* GDPR (General Data Protection Regulation)
* HIPAA (Health Insurance Portability and Accountability Act)
* SOC 2 (Service Organization Control 2)
* ISO 27001 (Information Security Management)
## Leistungsüberlegungen
[Section titled “Leistungsüberlegungen”](#leistungsüberlegungen)
### Verschlüsselungs-Overhead
[Section titled “Verschlüsselungs-Overhead”](#verschlüsselungs-overhead)
* **Bundle-Größe**: Verschlüsselte Bundles sind etwas größer (\~1-2% Overhead)
* **Verarbeitungszeit**: Ver-/Entschlüsselung fügt minimale Latenz hinzu
* **Speichernutzung**: Temporärer Anstieg während Ver-/Entschlüsselungsoperationen
### Optimierungstipps
[Section titled “Optimierungstipps”](#optimierungstipps)
* Verwenden Sie differentielle Updates, um verschlüsselte Datenübertragung zu minimieren
* Optimieren Sie Ihre Bundle-Größe durch Konvertierung von Bildern ins WebP-Format
* Minimieren Sie JavaScript- und CSS-Dateien vor dem Bundling
* Entfernen Sie ungenutzte Abhängigkeiten und Code
* Überwachen Sie die Geräteleistung auf älteren/langsameren Geräten
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
* Erfahren Sie mehr über [Custom Storage](/docs/live-updates/custom-storage/), um Verschlüsselung mit Ihrer eigenen Infrastruktur zu verwenden
* Erkunden Sie [Channels](/docs/live-updates/channels/), um verschlüsselte Bundles über Umgebungen hinweg zu verwalten
* Richten Sie [CI/CD Integration](/docs/getting-started/cicd-integration/) ein, um verschlüsselte Bereitstellungen zu automatisieren
# Funktionen
> Vollständige Referenz aller Capgo Live Update-Funktionen, vom Kern-Update-System bis hin zu fortgeschrittenen Bereitstellungskontrollen, Analytik und Funktionen zur Teamzusammenarbeit.
Diese Seite bietet einen umfassenden Überblick über alle in Capgo Live Updates verfügbaren Funktionen. Jede Funktion enthält eine kurze Beschreibung und Links zur detaillierten Dokumentation.
## Kern-Update-System
[Section titled “Kern-Update-System”](#kern-update-system)
### Over-the-Air (OTA) Updates
[Section titled “Over-the-Air (OTA) Updates”](#over-the-air-ota-updates)
Bereitstellung von JavaScript-, HTML-, CSS- und Asset-Updates direkt an die Benutzer ohne Genehmigung durch den App-Store. Updates werden im Hintergrund heruntergeladen und beim nächsten Neustart der App angewendet.
**Kernfunktionen:**
* Downloads im Hintergrund
* Automatische Installation
* Keine Unterbrechung durch den Benutzer
* Plattformübergreifende Unterstützung (iOS, Android, Electron)
[Weitere Informationen zum Verhalten von Updates →](/docs/live-updates/update-behavior/)
***
### Delta Updates (Differenzielle Updates)
[Section titled “Delta Updates (Differenzielle Updates)”](#delta-updates-differenzielle-updates)
Nur Dateien herunterladen, die sich zwischen Versionen geändert haben, wodurch der Bandbreitenverbrauch um bis zu 95 % reduziert und die Bereitstellung von Updates beschleunigt wird.
**Kernfunktionen:**
* Automatischer Unterschied-Vergleich auf Dateiebene
* Prüfum Basis auf Checksummen
* Manifest-Vergleich
* Intelligenter Rückgriff auf vollständige Updates bei Bedarf
[Weitere Informationen zu Differenz-Updates →](/docs/live-updates/differentials/)
***
### Automatisches Rollback
[Section titled “Automatisches Rollback”](#automatisches-rollback)
Wenn ein Update nicht lädt oder Abstürze verursacht, setzt das System automatisch auf die zuletzt bekannte funktionierende Version zurück.
**Kernfunktionen:**
* Crash-Erkennung
* Timeout-Erkennung
* Automatische Rückkehr
* Keine Benutzereingriffe erforderlich
[Weitere Informationen zu Rollbacks →](/docs/live-updates/rollbacks/)
***
### Prüfsummen-Validierung & Fallback
[Section titled “Prüfsummen-Validierung & Fallback”](#prüfsummen-validierung--fallback)
Überprüft die Integrität des Bundles anhand von Checksummen und fällt bei erkanntem Schaden automatisch auf die zuletzt funktionierende Version zurück.
**Kernfunktionen:**
* Prüfsummen-Validierung beim Download
* Erkennung von Beschädigungen
* Automatischer Fallback auf das zuletzt funktionierende Bundle
* Manuelle Wiederherstellungswerkzeuge verfügbar
***
### Breaking Update Detection
[Section titled “Breaking Update Detection”](#breaking-update-detection)
Verhindert, dass inkompatible Updates auf Geräten mit älteren nativen Code-Versionen angewendet werden.
**Kernfunktionen:**
* Prüfung der Kompatibilität nativer Versionen
* Validierung von Plugin-Abhängigkeiten
* Automatisches Blockieren inkompatibler Updates
* Klare Fehlermeldungen
[Weitere Informationen zur Versionszielausrichtung →](/docs/live-updates/version-targeting/)
***
## Deployment-Kontrolle
[Section titled “Deployment-Kontrolle”](#deployment-kontrolle)
### Kanal-System
[Section titled “Kanal-System”](#kanal-system)
Organisieren und verwalten Sie Updates über verschiedene Umgebungen und Benutzersegmente hinweg mit flexiblen Kanal-Konfigurationen.
**Kernfunktionen:**
* Unbegrenzte benutzerdefinierte Kanäle (Produktion, Staging, Beta usw.)
* Bündelzuweisungen pro Kanal
* Kanalspezifische Zielregeln
* Geräte-Selbstzuordnung
* Kanalkonflikt pro Gerät
[Weitere Informationen zu Kanälen →](/docs/live-updates/channels/)
***
### Geräte-Zielauswahl
[Section titled “Geräte-Zielauswahl”](#geräte-zielauswahl)
Gezielte Ansprache bestimmter Geräte, Versionen oder Benutzersegmente für gestaffelte Rollouts und kontrollierte Bereitstellungen.
**Kernfunktionen:**
* Versionsbasierte Zielauswahl
* Gerätebezogene Überschreibungen
* Plattform-Filterung (iOS, Android)
* Benutzerdefinierte Metadaten-Filterung
* Emulator- bzw. Entwicklungsbuild-Sperrung
***
### Kanalrichtlinien
[Section titled “Kanalrichtlinien”](#kanalrichtlinien)
Richten Sie Regeln und Einschränkungen dafür ein, wie Updates auf jedem Kanal ausgeliefert werden.
**Kernfunktionen:**
* Auto-Updates deaktivieren
* Großversions-Updates blockieren
* Updates auf Emulatoren deaktivieren
* Updates in Entwicklungs-Builds deaktivieren
* Plattformabhängige Richtlinien (nur iOS, nur Android)
[Weitere Informationen zu Kanalrichtlinien →](/docs/live-updates/channels/#channel-policies)
***
## Entwicklertools
[Section titled “Entwicklertools”](#entwicklertools)
### Bundle-Vorschau
[Section titled “Bundle-Vorschau”](#bundle-vorschau)
Vorschau von Bundles in einer Live-Web-Umgebung vor dem Bereitstellen auf Geräten, zugänglich über das Web-Dashboard.
**Standort:** Web Dashboard → App → Bundle → Vorschau-Reiter
***
### Live-Debugging
[Section titled “Live-Debugging”](#live-debugging)
Echtzeit-Überwachung von Update-Ereignissen für bestimmte Geräte über die CLI, zeigt Prüf-, Download-, Installations- und Fehlerereignisse.
**Verwendung:**
```bash
npx @capgo/cli app debug [appId]
```
**Zeigt an:**
* Update-Prüfungen
* Download-Fortschritt
* Installationsstatus
* Fehlermeldungen
* Richtlinienblockaden
***
### Bundle-Manifest-Viewer
[Section titled “Bundle-Manifest-Viewer”](#bundle-manifest-viewer)
Untersuchen Sie das vollständige Manifest eines Bundles einschließlich Dateiliste, Checksummen und Metadaten.
**Standort:** Web Dashboard → App → Bundle → Manifest-Reiter
**Zeigt an:**
* Dateiliste mit Checksums
* Bundle-Metadaten
* Native Version-Kompatibilität
* Plugin-Abhängigkeiten
***
### Native Plugin-Abhängigkeiten
[Section titled “Native Plugin-Abhängigkeiten”](#native-plugin-abhängigkeiten)
Zeigen Sie alle nativen Capacitor-Plugins, die in jedem Bundle enthalten sind, um Abhängigkeitsänderungen über Versionen hinweg zu verfolgen.
**Standort:** Web Dashboard → App → Bundle → Dependencies Reiter
**Zeigt an:**
* Plugin-Namen und Versionen
* Abhängigkeits-Hinzufügungen/-Entfernungen
* Kompatibilitätswarnungen
***
### CLI-Integration
[Section titled “CLI-Integration”](#cli-integration)
Umfassende Kommandozeilen-Schnittstelle für automatisierte Bereitstellungen und CI/CD-Integration.
**Kernbefehle:**
* `bundle upload` - Neue Bundles hochladen
* `bundle list` - Alle Bundles auflisten
* `bundle delete` - Bundles löschen
* `bundle cleanup` - Alte Bundles bereinigen
* `channel set` - Kanäle konfigurieren
* `app debug` - Live-Debugging
[Vollständige CLI-Referenz ansehen →](/docs/cli/reference/)
***
### Bundle-Verschlüsselung
[Section titled “Bundle-Verschlüsselung”](#bundle-verschlüsselung)
End-to-End-Verschlüsselung für Bundles mit AES-256-Verschlüsselung, schützt Ihren Code während der Übertragung und im Ruhezustand.
**Kernfunktionen:**
* Generierung eines RSA-Schlüsselpaares
* AES-256 Bundle-Verschlüsselung
* Signaturüberprüfung des Codes
* Verwaltung von Verschlüsselungsschlüsseln
[Weitere Informationen zur Verschlüsselung →](/docs/live-updates/encryption/)
***
### Bundle-Bereinigung & Aufbewahrung
[Section titled “Bundle-Bereinigung & Aufbewahrung”](#bundle-bereinigung--aufbewahrung)
Bereinigt automatisch alte Bundles basierend auf Aufbewahrungsrichtlinien, um den Speicherverbrauch zu verwalten.
**Kernfunktionen:**
* Konfigurierbare Aufbewahrungsanzahl
* Automatische Bereinigung über CLI
* Geplante Bereinigungsaufträge
* Speicherverbrauch-Überwachung
**Verwendung:**
```bash
npx @capgo/cli bundle cleanup --keep=10
```
***
## Analytik & Überwachung
[Section titled “Analytik & Überwachung”](#analytik--überwachung)
### Update-Statistiken
[Section titled “Update-Statistiken”](#update-statistiken)
Verfolgen Sie Akzeptanzraten von Updates, Erfolgsquoten und Bereitstellungsfortschritt in Ihrer Benutzerbasis.
**Verfügbare Kennzahlen:**
* Erfolgsquote beim Herunterladen
* Erfolgsquote bei der Installation
* Fehlerquoten nach Typ
* Update-Adoption im Zeitverlauf
* Versionsverteilung
**Standort:** Web Dashboard → App → Statistiken
***
### Geräte-Protokolle
[Section titled “Geräte-Protokolle”](#geräte-protokolle)
Ereignisprotokolle pro Gerät, die den gesamten Update-Zyklus von Prüfung bis Installation zeigen.
**Ereignistypen:**
* Update-Prüfungen
* Download-Start/Abschluss/Fehler
* Installationsstart/Abschluss/Fehler
* Rollback-Ereignisse
* Richtlinienblockaden
**Standort:**
* Web Dashboard → App → Device → Logs
* Web Dashboard → App → Logs (alle Geräte)
[Weitere Informationen zu Protokollen →](/docs/webapp/logs/)
***
### Bundle-Nutzungsanalytik
[Section titled “Bundle-Nutzungsanalytik”](#bundle-nutzungsanalytik)
Detaillierte Analysen darüber, welche Bundles aktiv sind, Download-Anzahlen und Speicherverbrauch.
**Kennzahlen:**
* Aktive Installationen pro Bundle
* Download-Anzahlen
* Speicherverbrauch pro Bundle
* Bandbreitennutzung
***
### Kanalstatistiken
[Section titled “Kanalstatistiken”](#kanalstatistiken)
Verfolgen Sie Leistungs- und Akzeptanzmetriken pro Kanal.
**Kennzahlen:**
* Geräte pro Kanal
* Erfolgsquoten bei Updates pro Kanal
* Bereitstellungshistorie
* Fehlerquoten nach Kanal
**Standort:** Web Dashboard → App → Channel → Statistiken
***
### Bereitstellungshistorie
[Section titled “Bereitstellungshistorie”](#bereitstellungshistorie)
Vollständige Audit-Trails aller Bundle-Bereitstellungen, Kanalzuweisungen und Konfigurationsänderungen.
**Verfolgte Ereignisse:**
* Bundle-Uploads
* Kanalzuweisungen
* Richtlinienänderungen
* Geräteüberschreibungen
**Standort:** Web Dashboard → App → Channel → History
***
## Sicherheit & Compliance
[Section titled “Sicherheit & Compliance”](#sicherheit--compliance)
### End-to-End-Verschlüsselung
[Section titled “End-to-End-Verschlüsselung”](#end-to-end-verschlüsselung)
Verschlüsselt Bundles im Ruhezustand und während der Übertragung mit der AES-256-Verschlüsselung gemäß Industriestandard.
[Weitere Informationen zur Verschlüsselung →](/docs/live-updates/encryption/)
***
### Code-Signierung
[Section titled “Code-Signierung”](#code-signierung)
Überprüfen Sie die Integrität von Bundles mithilfe kryptografischer Signaturen, um Manipulationen zu verhindern.
***
### SOC 2 Typ II-Compliance
[Section titled “SOC 2 Typ II-Compliance”](#soc-2-typ-ii-compliance)
Infrastruktur und Prozesse zertifiziert nach SOC 2 Type II Standards für Unternehmenssicherheit.
***
### App-Store-Compliance
[Section titled “App-Store-Compliance”](#app-store-compliance)
Vollständige Einhaltung der Richtlinien des Apple App Store und des Google Play Store für OTA-Updates.
[Weitere Informationen zur Compliance →](/docs/live-updates/compliance/)
***
### 2FA-Verpflichtung (Organisationsebene)
[Section titled “2FA-Verpflichtung (Organisationsebene)”](#2fa-verpflichtung-organisationsebene)
Erfordern Sie eine Zwei-Faktor-Authentifizierung für alle Organisationsmitglieder, um auf das Dashboard und die API zuzugreifen.
**Standort:** Web Dashboard → Organization → Security
[Weitere Informationen zur 2FA →](/docs/webapp/2fa-enforcement/)
***
### Durchsetzung verschlüsselter Bundles
[Section titled “Durchsetzung verschlüsselter Bundles”](#durchsetzung-verschlüsselter-bundles)
Verlangen Sie, dass alle Bundles auf Organisationsebene verschlüsselt sind.**Standort:** Web Dashboard → Organisation → Sicherheit
***
## Teamzusammenarbeit
[Section titled “Teamzusammenarbeit”](#teamzusammenarbeit)
### Rollenbasierte Zugriffskontrolle (RBAC)
[Section titled “Rollenbasierte Zugriffskontrolle (RBAC)”](#rollenbasierte-zugriffskontrolle-rbac)
Genaue Berechtigungen für die Organisations- und App-Ebene der Zugriffskontrolle
**Organisationsrollen:**
1. `super_admin` - Voller Zugriff
2. `admin` - Administrativer Zugriff
3. `read` - Nur-Lesezugriff
4. `upload` - Nur-Upload-Zugriff
**App-Rollen:**
1. `app_developer` - Voller App-Zugriff
2. `app_uploader` - Nur Upload von Bundles
3. `app_reader` - Nur-Lesezugriff
**Standort:**
1. Web Dashboard → Organisation → Mitglieder
2. Web Dashboard → App → Zugriff
[Learn more about RBAC →](/docs/webapp/organization-system/#roles-and-permissions)
***
### Audit-Protokolle
[Section titled “Audit-Protokolle”](#audit-protokolle)
Vollständige Audit-Spur aller Aktivitäten der Organisation und der Apps zur Einhaltung von Vorschriften und Sicherheit.
**Protokollierte Ereignisse:**
1. Benutzeraktionen (Anmeldung, Abmeldung, Berechtigungsänderungen)
2. Bundle-Operationen (Upload, Löschen, Zuweisen)
3. Kanal-Operationen (Erstellen, Aktualisieren, Löschen)
4. Organisationsänderungen (Einstellungen, Mitglieder)
**Standort:** Web Dashboard → Organisation → Audit Logs
***
### Webhooks
[Section titled “Webhooks”](#webhooks)
Echtzeit-Benachrichtigungen über Ereignisse in Ihren Apps per HTTP-Webhooks empfangen.
**Unterstützte Ereignisse:**
1. `apps` - App erstellt/aktualisiert/gelöscht
2. `app_versions` - Bundle hochgeladen/gelöscht
3. `channels` - Kanal erstellt/aktualisiert/gelöscht
4. `org_users` - Mitglied hinzugefügt/entfernt
5. `orgs` - Organisation aktualisiert
**Funktionen:**
1. Custom webhook URLs
2. Ereignis-Filterung
3. Zustellungsprotokolle
4. Wiederholungsmechanismus
5. Testfunktionalität
**Standort:** Web Dashboard → Organisation → Webhooks
***
### Mehrbenutzer-Zusammenarbeit
[Section titled “Mehrbenutzer-Zusammenarbeit”](#mehrbenutzer-zusammenarbeit)
Laden Sie Teammitglieder in Ihre Organisation mit bestimmten Rollen und Berechtigungen ein.
**Funktionen:**
1. Einladungen per E-Mail
2. Rollenzuweisung
3. Mitgliederverwaltung
4. Zugriff entziehen
**Standort:** Web Dashboard → Organisation → Mitglieder
***
### API-Schlüssel-Verwaltung
[Section titled “API-Schlüssel-Verwaltung”](#api-schlüssel-verwaltung)
Erstellen, verwalten und widerrufen Sie API-Schlüssel mit optionalen Ablaufdaten und gehashter Speicherung.
**Schlüssel-Funktionen:**
1. Pro-App- oder Organisationsschlüssel
2. Optionale Ablaufdaten
3. Gehashte Speicherung (irreversibel)
4. Schlüsselrotation unterstützt
**Standort:** Web Dashboard → API Keys
[Learn more about API keys →](/docs/public-api/#authentication)
***
### Passwortrichtlinien
[Section titled “Passwortrichtlinien”](#passwortrichtlinien)
Organisationsweite Passwortrichtlinien zur Durchsetzung von Sicherheitsstandards.
**Konfigurierbare Richtlinien:**
1. Mindestlänge
2. Großbuchstaben erforderlich
3. Zahlen erforderlich
4. Sonderzeichen erforderlich
**Standort:** Web Dashboard → Organisation → Security
***
## Plattformunterstützung
[Section titled “Plattformunterstützung”](#plattformunterstützung)
### Plattformübergreifende Unterstützung
[Section titled “Plattformübergreifende Unterstützung”](#plattformübergreifende-unterstützung)
Unterstützung für iOS-, Android- und Electron-Apps mit einem einzigen SDK.
**Unterstützte Plattformen:**
1. iOS (Capacitor 5, 6, 7, 8)
2. Android (Capacitor 5, 6, 7, 8)
3. Electron (NEU im Jahr 2025)
***
### Langzeitunterstützung
[Section titled “Langzeitunterstützung”](#langzeitunterstützung)
Fortlaufende Unterstützung älterer Capacitor-Versionen zur Aufrechterhaltung der Kompatibilität mit Legacy-Apps.
**Derzeit unterstützt:**
1. Capacitor 8 (neueste)
2. Capacitor 7
3. Capacitor 6
4. Capacitor 5
***
### Eigene Speicher-Backends
[Section titled “Eigene Speicher-Backends”](#eigene-speicher-backends)
Verwenden Sie Ihre eigene Speicherinfrastruktur (S3, R2, etc.) statt Capgo’s Standard-Speicher.
[Learn more about custom storage →](/docs/live-updates/custom-storage/)
***
### China-Konfiguration
[Section titled “China-Konfiguration”](#china-konfiguration)
Spezielle Konfiguration für Apps, die in Festlandchina verteilt werden, um lokale Vorschriften einzuhalten.
[Learn more about China configuration →](/docs/live-updates/china-configuration/)
***
## Erweiterte Funktionen
[Section titled “Erweiterte Funktionen”](#erweiterte-funktionen)
### Benutzerdefiniertes Update-Verhalten
[Section titled “Benutzerdefiniertes Update-Verhalten”](#benutzerdefiniertes-update-verhalten)
Konfigurieren Sie, wann und wie Updates über das SDK geprüft und angewendet werden.
**Konfigurierbare Optionen:**
1. Prüfintervall (`periodCheckDelay` - Mindestwert 600 Sekunden)
2. Direktes Update-Timing (`directUpdate` - atInstall, onLaunch, always)
3. Auto-Update aktivieren/deaktivieren (`autoUpdate`)
4. Netzwerk-Anforderungen (nur Android - über WorkManager)
[Learn more about update behavior →](/docs/live-updates/update-behavior/)
***
### Update-Typen
[Section titled “Update-Typen”](#update-typen)
Verschiedene Update-Typen für unterschiedliche Anwendungsfälle, von Sofort-Updates bis hin zu benutzerkontrollierten Installationen.
**Verfügbare Typen:**
1. Hintergrund-Updates (Standard)
2. Sofort-Updates
3. Vom Benutzer bestätigte Updates
4. Bedingte Updates
[Learn more about update types →](/docs/live-updates/update-types/)
***
### Kreditsystem
[Section titled “Kreditsystem”](#kreditsystem)
Nutzungsbasierte Abrechnung mit Guthaben für Bandbreite, Speicher und andere Ressourcen.
**Funktionen:**
1. Kreditnutzung verfolgen
2. Nutzungsbenachrichtigungen
3. Aufladen via Stripe
4. Kreditbuchführung
**Standort:** Web Dashboard → Organisation → Credits
***
## Erste Schritte
[Section titled “Erste Schritte”](#erste-schritte)
Bereit, diese Funktionen zu nutzen? Befolgen Sie unseren [Quickstart Guide](/docs/getting-started/quickstart/) um Ihre erste App mit Capgo Live Updates einzurichten.
## Hilfe benötigt?
[Section titled “Hilfe benötigt?”](#hilfe-benötigt)
* [Join our Discord](https://discord.capgo.app) für Community-Support
* [Check the FAQ](/docs/faq/) für häufig gestellte Fragen
* [Browse API documentation](/docs/public-api/) für API-Integration
* [Contact support](https://capgo.app/consulting/) für Unternehmensunterstützung .
# CI/CD Integrationen
> Integrieren Sie Capgo Live Updates mit Ihrer bevorzugten CI/CD-Plattform für automatisierte Bereitstellungs-Workflows.
Automatisieren Sie Ihren Capgo Live Updates-Bereitstellungsprozess durch Integration mit beliebten CI/CD-Plattformen. Diese Integrationen ermöglichen es Ihnen, App-Updates automatisch bereitzustellen, wenn Sie Code-Änderungen pushen, Feature-Branches zu testen und mehrere Bereitstellungsumgebungen zu verwalten.
## Verfügbare Integrationen
[Section titled “Verfügbare Integrationen”](#verfügbare-integrationen)
Wählen Sie Ihre CI/CD-Plattform, um mit automatisierten Bereitstellungen zu beginnen:
[Azure DevOps ](/docs/live-updates/integrations/azure-devops/)Integrieren Sie mit Azure DevOps Pipelines für automatisierte Builds, Tests und Bereitstellungs-Workflows.
[GitLab CI/CD ](/docs/live-updates/integrations/gitlab-ci/)Richten Sie GitLab CI/CD-Pipelines ein, um Ihre App-Updates automatisch mit umfassendem Umgebungsmanagement bereitzustellen.
[GitHub Actions ](/docs/live-updates/integrations/github-actions/)Verwenden Sie GitHub Actions für leistungsstarke Automatisierung mit Multi-Channel-Bereitstellungen und Umgebungsschutz.
[Bitbucket Pipelines ](/docs/live-updates/integrations/bitbucket-pipeline/)Deployen Sie mit Bitbucket Pipelines unter Verwendung einfacher oder erweiterter Konfigurationen für mehrere Umgebungen.
## Was Sie erhalten
[Section titled “Was Sie erhalten”](#was-sie-erhalten)
Alle Integrationsleitfäden enthalten:
* **Einfache Einrichtung**: Grundkonfiguration zum schnellen Einstieg
* **Erweiterte Workflows**: Multi-Umgebungs-Bereitstellungen mit Staging und Production
* **Feature-Branch-Tests**: Automatische Bereitstellung von Feature-Branches zu Test-Channels
* **Sicherheits-Best-Practices**: Sichere Geheimnisverwaltung und Umgebungsschutz
* **Überwachung**: Benachrichtigungen und Protokollierung für Bereitstellungsstatus
Tip
**Neu bei CI/CD?** Beginnen Sie mit der einfachen Konfiguration für Ihre Plattform und fügen Sie dann schrittweise erweiterte Funktionen wie Multi-Channel-Bereitstellungen und automatisierte Tests hinzu, wenn Ihre Anforderungen wachsen.
## Gemeinsame Funktionen
[Section titled “Gemeinsame Funktionen”](#gemeinsame-funktionen)
Jede Integration unterstützt:
* **Automatisierte Builds**: Bereitstellungen bei Code-Änderungen auslösen
* **Multi-Channel-Unterstützung**: Zu verschiedenen Channels bereitstellen (development, staging, production)
* **Pull-Request/Merge-Request-Tests**: Änderungen in isolierten Umgebungen testen
* **Verschlüsselungs-Unterstützung**: Sichere Bereitstellungen mit Capgos Verschlüsselungsfunktion
* **Umgebungsschutz**: Manuelle Genehmigungen und eingeschränkter Zugriff für Production
* **Benachrichtigungen**: Slack-, E-Mail- und andere Benachrichtigungsintegrationen
## Voraussetzungen
[Section titled “Voraussetzungen”](#voraussetzungen)
Bevor Sie eine Integration einrichten, stellen Sie sicher, dass Sie haben:
* Ein Capgo-Konto mit einer konfigurierten App
* Den Quellcode Ihrer App in einem Git-Repository
* Ein Capgo API-Token von [console.capgo.app/apikeys](https://console.capgo.app/apikeys)
* Node.js und npm/yarn in Ihrem Projekt konfiguriert
## Verwandte Dokumentation
[Section titled “Verwandte Dokumentation”](#verwandte-dokumentation)
* [Channels](/docs/live-updates/channels/) - Erfahren Sie, wie Sie verschiedene Bereitstellungsumgebungen verwalten
* [Encryption](/docs/live-updates/encryption/) - Sichern Sie Ihre Bereitstellungen mit Ende-zu-Ende-Verschlüsselung
* [Update Behavior](/docs/live-updates/update-behavior/) - Passen Sie an, wie Updates auf Ihre Apps angewendet werden
Wählen Sie oben Ihre CI/CD-Plattform, um mit der Automatisierung Ihrer Capgo-Bereitstellungen zu beginnen!
# Azure DevOps Integration
> Erfahren Sie, wie Sie Capgo Live Updates mit Azure DevOps Pipelines für die automatisierte Bereitstellung Ihrer App-Updates integrieren.
Integrieren Sie Capgo Live Updates mit Azure DevOps Pipelines, um Ihre App-Updates automatisch bereitzustellen, wenn Sie Code-Änderungen pushen. Dieser Leitfaden behandelt die Einrichtung automatisierter Build-, Test- und Bereitstellungs-Workflows.
## Voraussetzungen
[Section titled “Voraussetzungen”](#voraussetzungen)
Stellen Sie vor der Einrichtung der Azure DevOps-Integration sicher, dass Sie Folgendes haben:
* Eine Azure DevOps-Organisation und ein Projekt
* Ein Capgo-Konto mit einer konfigurierten App
* Den Quellcode Ihrer App in einem Azure Repos Git-Repository
* Node.js und npm/yarn in Ihrem Projekt konfiguriert
## Einrichten der Azure DevOps Pipeline
[Section titled “Einrichten der Azure DevOps Pipeline”](#einrichten-der-azure-devops-pipeline)
### Schritt 1: Pipeline-Variablen erstellen
[Section titled “Schritt 1: Pipeline-Variablen erstellen”](#schritt-1-pipeline-variablen-erstellen)
Richten Sie zunächst die erforderlichen Variablen in Ihrem Azure DevOps-Projekt ein:
1. Navigieren Sie zu Ihrem Azure DevOps-Projekt
2. Gehen Sie zu **Pipelines** → **Library** → **Variable groups**
3. Erstellen Sie eine neue Variablengruppe namens `Capgo-Variables`
4. Fügen Sie die folgenden Variablen hinzu:
| Variablenname | Wert | Sicher |
| ------------- | ------------------- | ------ |
| `CAPGO_TOKEN` | Ihr Capgo API-Token | ✅ Ja |
Tip
Holen Sie sich Ihr Capgo API-Token von [console.capgo.app/apikeys](https://console.capgo.app/apikeys). Ihre App-ID ist bereits in Ihrer `capacitor.config.ts`-Datei konfiguriert.
## Einfach
[Section titled “Einfach”](#einfach)
Grundkonfiguration, die bei jedem Push zum main-Branch in die Produktion deployt:
```yaml
# Simple Azure DevOps Pipeline for Capgo Live Updates
trigger:
branches:
include:
- main
variables:
- group: Capgo-Variables
jobs:
- job: BuildAndDeploy
displayName: 'Build and Deploy to Capgo'
pool:
vmImage: 'ubuntu-latest'
steps:
- task: NodeTool@0
displayName: 'Setup Node.js'
inputs:
versionSpec: '22.x'
- script: |
npm ci
npm run test
npm run build
displayName: 'Install, test and build'
- script: |
npm install -g @capgo/cli
npx @capgo/cli bundle upload --apikey $(CAPGO_TOKEN) --channel production
displayName: 'Deploy to Capgo'
```
## Erweitert
[Section titled “Erweitert”](#erweitert)
### Feature-Branch-Bereitstellungen
[Section titled “Feature-Branch-Bereitstellungen”](#feature-branch-bereitstellungen)
Deployen Sie Feature-Branches zu Test-Channels für Review und Testing:
```yaml
# Feature branch deployment
trigger:
branches:
include:
- feature/*
variables:
- group: Capgo-Variables
jobs:
- job: DeployFeature
displayName: 'Deploy Feature Branch'
pool:
vmImage: 'ubuntu-latest'
condition: startsWith(variables['Build.SourceBranch'], 'refs/heads/feature/')
steps:
- task: NodeTool@0
inputs:
versionSpec: '22.x'
- script: |
npm ci
npm run test
npm run build
displayName: 'Install, test and build'
- script: |
BRANCH_NAME=$(echo "$(Build.SourceBranchName)" | sed 's/[^a-zA-Z0-9-]/-/g')
CHANNEL_NAME="feature-$BRANCH_NAME"
npm install -g @capgo/cli
npx @capgo/cli channel create $CHANNEL_NAME --apikey $(CAPGO_TOKEN) || true
npx @capgo/cli bundle upload --apikey $(CAPGO_TOKEN) --channel $CHANNEL_NAME
displayName: 'Deploy to Feature Channel'
```
Tip
**Testen mit Channels**: Nach der Bereitstellung in einem Feature-Channel können Sie das Update in Ihrer App testen, indem Sie diese für die Verwendung dieses spezifischen Channels konfigurieren. Erfahren Sie mehr über [das Konfigurieren von Channels in Ihrer App](/docs/live-updates/channels/#configuring-the-channel-in-your-app).
### Verschlüsselung verwenden
[Section titled “Verschlüsselung verwenden”](#verschlüsselung-verwenden)
Wenn Sie [Capgos Verschlüsselungsfunktion](/docs/live-updates/encryption/) nutzen, müssen Sie Ihren privaten Schlüssel sicher in Ihrer CI/CD-Umgebung speichern.
Nach dem [Einrichten der Verschlüsselungsschlüssel](/docs/live-updates/encryption/#setting-up-encryption) lokal fügen Sie Ihren privaten Schlüssel zu den Azure DevOps-Variablen hinzu:
```shell
# Zeigen Sie den Inhalt Ihres privaten Schlüssels an (kopieren Sie diese Ausgabe)
cat .capgo_key_v2
```
Fügen Sie diesen Inhalt als `CAPGO_PRIVATE_KEY` in Ihrer Azure DevOps-Variablengruppe hinzu (als Secret markieren) und verwenden Sie ihn dann in Pipelines:
```yaml
# Deploy with encryption
- script: |
npm install -g @capgo/cli
npx @capgo/cli bundle upload --apikey $(CAPGO_TOKEN) --key-data-v2 "$(CAPGO_PRIVATE_KEY)" --channel production
displayName: 'Deploy to Capgo with Encryption'
```
Caution
**Sicherheits-Best-Practices:**
* Committen Sie niemals die `.capgo_key_v2`-Datei in die Versionskontrolle
* Speichern Sie den privaten Schlüssel nur in sicherer CI/CD-Geheimnisverwaltung
* Verwenden Sie unterschiedliche Schlüssel für verschiedene Umgebungen
### Multi-Channel-Konfiguration
[Section titled “Multi-Channel-Konfiguration”](#multi-channel-konfiguration)
Für umfassende Informationen zum Einrichten und Verwalten mehrerer Bereitstellungs-Channels siehe die [Channels-Dokumentation](/docs/live-updates/channels/).
Vollständige Konfiguration mit mehreren Umgebungen und Pull-Request-Bereitstellungen:
```yaml
# Advanced Azure DevOps Pipeline with Multiple Channels
trigger:
branches:
include:
- main
- develop
pr:
branches:
include:
- main
- develop
variables:
- group: Capgo-Variables
stages:
# Build stage
- stage: Build
jobs:
- job: BuildApp
pool:
vmImage: 'ubuntu-latest'
steps:
- task: NodeTool@0
inputs:
versionSpec: '22.x'
- script: |
npm ci
npm run test
npm run build
displayName: 'Install, test and build'
- task: PublishBuildArtifacts@1
inputs:
pathToPublish: 'dist'
artifactName: 'app-build'
# Deploy to development
- stage: DeployDev
condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/develop'))
jobs:
- deployment: DeployDevelopment
environment: development
pool:
vmImage: 'ubuntu-latest'
strategy:
runOnce:
deploy:
steps:
- task: NodeTool@0
inputs:
versionSpec: '22.x'
- task: DownloadBuildArtifacts@0
inputs:
artifactName: 'app-build'
downloadPath: '$(Pipeline.Workspace)'
- script: |
npm install -g @capgo/cli
npx @capgo/cli bundle upload --apikey $(CAPGO_TOKEN) --channel development --path $(Pipeline.Workspace)/app-build
displayName: 'Deploy to Development'
# Deploy PR to test channel
- stage: DeployPR
condition: and(succeeded(), eq(variables['Build.Reason'], 'PullRequest'))
jobs:
- job: DeployPRChannel
pool:
vmImage: 'ubuntu-latest'
steps:
- task: NodeTool@0
inputs:
versionSpec: '22.x'
- task: DownloadBuildArtifacts@0
inputs:
artifactName: 'app-build'
downloadPath: '$(Pipeline.Workspace)'
- script: |
CHANNEL_NAME="pr-$(System.PullRequest.PullRequestNumber)"
npm install -g @capgo/cli
npx @capgo/cli channel create $CHANNEL_NAME --apikey $(CAPGO_TOKEN) || true
npx @capgo/cli bundle upload --apikey $(CAPGO_TOKEN) --channel $CHANNEL_NAME --path $(Pipeline.Workspace)/app-build
displayName: 'Deploy to PR Channel'
# Deploy to production
- stage: DeployProd
condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
jobs:
- deployment: DeployProduction
environment: production
pool:
vmImage: 'ubuntu-latest'
strategy:
runOnce:
deploy:
steps:
- task: NodeTool@0
inputs:
versionSpec: '22.x'
- task: DownloadBuildArtifacts@0
inputs:
artifactName: 'app-build'
downloadPath: '$(Pipeline.Workspace)'
- script: |
npm install -g @capgo/cli
npx @capgo/cli bundle upload --apikey $(CAPGO_TOKEN) --channel production --path $(Pipeline.Workspace)/app-build
displayName: 'Deploy to Production'
```
### Multi-Umgebungs-Bereitstellung
[Section titled “Multi-Umgebungs-Bereitstellung”](#multi-umgebungs-bereitstellung)
Für komplexe Szenarien mit mehreren Umgebungen:
```yaml
# Extended pipeline with multiple environments
parameters:
- name: deployEnvironment
displayName: 'Deploy Environment'
type: string
default: 'staging'
values:
- staging
- production
variables:
- group: Capgo-Variables
- name: channelName
${{ if eq(parameters.deployEnvironment, 'production') }}:
value: 'production'
${{ else }}:
value: 'staging'
stages:
# Build stage
- stage: Build
jobs:
- job: BuildApp
pool:
vmImage: 'ubuntu-latest'
steps:
- task: NodeTool@0
inputs:
versionSpec: '22.x'
- script: |
npm ci
npm run test
npm run build
displayName: 'Install, test and build'
- task: PublishBuildArtifacts@1
inputs:
pathToPublish: 'dist'
artifactName: 'app-build'
- stage: DeployStaging
displayName: 'Deploy to Staging'
dependsOn: Build
condition: and(succeeded(), eq('${{ parameters.deployEnvironment }}', 'staging'))
jobs:
- deployment: DeployStaging
displayName: 'Deploy to Staging Channel'
pool:
vmImage: 'ubuntu-latest'
environment: 'staging'
strategy:
runOnce:
deploy:
steps:
- template: deploy-steps.yml
parameters:
channel: 'staging'
- stage: DeployProduction
displayName: 'Deploy to Production'
dependsOn: Build
condition: and(succeeded(), eq('${{ parameters.deployEnvironment }}', 'production'))
jobs:
- deployment: DeployProduction
displayName: 'Deploy to Production Channel'
pool:
vmImage: 'ubuntu-latest'
environment: 'production'
strategy:
runOnce:
deploy:
steps:
- template: deploy-steps.yml
parameters:
channel: 'production'
```
### Deployment-Vorlage (deploy-steps.yml)
[Section titled “Deployment-Vorlage (deploy-steps.yml)”](#deployment-vorlage-deploy-stepsyml)
Erstellen Sie eine wiederverwendbare Vorlagendatei `deploy-steps.yml`:
deploy-steps.yml
```yaml
parameters:
- name: channel
type: string
steps:
- task: NodeTool@0
displayName: 'Install Node.js'
inputs:
versionSpec: '22.x'
- task: DownloadBuildArtifacts@0
displayName: 'Download build artifacts'
inputs:
artifactName: 'app-build'
downloadPath: '$(System.ArtifactsDirectory)'
- script: |
npm install -g @capgo/cli
displayName: 'Install Capgo CLI'
- script: |
npx @capgo/cli bundle upload \
--apikey $(CAPGO_TOKEN) \
--channel ${{ parameters.channel }} \
--path $(System.ArtifactsDirectory)/app-build
displayName: 'Upload to Capgo (${{ parameters.channel }})'
```
### Branch-basierte Bereitstellungsstrategie
[Section titled “Branch-basierte Bereitstellungsstrategie”](#branch-basierte-bereitstellungsstrategie)
Konfigurieren Sie verschiedene Bereitstellungsstrategien basierend auf Git-Branches:
```yaml
trigger:
branches:
include:
- main
- develop
- feature/*
variables:
- group: Capgo-Variables
- name: targetChannel
${{ if eq(variables['Build.SourceBranch'], 'refs/heads/main') }}:
value: 'production'
${{ elseif eq(variables['Build.SourceBranch'], 'refs/heads/develop') }}:
value: 'staging'
${{ else }}:
value: 'development'
stages:
- stage: Build
jobs:
- job: BuildApp
pool:
vmImage: 'ubuntu-latest'
steps:
- task: NodeTool@0
inputs:
versionSpec: '22.x'
- script: |
npm ci
npm run test
npm run build
displayName: 'Install, test and build'
- task: PublishBuildArtifacts@1
inputs:
pathToPublish: 'dist'
artifactName: 'app-build'
- stage: Deploy
displayName: 'Deploy to $(targetChannel)'
dependsOn: Build
condition: succeeded()
jobs:
- deployment: DeployJob
displayName: 'Deploy to $(targetChannel) Channel'
pool:
vmImage: 'ubuntu-latest'
environment: '$(targetChannel)'
strategy:
runOnce:
deploy:
steps:
- template: deploy-steps.yml
parameters:
channel: '$(targetChannel)'
```
## Sicherheits-Best-Practices
[Section titled “Sicherheits-Best-Practices”](#sicherheits-best-practices)
### Sichere Variablenverwaltung
[Section titled “Sichere Variablenverwaltung”](#sichere-variablenverwaltung)
1. **Variablengruppen verwenden**: Sensible Daten in Azure DevOps-Variablengruppen speichern
2. **Als Secret markieren**: Immer API-Tokens und Schlüssel als Secret-Variablen markieren
3. **Zugriff einschränken**: Variablengruppen-Zugriff auf bestimmte Pipelines und Benutzer beschränken
4. **Schlüssel rotieren**: Regelmäßig Ihre Capgo API-Tokens rotieren
## Überwachung und Benachrichtigungen
[Section titled “Überwachung und Benachrichtigungen”](#überwachung-und-benachrichtigungen)
### Teams-Integration
[Section titled “Teams-Integration”](#teams-integration)
Fügen Sie Microsoft Teams-Benachrichtigungen zu Ihrer Pipeline hinzu:
```yaml
- task: ms-teams-deploy-card@1.4.1
displayName: 'Notify Teams on Success'
condition: succeeded()
inputs:
webhookUri: '$(TEAMS_WEBHOOK_URL)'
title: 'Capgo Deployment Successful'
text: 'App deployed to $(targetChannel) channel'
themeColor: '00FF00'
- task: ms-teams-deploy-card@1.4.1
displayName: 'Notify Teams on Failure'
condition: failed()
inputs:
webhookUri: '$(TEAMS_WEBHOOK_URL)'
title: 'Capgo Deployment Failed'
text: 'Deployment to $(targetChannel) failed'
themeColor: 'FF0000'
```
### E-Mail-Benachrichtigungen
[Section titled “E-Mail-Benachrichtigungen”](#e-mail-benachrichtigungen)
Konfigurieren Sie E-Mail-Benachrichtigungen für den Bereitstellungsstatus:
```yaml
- task: EmailReport@1
displayName: 'Send Email Report'
condition: always()
inputs:
sendMailConditionConfig: 'Always'
subject: 'Capgo Deployment Report - $(Build.BuildNumber)'
to: 'team@yourcompany.com'
body: |
Deployment Status: $(Agent.JobStatus)
Channel: $(targetChannel)
Build: $(Build.BuildNumber)
Commit: $(Build.SourceVersion)
```
## Fehlerbehebung
[Section titled “Fehlerbehebung”](#fehlerbehebung)
### Häufige Probleme
[Section titled “Häufige Probleme”](#häufige-probleme)
**Pipeline schlägt mit “Capgo CLI not found” fehl:**
```yaml
# Ensure global installation
- script: |
npm install -g @capgo/cli
which capgo || echo "Capgo CLI not found in PATH"
displayName: 'Install and verify Capgo CLI'
```
**Authentifizierungsfehler:**
```yaml
# Verify token is correctly set
- script: |
echo "Token length: ${#CAPGO_TOKEN}"
if [ -z "$CAPGO_TOKEN" ]; then
echo "CAPGO_TOKEN is not set"
exit 1
fi
displayName: 'Verify Capgo token'
env:
CAPGO_TOKEN: $(CAPGO_TOKEN)
```
**Build-Artefakte nicht gefunden:**
```yaml
# List available artifacts for debugging
- script: |
ls -la $(System.ArtifactsDirectory)
find $(System.ArtifactsDirectory) -name "*.js" -o -name "*.html"
displayName: 'Debug artifacts'
```
### Debug-Pipeline
[Section titled “Debug-Pipeline”](#debug-pipeline)
Fügen Sie Debugging-Schritte hinzu, um Probleme zu beheben:
```yaml
- script: |
echo "Build.SourceBranch: $(Build.SourceBranch)"
echo "Build.BuildNumber: $(Build.BuildNumber)"
echo "Target Channel: $(targetChannel)"
displayName: 'Debug Pipeline Variables'
- script: |
npx @capgo/cli app debug --apikey $(CAPGO_TOKEN)
displayName: 'Debug Capgo App Status'
```
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
* Erfahren Sie mehr über [Channels](/docs/live-updates/channels/), um verschiedene Bereitstellungsumgebungen zu verwalten
* Erkunden Sie [Custom Storage](/docs/live-updates/custom-storage/) für erweiterte Bereitstellungsszenarien
* Richten Sie [Encryption](/docs/live-updates/encryption/) für sichere Bereitstellungen ein
* Konfigurieren Sie [Update Behavior](/docs/live-updates/update-behavior/), um anzupassen, wie Updates angewendet werden
Mit der Azure DevOps-Integration können Sie Ihre Capgo-Bereitstellungen automatisieren und konsistente, zuverlässige Updates für Ihre mobilen App-Benutzer sicherstellen.
# Bitbucket Pipelines Integration
> Erfahren Sie, wie Sie Capgo Live Updates mit Bitbucket Pipelines für die automatisierte Bereitstellung Ihrer App-Updates integrieren.
Integrieren Sie Capgo Live Updates mit Bitbucket Pipelines, um Ihre App-Updates automatisch bereitzustellen, wenn Sie Code-Änderungen pushen. Dieser Leitfaden behandelt die Einrichtung automatisierter Build-, Test- und Bereitstellungs-Workflows.
## Voraussetzungen
[Section titled “Voraussetzungen”](#voraussetzungen)
Stellen Sie vor der Einrichtung der Bitbucket Pipelines-Integration sicher, dass Sie Folgendes haben:
* Ein Bitbucket-Konto mit einem Repository
* Ein Capgo-Konto mit einer konfigurierten App
* Node.js und npm/yarn in Ihrem Projekt konfiguriert
## Einrichten von Bitbucket Pipelines
[Section titled “Einrichten von Bitbucket Pipelines”](#einrichten-von-bitbucket-pipelines)
### Schritt 1: Repository-Variablen konfigurieren
[Section titled “Schritt 1: Repository-Variablen konfigurieren”](#schritt-1-repository-variablen-konfigurieren)
Richten Sie zunächst die erforderlichen Variablen in Ihrem Bitbucket-Repository ein:
1. Navigieren Sie zu Ihrem Bitbucket-Repository
2. Gehen Sie zu **Repository settings** → **Pipelines** → **Repository variables**
3. Fügen Sie die folgenden Variablen hinzu:
| Variablenname | Wert | Gesichert |
| ------------- | ------------------- | --------- |
| `CAPGO_TOKEN` | Ihr Capgo API-Token | ✅ Ja |
Tip
Holen Sie sich Ihr Capgo API-Token von [console.capgo.app/apikeys](https://console.capgo.app/apikeys). Ihre App-ID ist bereits in Ihrer `capacitor.config.ts`-Datei konfiguriert.
## Einfach
[Section titled “Einfach”](#einfach)
Grundkonfiguration, die bei jedem Push zum main-Branch in die Produktion deployt:
```yaml
# bitbucket-pipelines.yml - Simple Configuration
image: node:22
pipelines:
branches:
main:
- step:
name: Build and Deploy to Production
script:
- npm ci
- npm run test
- npm run build
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel production
artifacts:
- dist/**
```
## Erweitert
[Section titled “Erweitert”](#erweitert)
### Feature-Branch-Bereitstellungen
[Section titled “Feature-Branch-Bereitstellungen”](#feature-branch-bereitstellungen)
Deployen Sie Feature-Branches zu Test-Channels für Review und Testing:
```yaml
# Feature branch deployment
pipelines:
branches:
feature/*:
- step:
name: Deploy Feature Branch
script:
- npm ci
- npm run test
- npm run build
- BRANCH_NAME=$(echo $BITBUCKET_BRANCH | sed 's/[^a-zA-Z0-9-]/-/g')
- CHANNEL_NAME="feature-$BRANCH_NAME"
- npm install -g @capgo/cli
- npx @capgo/cli channel create $CHANNEL_NAME --apikey $CAPGO_TOKEN || true
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel $CHANNEL_NAME
artifacts:
- dist/**
```
Tip
**Testen mit Channels**: Nach der Bereitstellung in einem Feature-Channel können Sie das Update in Ihrer App testen, indem Sie diese für die Verwendung dieses spezifischen Channels konfigurieren. Erfahren Sie mehr über [das Konfigurieren von Channels in Ihrer App](/docs/live-updates/channels/#configuring-the-channel-in-your-app).
### Verschlüsselung verwenden
[Section titled “Verschlüsselung verwenden”](#verschlüsselung-verwenden)
Wenn Sie [Capgos Verschlüsselungsfunktion](/docs/live-updates/encryption/) nutzen, müssen Sie Ihren privaten Schlüssel sicher in Ihrer CI/CD-Umgebung speichern.
Nach dem [Einrichten der Verschlüsselungsschlüssel](/docs/live-updates/encryption/#setting-up-encryption) lokal fügen Sie Ihren privaten Schlüssel zu den Bitbucket-Variablen hinzu:
```shell
# Zeigen Sie den Inhalt Ihres privaten Schlüssels an (kopieren Sie diese Ausgabe)
cat .capgo_key_v2
```
Fügen Sie diesen Inhalt als `CAPGO_PRIVATE_KEY` in Ihren Bitbucket-Repository-Variablen hinzu (als gesichert markieren) und verwenden Sie ihn dann in Pipelines:
```yaml
# Deploy with encryption
- step:
name: Deploy to Capgo with Encryption
script:
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --key-data-v2 "$CAPGO_PRIVATE_KEY" --channel production
```
Caution
**Sicherheits-Best-Practices:**
* Committen Sie niemals die `.capgo_key_v2`-Datei in die Versionskontrolle
* Speichern Sie den privaten Schlüssel nur in sicherer CI/CD-Geheimnisverwaltung
* Verwenden Sie unterschiedliche Schlüssel für verschiedene Umgebungen
### Multi-Channel-Konfiguration
[Section titled “Multi-Channel-Konfiguration”](#multi-channel-konfiguration)
Für umfassende Informationen zum Einrichten und Verwalten mehrerer Bereitstellungs-Channels siehe die [Channels-Dokumentation](/docs/live-updates/channels/).
Vollständige Konfiguration mit mehreren Umgebungen und Pull-Request-Bereitstellungen:
```yaml
# bitbucket-pipelines.yml - Advanced Multi-Channel Configuration
image: node:22
definitions:
steps:
- step: &build-step
name: Build Application
script:
- npm ci
- npm run test
- npm run build
artifacts:
- dist/**
- step: &deploy-step
name: Deploy to Capgo
script:
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel $CHANNEL_NAME
pipelines:
branches:
main:
- step:
<<: *build-step
- step:
<<: *deploy-step
name: Deploy to Production
deployment: production
trigger: manual
script:
- export CHANNEL_NAME=production
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel $CHANNEL_NAME
develop:
- step:
<<: *build-step
- step:
<<: *deploy-step
name: Deploy to Development
deployment: development
script:
- export CHANNEL_NAME=development
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel $CHANNEL_NAME
pull-requests:
'**':
- step:
<<: *build-step
- step:
name: Deploy PR to Test Channel
script:
- CHANNEL_NAME="pr-$BITBUCKET_PR_ID"
- npm install -g @capgo/cli
- npx @capgo/cli channel create $CHANNEL_NAME --apikey $CAPGO_TOKEN || true
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel $CHANNEL_NAME
artifacts:
- dist/**
```
### Multi-Umgebungs-Pipeline
[Section titled “Multi-Umgebungs-Pipeline”](#multi-umgebungs-pipeline)
Für komplexe Bereitstellungsszenarien mit Staging- und Production-Umgebungen:
```yaml
# Multi-environment pipeline
image: node:22
pipelines:
branches:
main:
- step:
name: Build
script:
- npm ci
- npm run test
- npm run build
artifacts:
- dist/**
- step:
name: Deploy to Staging
deployment: staging
script:
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel staging
- step:
name: Deploy to Production
deployment: production
trigger: manual
script:
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel production
develop:
- step:
name: Build and Deploy to Development
script:
- npm ci
- npm run test
- npm run build
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel development
artifacts:
- dist/**
```
### Branch-basierte Bereitstellungsstrategie
[Section titled “Branch-basierte Bereitstellungsstrategie”](#branch-basierte-bereitstellungsstrategie)
Deployen Sie verschiedene Branches automatisch zu entsprechenden Channels:
```yaml
# Dynamic channel deployment
image: node:22
definitions:
scripts:
- script: &determine-channel |
if [ "$BITBUCKET_BRANCH" = "main" ]; then
export CHANNEL_NAME="production"
elif [ "$BITBUCKET_BRANCH" = "develop" ]; then
export CHANNEL_NAME="staging"
else
export CHANNEL_NAME="development"
fi
echo "Deploying to channel: $CHANNEL_NAME"
pipelines:
default:
- step:
name: Build and Deploy
script:
- npm ci
- npm run test
- npm run build
- *determine-channel
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel $CHANNEL_NAME
artifacts:
- dist/**
```
### Parallele Pipeline-Ausführung
[Section titled “Parallele Pipeline-Ausführung”](#parallele-pipeline-ausführung)
Optimieren Sie Build-Zeiten mit parallelen Schritten:
```yaml
# Parallel execution pipeline
image: node:22
pipelines:
branches:
main:
- parallel:
- step:
name: Run Tests
script:
- npm ci
- npm run test
- step:
name: Lint Code
script:
- npm ci
- npm run lint
- step:
name: Build Application
script:
- npm ci
- npm run build
artifacts:
- dist/**
- step:
name: Deploy to Production
deployment: production
script:
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel production
```
## Sicherheits-Best-Practices
[Section titled “Sicherheits-Best-Practices”](#sicherheits-best-practices)
### Repository-Variablen
[Section titled “Repository-Variablen”](#repository-variablen)
1. **Gesicherte Variablen**: Immer API-Tokens als gesichert markieren
2. **Umgebungsvariablen**: Deployment-spezifische Variablen bei Bedarf verwenden
3. **Zugriffskontrolle**: Repository-Zugriff auf autorisierte Teammitglieder beschränken
4. **Token-Rotation**: Regelmäßig Ihre Capgo API-Tokens rotieren
### Deployment-Umgebungen
[Section titled “Deployment-Umgebungen”](#deployment-umgebungen)
Konfigurieren Sie Deployment-Umgebungen für bessere Sicherheit:
```yaml
# Deployment with environment restrictions
pipelines:
branches:
main:
- step:
name: Deploy to Production
deployment: production
trigger: manual
script:
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel production
```
## Überwachung und Benachrichtigungen
[Section titled “Überwachung und Benachrichtigungen”](#überwachung-und-benachrichtigungen)
### Slack-Integration
[Section titled “Slack-Integration”](#slack-integration)
Fügen Sie Slack-Benachrichtigungen zu Ihrer Pipeline hinzu:
```yaml
# Pipeline with Slack notifications
pipelines:
branches:
main:
- step:
name: Build and Deploy
script:
- npm ci
- npm run test
- npm run build
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel production
after-script:
- |
if [ $BITBUCKET_EXIT_CODE -eq 0 ]; then
curl -X POST -H 'Content-type: application/json' \
--data '{"text":"✅ Capgo deployment successful for '$BITBUCKET_BRANCH'"}' \
$SLACK_WEBHOOK_URL
else
curl -X POST -H 'Content-type: application/json' \
--data '{"text":"❌ Capgo deployment failed for '$BITBUCKET_BRANCH'"}' \
$SLACK_WEBHOOK_URL
fi
```
### E-Mail-Benachrichtigungen
[Section titled “E-Mail-Benachrichtigungen”](#e-mail-benachrichtigungen)
Konfigurieren Sie E-Mail-Benachrichtigungen durch die integrierten Funktionen von Bitbucket oder über externe Services:
```yaml
# Email notification step
- step:
name: Send Notification
script:
- |
curl -X POST \
-H "Content-Type: application/json" \
-d '{
"to": "team@yourcompany.com",
"subject": "Capgo Deployment Status",
"body": "Deployment of '$BITBUCKET_BRANCH' completed with status: '$BITBUCKET_EXIT_CODE'"
}' \
$EMAIL_SERVICE_URL
condition:
result: [successful, failed]
```
## Fehlerbehebung
[Section titled “Fehlerbehebung”](#fehlerbehebung)
### Häufige Probleme
[Section titled “Häufige Probleme”](#häufige-probleme)
**Pipeline schlägt mit “Capgo CLI not found” fehl:**
```yaml
# Debug CLI installation
- step:
name: Debug CLI
script:
- npm install -g @capgo/cli
- which capgo || echo "Capgo CLI not found"
- npx @capgo/cli --version
```
**Authentifizierungsfehler:**
```yaml
# Verify token configuration
- step:
name: Debug Auth
script:
- |
if [ -z "$CAPGO_TOKEN" ]; then
echo "CAPGO_TOKEN is not set"
exit 1
fi
echo "Token length: ${#CAPGO_TOKEN}"
```
**Build-Artefakte nicht gefunden:**
```yaml
# List build outputs
- step:
name: Debug Build
script:
- ls -la dist/
- find dist/ -type f -name "*.js" -o -name "*.html"
```
### Debug-Pipeline
[Section titled “Debug-Pipeline”](#debug-pipeline)
Fügen Sie Debugging-Informationen hinzu, um Probleme zu beheben:
```yaml
# Debug pipeline
pipelines:
branches:
main:
- step:
name: Debug Information
script:
- echo "Branch: $BITBUCKET_BRANCH"
- echo "Commit: $BITBUCKET_COMMIT"
- echo "Build: $BITBUCKET_BUILD_NUMBER"
- env | grep BITBUCKET_ | sort
- step:
name: Build and Deploy
script:
- npm ci
- npm run test
- npm run build
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel production
```
### Pipeline-Validierung
[Section titled “Pipeline-Validierung”](#pipeline-validierung)
Aktivieren Sie Pipeline-Validierung, um Konfigurationsfehler zu erkennen:
```yaml
# Enable pipeline validation
options:
docker: true
size: 2x
pipelines:
branches:
main:
- step:
name: Validate Pipeline
script:
- echo "Pipeline validation successful"
- step:
name: Build and Deploy
script:
# ... deployment steps
```
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
* Erfahren Sie mehr über [Channels](/docs/live-updates/channels/), um verschiedene Bereitstellungsumgebungen zu verwalten
* Erkunden Sie [Custom Storage](/docs/live-updates/custom-storage/) für erweiterte Bereitstellungsszenarien
* Richten Sie [Encryption](/docs/live-updates/encryption/) für sichere Bereitstellungen ein
* Konfigurieren Sie [Update Behavior](/docs/live-updates/update-behavior/), um anzupassen, wie Updates angewendet werden
Mit der Bitbucket Pipelines-Integration können Sie Ihre Capgo-Bereitstellungen automatisieren und konsistente, zuverlässige Updates für Ihre mobilen App-Benutzer sicherstellen.
# GitHub Actions Integration
> Erfahren Sie, wie Sie Capgo Live Updates mit GitHub Actions für die automatisierte Bereitstellung Ihrer App-Updates integrieren.
Integrieren Sie Capgo Live Updates mit GitHub Actions, um Ihre App-Updates automatisch bereitzustellen, wenn Sie Code-Änderungen pushen. Dieser Leitfaden behandelt die Einrichtung automatisierter Build-, Test- und Bereitstellungs-Workflows mit GitHubs leistungsstarker CI/CD-Plattform.
## Voraussetzungen
[Section titled “Voraussetzungen”](#voraussetzungen)
Stellen Sie vor der Einrichtung der GitHub Actions-Integration sicher, dass Sie Folgendes haben:
* Ein GitHub-Repository mit dem Quellcode Ihrer App
* Ein Capgo-Konto mit einer konfigurierten App
* Node.js und npm/yarn in Ihrem Projekt konfiguriert
* GitHub Actions für Ihr Repository aktiviert
## Einrichten von GitHub Secrets
[Section titled “Einrichten von GitHub Secrets”](#einrichten-von-github-secrets)
### Schritt 1: Repository-Secrets konfigurieren
[Section titled “Schritt 1: Repository-Secrets konfigurieren”](#schritt-1-repository-secrets-konfigurieren)
Richten Sie die erforderlichen Secrets in Ihrem GitHub-Repository ein:
1. Navigieren Sie zu Ihrem GitHub-Repository
2. Gehen Sie zu **Settings** → **Secrets and variables** → **Actions**
3. Klicken Sie auf **New repository secret** und fügen Sie Folgendes hinzu:
| Secret-Name | Wert |
| ------------- | ------------------- |
| `CAPGO_TOKEN` | Ihr Capgo API-Token |
Tip
Holen Sie sich Ihr Capgo API-Token von [console.capgo.app/apikeys](https://console.capgo.app/apikeys). Ihre App-ID ist bereits in Ihrer `capacitor.config.ts`-Datei konfiguriert.
## Einfache Production-Bereitstellung
[Section titled “Einfache Production-Bereitstellung”](#einfache-production-bereitstellung)
Beginnen Sie mit dieser Grundkonfiguration, die bei jedem Push zum main-Branch in die Produktion deployt:
```yaml
# Simple GitHub Actions Workflow for Capgo Live Updates
name: Deploy to Capgo
on:
push:
branches:
- main
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v6
- name: Setup Node.js
uses: actions/setup-node@v6
with:
node-version: '24'
cache: 'npm'
- name: Install, test and build
run: |
npm ci
npm run test
npm run build
- name: Deploy to Capgo
run: |
npm install -g @capgo/cli
npx @capgo/cli bundle upload --channel production
env:
CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}
# For encrypted uploads, add: --key-data-v2 "${{ secrets.CAPGO_PRIVATE_KEY }}"
```
## Erweiterte Multi-Channel-Konfiguration
[Section titled “Erweiterte Multi-Channel-Konfiguration”](#erweiterte-multi-channel-konfiguration)
### Feature-Branch-Bereitstellungen
[Section titled “Feature-Branch-Bereitstellungen”](#feature-branch-bereitstellungen)
Deployen Sie Feature-Branches zu temporären Channels zum Testen:
```yaml
# Feature branch deployment
name: Deploy Feature Branch to Capgo
on:
push:
branches:
- 'feature/**'
jobs:
deploy-feature:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6
- uses: actions/setup-node@v6
with:
node-version: '24'
cache: 'npm'
- run: |
npm ci
npm run test
npm run build
- name: Deploy to feature channel
run: |
CHANNEL_NAME=$(echo "${{ github.ref_name }}" | sed 's/[^a-zA-Z0-9]/-/g' | tr '[:upper:]' '[:lower:]')
npm install -g @capgo/cli
npx @capgo/cli channel create $CHANNEL_NAME --apikey ${{ secrets.CAPGO_TOKEN }} || true
npx @capgo/cli bundle upload --apikey ${{ secrets.CAPGO_TOKEN }} --channel $CHANNEL_NAME
```
### Verschlüsselung verwenden
[Section titled “Verschlüsselung verwenden”](#verschlüsselung-verwenden)
Wenn Sie [Capgos Verschlüsselungsfunktion](/docs/live-updates/encryption/) nutzen, müssen Sie Ihren privaten Schlüssel sicher in Ihrer CI/CD-Umgebung speichern.
Nach dem [Einrichten der Verschlüsselungsschlüssel](/docs/live-updates/encryption/#setting-up-encryption) lokal fügen Sie Ihren privaten Schlüssel zu den GitHub-Secrets hinzu:
```shell
# Zeigen Sie den Inhalt Ihres privaten Schlüssels an (kopieren Sie diese Ausgabe)
cat .capgo_key_v2
```
Fügen Sie diesen Inhalt als `CAPGO_PRIVATE_KEY` in Ihren GitHub-Repository-Secrets hinzu und verwenden Sie ihn dann in Workflows:
```yaml
# Deploy with encryption
- name: Deploy to Capgo with Encryption
run: |
npm install -g @capgo/cli
npx @capgo/cli bundle upload --apikey ${{ secrets.CAPGO_TOKEN }} --key-data-v2 "${{ secrets.CAPGO_PRIVATE_KEY }}" --channel production
```
Caution
**Sicherheits-Best-Practices:**
* Committen Sie niemals die `.capgo_key_v2`-Datei in die Versionskontrolle
* Speichern Sie den privaten Schlüssel nur in sicherer CI/CD-Geheimnisverwaltung
* Verwenden Sie unterschiedliche Schlüssel für verschiedene Umgebungen
### Multi-Channel-Konfiguration
[Section titled “Multi-Channel-Konfiguration”](#multi-channel-konfiguration)
Für umfassende Informationen zum Einrichten und Verwalten mehrerer Bereitstellungs-Channels siehe die [Channels-Dokumentation](/docs/live-updates/channels/).
Vollständiger Workflow mit Development-, Pull-Request- und Production-Bereitstellungen:
```yaml
# Complete multi-environment workflow
name: Deploy to Capgo
on:
push:
branches: [main, develop]
pull_request:
branches: [main, develop]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6
- uses: actions/setup-node@v6
with:
node-version: '24'
cache: 'npm'
- run: |
npm ci
npm run test
npm run build
- uses: actions/upload-artifact@v4
with:
name: dist
path: dist/
deploy-development:
if: github.ref == 'refs/heads/develop'
needs: build
runs-on: ubuntu-latest
environment: development
steps:
- uses: actions/setup-node@v6
with:
node-version: '24'
- uses: actions/download-artifact@v4
with:
name: dist
path: dist/
- run: |
npm install -g @capgo/cli
npx @capgo/cli bundle upload --apikey ${{ secrets.CAPGO_TOKEN }} --channel development
deploy-pr:
if: github.event_name == 'pull_request'
needs: build
runs-on: ubuntu-latest
steps:
- uses: actions/setup-node@v6
with:
node-version: '24'
- uses: actions/download-artifact@v4
with:
name: dist
path: dist/
- name: Deploy to PR channel
run: |
CHANNEL_NAME="pr-${{ github.event.number }}"
npm install -g @capgo/cli
npx @capgo/cli channel create $CHANNEL_NAME --apikey ${{ secrets.CAPGO_TOKEN }} || true
npx @capgo/cli bundle upload --apikey ${{ secrets.CAPGO_TOKEN }} --channel $CHANNEL_NAME
- name: Comment PR
uses: actions/github-script@v7
with:
script: |
github.rest.issues.createComment({
issue_number: context.issue.number,
owner: context.repo.owner,
repo: context.repo.repo,
body: `🚀 This PR has been deployed to Capgo channel: \`pr-${{ github.event.number }}\`\n\nTo test this update in your app, configure it to use this channel. [Learn how to configure channels →](/docs/live-updates/channels/#configuring-the-channel-in-your-app)`
})
deploy-production:
if: github.ref == 'refs/heads/main'
needs: build
runs-on: ubuntu-latest
environment: production
steps:
- uses: actions/setup-node@v6
with:
node-version: '24'
- uses: actions/download-artifact@v4
with:
name: dist
path: dist/
- run: |
npm install -g @capgo/cli
npx @capgo/cli bundle upload --apikey ${{ secrets.CAPGO_TOKEN }} --channel production
```
Tip
**Testen mit Channels**: Nach der Bereitstellung in einem PR- oder Development-Channel können Sie das Update in Ihrer App testen, indem Sie diese für die Verwendung dieses spezifischen Channels konfigurieren. Erfahren Sie mehr über [das Konfigurieren von Channels in Ihrer App](/docs/live-updates/channels/#configuring-the-channel-in-your-app).
### Feature-Channels aufräumen
[Section titled “Feature-Channels aufräumen”](#feature-channels-aufräumen)
Automatisches Aufräumen von Feature-Channels, wenn Branches gelöscht werden:
```yaml
name: Cleanup Feature Channels
on:
delete:
jobs:
cleanup:
runs-on: ubuntu-latest
if: github.event.ref_type == 'branch' && startsWith(github.event.ref, 'feature/')
steps:
- uses: actions/setup-node@v6
with:
node-version: '24'
- name: Delete Capgo channel
run: |
CHANNEL_NAME=$(echo "${{ github.event.ref }}" | sed 's/[^a-zA-Z0-9]/-/g' | tr '[:upper:]' '[:lower:]')
npm install -g @capgo/cli
npx @capgo/cli channel delete $CHANNEL_NAME --apikey ${{ secrets.CAPGO_TOKEN }} || true
```
## Sicherheit und Bewährte Methoden
[Section titled “Sicherheit und Bewährte Methoden”](#sicherheit-und-bewährte-methoden)
### Umgebungsschutzregeln
[Section titled “Umgebungsschutzregeln”](#umgebungsschutzregeln)
Richten Sie Umgebungsschutzregeln in GitHub ein:
1. Gehen Sie zu **Settings** → **Environments** in Ihrem Repository
2. Erstellen Sie Umgebungen: `development`, `staging`, `production`
3. Für die Production-Umgebung fügen Sie hinzu:
* **Required reviewers**: Fügen Sie Teammitglieder hinzu, die Bereitstellungen genehmigen müssen
* **Wait timer**: Fügen Sie eine Verzögerung vor der Bereitstellung hinzu (optional)
* **Deployment branches**: Nur auf `main`-Branch beschränken
### Sichere Secrets-Verwaltung
[Section titled “Sichere Secrets-Verwaltung”](#sichere-secrets-verwaltung)
Verwenden Sie umgebungsspezifische Secrets:
```yaml
# Use different secrets per environment
deploy-production:
environment: production
steps:
- name: Deploy to Production
run: |
npx @capgo/cli bundle upload \
--apikey ${{ secrets.CAPGO_PROD_TOKEN }} \
--app ${{ secrets.CAPGO_PROD_APP_ID }} \
--channel production
```
## Überwachung und Benachrichtigungen
[Section titled “Überwachung und Benachrichtigungen”](#überwachung-und-benachrichtigungen)
### Slack-Integration
[Section titled “Slack-Integration”](#slack-integration)
Fügen Sie Slack-Benachrichtigungen zu Ihrem Workflow hinzu:
```yaml
name: Deploy with Notifications
jobs:
deploy:
runs-on: ubuntu-latest
steps:
# ... deployment steps
- name: Notify Slack on Success
if: success()
uses: 8398a7/action-slack@v3
with:
status: success
text: '✅ Capgo deployment successful!'
fields: repo,message,commit,author,action,eventName,ref,workflow
env:
SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
- name: Notify Slack on Failure
if: failure()
uses: 8398a7/action-slack@v3
with:
status: failure
text: '❌ Capgo deployment failed!'
fields: repo,message,commit,author,action,eventName,ref,workflow
env:
SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
```
### Discord-Integration
[Section titled “Discord-Integration”](#discord-integration)
Senden Sie Benachrichtigungen an Discord:
```yaml
- name: Discord notification
if: always()
uses: Ilshidur/action-discord@master
with:
args: |
Capgo deployment ${{ job.status }}!
App: ${{ secrets.CAPGO_APP_ID }}
Channel: ${{ github.ref_name }}
Commit: ${{ github.sha }}
env:
DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}
```
### E-Mail-Benachrichtigungen
[Section titled “E-Mail-Benachrichtigungen”](#e-mail-benachrichtigungen)
Konfigurieren Sie E-Mail-Benachrichtigungen:
```yaml
- name: Send email notification
if: failure()
uses: dawidd6/action-send-mail@v3
with:
server_address: smtp.gmail.com
server_port: 465
username: ${{ secrets.EMAIL_USERNAME }}
password: ${{ secrets.EMAIL_PASSWORD }}
subject: 'Capgo Deployment Failed - ${{ github.repository }}'
to: team@yourcompany.com
from: ci-cd@yourcompany.com
body: |
Deployment failed for ${{ github.repository }}
Branch: ${{ github.ref_name }}
Commit: ${{ github.sha }}
Workflow: ${{ github.workflow }}
```
## Fehlerbehebung
[Section titled “Fehlerbehebung”](#fehlerbehebung)
### Debug-Workflow
[Section titled “Debug-Workflow”](#debug-workflow)
Fügen Sie Debugging-Schritte hinzu, um Probleme zu beheben:
```yaml
- name: Debug environment
run: |
echo "Node version: $(node --version)"
echo "NPM version: $(npm --version)"
echo "Working directory: $(pwd)"
echo "Files in dist/: $(ls -la dist/ || echo 'No dist directory')"
echo "Environment variables:"
env | grep -E "(GITHUB_|CAPGO_)" | sort
- name: Test Capgo CLI
run: |
npx @capgo/cli --version
npx @capgo/cli app debug --apikey ${{ secrets.CAPGO_TOKEN }} --app ${{ secrets.CAPGO_APP_ID }}
```
### Häufige Probleme und Lösungen
[Section titled “Häufige Probleme und Lösungen”](#häufige-probleme-und-lösungen)
**Workflow schlägt mit “CAPGO\_TOKEN not found” fehl:**
```yaml
- name: Verify secrets
run: |
if [ -z "${{ secrets.CAPGO_TOKEN }}" ]; then
echo "ERROR: CAPGO_TOKEN secret is not set"
exit 1
fi
echo "CAPGO_TOKEN is set (length: ${#CAPGO_TOKEN})"
env:
CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}
```
**Build-Artefakte nicht gefunden:**
```yaml
- name: Debug artifacts
run: |
echo "Checking for build artifacts..."
ls -la dist/ || echo "No dist directory found"
find . -name "*.js" -o -name "*.html" | head -10
```
**Netzwerkverbindungsprobleme:**
```yaml
- name: Test connectivity
run: |
ping -c 3 api.capgo.io || echo "Ping failed"
curl -I https://api.capgo.io/health || echo "Health check failed"
```
## Wiederverwendbare Workflows
[Section titled “Wiederverwendbare Workflows”](#wiederverwendbare-workflows)
Erstellen Sie wiederverwendbare Workflows für Konsistenz über Projekte hinweg:
.github/workflows/reusable-capgo-deploy.yml
```yaml
name: Reusable Capgo Deploy
on:
workflow_call:
inputs:
environment:
required: true
type: string
channel:
required: true
type: string
secrets:
CAPGO_TOKEN:
required: true
CAPGO_APP_ID:
required: true
jobs:
deploy:
runs-on: ubuntu-latest
environment: ${{ inputs.environment }}
steps:
- uses: actions/checkout@v6
- name: Setup Node.js
uses: actions/setup-node@v6
with:
node-version: '24'
cache: 'npm'
- name: Install and build
run: |
npm ci
npm run build
- name: Deploy to Capgo
run: |
npm install -g @capgo/cli
npx @capgo/cli bundle upload \
--apikey ${{ secrets.CAPGO_TOKEN }} \
--app ${{ secrets.CAPGO_APP_ID }} \
--channel ${{ inputs.channel }}
```
Verwenden Sie den wiederverwendbaren Workflow:
.github/workflows/deploy.yml
```yaml
name: Deploy App
on:
push:
branches: [main, develop]
jobs:
deploy-dev:
if: github.ref == 'refs/heads/develop'
uses: ./.github/workflows/reusable-capgo-deploy.yml
with:
environment: development
channel: development
secrets:
CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}
CAPGO_APP_ID: ${{ secrets.CAPGO_APP_ID }}
deploy-prod:
if: github.ref == 'refs/heads/main'
uses: ./.github/workflows/reusable-capgo-deploy.yml
with:
environment: production
channel: production
secrets:
CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}
CAPGO_APP_ID: ${{ secrets.CAPGO_APP_ID }}
```
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
* Erfahren Sie mehr über [Channels](/docs/live-updates/channels/), um verschiedene Bereitstellungsumgebungen zu verwalten
* Erkunden Sie [Custom Storage](/docs/live-updates/custom-storage/) für erweiterte Bereitstellungsszenarien
* Richten Sie [Encryption](/docs/live-updates/encryption/) für sichere Bereitstellungen ein
* Konfigurieren Sie [Update Behavior](/docs/live-updates/update-behavior/), um anzupassen, wie Updates angewendet werden
Mit der GitHub Actions-Integration können Sie GitHubs leistungsstarke CI/CD-Plattform nutzen, um ausgefeilte Bereitstellungs-Workflows mit integrierter Sicherheit, Überwachung und Kollaborationsfunktionen für Ihre Capgo Live Updates zu erstellen.
# GitLab CI/CD Integration
> Erfahren Sie, wie Sie Capgo Live Updates mit GitLab CI/CD für die automatisierte Bereitstellung Ihrer App-Updates integrieren.
Integrieren Sie Capgo Live Updates mit GitLab CI/CD, um Ihre App-Updates automatisch bereitzustellen, wenn Sie Code-Änderungen pushen. Dieser Leitfaden behandelt die Einrichtung automatisierter Build-, Test- und Bereitstellungs-Workflows.
## Voraussetzungen
[Section titled “Voraussetzungen”](#voraussetzungen)
Stellen Sie vor der Einrichtung der GitLab CI/CD-Integration sicher, dass Sie Folgendes haben:
* Ein GitLab-Konto mit einem Projekt-Repository
* Ein Capgo-Konto mit einer konfigurierten App
* Node.js und npm/yarn in Ihrem Projekt konfiguriert
## Einrichten von GitLab CI/CD
[Section titled “Einrichten von GitLab CI/CD”](#einrichten-von-gitlab-cicd)
### Schritt 1: Umgebungsvariablen konfigurieren
[Section titled “Schritt 1: Umgebungsvariablen konfigurieren”](#schritt-1-umgebungsvariablen-konfigurieren)
Richten Sie zunächst die erforderlichen Variablen in Ihrem GitLab-Projekt ein:
1. Navigieren Sie zu Ihrem GitLab-Projekt
2. Gehen Sie zu **Settings** → **CI/CD** → **Variables**
3. Fügen Sie die folgenden Variablen hinzu:
| Variablenname | Wert | Protected | Masked |
| ------------- | ------------------- | --------- | ------ |
| `CAPGO_TOKEN` | Ihr Capgo API-Token | ✅ Ja | ✅ Ja |
Tip
Holen Sie sich Ihr Capgo API-Token von [console.capgo.app/apikeys](https://console.capgo.app/apikeys). Ihre App-ID ist bereits in Ihrer `capacitor.config.ts`-Datei konfiguriert.
## Einfach
[Section titled “Einfach”](#einfach)
Grundkonfiguration, die bei jedem Push zum main-Branch in die Produktion deployt:
```yaml
# .gitlab-ci.yml - Simple Configuration
image: node:22
stages:
- build
- deploy
variables:
npm_config_cache: "$CI_PROJECT_DIR/.npm"
build:
stage: build
script:
- npm ci
- npm run test
- npm run build
artifacts:
paths:
- dist/
expire_in: 1 hour
only:
- main
deploy_production:
stage: deploy
script:
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel production
# For encrypted uploads, add: --key-data-v2 "$CAPGO_PRIVATE_KEY"
dependencies:
- build
only:
- main
```
## Erweitert
[Section titled “Erweitert”](#erweitert)
### Feature-Branch-Bereitstellungen
[Section titled “Feature-Branch-Bereitstellungen”](#feature-branch-bereitstellungen)
Deployen Sie Feature-Branches zu Test-Channels für Review und Testing:
```yaml
# Feature branch deployment
deploy_feature:
stage: deploy
script:
- npm install -g @capgo/cli
- CHANNEL_NAME="feature-$(echo $CI_COMMIT_REF_NAME | sed 's/[^a-zA-Z0-9-]/-/g')"
- npx @capgo/cli channel create $CHANNEL_NAME --apikey $CAPGO_TOKEN || true
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel $CHANNEL_NAME
dependencies:
- build
only:
- /^feature\/.*$/
environment:
name: feature/$CI_COMMIT_REF_NAME
url: https://your-app.com/channels/$CHANNEL_NAME
```
Tip
**Testen mit Channels**: Nach der Bereitstellung in einem Feature-Channel können Sie das Update in Ihrer App testen, indem Sie diese für die Verwendung dieses spezifischen Channels konfigurieren. Erfahren Sie mehr über [das Konfigurieren von Channels in Ihrer App](/docs/live-updates/channels/#configuring-the-channel-in-your-app).
### Verschlüsselung verwenden
[Section titled “Verschlüsselung verwenden”](#verschlüsselung-verwenden)
Wenn Sie [Capgos Verschlüsselungsfunktion](/docs/live-updates/encryption/) nutzen, müssen Sie Ihren privaten Schlüssel sicher in Ihrer CI/CD-Umgebung speichern.
Nach dem [Einrichten der Verschlüsselungsschlüssel](/docs/live-updates/encryption/#setting-up-encryption) lokal fügen Sie Ihren privaten Schlüssel zu den GitLab-Variablen hinzu:
```shell
# Zeigen Sie den Inhalt Ihres privaten Schlüssels an (kopieren Sie diese Ausgabe)
cat .capgo_key_v2
```
Fügen Sie diesen Inhalt als `CAPGO_PRIVATE_KEY` in Ihren GitLab-Projektvariablen hinzu (als protected und masked markieren) und verwenden Sie ihn dann in Pipelines:
```yaml
# Deploy with encryption
deploy_production:
script:
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --key-data-v2 "$CAPGO_PRIVATE_KEY" --channel production
```
Caution
**Sicherheits-Best-Practices:**
* Committen Sie niemals die `.capgo_key_v2`-Datei in die Versionskontrolle
* Speichern Sie den privaten Schlüssel nur in sicherer CI/CD-Geheimnisverwaltung
* Verwenden Sie unterschiedliche Schlüssel für verschiedene Umgebungen
### Multi-Channel-Konfiguration
[Section titled “Multi-Channel-Konfiguration”](#multi-channel-konfiguration)
Für umfassende Informationen zum Einrichten und Verwalten mehrerer Bereitstellungs-Channels siehe die [Channels-Dokumentation](/docs/live-updates/channels/).
Vollständige Konfiguration mit mehreren Umgebungen und Merge-Request-Bereitstellungen:
```yaml
# .gitlab-ci.yml - Advanced Multi-Channel Configuration
image: node:22
stages:
- build
- deploy
variables:
npm_config_cache: "$CI_PROJECT_DIR/.npm"
# Build stage
build:
stage: build
script:
- npm ci
- npm run test
- npm run build
artifacts:
paths:
- dist/
expire_in: 24 hours
# Deploy to development channel
deploy_development:
stage: deploy
script:
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel development
dependencies:
- build
only:
- develop
environment:
name: development
# Deploy merge requests to test channels
deploy_mr:
stage: deploy
script:
- npm install -g @capgo/cli
- CHANNEL_NAME="mr-$CI_MERGE_REQUEST_IID"
- npx @capgo/cli channel create $CHANNEL_NAME --apikey $CAPGO_TOKEN || true
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel $CHANNEL_NAME
dependencies:
- build
only:
- merge_requests
environment:
name: review/$CI_MERGE_REQUEST_IID
url: https://your-app.com/channels/mr-$CI_MERGE_REQUEST_IID
on_stop: cleanup_mr
# Cleanup MR channels when MR is closed
cleanup_mr:
stage: deploy
script:
- npm install -g @capgo/cli
- npx @capgo/cli channel delete mr-$CI_MERGE_REQUEST_IID --apikey $CAPGO_TOKEN || true
when: manual
environment:
name: review/$CI_MERGE_REQUEST_IID
action: stop
only:
- merge_requests
# Deploy to staging
deploy_staging:
stage: deploy
script:
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel staging
dependencies:
- build
only:
- develop
environment:
name: staging
# Deploy to production
deploy_production:
stage: deploy
script:
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel production
dependencies:
- build
only:
- main
environment:
name: production
```
### Multi-Umgebung mit manueller Genehmigung
[Section titled “Multi-Umgebung mit manueller Genehmigung”](#multi-umgebung-mit-manueller-genehmigung)
Für Production-Bereitstellungen mit manueller Genehmigung:
```yaml
deploy_production:
stage: deploy
script:
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel production
dependencies:
- build
only:
- main
when: manual
environment:
name: production
```
### Branch-basierte Bereitstellungsstrategie
[Section titled “Branch-basierte Bereitstellungsstrategie”](#branch-basierte-bereitstellungsstrategie)
Deployen Sie verschiedene Branches automatisch zu entsprechenden Channels:
```yaml
# Dynamic channel deployment based on branch
deploy:
stage: deploy
script:
- npm install -g @capgo/cli
- |
if [ "$CI_COMMIT_REF_NAME" = "main" ]; then
CHANNEL="production"
elif [ "$CI_COMMIT_REF_NAME" = "develop" ]; then
CHANNEL="staging"
else
CHANNEL="development"
fi
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel $CHANNEL
dependencies:
- build
environment:
name: $CHANNEL
```
## Sicherheits-Best-Practices
[Section titled “Sicherheits-Best-Practices”](#sicherheits-best-practices)
### Protected-Variablen
[Section titled “Protected-Variablen”](#protected-variablen)
1. **Sensible Variablen markieren**: Immer API-Tokens als protected und masked markieren
2. **Branch-Schutz**: Protected-Variablen für Production-Bereitstellungen verwenden
3. **Zugriffskontrolle**: Variablenzugriff nur auf Maintainer beschränken
4. **Regelmäßige Rotation**: API-Tokens regelmäßig rotieren
### Sichere Pipeline-Konfiguration
[Section titled “Sichere Pipeline-Konfiguration”](#sichere-pipeline-konfiguration)
```yaml
# Use protected variables for production
deploy_production:
stage: deploy
script:
- npm install -g @capgo/cli
- npx @capgo/cli bundle upload --apikey $CAPGO_TOKEN --channel production
only:
refs:
- main
variables:
- $CI_COMMIT_REF_PROTECTED == "true"
```
## Überwachung und Benachrichtigungen
[Section titled “Überwachung und Benachrichtigungen”](#überwachung-und-benachrichtigungen)
### Slack-Integration
[Section titled “Slack-Integration”](#slack-integration)
Fügen Sie Slack-Benachrichtigungen zu Ihrer Pipeline hinzu:
```yaml
notify_success:
stage: .post
image: alpine:latest
before_script:
- apk add --no-cache curl
script:
- |
curl -X POST -H 'Content-type: application/json' \
--data '{"text":"✅ Capgo deployment successful for '"$CI_COMMIT_REF_NAME"'"}' \
$SLACK_WEBHOOK_URL
when: on_success
notify_failure:
stage: .post
image: alpine:latest
before_script:
- apk add --no-cache curl
script:
- |
curl -X POST -H 'Content-type: application/json' \
--data '{"text":"❌ Capgo deployment failed for '"$CI_COMMIT_REF_NAME"'"}' \
$SLACK_WEBHOOK_URL
when: on_failure
```
### E-Mail-Benachrichtigungen
[Section titled “E-Mail-Benachrichtigungen”](#e-mail-benachrichtigungen)
Konfigurieren Sie E-Mail-Benachrichtigungen in Ihren GitLab-Projekteinstellungen oder verwenden Sie die API:
```yaml
notify_email:
stage: .post
script:
- |
curl --request POST \
--header "PRIVATE-TOKEN: $GITLAB_API_TOKEN" \
--form "to=team@yourcompany.com" \
--form "subject=Capgo Deployment Status" \
--form "body=Deployment of $CI_COMMIT_REF_NAME completed with status: $CI_JOB_STATUS" \
"https://gitlab.com/api/v4/projects/$CI_PROJECT_ID/emails"
when: always
```
## Fehlerbehebung
[Section titled “Fehlerbehebung”](#fehlerbehebung)
### Häufige Probleme
[Section titled “Häufige Probleme”](#häufige-probleme)
**Pipeline schlägt mit “Capgo CLI not found” fehl:**
```yaml
# Debug CLI installation
debug_cli:
script:
- npm install -g @capgo/cli
- which capgo || echo "Capgo CLI not found"
- npx @capgo/cli --version
```
**Authentifizierungsfehler:**
```yaml
# Verify token configuration
debug_auth:
script:
- |
if [ -z "$CAPGO_TOKEN" ]; then
echo "CAPGO_TOKEN is not set"
exit 1
fi
echo "Token length: ${#CAPGO_TOKEN}"
```
**Build-Artefakte nicht gefunden:**
```yaml
# List build outputs
debug_build:
script:
- ls -la dist/
- find dist/ -type f -name "*.js" -o -name "*.html"
```
### Debug-Pipeline
[Section titled “Debug-Pipeline”](#debug-pipeline)
Fügen Sie Debugging-Informationen hinzu, um Probleme zu beheben:
```yaml
debug:
stage: build
script:
- echo "Branch: $CI_COMMIT_REF_NAME"
- echo "Commit: $CI_COMMIT_SHA"
- echo "Build: $CI_PIPELINE_ID"
- env | grep CI_ | sort
only:
- branches
```
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
* Erfahren Sie mehr über [Channels](/docs/live-updates/channels/), um verschiedene Bereitstellungsumgebungen zu verwalten
* Erkunden Sie [Custom Storage](/docs/live-updates/custom-storage/) für erweiterte Bereitstellungsszenarien
* Richten Sie [Encryption](/docs/live-updates/encryption/) für sichere Bereitstellungen ein
* Konfigurieren Sie [Update Behavior](/docs/live-updates/update-behavior/), um anzupassen, wie Updates angewendet werden
Mit der GitLab CI/CD-Integration können Sie Ihre Capgo-Bereitstellungen automatisieren und konsistente, zuverlässige Updates für Ihre mobilen App-Benutzer sicherstellen.
# Rollbacks
Während die Live-Updates von Capgo es Ihnen ermöglichen, schnell Verbesserungen und Fehlerbehebungen an Ihre Nutzer zu liefern, kann es Situationen geben, in denen Sie zu einer vorherigen Version Ihrer App zurückkehren müssen. Vielleicht hat ein neues Update ein unerwartetes kritisches Problem eingeführt, oder Sie möchten eine bestimmte Änderung rückgängig machen, während Sie an einer Lösung arbeiten.
Capgo bietet verschiedene Möglichkeiten, die Builds eines Kanals zu verwalten und die Version Ihrer App zu kontrollieren, die Benutzer erhalten.
## Zurücksetzen auf ein vorheriges Bundle
[Section titled “Zurücksetzen auf ein vorheriges Bundle”](#zurücksetzen-auf-ein-vorheriges-bundle)
Jedes Mal, wenn Sie einen neuen Build hochladen und einem Kanal zuweisen, behält Capgo einen Verlauf dieser Builds bei. Wenn Sie ein bestimmtes Update rückgängig machen müssen, können Sie einen dieser vorherigen Builds auswählen, um ihn erneut im Kanal bereitzustellen.
Um zu einem vorherigen Build zurückzukehren:
1. Melden Sie sich beim [Capgo Dashboard](https://app.capgo.io) an
2. Navigieren Sie zum Bereich “Channels”
3. Klicken Sie auf den Namen des Kanals, den Sie zurücksetzen möchten
4. Suchen Sie den Build, zu dem Sie zurückkehren möchten, in der Build-Historie des Kanals
5. Klicken Sie auf das Kronen-Symbol neben diesem Build, um ihn zum aktiven Build für den Kanal zu machen 
6. Bestätigen Sie, dass Sie zu diesem Build zurückkehren möchten
Note
Das Zurücksetzen auf einen vorherigen Build betrifft nur den ausgewählten Kanal. Wenn Sie mehrere Kanäle haben (z.B. Produktion, Staging, etc.), müssen Sie den Rollback-Prozess für jeden betroffenen Kanal wiederholen.
Nach dem Zurücksetzen erhalten Geräte, die für den aktualisierten Kanal konfiguriert sind, beim nächsten Update-Check den vorherigen Build. Der zurückgesetzte Build wird als neues Update behandelt, sodass der übliche Update-Ablauf und die Bedingungen gelten.
## Trennen eines Kanals
[Section titled “Trennen eines Kanals”](#trennen-eines-kanals)
Wenn Sie Updates auf einem Kanal vorübergehend anhalten möchten, während Sie ein Problem untersuchen, können Sie den Kanal von seinem aktuellen Build trennen.
Um einen Kanal zu trennen:
1. Navigieren Sie zum Kanal im Capgo Dashboard
2. Klicken Sie auf die Schaltfläche “Unlink” neben dem aktuellen Build
3. Bestätigen Sie, dass Sie den Kanal trennen möchten
Sobald ein Kanal getrennt ist, werden keine neuen Updates mehr verteilt. Geräte, die für diesen Kanal konfiguriert sind, bleiben bei ihrem aktuellen Build, bis der Kanal wieder mit einem Build verknüpft wird.
Dies ist nützlich, wenn Sie ein Problem mit einem Update identifiziert haben, aber noch nicht sicher sind, zu welchem Build Sie zurückkehren möchten. Das Trennen des Kanals gibt Ihnen Zeit zur Untersuchung, ohne weitere Updates zu verteilen.
## Erzwingen des eingebauten Bundles
[Section titled “Erzwingen des eingebauten Bundles”](#erzwingen-des-eingebauten-bundles)
In schwerwiegenderen Situationen möchten Sie möglicherweise alle Geräte eines Kanals auf den Web-Build zurücksetzen, der ursprünglich mit dem nativen Binary Ihrer App gepackt wurde. Dies ist als “eingebautes Bundle” bekannt.
Um das eingebaute Bundle auf einem Kanal zu erzwingen:
1. Navigieren Sie zum Kanal im Capgo Dashboard
2. Klicken Sie auf die Schaltfläche “Built-in Bundle”
3. Bestätigen Sie, dass Sie das eingebaute Bundle erzwingen möchten
Wenn Sie das eingebaute Bundle erzwingen, kehren alle Geräte, die für diesen Kanal konfiguriert sind, bei ihrer nächsten Update-Prüfung zum ursprünglich gepackten Web-Build zurück. Dies geschieht unabhängig davon, welchen Build sie derzeit verwenden.
Dies ist eine aggressivere Rollback-Option als das Zurücksetzen auf einen bestimmten vorherigen Build, da es alle Live-Updates verwirft, die seit der letzten Veröffentlichung der App in den App Stores freigegeben wurden.
Caution
Seien Sie vorsichtig beim Erzwingen des eingebauten Bundles, da es alle Geräte im Kanal betrifft. Stellen Sie sicher, dass Sie die Auswirkungen bedacht und einen Plan für das weitere Vorgehen haben, bevor Sie diese Aktion durchführen.
## Überwachung und Reaktion auf Probleme
[Section titled “Überwachung und Reaktion auf Probleme”](#überwachung-und-reaktion-auf-probleme)
Um Probleme schnell zu erkennen und die Auswirkungen problematischer Updates zu minimieren, ist es wichtig, einen Plan für die Überwachung Ihrer Releases und die Reaktion auf Probleme zu haben.
Einige Strategien umfassen:
* Überwachung von Absturzberichten und Benutzer-Feedback unmittelbar nach der Veröffentlichung eines Updates
* Verwendung von stufenweisen Rollouts oder einem mehrstufigen Kanalsystem, um Updates an einer kleineren Gruppe zu testen, bevor sie breit veröffentlicht werden
* Einen klaren Entscheidungsprozess haben, wann zurückgesetzt, getrennt oder das eingebaute Bundle erzwungen werden soll, und wer dazu berechtigt ist
* Gegebenenfalls Kommunikation mit den Benutzern über das Problem und die Lösung
Durch die Kombination sorgfältiger Überwachung mit der Möglichkeit, problematische Updates schnell zu verwalten, können Sie eine kontinuierlich verbesserte App-Erfahrung bieten und gleichzeitig Störungen für Ihre Benutzer minimieren.
# Aktualisierungsverhalten
Wenn Sie ein Update für Ihre Capgo-App veröffentlichen, möchten Sie wahrscheinlich, dass Ihre Nutzer dieses Update so schnell wie möglich erhalten. Allerdings möchten Sie deren Nutzungserfahrung nicht stören, indem Sie sie zwingen, mitten in einer Sitzung auf einen Download zu warten oder die App neu zu starten.
Das Update-Verhalten von Capgo wurde entwickelt, um eine Balance zwischen schneller Update-Bereitstellung und minimaler Störung der Nutzer zu finden.
## Standard Update-Ablauf
[Section titled “Standard Update-Ablauf”](#standard-update-ablauf)
Standardmäßig behandelt Capgo App-Updates wie folgt:
1. Beim App-Start prüft das Capgo-Plugin, ob ein neues Update verfügbar ist
2. Wenn ein Update gefunden wird, wird es im Hintergrund heruntergeladen, während der Nutzer die aktuelle Version der App weiter verwendet
3. Sobald der Download abgeschlossen ist, wartet Capgo darauf, dass der Nutzer die App entweder in den Hintergrund verschiebt oder vollständig beendet
4. Wenn der Nutzer die App das nächste Mal startet, wird die aktualisierte Version ausgeführt
Dieser Ablauf stellt sicher, dass Nutzer immer die neueste Version Ihrer App verwenden, ohne jemals durch Update-Benachrichtigungen unterbrochen oder zum Warten auf Downloads gezwungen zu werden.
Tip
Capgo prüft auch auf Updates, wenn die App aus dem Hintergrund fortgesetzt wird. So erhalten Nutzer Updates auch dann, wenn sie die App nicht vollständig beenden.
## Warum dieser Ansatz?
[Section titled “Warum dieser Ansatz?”](#warum-dieser-ansatz)
Das Anwenden von Updates bei Hintergrund- oder Beendigungsereignissen hat einige wichtige Vorteile für die Benutzererfahrung:
* Nutzer werden nicht durch Update-Aufforderungen unterbrochen oder müssen mitten in einer Sitzung auf Downloads warten
* Updates werden nahtlos zwischen den Sitzungen angewendet, sodass das Starten der App immer ein frisches Erlebnis ist
* Sie können häufig Updates bereitstellen, ohne sich Sorgen machen zu müssen, aktive Nutzer zu stören
Der Hauptnachteil ist, dass wenn ein Nutzer die App in den Hintergrund verschiebt und schnell wieder aufruft, könnte nicht gespeicherter Status verloren gehen, da das Update zwischen diesen Aktionen angewendet wurde.
Um dies zu vermeiden, empfehlen wir:
* Status häufig zu speichern und ihn beim Fortsetzen der App korrekt wiederherzustellen
* Sehr häufige Updates zu vermeiden, die große Teile des App-Status verändern
* Die Anpassung des Update-Verhaltens für sensible Abläufe in Erwägung zu ziehen (siehe unten)
## Anpassen wann Updates angewendet werden
[Section titled “Anpassen wann Updates angewendet werden”](#anpassen-wann-updates-angewendet-werden)
In manchen Fällen möchten Sie möglicherweise mehr Kontrolle darüber haben, wann genau ein Update angewendet wird. Zum Beispiel möchten Sie vielleicht sicherstellen, dass ein Nutzer einen laufenden Prozess abschließt, bevor das Update installiert wird, oder ein App-Update mit einer serverseitigen Änderung koordinieren.
Capgo bietet eine `setDelay`-Funktion, mit der Sie Bedingungen festlegen können, die erfüllt sein müssen, bevor ein Update installiert wird:
```typescript
import { CapacitorUpdater } from '@capgo/capacitor-updater';
await CapacitorUpdater.setMultiDelay({
delayConditions: [
{
kind: 'date',
value: '2023-06-01T00:00:00.000Z',
},
{
kind: 'background',
value: '60000',
},
],
});
```
Dieses Beispiel würde die Installation eines Updates verzögern, bis nach dem 1. Juni 2023 UND die App mindestens 60 Sekunden im Hintergrund war.
Die verfügbaren Verzögerungsbedingungen sind:
* `date`: Warten bis nach einem bestimmten Datum/Uhrzeit, um das Update anzuwenden
* `background`: Nach einer Mindestdauer warten, nachdem die App in den Hintergrund verschoben wurde
* `nativeVersion`: Warten auf die Installation einer nativen Binary mit einer Mindestversion
* `kill`: Warten bis zum nächsten App-Beendigungsereignis
Sie können diese Bedingungen kombinieren, um präzise zu steuern, wann ein Update installiert wird.
Danger
Beachten Sie, dass die `kill`-Bedingung das Update derzeit nach dem ersten Beendigungsereignis auslöst, nicht nach dem nächsten Hintergrundereignis wie die anderen Bedingungen. Diese Inkonsistenz wird in einer zukünftigen Version behoben.
## Sofortiges Anwenden von Updates
[Section titled “Sofortiges Anwenden von Updates”](#sofortiges-anwenden-von-updates)
Für kritische Updates oder Apps mit sehr einfachem Status möchten Sie möglicherweise ein Update sofort nach dem Download anwenden, ohne auf ein Hintergrund- oder Beendigungsereignis zu warten. Capgo unterstützt dies über die `directUpdate`-Konfigurationsoption.
Empfohlen: Delta Updates mit Direct Update verwenden
Bei Verwendung von `directUpdate` **empfehlen wir dringend**, [Delta Updates](/docs/live-updates/differentials/) zu aktivieren, um Download-Zeiten zu minimieren und die Benutzererfahrung zu verbessern. Delta Updates laden nur geänderte Dateien statt des gesamten Bundles herunter, was besonders wichtig ist, wenn Updates sofort angewendet werden, während Benutzer Ihre App aktiv nutzen.
**Warum dies für Direct Updates wichtig ist:**
* **Schnellere Updates**: Kleinere Downloads bedeuten, dass Updates schnell abgeschlossen werden und die Zeit reduziert wird, in der Benutzer Ladebildschirme sehen
* **Besseres mobiles Erlebnis**: Benutzer mit mobilen Netzwerken oder langsameren Verbindungen haben keine langen Wartezeiten
* **Geringere Bandbreitennutzung**: Es werden nur geänderte Dateien heruntergeladen, was Daten für Sie und Ihre Benutzer spart
Um Delta Updates zu aktivieren, verwenden Sie einfach das `--partial`-Flag beim Hochladen von Bundles:
```shell
npx @capgo/cli@latest bundle upload --partial
```
Erfahren Sie mehr in der [Delta Updates Dokumentation](/docs/live-updates/differentials/).
`directUpdate` wird in Ihrer `capacitor.config.ts`-Datei gesetzt, nicht im JavaScript-Code:
```typescript
import { CapacitorConfig } from '@capacitor/cli';
const config: CapacitorConfig = {
plugins: {
CapacitorUpdater: {
autoUpdate: true,
directUpdate: true,
keepUrlPathAfterReload: true,
},
},
};
export default config;
```
Mit aktiviertem `directUpdate` wird Capgo ein Update sofort anwenden, sobald der Download abgeschlossen ist, auch wenn der Nutzer die App aktiv verwendet.
Beachten Sie, dass `directUpdate` als native Konfiguration zusätzliche Behandlung in Ihrem JavaScript-Code erfordert.
Bei Verwendung von `directUpdate` müssen Sie auf das `appReady`-Event hören und den Splash-Screen Ihrer App entsprechend ausblenden:
```js
import { CapacitorUpdater } from '@capgo/capacitor-updater';
import { SplashScreen } from '@capacitor/splash-screen';
CapacitorUpdater.addListener('appReady', () => {
// Splash Screen ausblenden
SplashScreen.hide();
});
CapacitorUpdater.notifyAppReady();
```
Das `appReady`-Event wird ausgelöst, sobald die App die Initialisierung abgeschlossen und alle ausstehenden Updates angewendet hat. Ab diesem Zeitpunkt ist es sicher, die Benutzeroberfläche Ihrer App anzuzeigen, da sichergestellt ist, dass der Nutzer die neueste Version sieht.
Zusätzlich zur Behandlung des `appReady`-Events empfehlen wir, die Konfigurationsoption `keepUrlPathAfterReload` auf `true` zu setzen, wenn Sie `directUpdate` verwenden. Dies bewahrt den aktuellen URL-Pfad, wenn die App aufgrund eines Updates neu geladen wird, und hilft dabei, den Standort des Nutzers in der App beizubehalten und Desorientierung zu reduzieren.
Wenn Sie das `appReady`-Event nicht behandeln und `keepUrlPathAfterReload` nicht setzen, wenn Sie `directUpdate` verwenden, könnte der Nutzer kurzzeitig eine veraltete Version der App sehen, zur Ausgangsroute zurückgeführt werden oder ein Flackern sehen, während das Update angewendet wird.
Die Verwendung von `directUpdate` kann nützlich sein, um kritische Fehlerbehebungen oder Sicherheitspatches bereitzustellen, bringt aber einige Kompromisse mit sich:
* Der Nutzer könnte ein kurzes Flackern oder einen Ladezustand sehen, während das Update angewendet wird, wenn Sie das `appReady`-Event nicht richtig behandeln
* Wenn das Update den App-Status oder die Benutzeroberfläche ändert, könnte der Nutzer eine störende Änderung mitten in einer Sitzung sehen
* Der Standort des Nutzers in der App könnte verloren gehen, wenn `keepUrlPathAfterReload` nicht gesetzt ist, was möglicherweise desorientierend wirkt
* Sie müssen sorgfältig das Speichern und Wiederherstellen des Status handhaben, um einen reibungslosen Übergang zu gewährleisten
Wenn Sie `directUpdate` aktivieren, empfehlen wir:
* Behandlung des `appReady`-Events zur Kontrolle, wann die Benutzeroberfläche Ihrer App angezeigt wird
* Setzen von `keepUrlPathAfterReload` auf `true`, um den Standort des Nutzers in der App zu bewahren
* Speichern und Wiederherstellen des App-Status nach Bedarf, um Nutzerffortschritt nicht zu verlieren
* Gründliches Testen des Update-Verhaltens Ihrer App, um sicherzustellen, dass es keine störenden Übergänge, verlorenen Status oder desorientierenden Standortänderungen gibt
In den meisten Fällen bietet das Standard-Update-Verhalten die beste Balance zwischen schneller Update-Bereitstellung und minimaler Störung. Aber für Apps mit spezifischen Anforderungen bietet Capgo die Flexibilität, anzupassen, wann und wie Updates angewendet werden.
# Update-Typen
> Eine umfassende Referenz aller OTA-Update-Typen, die Capgo bereitstellt: Anwendungszeitpunkt, Verzögerungsbedingungen, Versionssperrung und Bereitstellungsmethoden.
Capgo unterstützt verschiedene Arten von Over-the-Air (OTA) Updates. Diese Seite listet und erklärt alle, damit Sie die richtige Kombination für Ihre App wählen können.
## Anwendungszeitpunkt
[Section titled “Anwendungszeitpunkt”](#anwendungszeitpunkt)
Steuert **wann** ein Update angewendet wird, nachdem es heruntergeladen wurde.
| Typ | Beschreibung | Anwendungsfall |
| ----------------------------- | --------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
| **Standard** | Download im Hintergrund, Anwendung wenn Benutzer die App in den Hintergrund verschiebt oder beendet | Die meisten Apps; minimale Unterbrechung |
| **directUpdate: `atInstall`** | Sofortige Anwendung nur bei Neuinstallation oder App-Store-Update | Neue Benutzer erhalten die neueste Version; bestehende Benutzer nutzen den Standard-Ablauf |
| **directUpdate: `onLaunch`** | Sofortige Anwendung bei Installation, Store-Update oder nach App-Beendigung | Balance zwischen Aktualität und Sitzungsstabilität |
| **directUpdate: `always`** | Sofortige Anwendung wann immer ein Update heruntergeladen wird (auch beim Fortsetzen) | Kritische Fixes, Apps mit einfachem Zustand |
Konfiguration in `capacitor.config.ts`:
```typescript
plugins: {
CapacitorUpdater: {
directUpdate: false, // default
// or: 'atInstall' | 'onLaunch' | 'always'
}
}
```
Tip
Für vollständige Details und Splashscreen-Handhabung siehe [Update-Verhalten](/docs/live-updates/update-behavior/).
## Verzögerungsbedingungen
[Section titled “Verzögerungsbedingungen”](#verzögerungsbedingungen)
Bedingungen, die erfüllt sein müssen, **bevor** ein Update installiert wird. Verwenden Sie `setMultiDelay`, um sie zu kombinieren (alle Bedingungen müssen erfüllt sein).
| Bedingung | Beschreibung | Beispiel |
| ----------------- | ------------------------------------------------------------------------------------- | -------------------------------------------------------------- |
| **date** | Warten bis nach einem bestimmten Datum/Zeitpunkt | Koordination mit serverseitiger Veröffentlichung |
| **background** | Warten auf eine Mindestdauer (ms) nachdem die App in den Hintergrund verschoben wurde | Vermeidung der Anwendung bei schnellen App-Wechseln |
| **nativeVersion** | Erfordert eine minimale native Binärversion | Blockierung von Updates bei inkompatibler nativer Code-Version |
| **kill** | Warten bis zum nächsten App-Beendigungs-Ereignis | Anwendung nur bei vollständigem Neustart |
```typescript
import { CapacitorUpdater } from '@capgo/capacitor-updater';
await CapacitorUpdater.setMultiDelay({
delayConditions: [
{ kind: 'date', value: '2023-06-01T00:00:00.000Z' },
{ kind: 'background', value: '60000' },
],
});
```
Danger
Die `kill`-Bedingung wird nach dem ersten Beendigungs-Ereignis ausgelöst, nicht beim nächsten Hintergrund-Ereignis wie die anderen. Dies wird in einer zukünftigen Version behoben.
## Versionssperrung (Channel-Richtlinie)
[Section titled “Versionssperrung (Channel-Richtlinie)”](#versionssperrung-channel-richtlinie)
Steuert, welche **Semver-Updates** ein Channel automatisch bereitstellt. Wird über `--disable-auto-update` bei Channels festgelegt.
| Strategie | Blockiert | Erlaubt | Anwendungsfall |
| ------------ | ---------------------------------- | ------------------------------------------------ | ----------------------------------------------------------- |
| **none** | Nichts | Alle Updates | Standard; vollständiges Auto-Update |
| **major** | 0.0.0 → 1.0.0 | Gleiche Major-Version (z.B. 1.x → 1.y) | Verhinderung von Breaking Changes bei alter nativer Version |
| **minor** | 0.0.0 → 1.1.0, 1.1.0 → 1.2.0 | Gleiche Minor-Version (z.B. 1.2.x → 1.2.y) | Strengere Kontrolle innerhalb der Major-Version |
| **patch** | Jede Änderung außer Patch-Erhöhung | Nur 0.0.311 → 0.0.314 | Sehr streng; nur Patch-Updates |
| **metadata** | Updates ohne `min_update_version` | Updates mit expliziten Kompatibilitäts-Metadaten | Benutzerdefinierte Kompatibilitätsregeln pro Bundle |
```bash
npx @capgo/cli channel set production --disable-auto-update major
```
Caution
`patch` und `metadata` erfordern sorgfältige Einrichtung. Siehe [CLI-Befehle](/docs/cli/commands/#disable-updates-strategy) und [Versions-Targeting](/docs/live-updates/version-targeting/) für Details.
## Bereitstellungstypen
[Section titled “Bereitstellungstypen”](#bereitstellungstypen)
Wie das **Bundle auf das Gerät übertragen** wird.
| Typ | Beschreibung | Wann verwenden |
| ------------------------ | -------------------------------------------- | ------------------------------------------------------------------------ |
| **Vollständiges Bundle** | Das gesamte JS-Bundle wird heruntergeladen | Erste Installation, große Änderungen oder wenn Delta nicht verfügbar ist |
| **Delta (Manifest)** | Nur geänderte Dateien werden heruntergeladen | Die meisten Updates; schneller und bandbreitenfreundlich |
```bash
# Full bundle (default)
npx @capgo/cli bundle upload --channel production
# Delta updates
npx @capgo/cli bundle upload --channel production --delta
```
Tip
Bei Verwendung von `directUpdate` aktivieren Sie [Delta-Updates](/docs/live-updates/differentials/), um die Download-Zeit zu minimieren und die UX zu verbessern.
## Schnellreferenz
[Section titled “Schnellreferenz”](#schnellreferenz)
| Kategorie | Typen |
| --------------------------- | --------------------------------------------- |
| **Anwendungszeitpunkt** | Standard, `atInstall`, `onLaunch`, `always` |
| **Verzögerungsbedingungen** | `date`, `background`, `nativeVersion`, `kill` |
| **Versionssperrung** | `none`, `major`, `minor`, `patch`, `metadata` |
| **Bereitstellung** | Vollständiges Bundle, Delta (Manifest) |
## Verwandte Themen
[Section titled “Verwandte Themen”](#verwandte-themen)
* [Update-Verhalten](/docs/live-updates/update-behavior/) — Konfiguration von Anwendungszeitpunkt und Verzögerungen
* [Versions-Targeting](/docs/live-updates/version-targeting/) — Channel-basiertes Versions-Routing
* [Delta (Manifest) Updates](/docs/live-updates/differentials/) — Aktivierung von Teil-Downloads
* [Channels](/docs/live-updates/channels/) — Channel-Konfiguration und Priorität
# Version Targeting
> Stellen Sie automatisch kompatible Updates für Benutzer basierend auf ihrer nativen App-Version bereit
Diese Anleitung erklärt, wie Sie automatisch das neueste kompatible Bundle für Benutzer basierend auf ihrer nativen App-Version bereitstellen, **ähnlich wie bei Ionic AppFlow**. Dies gewährleistet vereinfachte Update-Verwaltung und schnellere Rollouts bei gleichzeitiger Vermeidung von Kompatibilitätsproblemen.
Migration von Ionic AppFlow?
Falls Sie von Ionic AppFlow migrieren, ist diese Anleitung besonders wichtig für Sie. AppFlow hat Updates automatisch nativen Versionen zugeordnet, und Capgo bietet die gleiche Möglichkeit mit noch mehr Kontrolle und Flexibilität. Siehe den [AppFlow-Migrationsleitfaden](/docs/upgrade/from-appflow-to-capgo) für schrittweise Migrationsanweisungen.
## Übersicht
[Section titled “Übersicht”](#übersicht)
Das Version-Targeting-System von Capgo ermöglicht es Ihnen zu:
* **Automatisch kompatible Updates** für Benutzer basierend auf ihrer nativen App-Version bereitzustellen
* **Brechende Änderungen** daran zu hindern, inkompatible App-Versionen zu erreichen
* **Mehrere App-Versionen** gleichzeitig zu verwalten ohne komplexe Logik
* **Updates nahtlos** für spezifische Benutzergruppen bereitzustellen
### Warum Version Targeting wichtig ist (besonders für AppFlow-Benutzer)
[Section titled “Warum Version Targeting wichtig ist (besonders für AppFlow-Benutzer)”](#warum-version-targeting-wichtig-ist-besonders-für-appflow-benutzer)
Falls Sie mit **Ionic AppFlow** vertraut sind, wissen Sie, wie wichtig es ist, sicherzustellen, dass Benutzer nur kompatible Updates erhalten. AppFlow hat Live-Update-Bundles automatisch nativen App-Versionen zugeordnet, um zu verhindern, dass inkompatibles JavaScript an ältere native Codes geliefert wird.
**Capgo bietet die gleichen Sicherheitsgarantien**, mit zusätzlichen Funktionen:
* Granularere Kontrolle über das Versions-Matching
* Mehrere Strategien (Kanäle, Semver, native Einschränkungen)
* Bessere Sichtbarkeit der Versionsverteilung
* API- und CLI-Kontrolle neben Dashboard-Verwaltung
Dieser Ansatz ist besonders nützlich, wenn:
* Sie Benutzer auf verschiedenen Hauptversionen Ihrer App haben (z. B. v1.x, v2.x, v3.x)
* Sie Abwärtskompatibilität aufrechterhalten müssen, während Sie brechende Änderungen einführen
* Sie verhindern möchten, dass neuere Bundles älteren nativen Code beschädigen
* Sie Benutzer graduell von einer Version zu einer anderen migrieren
* **Sie von AppFlow migrieren** und die gleiche Update-Sicherheit beibehalten möchten
## Wie es funktioniert
[Section titled “Wie es funktioniert”](#wie-es-funktioniert)
Capgo verwendet einen mehrschichtigen Ansatz, um Benutzer mit kompatiblen Updates zu vergleichen:
1. **Native Versionsbeschränkungen**: Verhindern Sie, dass Bundles an inkompatible native Versionen geliefert werden
2. **Kanalbasiertes Routing**: Leiten Sie verschiedene App-Versionen an verschiedene Update-Kanäle weiter
3. **Semantische Versionierungskontrollen**: Blockieren Sie Updates automatisch über Major-/Minor-/Patch-Grenzen
4. **Geräteebene-Overrides**: Zielbenutzer spezifische Geräte oder Benutzergruppen an
### Version-Matching-Fluss
[Section titled “Version-Matching-Fluss”](#version-matching-fluss)
```mermaid
graph TD
A[User Opens App] --> B{Check Device Override}
B -->|Override Set| C[Use Override Channel]
B -->|No Override| D{Check defaultChannel in App}
D -->|Has defaultChannel| E[Use App's defaultChannel]
D -->|No defaultChannel| F[Use Cloud Default Channel]
C --> G{Check Version Constraints}
E --> G
F --> G
G -->|Compatible| H[Deliver Update]
G -->|Incompatible| I[Skip Update]
```
## Strategie 1: Kanalbasiertes Versions-Routing
[Section titled “Strategie 1: Kanalbasiertes Versions-Routing”](#strategie-1-kanalbasiertes-versions-routing)
Dies ist der **empfohlene Ansatz** zum Verwalten von brechenden Änderungen und Hauptversions-Updates. Es ähnelt AppFlow’s Liefermodell.
### Beispielszenario
[Section titled “Beispielszenario”](#beispielszenario)
* **App v1.x** (100.000 Benutzer) → `production` Kanal
* **App v2.x** (50.000 Benutzer mit brechenden Änderungen) → `v2` Kanal
* **App v3.x** (10.000 Beta-Benutzer) → `v3` Kanal
### Implementierung
[Section titled “Implementierung”](#implementierung)
#### Schritt 1: Kanäle für jede Hauptversion konfigurieren
[Section titled “Schritt 1: Kanäle für jede Hauptversion konfigurieren”](#schritt-1-kanäle-für-jede-hauptversion-konfigurieren)
```typescript
// capacitor.config.ts für Version 1.x Builds
import { CapacitorConfig } from '@capacitor/cli';
const config: CapacitorConfig = {
appId: 'com.example.app',
appName: 'Example App',
plugins: {
CapacitorUpdater: {
autoUpdate: true,
defaultChannel: 'production', // oder weglassen für Standard
}
}
};
export default config;
```
```typescript
// capacitor.config.ts für Version 2.x Builds
const config: CapacitorConfig = {
appId: 'com.example.app',
appName: 'Example App',
plugins: {
CapacitorUpdater: {
autoUpdate: true,
defaultChannel: 'v2', // Leitet v2-Benutzer automatisch weiter
}
}
};
```
```typescript
// capacitor.config.ts für Version 3.x Builds
const config: CapacitorConfig = {
appId: 'com.example.app',
appName: 'Example App',
plugins: {
CapacitorUpdater: {
autoUpdate: true,
defaultChannel: 'v3', // Leitet v3-Benutzer automatisch weiter
}
}
};
```
#### Schritt 2: Kanäle erstellen
[Section titled “Schritt 2: Kanäle erstellen”](#schritt-2-kanäle-erstellen)
```bash
# Erstellen Sie Kanäle für jede Hauptversion
npx @capgo/cli channel create production
npx @capgo/cli channel create v2
npx @capgo/cli channel create v3
# Aktivieren Sie die Selbstzuweisung, damit Apps Kanäle wechseln können
npx @capgo/cli channel set production --self-assign
npx @capgo/cli channel set v2 --self-assign
npx @capgo/cli channel set v3 --self-assign
```
#### Schritt 3: Versionsspezifische Bundles hochladen
[Section titled “Schritt 3: Versionsspezifische Bundles hochladen”](#schritt-3-versionsspezifische-bundles-hochladen)
```bash
# Für v1.x Benutzer (von v1-maintenance Branch)
git checkout v1-maintenance
npm run build
npx @capgo/cli bundle upload --channel production
# Für v2.x Benutzer (von v2-maintenance oder main Branch)
git checkout main
npm run build
npx @capgo/cli bundle upload --channel v2
# Für v3.x Benutzer (von beta/v3 Branch)
git checkout beta
npm run build
npx @capgo/cli bundle upload --channel v3
```
Automatisches Routing
Wenn Benutzer die App öffnen, stellen sie automatisch eine Verbindung zu ihrem designierten Kanal basierend auf dem `defaultChannel` in ihrem installierten App-Bundle her. Keine JavaScript-Codeänderungen erforderlich!
### Vorteile
[Section titled “Vorteile”](#vorteile)
* **Null Code-Änderungen** - Kanalrouting erfolgt automatisch
* **Klare Trennung** - Jede Version hat ihre eigene Update-Pipeline
* **Flexible Targeting** - Pushen Sie Updates an spezifische Versionsgruppen
* **Sichere Rollouts** - Brechende Änderungen erreichen nie inkompatible Versionen
## Strategie 2: Semantische Versionierungskontrollen
[Section titled “Strategie 2: Semantische Versionierungskontrollen”](#strategie-2-semantische-versionierungskontrollen)
Verwenden Sie die integrierten semantischen Versionierungskontrollen von Capgo, um Updates über Versionsgrenzen hinweg zu verhindern.
### Deaktivieren Sie Auto-Update über Hauptversionen hinweg
[Section titled “Deaktivieren Sie Auto-Update über Hauptversionen hinweg”](#deaktivieren-sie-auto-update-über-hauptversionen-hinweg)
```bash
# Erstellen Sie einen Kanal, der Update über Hauptversionen blockiert
npx @capgo/cli channel create stable --disable-auto-update major
```
Diese Konfiguration bedeutet:
* Benutzer mit App-Version **1.2.3** erhalten Updates bis zu **1.9.9**
* Benutzer erhalten **NICHT** Version **2.0.0** automatisch
* Verhindert, dass brechende Änderungen älteren nativen Code erreichen
### Granulare Steuerungsoptionen
[Section titled “Granulare Steuerungsoptionen”](#granulare-steuerungsoptionen)
```bash
# Blockieren Sie Update über Minor-Versionen (1.2.x erhält 1.3.0 nicht)
npx @capgo/cli channel set stable --disable-auto-update minor
# Blockieren Sie Patch-Updates (1.2.3 erhält 1.2.4 nicht)
npx @capgo/cli channel set stable --disable-auto-update patch
# Erlauben Sie alle Updates
npx @capgo/cli channel set stable --disable-auto-update none
```
Semantische Versionierung erforderlich
Diese Strategie funktioniert nur, wenn Sie semantische Versionierung (Semver) für Ihre App-Versionen befolgen. Stellen Sie sicher, dass Ihre Versionsnummern das `MAJOR.MINOR.PATCH` Format befolgen.
## Strategie 3: Native Versionsbeschränkungen
[Section titled “Strategie 3: Native Versionsbeschränkungen”](#strategie-3-native-versionsbeschränkungen)
Geben Sie die Mindestanforderungen für native Versionen für Bundles an, um die Lieferung an inkompatible Geräte zu verhindern.
### Verwenden der nativeVersion Verzögerungsbedingung
[Section titled “Verwenden der nativeVersion Verzögerungsbedingung”](#verwenden-der-nativeversion-verzögerungsbedingung)
Beim Hochladen eines Bundles können Sie eine Mindest-Native-Version angeben:
```bash
# Dieses Bundle erfordert native Version 2.0.0 oder höher
npx @capgo/cli bundle upload \
--channel production \
--native-version "2.0.0"
```
Wie es funktioniert
Geräte mit nativer Version 1.x erhalten dieses Bundle NICHT. Nur Geräte mit 2.0.0+ erhalten es. Dies ist perfekt für Updates, die neue native APIs oder Plugins erfordern.
### Anwendungsfälle
[Section titled “Anwendungsfälle”](#anwendungsfälle)
1. **Neues Native Plugin erforderlich**
```bash
# Bundle benötigt Camera-Plugin in v2.0.0 hinzugefügt
npx @capgo/cli bundle upload --native-version "2.0.0"
```
2. **Breaking Native API-Änderungen**
```bash
# Bundle verwendet neue Capacitor 6 APIs
npx @capgo/cli bundle upload --native-version "3.0.0"
```
3. **Graduelle Migration**
```bash
# Test Bundle nur auf neuester nativer Version
npx @capgo/cli bundle upload \
--channel beta \
--native-version "2.5.0"
```
## Strategie 4: Prävention von Auto-Downgrade
[Section titled “Strategie 4: Prävention von Auto-Downgrade”](#strategie-4-prävention-von-auto-downgrade)
Verhindern Sie, dass Benutzer Bundles erhalten, die älter als ihre aktuelle native Version sind.
### In Kanaleinstellungen aktivieren
[Section titled “In Kanaleinstellungen aktivieren”](#in-kanaleinstellungen-aktivieren)
Im Capgo-Dashboard:
1. Gehen Sie zu **Kanäle** → Wählen Sie Ihren Kanal
2. Aktivieren Sie **“Deaktivieren Sie automatisches Downgrade unter native”**
3. Speichern Sie die Änderungen
Oder über CLI:
```bash
npx @capgo/cli channel set production --disable-downgrade
```
### Beispiel
[Section titled “Beispiel”](#beispiel)
* Geräteversion des Benutzers: Native Version **1.2.5**
* Kanal Bundle: Version **1.2.3**
* **Ergebnis**: Update wird blockiert (wäre ein Downgrade)
Dies ist nützlich, wenn:
* Benutzer eine neuere Version manuell aus dem App-Store installiert haben
* Sie sicherstellen müssen, dass Benutzer immer die neuesten Sicherheits-Patches haben
* Sie Regressionsfehler verhindern möchten
## Strategie 5: Geräteebene-Targeting
[Section titled “Strategie 5: Geräteebene-Targeting”](#strategie-5-geräteebene-targeting)
Überschreiben Sie die Kanalzuweisung für spezifische Geräte oder Benutzergruppen.
### Erzwinge spezifische Version zum Testen
[Section titled “Erzwinge spezifische Version zum Testen”](#erzwinge-spezifische-version-zum-testen)
```typescript
import { CapacitorUpdater } from '@capgo/capacitor-updater'
// Erzwinge Beta-Tester zur Verwendung des v3-Kanals
async function assignBetaTesters() {
const deviceId = await CapacitorUpdater.getDeviceId()
// Überprüfen Sie, ob Benutzer Beta-Tester ist
if (isBetaTester(userId)) {
await CapacitorUpdater.setChannel({ channel: 'v3' })
}
}
```
### Dashboard-Geräte-Override
[Section titled “Dashboard-Geräte-Override”](#dashboard-geräte-override)
Im Capgo-Dashboard:
1. Gehen Sie zu **Geräte** → Finden Sie Gerät
2. Klicken Sie auf **Set Channel** oder **Set Version**
3. Überschreiben Sie mit spezifischem Kanal oder Bundle-Version
4. Gerät erhält Updates von der überschriebenen Quelle
Testing Updates
Verwenden Sie Geräte-Overrides, um Updates auf Ihrem eigenen Gerät zu testen, bevor Sie sie für alle Benutzer einführen.
## Kompletter AppFlow-ähnlicher Workflow
[Section titled “Kompletter AppFlow-ähnlicher Workflow”](#kompletter-appflow-ähnlicher-workflow)
Hier ist ein vollständiges Beispiel, das alle Strategien kombiniert:
### 1. Initiales Setup (App v1.0.0)
[Section titled “1. Initiales Setup (App v1.0.0)”](#1-initiales-setup-app-v100)
```bash
# Erstellen Sie Production-Kanal mit Semver-Kontrollen
npx @capgo/cli channel create production \
--disable-auto-update major \
--disable-downgrade
```
capacitor.config.ts
```typescript
const config: CapacitorConfig = {
plugins: {
CapacitorUpdater: {
autoUpdate: true,
defaultChannel: 'production',
}
}
};
```
### 2. Brechende Änderung freigeben (App v2.0.0)
[Section titled “2. Brechende Änderung freigeben (App v2.0.0)”](#2-brechende-änderung-freigeben-app-v200)
```bash
# Erstellen Sie v2 Kanal für neue Version
npx @capgo/cli channel create v2 \
--disable-auto-update major \
--disable-downgrade \
--self-assign
# Erstellen Sie Git-Branch für v1 Wartung
git checkout -b v1-maintenance
git push origin v1-maintenance
```
```typescript
// capacitor.config.ts für v2.0.0
const config: CapacitorConfig = {
plugins: {
CapacitorUpdater: {
autoUpdate: true,
defaultChannel: 'v2', // Neue Benutzer erhalten v2 Kanal
}
}
};
```
### 3. Updates für beide Versionen pushen
[Section titled “3. Updates für beide Versionen pushen”](#3-updates-für-beide-versionen-pushen)
```bash
# Update v1.x Benutzer (Fehlerbehebung)
git checkout v1-maintenance
# Vornehmen von Änderungen
npx @capgo/cli bundle upload \
--channel production \
--native-version "1.0.0"
# Update v2.x Benutzer (neues Feature)
git checkout main
# Vornehmen von Änderungen
npx @capgo/cli bundle upload \
--channel v2 \
--native-version "2.0.0"
```
### 4. Versionsverteilung überwachen
[Section titled “4. Versionsverteilung überwachen”](#4-versionsverteilung-überwachen)
Verwenden Sie das Capgo-Dashboard zum Verfolgen von:
* Wie viele Benutzer auf v1 vs v2 sind
* Bundle-Adoptionsraten pro Version
* Fehler oder Abstürze pro Version
### 5. Alte Version abschaffen
[Section titled “5. Alte Version abschaffen”](#5-alte-version-abschaffen)
Sobald v1-Nutzung unter Schwellenwert fällt:
```bash
# Stopfen Sie das Hochladen zum Production-Kanal
# Optional: Löschen Sie v1 Maintenance-Branch
git branch -d v1-maintenance
# Verschieben Sie alle verbleibenden Benutzer zum Standard
# (Sie müssen über App-Store aktualisieren)
```
## Kanal-Priorität
[Section titled “Kanal-Priorität”](#kanal-priorität)
Wenn mehrere Kanalkonfigurationen vorhanden sind, verwendet Capgo diese Prioritätsreihenfolge:
1. **Geräte-Override** (Dashboard oder API) - Höchste Priorität
2. **Cloud Override** via `setChannel()` Aufruf
3. **defaultChannel** in capacitor.config.ts
4. **Standard Kanal** (Cloud-Einstellung) - Niedrigste Priorität
Prioritäts-Beispiel
Wenn die App eines Benutzers `defaultChannel: 'v2'` hat, aber Sie ihr Gerät im Dashboard zu `'beta'` überschreiben, erhalten sie Updates vom `'beta'` Kanal.
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
### 1. Setzen Sie immer defaultChannel für Hauptversionen
[Section titled “1. Setzen Sie immer defaultChannel für Hauptversionen”](#1-setzen-sie-immer-defaultchannel-für-hauptversionen)
```typescript
// ✅ Gut: Jede Hauptversion hat expliziten Kanal
// v1.x → production
// v2.x → v2
// v3.x → v3
// ❌ Schlecht: Verlassen Sie sich auf dynamischen Kanalwechsel
// Alle Versionen → production, Manueller Wechsel
```
### 2. Verwenden Sie semantische Versionierung
[Section titled “2. Verwenden Sie semantische Versionierung”](#2-verwenden-sie-semantische-versionierung)
```bash
# ✅ Gut
1.0.0 → 1.0.1 → 1.1.0 → 2.0.0
# ❌ Schlecht
1.0 → 1.1 → 2 → 2.5
```
### 3. Behalten Sie separate Branches bei
[Section titled “3. Behalten Sie separate Branches bei”](#3-behalten-sie-separate-branches-bei)
```bash
# ✅ Gut: Separate Branches pro Hauptversion
main (v3.x)
v2-maintenance (v2.x)
v1-maintenance (v1.x)
# ❌ Schlecht: Einzelner Branch für alle Versionen
```
### 4. Testen Sie vor dem Rollout
[Section titled “4. Testen Sie vor dem Rollout”](#4-testen-sie-vor-dem-rollout)
```bash
# Testen Sie zuerst auf Beta-Kanal
npx @capgo/cli bundle upload --channel beta
# Überwachen Sie Probleme, dann fördern Sie zur Production
npx @capgo/cli bundle upload --channel production
```
### 5. Versionsverteilung überwachen
[Section titled “5. Versionsverteilung überwachen”](#5-versionsverteilung-überwachen)
Überprüfen Sie regelmäßig Ihr Dashboard:
* Aktualisieren Benutzer auf neuere native Versionen?
* Erhalten alte Versionen noch hohen Verkehr?
* Sollten Sie alte Kanäle abschaffen?
## Vergleich mit Ionic AppFlow
[Section titled “Vergleich mit Ionic AppFlow”](#vergleich-mit-ionic-appflow)
Für Teams, die von **Ionic AppFlow** migrieren, ist hier ein Vergleich des Version-Targetings von Capgo:
| Feature | Ionic AppFlow | Capgo |
| --------------------------------- | ------------------------------------------- | --------------------------------------------------------- |
| **Versionsbasiertes Routing** | Automatisch basierend auf nativer Version | Automatisch via `defaultChannel` + mehrere Strategien |
| **Semantische Versionierung** | Grundlegende Unterstützung | Erweitert mit `--disable-auto-update` (major/minor/patch) |
| **Native Versionsbeschränkungen** | Manuelle Konfiguration im AppFlow-Dashboard | Eingebautes `--native-version` Flag in CLI |
| **Kanal-Management** | Web UI + CLI | Web UI + CLI + API |
| **Geräte-Overrides** | Begrenzte Geräteebene-Kontrolle | Vollständige Kontrolle via Dashboard/API |
| **Auto-Downgrade-Prävention** | Ja | Ja via `--disable-downgrade` |
| **Multi-Versions-Wartung** | Manuelle Branch-/Kanal-Verwaltung | Automatisiert mit Kanal-Priorität |
| **Self-Hosting** | Nein | Ja (vollständige Kontrolle) |
| **Versions-Analytik** | Grundlegend | Detailliert pro-Version Metriken |
AppFlow-Parität und darüber hinaus
Capgo bietet **alle Version-Targeting-Fähigkeiten**, die AppFlow angeboten hat, plus zusätzliche Kontrollmechanismen. Wenn Sie sich auf AppFlow’s automatisches Versions-Matching verlassen haben, werden Sie feststellen, dass Capgo gleich sicher ist mit mehr Flexibilität.
## Fehlerbehebung
[Section titled “Fehlerbehebung”](#fehlerbehebung)
### Benutzer erhalten Updates nicht
[Section titled “Benutzer erhalten Updates nicht”](#benutzer-erhalten-updates-nicht)
Überprüfen Sie Folgendes:
1. **Kanal-Zuordnung**: Überprüfen Sie, dass Gerät auf korrektem Kanal ist
```typescript
const channel = await CapacitorUpdater.getChannel()
console.log('Current channel:', channel)
```
2. **Versions-Einschränkungen**: Überprüfen Sie, ob Bundle native Versionsanforderungen hat
* Dashboard → Bundles → Überprüfen Sie “Native Version” Spalte
3. **Semver-Einstellungen**: Überprüfen Sie die `disable-auto-update` Einstellung des Kanals
```bash
npx @capgo/cli channel list
```
4. **Geräte-Override**: Überprüfen Sie, ob Gerät manuellen Override hat
* Dashboard → Geräte → Suchen Sie nach Gerät → Überprüfen Sie Kanal/Version
### Bundle wird an falsche Version geliefert
[Section titled “Bundle wird an falsche Version geliefert”](#bundle-wird-an-falsche-version-geliefert)
1. **Überprüfen Sie defaultChannel**: Stellen Sie sicher, korrekter Kanal in `capacitor.config.ts`
2. **Überprüfen Sie Bundle-Upload**: Verifizieren Sie, dass Bundle zum beabsichtigten Kanal hochgeladen wurde
3. **Überprüfen Sie Native-Version**: Bestätigen Sie, dass `--native-version` Flag korrekt verwendet wurde
### Brechende Änderungen beeinflussen alte Versionen
[Section titled “Brechende Änderungen beeinflussen alte Versionen”](#brechende-änderungen-beeinflussen-alte-versionen)
1. **Sofort-Fix**: Überschreiben Sie betroffene Geräte zum sicheren Bundle
* Dashboard → Geräte → Mehrfach auswählen → Set Version
2. **Langfristig-Fix**: Erstellen Sie versionierte Kanäle und behalten Sie separate Branches
3. **Prävention**: Testen Sie immer Updates auf repräsentativen Geräten vor dem Rollout
## Migration von Ionic AppFlow
[Section titled “Migration von Ionic AppFlow”](#migration-von-ionic-appflow)
Falls Sie von **Ionic AppFlow** migrieren, funktioniert Version-Targeting in Capgo sehr ähnlich, mit verbesserter Flexibilität:
### Konzept-Mapping
[Section titled “Konzept-Mapping”](#konzept-mapping)
| AppFlow Concept | Capgo Equivalent | Notes |
| ------------------------------ | ---------------------------------------------- | ---------------------------------- |
| **Deploy Channel** | Capgo Channel | Gleiches Konzept, leistungsreicher |
| **Native Version Lock** | `--native-version` flag | Granularere Kontrolle |
| **Channel Priority** | Channel Priorität (override → cloud → default) | Transparentere Priorität |
| **Deployment Target** | Channel + Semver-Kontrollen | Mehrere Strategien verfügbar |
| **Production Channel** | `production` Kanal (oder beliebiger Name) | Flexible Benennung |
| **Git-based deployment** | CLI Bundle-Upload von Branch | Gleicher Workflow |
| **Automatic version matching** | `defaultChannel` + Versions-Einschränkungen | Erweitert mit mehreren Strategien |
### Schlüsseldifferenzen für AppFlow-Benutzer
[Section titled “Schlüsseldifferenzen für AppFlow-Benutzer”](#schlüsseldifferenzen-für-appflow-benutzer)
1. **Mehr Kontrolle**: Capgo gibt Ihnen mehrere Strategien (Kanäle, Semver, native Version), die kombiniert werden können
2. **Bessere Sichtbarkeit**: Dashboard zeigt Versionsverteilung und Kompatibilitätsprobleme
3. **API-Zugriff**: Vollständige programmatische Kontrolle über Version-Targeting
4. **Self-Hosting**: Option, Ihren eigenen Update-Server mit gleicher Versionslogik zu betreiben
### Migrations-Schritte
[Section titled “Migrations-Schritte”](#migrations-schritte)
1. **Ordnen Sie Ihre AppFlow-Kanäle** Capgo-Kanälen zu (üblicherweise 1:1)
2. **Setzen Sie `defaultChannel`** in `capacitor.config.ts` für jede Hauptversion
3. **Konfigurieren Sie Semver-Regeln**, wenn Sie automatisches Blockieren auf Versionsgrenzen wünschen
4. **Laden Sie versionsspezifische Bundles** mit `--native-version` Flag hoch
5. **Überwachen Sie Versionsverteilung** im Capgo-Dashboard
Kompletter Migrations-Leitfaden
Für vollständige Migrationsanweisungen einschließlich SDK-Ersatz und API-Zuordnung, siehe den [AppFlow zu Capgo Migrations-Leitfaden](/docs/upgrade/from-appflow-to-capgo).
## Erweiterte Muster
[Section titled “Erweiterte Muster”](#erweiterte-muster)
### Gradueller Rollout nach Version
[Section titled “Gradueller Rollout nach Version”](#gradueller-rollout-nach-version)
```typescript
// Migrieren Sie v1-Benutzer graduell zu v2
async function migrateUsers() {
const deviceId = await CapacitorUpdater.getDeviceId()
const rolloutPercentage = 10 // Beginnen Sie mit 10%
// Hash Device-ID zum Abrufen deterministischen Prozentsatz
const hash = hashCode(deviceId) % 100
if (hash < rolloutPercentage) {
// Benutzer ist in Rollout-Gruppe - Migrieren Sie zu v2
await CapacitorUpdater.setChannel({ channel: 'v2' })
}
}
```
### Feature-Flags nach Version
[Section titled “Feature-Flags nach Version”](#feature-flags-nach-version)
```typescript
// Aktivieren Sie Features basierend auf nativer Version
async function checkFeatureAvailability() {
const info = await CapacitorUpdater.getDeviceId()
const nativeVersion = info.nativeVersion
if (compareVersions(nativeVersion, '2.0.0') >= 0) {
// Aktivieren Sie Features, die v2.0.0+ erfordern
enableNewCameraFeature()
}
}
```
### A/B-Tests über Versionen hinweg
[Section titled “A/B-Tests über Versionen hinweg”](#ab-tests-über-versionen-hinweg)
```typescript
// Führen Sie A/B-Tests innerhalb gleicher nativer Version aus
async function assignABTest() {
const nativeVersion = await getNativeVersion()
if (nativeVersion.startsWith('2.')) {
// Nur A/B-Test auf v2-Benutzern
const variant = Math.random() < 0.5 ? 'v2-test-a' : 'v2-test-b'
await CapacitorUpdater.setChannel({ channel: variant })
}
}
```
## Zusammenfassung
[Section titled “Zusammenfassung”](#zusammenfassung)
Capgo bietet mehrere Strategien für versionsspezifische Update-Lieferung:
1. **Kanalbasiertes Routing**: Automatische Versionsaufteilung via `defaultChannel`
2. **Semantische Versionierung**: Verhindern Sie Updates über Major-/Minor-/Patch-Grenzen
3. **Native Versionsbeschränkungen**: Erfordern Sie Mindest-Native-Version für Bundles
4. **Auto-Downgrade-Prävention**: Liefern Sie nie ältere Bundles an neuere native Versionen
5. **Geräte-Overrides**: Manuelle Kontrolle zum Testen und Targeting
Durch das Kombinieren dieser Strategien können Sie AppFlow-ähnliche automatische Update-Lieferung mit noch mehr Flexibilität und Kontrolle erreichen. Wählen Sie den Ansatz, der am besten zu Ihrem App’s Versionierung und Deployment-Workflow passt.
Für mehr Details zu spezifischen Funktionen:
* [Leitfaden zu brechenden Änderungen](/docs/live-updates/breaking-changes) - Detaillierte Kanal-Versionierungs-Strategie
* [Kanal-Verwaltung](/docs/live-updates/channels) - Vollständige Kanal-Konfigurationsreferenz
* [Update-Verhalten](/docs/live-updates/update-behavior) - Native Versions-Verzögerungen und Bedingungen
# Funktionen und Einstellungen
> Alle verfügbaren Methoden und Einstellungen des Plugins
# Updater Plugin Konfiguration
[Section titled “Updater Plugin Konfiguration”](#updater-plugin-konfiguration)
Siehe Github [Readme](https://github.com/Cap-go/capacitor-updater) für weitere Informationen
CapacitorUpdater kann mit diesen Optionen konfiguriert werden:
| Eigenschaft | Typ | Beschreibung | Standard | Seit |
| ---------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------- | ------- |
| **`appReadyTimeout`** | `number` | Konfiguriert die Anzahl der Millisekunden, die das native Plugin warten soll, bevor ein Update als ‘fehlgeschlagen’ gilt. Nur verfügbar für Android und iOS | `10000 // (10 Sekunden)` | |
| **`responseTimeout`** | `number` | Konfiguriert die Anzahl der Millisekunden, die das native Plugin warten soll, bevor API-Timeout eintritt. Nur verfügbar für Android und iOS | `20 // (20 Sekunden)` | |
| **`autoDeleteFailed`** | `boolean` | Konfiguriert, ob das Plugin fehlgeschlagene Bundles automatisch löschen soll. Nur verfügbar für Android und iOS | `true` | |
| **`autoDeletePrevious`** | `boolean` | Konfiguriert, ob das Plugin vorherige Bundles nach einem erfolgreichen Update automatisch löschen soll. Nur verfügbar für Android und iOS | `true` | |
| **`autoUpdate`** | `boolean` | Konfiguriert, ob das Plugin Auto-Update über einen Update-Server verwenden soll. Nur verfügbar für Android und iOS | `true` | |
| **`resetWhenUpdate`** | `boolean` | Löscht automatisch zuvor heruntergeladene Bundles, wenn ein neueres natives App-Bundle auf dem Gerät installiert wird. Nur verfügbar für Android und iOS | `true` | |
| **`updateUrl`** | `string` | Konfiguriert die URL / den Endpunkt, an den Update-Prüfungen gesendet werden. Nur verfügbar für Android und iOS | `https://plugin.capgo.app/updates` | |
| **`channelUrl`** | `string` | Konfiguriert die URL / den Endpunkt für Kanal-Operationen. Nur verfügbar für Android und iOS | `https://plugin.capgo.app/channel_self` | |
| **`statsUrl`** | `string` | Konfiguriert die URL / den Endpunkt, an den Update-Statistiken gesendet werden. Nur verfügbar für Android und iOS. Auf "" setzen, um Statistik-Reporting zu deaktivieren | `https://plugin.capgo.app/stats` | |
| **`privateKey`** | `string` | Konfiguriert den privaten Schlüssel für Ende-zu-Ende Live-Update-Verschlüsselung. Nur verfügbar für Android und iOS. Veraltet in Version 6.2.0, wird in Version 7.0.0 entfernt | `undefined` | |
| **`publicKey`** | `string` | Konfiguriert den öffentlichen Schlüssel für Ende-zu-Ende Live-Update-Verschlüsselung Version 2. Nur verfügbar für Android und iOS | `undefined` | 6.2.0 |
| **`version`** | `string` | Konfiguriert die aktuelle Version der App. Wird für die erste Update-Anfrage verwendet. Wenn nicht gesetzt, holt das Plugin die Version aus dem nativen Code. Nur verfügbar für Android und iOS | `undefined` | 4.17.48 |
| **`directUpdate`** | `boolean` | Lässt das Plugin Updates direkt installieren, wenn die App gerade aktualisiert/installiert wurde. Nur für autoUpdate-Modus. Nur verfügbar für Android und iOS | `undefined` | 5.1.0 |
| **`periodCheckDelay`** | `number` | Konfiguriert die Verzögerungsperiode für periodische Update-Prüfungen in Sekunden. Nur verfügbar für Android und iOS. Kann nicht weniger als 600 Sekunden (10 Minuten) sein | `600 // (10 Minuten)` | |
| **`localS3`** | `boolean` | Konfiguriert die CLI zur Verwendung eines lokalen Servers für Tests oder selbst-gehosteten Update-Server | `undefined` | 4.17.48 |
| **`localHost`** | `string` | Konfiguriert die CLI zur Verwendung eines lokalen Servers für Tests oder selbst-gehosteten Update-Server | `undefined` | 4.17.48 |
| **`localWebHost`** | `string` | Konfiguriert die CLI zur Verwendung eines lokalen Servers für Tests oder selbst-gehosteten Update-Server | `undefined` | 4.17.48 |
| **`localSupa`** | `string` | Konfiguriert die CLI zur Verwendung eines lokalen Servers für Tests oder selbst-gehosteten Update-Server | `undefined` | 4.17.48 |
| **`localSupaAnon`** | `string` | Konfiguriert die CLI zur Verwendung eines lokalen Servers für Tests | `undefined` | 4.17.48 |
| **`localApi`** | `string` | Konfiguriert die CLI zur Verwendung einer lokalen API für Tests | `undefined` | 6.3.3 |
| **`localApiFiles`** | `string` | Konfiguriert die CLI zur Verwendung einer lokalen Datei-API für Tests | `undefined` | 6.3.3 |
| **`allowModifyUrl`** | `boolean` | Erlaubt dem Plugin, updateUrl, statsUrl und channelUrl dynamisch von der JavaScript-Seite zu ändern | `false` | 5.4.0 |
| **`defaultChannel`** | `string` | Setzt den Standard-Kanal für die App in der Konfiguration | `undefined` | 4.17.48 |
| **`appId`** | `string` | App-ID in der Konfiguration für die App konfigurieren | `undefined` | 600 |
| **`keepUrlPathAfterReload`** | `boolean` | Plugin so konfigurieren, dass der URL-Pfad nach einem Reload erhalten bleibt WARNUNG: Wenn ein Reload ausgelöst wird, wird ‘windowhistory’ gelöscht | `false` | 680 |
## Beispiele
[Section titled “Beispiele”](#beispiele)
In `capacitorconfigjson`:
```json
{
"plugins": {
"CapacitorUpdater": {
"appReadyTimeout": 1000 // (1 Sekunde),
"responseTimeout": 10 // (10 Sekunden),
"autoDeleteFailed": false,
"autoDeletePrevious": false,
"autoUpdate": false,
"resetWhenUpdate": false,
"updateUrl": https://examplecom/api/auto_update,
"channelUrl": https://examplecom/api/channel,
"statsUrl": https://examplecom/api/stats,
"privateKey": undefined,
"publicKey": undefined,
"version": undefined,
"directUpdate": undefined,
"periodCheckDelay": undefined,
"localS3": undefined,
"localHost": undefined,
"localWebHost": undefined,
"localSupa": undefined,
"localSupaAnon": undefined,
"localApi": undefined,
"localApiFiles": undefined,
"allowModifyUrl": undefined,
"defaultChannel": undefined,
"appId": undefined,
"keepUrlPathAfterReload": undefined
}
}
}
```
In `capacitorconfigts`:
```ts
import { CapacitorConfig } from '@capacitor/cli';
const config: CapacitorConfig = {
plugins: {
CapacitorUpdater: {
appReadyTimeout: 1000 // (1 Sekunde),
responseTimeout: 10 // (10 Sekunden),
autoDeleteFailed: false,
autoDeletePrevious: false,
autoUpdate: false,
resetWhenUpdate: false,
updateUrl: https://examplecom/api/auto_update,
channelUrl: https://examplecom/api/channel,
statsUrl: https://examplecom/api/stats,
privateKey: undefined,
publicKey: undefined,
version: undefined,
directUpdate: undefined,
periodCheckDelay: undefined,
localS3: undefined,
localHost: undefined,
localWebHost: undefined,
localSupa: undefined,
localSupaAnon: undefined,
localApi: undefined,
localApiFiles: undefined,
allowModifyUrl: undefined,
defaultChannel: undefined,
appId: undefined,
keepUrlPathAfterReload: undefined,
},
},
};
export default config;
```
* [`notifyAppReady()`](#notifyappready)
* [`setUpdateUrl()`](#setupdateurl)
* [`setStatsUrl()`](#setstatsurl)
* [`setChannelUrl()`](#setchannelurl)
* [`download()`](#download)
* [`next()`](#next)
* [`set()`](#set)
* [`delete()`](#delete)
* [`list()`](#list)
* [`reset()`](#reset)
* [`current()`](#current)
* [`reload()`](#reload)
* [`setMultiDelay()`](#setmultidelay)
* [`cancelDelay()`](#canceldelay)
* [`getLatest()`](#getlatest)
* [`setChannel()`](#setchannel)
* [`unsetChannel()`](#unsetchannel)
* [`getChannel()`](#getchannel)
* [`setCustomId()`](#setcustomid)
* [`getBuiltinVersion()`](#getbuiltinversion)
* [`getDeviceId()`](#getdeviceid)
* [`getPluginVersion()`](#getpluginversion)
* [`isAutoUpdateEnabled()`](#isautoupdateenabled)
* [`removeAllListeners()`](#removealllisteners)
* [`addListener('download', )`](#addlistenerdownload-)
* [`addListener('noNeedUpdate', )`](#addlistenernoneedupdate-)
* [`addListener('updateAvailable', )`](#addlistenerupdateavailable-)
* [`addListener('downloadComplete', )`](#addlistenerdownloadcomplete-)
* [`addListener('majorAvailable', )`](#addlistenermajoravailable-)
* [`addListener('updateFailed', )`](#addlistenerupdatefailed-)
* [`addListener('downloadFailed', )`](#addlistenerdownloadfailed-)
* [`addListener('appReloaded', )`](#addlistenerappreloaded-)
* [`addListener('appReady', )`](#addlistenerappready-)
* [`isAutoUpdateAvailable()`](#isautoupdateavailable)
* [`getNextBundle()`](#getnextbundle)
* [Schnittstellen](#interfaces)
* [Typalias](#type-aliases)
# Methoden
[Section titled “Methoden”](#methoden)
## notifyAppReady()
[Section titled “notifyAppReady()”](#notifyappready)
```typescript
notifyAppReady() => Promise
```
Benachrichtigt Capacitor Updater, dass das aktuelle Bundle funktioniert (ein Rollback erfolgt, wenn diese Methode nicht bei jedem App-Start aufgerufen wird) Standardmäßig sollte diese Methode innerhalb der ersten 10 Sekunden nach dem App-Start aufgerufen werden, andernfalls erfolgt ein Rollback Dieses Verhalten kann mit {@link appReadyTimeout} geändert werden
**Returns:** `Promise`
***
## setUpdateUrl()
[Section titled “setUpdateUrl()”](#setupdateurl)
```typescript
setUpdateUrl(options: UpdateUrl) => Promise
```
Legt die updateUrl für die App fest, diese wird zum Prüfen auf Updates verwendet
| Param | Type | Description |
| ------------- | ----------- | ------------------------------------------------------ |
| **`options`** | `UpdateUrl` | enthält die URL, die für Update-Prüfungen genutzt wird |
**Seit:** 540
***
## setStatsUrl()
[Section titled “setStatsUrl()”](#setstatsurl)
```typescript
setStatsUrl(options: StatsUrl) => Promise
```
Legt die statsUrl für die App fest, diese wird zum Senden von Statistiken verwendet. Wenn ein leerer String übergeben wird, wird die Erfassung von Statistiken deaktiviert
| Param | Type | Description |
| ------------- | ---------- | ------------------------------------------------------------------ |
| **`options`** | `StatsUrl` | enthält die URL, die für das Senden von Statistiken verwendet wird |
**Seit:** 540
***
## setChannelUrl()
[Section titled “setChannelUrl()”](#setchannelurl)
```typescript
setChannelUrl(options: ChannelUrl) => Promise
```
Legt die channelUrl für die App fest, diese wird zum Setzen des Kanals verwendet
| Param | Type | Description |
| ------------- | ------------ | ------------------------------------------------------------- |
| **`options`** | `ChannelUrl` | enthält die URL, die für das Setzen des Kanals verwendet wird |
**Seit:** 540
***
## download()
[Section titled “download()”](#download)
```typescript
download(options: DownloadOptions) => Promise
```
Lädt ein neues Bundle von der angegebenen URL herunter, es sollte eine ZIP-Datei sein, mit Dateien innerhalb oder mit einer eindeutigen ID innerhalb mit all Ihren Dateien
| Param | Type | Description |
| ------------- | ----------------- | --------------------------------------------------------------------------------------------- |
| **`options`** | `DownloadOptions` | Die {@link [DownloadOptions](#downloadoptions)} für das Herunterladen eines neuen Bundle-ZIPs |
**Returns:** `Promise`
***
## next()
[Section titled “next()”](#next)
```typescript
next(options: BundleId) => Promise
```
Legt das nächste Bundle fest, das verwendet werden soll, wenn die App neu geladen wird| Param | Type | Beschreibung | | ------------- | --------------------------------------------- | ---------------------------------------------------------------------------------------------- | | **`options`** | `BundleId` | Enthält die ID des nächsten Bundles, das beim nächsten App-Start gesetzt wird {@link [BundleInfoid](#bundleinfo)} |
**Returns:** `Promise`
***
## set()
[Section titled “set()”](#set)
```typescript
set(options: BundleId) => Promise
```
Setzt das aktuelle Bundle und lädt die App sofort neu
| Param | Type | Beschreibung |
| ------------- | ---------- | ------------------------------------------------------------------------ |
| **`options`** | `BundleId` | Ein {@link [BundleId](#bundleid)} Objekt, das die neue Bundle-ID enthält |
***
## delete()
[Section titled “delete()”](#delete)
```typescript
delete(options: BundleId) => Promise
```
Löscht das angegebene Bundle aus dem nativen App-Speicher. Verwenden Sie {@link list} um die gespeicherten Bundle-IDs zu erhalten
| Param | Type | Beschreibung |
| ------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| **`options`** | `BundleId` | Ein {@link [BundleId](#bundleid)} Objekt, das die ID des zu löschenden Bundles enthält (Hinweis: dies ist die Bundle-ID, NICHT der Versionsname) |
***
## list()
[Section titled “list()”](#list)
```typescript
list(options?: ListOptions | undefined) => Promise
```
Alle lokal heruntergeladenen Bundles in Ihrer App abrufen
| Param | Type | Beschreibung |
| ------------- | ------------- | --------------------------------------------------------------------- |
| **`options`** | `ListOptions` | Die {@link [ListOptions](#listoptions)} für das Auflisten von Bundles |
**Returns:** `Promise`
***
## reset()
[Section titled “reset()”](#reset)
```typescript
reset(options?: ResetOptions | undefined) => Promise
```
Setzt die App auf das ‘builtin’ Bundle (das an den Apple App Store / Google Play Store gesendet wurde) oder das zuletzt erfolgreich geladene Bundle zurück
| Param | Type | Beschreibung |
| ------------- | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **`options`** | `ResetOptions` | Enthält {@link [ResetOptionstoLastSuccessful](#resetoptions)}, `true` setzt auf das builtin Bundle zurück und `false` setzt auf das zuletzt erfolgreich geladene Bundle zurück |
***
## current()
[Section titled “current()”](#current)
```typescript
current() => Promise
```
Ruft das aktuelle Bundle ab, wenn keines gesetzt ist, wird ‘builtin’ zurückgegeben. currentNative ist das ursprünglich auf dem Gerät installierte Bundle
**Returns:** `Promise`
***
## reload()
[Section titled “reload()”](#reload)
```typescript
reload() => Promise
```
Die Ansicht neu laden
***
## setMultiDelay()
[Section titled “setMultiDelay()”](#setmultidelay)
```typescript
setMultiDelay(options: MultiDelayConditions) => Promise
```
Setzt ein {@link [DelayCondition](#delaycondition)} Array mit Bedingungen, die das Plugin verwendet, um das Update zu verzögern Nachdem alle Bedingungen erfüllt sind, wird der Update-Prozess wie gewohnt neu gestartet, sodass das Update nach dem Hintergrundsetzen oder Beenden der App installiert wird Für die Art ‘date’ sollte der Wert ein iso8601-Datums-String sein Für die Art ‘background’ sollte der Wert eine Zahl in Millisekunden sein Für die Art ‘nativeVersion’ sollte der Wert die Versionsnummer sein Für die Art ‘kill’ wird der Wert nicht verwendet Die Funktion hat inkonsistentes Verhalten: Die Option kill löst das Update nach dem ersten Beenden aus und nicht nach dem nächsten Hintergrundsetzen wie andere Optionen. Dies wird in einem zukünftigen Major Release behoben
| Param | Type | Beschreibung |
| ------------- | ---------------------- | --------------------------------------------------------------------------------------- |
| **`options`** | `MultiDelayConditions` | Enthält das {@link [MultiDelayConditions](#multidelayconditions)} Array von Bedingungen |
**Seit:** 430
***
## cancelDelay()
[Section titled “cancelDelay()”](#canceldelay)
```typescript
cancelDelay() => Promise
```
Bricht eine {@link [DelayCondition](#delaycondition)} ab, um ein Update sofort zu verarbeiten
**Seit:** 400
***
## getLatest()
[Section titled “getLatest()”](#getlatest)
```typescript
getLatest(options?: GetLatestOptions | undefined) => Promise
```
Neuestes verfügbares Bundle von der Update-URL abrufen
| Param | Type |
| ------------- | ------------------ |
| **`options`** | `GetLatestOptions` |
**Returns:** `Promise`
**Seit:** 400
***
## setChannel()
[Section titled “setChannel()”](#setchannel)
```typescript
setChannel(options: SetChannelOptions) => Promise
```
Setzt den Kanal für dieses Gerät. Der Kanal muss Selbstzuweisung erlauben, damit dies funktioniert Verwenden Sie diese Methode nicht, um den Kanal beim Start zu setzen, wenn `autoUpdate` in der {@link PluginsConfig} aktiviert ist Diese Methode dient dazu, den Kanal zu setzen, nachdem die App bereit ist Diese Methode sendet eine Anfrage an den Capgo-Backend, um die Geräte-ID mit dem Kanal zu verknüpfen. Capgo kann dies je nach den Einstellungen Ihres Kanals akzeptieren oder ablehnen
| Param | Type | Beschreibung |
| ------------- | ------------------- | ----------------------------------------------------------------------- |
| **`options`** | `SetChannelOptions` | Ist die {@link [SetChannelOptions](#setchanneloptions)} Kanal zu setzen |
**Returns:** `Promise`
**Seit:** 470
***
## unsetChannel()
[Section titled “unsetChannel()”](#unsetchannel)
```typescript
unsetChannel(options: UnsetChannelOptions) => Promise
```
Hebt die Einstellung des Kanals für dieses Gerät aufDas Gerät kehrt dann zum Standardkanal zurück
| Param | Type |
| ------------- | --------------------- |
| **`options`** | `UnsetChannelOptions` |
**Seit:** 470
***
## getChannel()
[Section titled “getChannel()”](#getchannel)
```typescript
getChannel() => Promise
```
Rufe den Kanal für dieses Gerät ab
**Returns:** `Promise`
**Seit:** 480
***
## setCustomId()
[Section titled “setCustomId()”](#setcustomid)
```typescript
setCustomId(options: SetCustomIdOptions) => Promise
```
Lege eine benutzerdefinierte ID für dieses Gerät fest
| Param | Type | Description |
| ------------- | -------------------- | ----------------------------------------------------------------------------- |
| **`options`** | `SetCustomIdOptions` | ist die {@link [SetCustomIdOptions](#setcustomidoptions)} customId zum Setzen |
**Seit:** 490
***
## getBuiltinVersion()
[Section titled “getBuiltinVersion()”](#getbuiltinversion)
```typescript
getBuiltinVersion() => Promise
```
Rufe die native App-Version oder die in der Konfiguration festgelegte Builtin-Version ab
**Returns:** `Promise`
**Seit:** 520
***
## getDeviceId()
[Section titled “getDeviceId()”](#getdeviceid)
```typescript
getDeviceId() => Promise
```
Rufe eindeutige ID ab, die zur Identifizierung des Geräts verwendet wird (wird an den Auto-Update-Server gesendet)
**Returns:** `Promise`
***
## getPluginVersion()
[Section titled “getPluginVersion()”](#getpluginversion)
```typescript
getPluginVersion() => Promise
```
Rufe die native Capacitor Updater Plugin-Version ab (wird an den Auto-Update-Server gesendet)
**Returns:** `Promise`
***
## isAutoUpdateEnabled()
[Section titled “isAutoUpdateEnabled()”](#isautoupdateenabled)
```typescript
isAutoUpdateEnabled() => Promise
```
Rufe den Status der Auto-Update-Konfiguration ab
**Returns:** `Promise`
***
## removeAllListeners()
[Section titled “removeAllListeners()”](#removealllisteners)
```typescript
removeAllListeners() => Promise
```
Entferne alle Listener für dieses Plugin
**Seit:** 100
***
## addListener(‘download’, )
[Section titled “addListener(‘download’, )”](#addlistenerdownload)
```typescript
addListener(eventName: 'download', listenerFunc: (state: DownloadEvent) => void) => Promise
```
Höre auf Bundle-Download-Events in der App. Wird ausgelöst, wenn ein Download startet, während des Downloads und wenn er abgeschlossen ist
| Param | Type |
| ------------------ | -------------------------------- |
| **`eventName`** | `’download’` |
| **`listenerFunc`** | `(state: DownloadEvent) => void` |
**Returns:** `Promise`
**Seit:** 2011
***
## addListener(‘noNeedUpdate’, )
[Section titled “addListener(‘noNeedUpdate’, )”](#addlistenernoneedupdate)
```typescript
addListener(eventName: 'noNeedUpdate', listenerFunc: (state: NoNeedEvent) => void) => Promise
```
Höre auf Events, wenn kein Update benötigt wird. Nützlich, wenn bei jedem App-Start eine Überprüfung erzwungen werden soll
| Param | Type |
| ------------------ | ------------------------------ |
| **`eventName`** | `’noNeedUpdate’` |
| **`listenerFunc`** | `(state: NoNeedEvent) => void` |
**Returns:** `Promise`
**Seit:** 400
***
## addListener(‘updateAvailable’, )
[Section titled “addListener(‘updateAvailable’, )”](#addlistenerupdateavailable)
```typescript
addListener(eventName: 'updateAvailable', listenerFunc: (state: UpdateAvailableEvent) => void) => Promise
```
Höre auf verfügbare Update-Events. Nützlich, wenn bei jedem App-Start eine Überprüfung erzwungen werden soll
| Param | Type |
| ------------------ | --------------------------------------- |
| **`eventName`** | `’updateAvailable’` |
| **`listenerFunc`** | `(state: UpdateAvailableEvent) => void` |
**Returns:** `Promise`
**Seit:** 400
***
## addListener(‘downloadComplete’, )
[Section titled “addListener(‘downloadComplete’, )”](#addlistenerdownloadcomplete)
```typescript
addListener(eventName: 'downloadComplete', listenerFunc: (state: DownloadCompleteEvent) => void) => Promise
```
Höre auf downloadComplete Events
| Param | Type |
| ------------------ | ---------------------------------------- |
| **`eventName`** | `’downloadComplete’` |
| **`listenerFunc`** | `(state: DownloadCompleteEvent) => void` |
**Returns:** `Promise`
**Seit:** 400
***
## addListener(‘majorAvailable’, )
[Section titled “addListener(‘majorAvailable’, )”](#addlistenermajoravailable)
```typescript
addListener(eventName: 'majorAvailable', listenerFunc: (state: MajorAvailableEvent) => void) => Promise
```
Höre auf Major-Update-Events in der App. Informiert dich, wenn ein Major-Update durch die Einstellung disableAutoUpdateBreaking blockiert wird
| Param | Type |
| ------------------ | -------------------------------------- |
| **`eventName`** | `’majorAvailable’` |
| **`listenerFunc`** | `(state: MajorAvailableEvent) => void` |
**Returns:** `Promise`
**Seit:** 230
***
## addListener(‘updateFailed’, )
[Section titled “addListener(‘updateFailed’, )”](#addlistenerupdatefailed)
```typescript
addListener(eventName: 'updateFailed', listenerFunc: (state: UpdateFailedEvent) => void) => Promise
```
Höre auf Update-Fehlschlag-Events in der App. Informiert dich, wenn ein Update beim nächsten App-Start nicht installiert werden konnte
| Param | Type |
| ------------------ | ------------------------------------ |
| **`eventName`** | `’updateFailed’` |
| **`listenerFunc`** | `(state: UpdateFailedEvent) => void` |
**Returns:** `Promise`
**Seit:** 230
***
## addListener(‘downloadFailed’,
[Section titled “addListener(‘downloadFailed’,”](#addlistenerdownloadfailed)
```typescript
addListener(eventName: 'downloadFailed', listenerFunc: (state: DownloadFailedEvent) => void) => Promise
```
Lauschen Sie auf das Download-Fehlerereignis in der App, das Sie darüber informiert, wenn ein Bundle-Download fehlgeschlagen ist
| Param | Typ |
| ------------------ | -------------------------------------- |
| **`eventName`** | `’downloadFailed’` |
| **`listenerFunc`** | `(state: DownloadFailedEvent) => void` |
**Gibt zurück:** `Promise`
**Seit:** 400
***
## addListener(‘appReloaded’, )
[Section titled “addListener(‘appReloaded’, )”](#addlistenerappreloaded)
```typescript
addListener(eventName: 'appReloaded', listenerFunc: () => void) => Promise
```
Lauschen Sie auf das Neuladen-Ereignis in der App, das Sie darüber informiert, wenn ein Neuladen stattgefunden hat
| Param | Typ |
| ------------------ | --------------- |
| **`eventName`** | `’appReloaded’` |
| **`listenerFunc`** | `() => void` |
**Gibt zurück:** `Promise`
**Seit:** 430
***
## addListener(‘appReady’, )
[Section titled “addListener(‘appReady’, )”](#addlistenerappready)
```typescript
addListener(eventName: 'appReady', listenerFunc: (state: AppReadyEvent) => void) => Promise
```
Lauschen Sie auf das App-Bereit-Ereignis in der App, das Sie darüber informiert, wenn die App einsatzbereit ist
| Param | Typ |
| ------------------ | -------------------------------- |
| **`eventName`** | `’appReady’` |
| **`listenerFunc`** | `(state: AppReadyEvent) => void` |
**Gibt zurück:** `Promise`
**Seit:** 510
***
## isAutoUpdateAvailable()
[Section titled “isAutoUpdateAvailable()”](#isautoupdateavailable)
```typescript
isAutoUpdateAvailable() => Promise
```
Prüfen Sie, ob automatische Aktualisierung verfügbar ist (nicht durch serverUrl deaktiviert)
**Gibt zurück:** `Promise`
***
## getNextBundle()
[Section titled “getNextBundle()”](#getnextbundle)
```typescript
getNextBundle() => Promise
```
Ruft das nächste Bundle ab, das beim Neuladen der App verwendet wird Gibt null zurück, wenn kein nächstes Bundle festgelegt ist
**Gibt zurück:** `Promise`
**Seit:** 680
***
## Interfaces
[Section titled “Interfaces”](#interfaces)
### AppReadyResult
[Section titled “AppReadyResult”](#appreadyresult)
| Eigenschaft | Typ |
| ------------ | ------------ |
| **`bundle`** | `BundleInfo` |
### BundleInfo
[Section titled “BundleInfo”](#bundleinfo)
| Eigenschaft | Typ |
| ---------------- | -------------- |
| **`id`** | `string` |
| **`version`** | `string` |
| **`downloaded`** | `string` |
| **`checksum`** | `string` |
| **`status`** | `BundleStatus` |
### UpdateUrl
[Section titled “UpdateUrl”](#updateurl)
| Eigenschaft | Typ |
| ----------- | -------- |
| **`url`** | `string` |
### StatsUrl
[Section titled “StatsUrl”](#statsurl)
| Eigenschaft | Typ |
| ----------- | -------- |
| **`url`** | `string` |
### ChannelUrl
[Section titled “ChannelUrl”](#channelurl)
| Eigenschaft | Typ |
| ----------- | -------- |
| **`url`** | `string` |
### DownloadOptions
[Section titled “DownloadOptions”](#downloadoptions)
| Eigenschaft | Typ | Beschreibung | Standard | Seit |
| ---------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- | ---- |
| **`url`** | `string` | Die URL der Bundle-ZIP-Datei (z.B. distzip), die heruntergeladen werden soll (Dies kann eine beliebige URL sein, z.B. Amazon S3, ein GitHub-Tag oder ein anderer Ort, an dem Sie Ihr Bundle gehostet haben) | | |
| **`version`** | `string` | Der Versions-Code/Name dieses Bundles/dieser Version | | |
| **`sessionKey`** | `string` | Der Sitzungsschlüssel für das Update | `undefined` | 400 |
| **`checksum`** | `string` | Die Prüfsumme für das Update | `undefined` | 400 |
### BundleId
[Section titled “BundleId”](#bundleid)
| Eigenschaft | Typ |
| ----------- | -------- |
| **`id`** | `string` |
### BundleListResult
[Section titled “BundleListResult”](#bundlelistresult)
| Eigenschaft | Typ |
| ------------- | -------------- |
| **`bundles`** | `BundleInfo[]` |
### ListOptions
[Section titled “ListOptions”](#listoptions)
| Eigenschaft | Typ | Beschreibung | Standard | Seit |
| ----------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- | ---- |
| **`raw`** | `boolean` | Ob die rohe Bundle-Liste oder das Manifest zurückgegeben werden soll. Wenn true, wird versucht, die interne Datenbank anstelle von Dateien auf der Festplatte zu lesen | `false` | 6140 |
### ResetOptions
[Section titled “ResetOptions”](#resetoptions)
| Eigenschaft | Typ |
| ---------------------- | --------- |
| **`toLastSuccessful`** | `boolean` |
### CurrentBundleResult
[Section titled “CurrentBundleResult”](#currentbundleresult)
| Eigenschaft | Typ |
| ------------ | ------------ |
| **`bundle`** | `BundleInfo` |
| **`native`** | `string` |
### MultiDelayConditions
[Section titled “MultiDelayConditions”](#multidelayconditions)
| Eigenschaft | Typ |
| --------------------- | ------------------ |
| **`delayConditions`** | `DelayCondition[]` |
### DelayCondition
[Section titled “DelayCondition”](#delaycondition)
| Eigenschaft | Typ | Beschreibung |
| ----------- | ---------------- | --------------------------------------------------- |
| **`kind`** | `DelayUntilNext` | Verzögerungsbedingungen in setMultiDelay einrichten |
| **`value`** | `string` | |
### LatestVersion
[Section titled “LatestVersion”](#latestversion)
| Eigenschaft | Typ | Beschreibung | Seit |
| ---------------- | ----------------- | ------------------------------ | ---- |
| **`version`** | `string` | Ergebnis der getLatest-Methode | 400 |
| **`checksum`** | `string` | | 6 |
| **`major`** | `boolean` | | |
| **`message`** | `string` | | |
| **`sessionKey`** | `string` | | |
| **`error`** | `string` | | |
| **`old`** | `string` | | |
| **`url`** | `string` | | |
| **`manifest`** | `ManifestEntry[]` | | 61 |
### ManifestEntry
[Section titled “ManifestEntry”](#manifestentry)
| Eigenschaft | Typ |
| ------------------ | ---------------- |
| **`file_name`** | `string \| null` |
| **`file_hash`** | `string \| null` |
| **`download_url`** | `string \| null` |
### GetLatestOptions
[Section titled “GetLatestOptions”](#getlatestoptions)
| Eigenschaft | Typ | Beschreibung | Standard | Seit |
| ------------- | -------- | --------------------------------------------------------------------------------------------------------------------------- | ----------- | ---- |
| **`channel`** | `string` | Der Kanal, für den die neueste Version abgerufen werden soll. Der Kanal muss ‘self\_assign’ für die Funktionalität erlauben | `undefined` | 680 |
### ChannelRes
[Section titled “ChannelRes”](#channelres)
| Eigenschaft | Typ | Beschreibung | Seit |
| ------------- | -------- | --------------------------- | ---- |
| **`status`** | `string` | Aktueller Status des Kanals | 470 |
| **`error`** | `string` | | |
| **`message`** | `string` | | |
### SetChannelOptions
[Section titled “SetChannelOptions”](#setchanneloptions)
| Eigenschaft | Typ |
| ----------------------- | --------- |
| **`channel`** | `string` |
| **`triggerAutoUpdate`** | `boolean` |
### UnsetChannelOptions
[Section titled “UnsetChannelOptions”](#unsetchanneloptions)
| Eigenschaft | Typ |
| ----------------------- | --------- |
| **`triggerAutoUpdate`** | `boolean` |
### GetChannelRes
[Section titled “GetChannelRes”](#getchannelres)
| Eigenschaft | Typ | Beschreibung | Seit |
| -------------- | --------- | --------------------------- | ---- |
| **`channel`** | `string` | Aktueller Status des Kanals | 480 |
| **`error`** | `string` | | |
| **`message`** | `string` | | |
| **`status`** | `string` | | |
| **`allowSet`** | `boolean` | | |
### SetCustomIdOptions
[Section titled “SetCustomIdOptions”](#setcustomidoptions)
| Eigenschaft | Typ |
| -------------- | -------- |
| **`customId`** | `string` |
### BuiltinVersion
[Section titled “BuiltinVersion”](#builtinversion)
| Eigenschaft | Typ |
| ------------- | -------- |
| **`version`** | `string` |
### DeviceId
[Section titled “DeviceId”](#deviceid)
| Eigenschaft | Typ |
| -------------- | -------- |
| **`deviceId`** | `string` |
### PluginVersion
[Section titled “PluginVersion”](#pluginversion)
| Eigenschaft | Typ |
| ------------- | -------- |
| **`version`** | `string` |
### AutoUpdateEnabled
[Section titled “AutoUpdateEnabled”](#autoupdateenabled)
| Eigenschaft | Typ |
| ------------- | --------- |
| **`enabled`** | `boolean` |
### PluginListenerHandle
[Section titled “PluginListenerHandle”](#pluginlistenerhandle)
| Eigenschaft | Typ |
| ------------ | --------------------- |
| **`remove`** | `() => Promise` |
### DownloadEvent
[Section titled “DownloadEvent”](#downloadevent)
| Eigenschaft | Typ | Beschreibung | Seit |
| ------------- | ------------ | --------------------------------------------- | ---- |
| **`percent`** | `number` | Aktueller Download-Status, zwischen 0 und 100 | 400 |
| **`bundle`** | `BundleInfo` | | |
### NoNeedEvent
[Section titled “NoNeedEvent”](#noneedevent)
| Eigenschaft | Typ | Beschreibung | Seit |
| ------------ | ------------ | --------------------------------------------- | ---- |
| **`bundle`** | `BundleInfo` | Aktueller Download-Status, zwischen 0 und 100 | 400 |
### UpdateAvailableEvent
[Section titled “UpdateAvailableEvent”](#updateavailableevent)
| Eigenschaft | Typ | Beschreibung | Seit |
| ------------ | ------------ | --------------------------------------------- | ---- |
| **`bundle`** | `BundleInfo` | Aktueller Download-Status, zwischen 0 und 100 | 400 |
### DownloadCompleteEvent
[Section titled “DownloadCompleteEvent”](#downloadcompleteevent)
| Eigenschaft | Typ | Beschreibung | Seit |
| ------------ | ------------ | --------------------------------------------- | ---- |
| **`bundle`** | `BundleInfo` | Wird ausgelöst, wenn ein Update verfügbar ist | 400 |
### MajorAvailableEvent
[Section titled “MajorAvailableEvent”](#majoravailableevent)
| Eigenschaft | Typ | Beschreibung | Seit |
| ------------- | -------- | --------------------------------------------------- | ---- |
| **`version`** | `string` | Wird ausgelöst, wenn ein Major-Update verfügbar ist | 400 |
### UpdateFailedEvent
[Section titled “UpdateFailedEvent”](#updatefailedevent)
| Eigenschaft | Typ | Beschreibung | Seit |
| ------------ | ------------ | -------------------------------------------------- | ---- |
| **`bundle`** | `BundleInfo` | Wird ausgelöst, wenn ein Update fehlgeschlagen ist | 400 |
### DownloadFailedEvent
[Section titled “DownloadFailedEvent”](#downloadfailedevent)
| Eigenschaft | Typ | Beschreibung | Seit |
| ------------- | -------- | --------------------------------------------- | ---- |
| **`version`** | `string` | Wird ausgelöst, wenn ein Download fehlschlägt | 400 |
### AppReadyEvent
[Section titled “AppReadyEvent”](#appreadyevent)
| Eigenschaft | Typ | Beschreibung | Seit |
| ------------ | ------------ | --------------------------------------- | ---- |
| **`bundle`** | `BundleInfo` | Wird ausgelöst, wenn die App bereit ist | 520 |
| **`status`** | `string` | | |
### AutoUpdateAvailable
[Section titled “AutoUpdateAvailable”](#autoupdateavailable)
| Eigenschaft | Typ |
| --------------- | --------- |
| **`available`** | `boolean` |
## Type Aliases
[Section titled “Type Aliases”](#type-aliases)
### BundleStatus
[Section titled “BundleStatus”](#bundlestatus)
`‘success’ | ‘error’ | ‘pending’ | ‘downloading’`
### DelayUntilNext
[Section titled “DelayUntilNext”](#delayuntilnext)
`‘background’ | ‘kill’ | ‘nativeVersion’ | ‘date’`
# Capacitor Plugins von Capgo
> Entdecken Sie unsere umfassende Sammlung von Capacitor-Plugins, um die nativen Funktionen Ihrer App mit leistungsstarken Features zu erweitern.
Willkommen bei der Capgo Capacitor Plugins-Sammlung! Wir pflegen eine Suite hochwertiger, gut dokumentierter Plugins, um Ihnen zu helfen, erstaunliche native Erlebnisse in Ihren Capacitor-Apps zu erstellen.
## Capgo Cloud - Live-Updates
[Section titled “Capgo Cloud - Live-Updates”](#capgo-cloud---live-updates)
[Capacitor Updater ](/docs/plugins/updater/)Das Kern-Plugin, das Capgo Cloud antreibt - liefern Sie sofortige Updates an Ihre Capacitor-Apps ohne Verzögerungen im App Store. Pushen Sie Fixes und Features direkt an Ihre Benutzer.
Das Updater-Plugin ist die Grundlage von Capgo Cloud und ermöglicht Ihnen:
* Aktualisierungen sofort ohne App Store Reviews bereitstellen
* JavaScript, HTML, CSS und Assets Ihrer App aktualisieren
* Spezifische Benutzersegmente mit Kanälen ansprechen
* Update-Erfolg mit integrierten Analysen überwachen
* Updates mit Verschlüsselung und Code-Signierung sichern
## Ausgewählte Plugins
[Section titled “Ausgewählte Plugins”](#ausgewählte-plugins)
[Social Login ](/docs/plugins/social-login/)Nahtlose Authentifizierung mit Google, Apple und Facebook. Ein Plugin für alle großen Social-Anbieter.
[Native Purchases ](/docs/plugins/capacitor-native-purchases/)Implementieren Sie In-App-Käufe und Abonnements mit einer einheitlichen API für iOS und Android.
[Camera Preview ](/docs/plugins/capacitor-camera-preview/)Zeigen Sie Echtzeit-Kamera-Feed in Ihrer App mit voller Kontrolle über Aufnahme und Einstellungen an.
[Data Storage SQLite ](/docs/plugins/data-storage-sqlite/)Schneller und sicherer Key-Value-Speicher, angetrieben von SQLite mit optionaler Verschlüsselung.
## Geräte- und System-Plugins
[Section titled “Geräte- und System-Plugins”](#geräte--und-system-plugins)
[Native Market ](/docs/plugins/capacitor-native-market/)Verlinken Sie zu App Stores für Bewertungen, Reviews und App-Updates.
[Native Biometric ](/docs/plugins/native-biometric/)Zugriff auf biometrische Authentifizierungs-APIs für sicheren App-Zugang.
[Shake ](/docs/plugins/shake/)Erkennen Sie Schüttelgesten für interaktive Features und Debug-Menüs.
[Navigation Bar ](/docs/plugins/navigation-bar/)Passen Sie die Farbe der Android-Navigationsleiste an Ihr App-Theme an.
[Home Indicator ](/docs/plugins/capacitor-home-indicator/)Steuern Sie die Sichtbarkeit des iOS-Home-Indikators für immersive Erlebnisse.
[NFC ](/docs/plugins/nfc/)Lesen und schreiben Sie NFC-Tags mit nativer Unterstützung für iOS und Android.
[Barometer ](/docs/plugins/barometer/)Greifen Sie auf das Gerätebarometer für atmosphärische Druck- und Höhenmessungen zu.
[Accelerometer ](/docs/plugins/accelerometer/)Lesen Sie das Gerätebeschleunigungsmesser für Bewegungserkennung und Orientierungsverfolgung.
## Medien- und Kamera-Plugins
[Section titled “Medien- und Kamera-Plugins”](#medien--und-kamera-plugins)
[Screen Recorder ](/docs/plugins/screen-recorder/)Nehmen Sie Ihren Gerätebildschirm für Tutorials, Demos oder Benutzerfeedback auf.
[IVS Player ](/docs/plugins/capacitor-ivs-player/)Amazon IVS-Integration für ultra-niedrige Latenz Live-Streaming.
[Native Audio ](/docs/plugins/capacitor-native-audio/)Hochleistungs-Native-Audio-Engine für Spiele und Apps.
[Mute ](/docs/plugins/mute/)Erkennen Sie, ob der Gerätestummschalter aktiviert oder deaktiviert ist.
[Video Player ](/docs/plugins/video-player/)Native Videowiedergabe mit Untertiteln, Vollbild und umfassenden Steuerelementen.
[YouTube Player ](/docs/plugins/youtube-player/)Betten Sie YouTube-Videos mit voller Player-API-Steuerung und Ereignisbehandlung ein.
[FFmpeg ](/docs/plugins/ffmpeg/)Videokodierung und -verarbeitung mit FFmpeg für Komprimierung und Konvertierung.
[Volume Buttons ](/docs/plugins/volume-buttons/)Hören Sie auf Hardware-Lautstärketasten-Drücke für benutzerdefinierte Steuerelemente.
[Audio Recorder ](/docs/plugins/audio-recorder/)Nehmen Sie Audio auf iOS, Android und Web mit einfachen Steuerelementen auf.
## Utility-Plugins
[Section titled “Utility-Plugins”](#utility-plugins)
[Uploader ](/docs/plugins/uploader/)Hintergrund-Datei-Upload mit Fortschrittsverfolgung und fortsetzbaren Uploads.
[Flash ](/docs/plugins/flash/)Steuern Sie die Geräte-Taschenlampe/Torch für Utility- und Kamera-Features.
[Native Geocoder ](/docs/plugins/nativegeocoder/)Vorwärts- und Rückwärts-Geocodierung mit nativen Plattform-APIs.
[InAppBrowser ](/docs/plugins/inappbrowser/)Öffnen Sie Webinhalte in einem anpassbaren In-App-Browser.
[Crisp ](/docs/plugins/crisp/)Integrieren Sie Crisp-Chat-Support direkt in Ihre mobile App.
[Live Reload ](/docs/plugins/live-reload/)Verbinden Sie sich mit Ihrem Dev-Server für sofortiges Hot-Reloading während der Entwicklung.
[Contacts ](/docs/plugins/contacts/)Greifen Sie auf Gerätekontakte mit Lese- und Schreibfunktionen zu und verwalten Sie sie.
## KI und erweiterte Medien
[Section titled “KI und erweiterte Medien”](#ki-und-erweiterte-medien)
[LLM ](/docs/plugins/llm/)Führen Sie Large Language Models lokal mit Apple Intelligence-Unterstützung aus.
[StreamCall ](/docs/plugins/streamcall/)Aktivieren Sie hochwertige Video-Streaming- und Anruffunktionen.
[JW Player ](/docs/plugins/jw-player/)Professioneller Videoplayer mit erweiterten Streaming-Funktionen.
[Ricoh 360 Camera ](/docs/plugins/ricoh360-camera/)Steuern und erfassen Sie von Ricoh 360-Grad-Kameras.
## Standort und Hintergrunddienste
[Section titled “Standort und Hintergrunddienste”](#standort-und-hintergrunddienste)
[Background Geolocation ](/docs/plugins/background-geolocation/)Verfolgen Sie den Gerätestandort im Hintergrund mit Batterieoptimierung.
[Alarm ](/docs/plugins/alarm/)Planen Sie native Alarme und Benachrichtigungen auch wenn die App geschlossen ist.
[iBeacon ](/docs/plugins/ibeacon/)Näherungserkennung und Beacon-Regionsüberwachung für standortbasierte Features.
## Kommunikation und Analysen
[Section titled “Kommunikation und Analysen”](#kommunikation-und-analysen)
[Twilio Voice ](/docs/plugins/twilio-voice/)Tätigen und empfangen Sie Telefonanrufe mit Twilio Voice API.
[GTM ](/docs/plugins/gtm/)Google Tag Manager-Integration für Analysen und Tracking.
[AppInsights ](/docs/plugins/appinsights/)Anwendungseinblicke und Analysen mit dem Apptopia AppInsights SDK.
[WeChat ](/docs/plugins/wechat/)WeChat SDK-Integration für Authentifizierung, Teilen, Zahlungen und Mini-Programme.
## Sicherheit und System
[Section titled “Sicherheit und System”](#sicherheit-und-system)
[Is Root ](/docs/plugins/is-root/)Erkennen Sie, ob das Gerät gerootet oder jailbroken ist, um die Sicherheit zu gewährleisten.
[Persistent Account ](/docs/plugins/persistent-account/)Behalten Sie Benutzerkonten über App-Neuinstallationen hinweg bei.
[Autofill Save Password ](/docs/plugins/autofill-save-password/)Aktivieren Sie Passwort-Autofill und Speicherfunktionalität.
## Android-spezifische Features
[Section titled “Android-spezifische Features”](#android-spezifische-features)
[Android Kiosk ](/docs/plugins/android-kiosk/)Sperren Sie Android-Geräte in den Kiosk-Modus mit Launcher-Funktionalität und Hardware-Tastensteuerung.
[Android Usage Stats ](/docs/plugins/android-usagestatsmanager/)Greifen Sie auf Android-App-Nutzungsstatistiken und Bildschirmzeitdaten zu.
[Android Inline Install ](/docs/plugins/android-inline-install/)Aktivieren Sie Inline-App-Installation auf Android-Geräten.
[Age Signals ](/docs/plugins/age-signals/)Greifen Sie auf Google Play Age Signals zu, um überwachte Konten und verifizierte Benutzer zu erkennen.
## Download und Navigation
[Section titled “Download und Navigation”](#download-und-navigation)
[Downloader ](/docs/plugins/downloader/)Hintergrund-Datei-Downloads mit Fortschrittsverfolgung.
[Launch Navigator ](/docs/plugins/launch-navigator/)Starten Sie Navigations-Apps mit Adressen und Koordinaten.
## Warum Capgo Plugins wählen?
[Section titled “Warum Capgo Plugins wählen?”](#warum-capgo-plugins-wählen)
**Gut gepflegt**: Regelmäßige Updates und Kompatibilität mit den neuesten Capacitor-Versionen
**Umfassende Dokumentation**: Detaillierte Dokumentation mit Beispielen für jedes Plugin
**Einfache Integration**: Einfache APIs, die den Bewährte Methoden von Capacitor folgen
**TypeScript-Unterstützung**: Vollständige TypeScript-Definitionen für bessere Entwicklungserfahrung
## Erste Schritte
[Section titled “Erste Schritte”](#erste-schritte)
Jedes Plugin folgt einem ähnlichen Installationsmuster:
1. **Installieren Sie das Plugin** mit Ihrem bevorzugten Paketmanager
2. **Synchronisieren Sie Ihr Projekt** mit `npx cap sync`
3. **Konfigurieren Sie plattformspezifische Einstellungen**, falls erforderlich
4. **Beginnen Sie mit der Verwendung des Plugins** in Ihrem Code
Besuchen Sie die Dokumentation jedes Plugins für detaillierte Installationsanweisungen und API-Referenzen.
## Benötigen Sie Hilfe?
[Section titled “Benötigen Sie Hilfe?”](#benötigen-sie-hilfe)
* Sehen Sie sich die individuelle Plugin-Dokumentation an
* Treten Sie unserer [Discord-Community](https://discord.capgo.app) bei
* Melden Sie Probleme im GitHub-Repository des Plugins
* Kontaktieren Sie den Support für Unternehmensanfragen
## Benötigen Sie ein individuelles Plugin?
[Section titled “Benötigen Sie ein individuelles Plugin?”](#benötigen-sie-ein-individuelles-plugin)
Können Sie die genaue Funktionalität, die Sie benötigen, nicht finden? Wir können helfen!
[Individuelle Plugin-Entwicklung ](/consulting/)Unser Team ist spezialisiert auf die Entwicklung individueller Capacitor-Plugins, die auf Ihre spezifischen Anforderungen zugeschnitten sind. Von komplexen nativen Integrationen bis hin zu einzigartigen Gerätefunktionen - wir haben alles für Sie.
Egal ob Sie benötigen:
* Ein völlig neues Plugin von Grund auf erstellt
* Modifikationen an bestehenden Plugins
* Expertenberatung zur nativen Entwicklung
* Plattformspezifische Implementierungen
[Nehmen Sie Kontakt mit unserem Team auf](/consulting/), um Ihre individuellen Plugin-Bedürfnisse zu besprechen.
## Mitwirken
[Section titled “Mitwirken”](#mitwirken)
Wir begrüßen Beiträge! Jedes Plugin ist Open Source und auf GitHub verfügbar. Fühlen Sie sich frei:
* Fehler zu melden und Features anzufordern
* Pull Requests einzureichen
* Dokumentation zu verbessern
* Ihre Anwendungsfälle zu teilen
***
**Entwickelt mit Herz vom Capgo-Team**
# @capgo/capacitor-accelerometer
> Zugriff auf Gerätebewegung und Beschleunigungsdaten von Beschleunigungssensoren
3-Achsen-Beschleunigung
Messung von Beschleunigungskräften in X-, Y- und Z-Achsen
Bewegungserkennung
Erkennung von Geräteschütteln, Neigungen und Bewegungen
Echtzeit-Updates
Kontinuierliche Überwachung von Beschleunigungsdaten
Umfassende Dokumentation
Sehen Sie sich die [Dokumentation](/docs/plugins/accelerometer/getting-started/) an, um das Plugin in nur wenigen Minuten zu meistern.
# Erste Schritte mit Accelerometer
> Erfahren Sie, wie Sie Beschleunigungssensor-Erfassung in Ihre Capacitor-App integrieren
Dieser Leitfaden führt Sie durch die Integration des Capacitor Accelerometer Plugins in Ihre Anwendung.
## Installation
[Section titled “Installation”](#installation)
Installieren Sie das Plugin mit npm:
```bash
npm install @capgo/capacitor-accelerometer
npx cap sync
```
## Plattformkonfiguration
[Section titled “Plattformkonfiguration”](#plattformkonfiguration)
### iOS
[Section titled “iOS”](#ios)
Keine zusätzliche Konfiguration erforderlich. Der Beschleunigungssensor ist immer verfügbar.
### Android
[Section titled “Android”](#android)
Keine zusätzliche Konfiguration erforderlich. Der Beschleunigungssensor ist immer verfügbar.
### Web
[Section titled “Web”](#web)
Das Plugin verwendet die DeviceMotion API. Erfordert HTTPS in der Produktion.
## Grundlegende Verwendung
[Section titled “Grundlegende Verwendung”](#grundlegende-verwendung)
### Plugin importieren
[Section titled “Plugin importieren”](#plugin-importieren)
```typescript
import { Accelerometer } from '@capgo/capacitor-accelerometer';
```
### Überwachung starten
[Section titled “Überwachung starten”](#überwachung-starten)
```typescript
const startAccelerometer = async () => {
await Accelerometer.start({
interval: 100 // Update-Intervall in Millisekunden
});
console.log('Accelerometer started');
};
```
### Beschleunigungsereignisse abhören
[Section titled “Beschleunigungsereignisse abhören”](#beschleunigungsereignisse-abhören)
```typescript
Accelerometer.addListener('accelerationChange', (data) => {
console.log('X:', data.x);
console.log('Y:', data.y);
console.log('Z:', data.z);
console.log('Timestamp:', data.timestamp);
});
```
### Aktuelle Messung abrufen
[Section titled “Aktuelle Messung abrufen”](#aktuelle-messung-abrufen)
```typescript
const getCurrentAcceleration = async () => {
const reading = await Accelerometer.getCurrentAcceleration();
console.log('Current acceleration:', reading);
};
```
### Überwachung stoppen
[Section titled “Überwachung stoppen”](#überwachung-stoppen)
```typescript
const stopAccelerometer = async () => {
await Accelerometer.stop();
console.log('Accelerometer stopped');
};
```
## Vollständiges Beispiel
[Section titled “Vollständiges Beispiel”](#vollständiges-beispiel)
Hier ist ein vollständiges Beispiel mit Schüttel-Erkennung:
```typescript
import { Accelerometer } from '@capgo/capacitor-accelerometer';
class AccelerometerService {
private listener: any;
private lastX = 0;
private lastY = 0;
private lastZ = 0;
private shakeThreshold = 15;
async initialize() {
await Accelerometer.start({ interval: 100 });
this.listener = Accelerometer.addListener('accelerationChange', (data) => {
this.handleAcceleration(data);
});
}
handleAcceleration(data: any) {
// Delta berechnen
const deltaX = Math.abs(data.x - this.lastX);
const deltaY = Math.abs(data.y - this.lastY);
const deltaZ = Math.abs(data.z - this.lastZ);
// Auf Schütteln prüfen
if (deltaX > this.shakeThreshold ||
deltaY > this.shakeThreshold ||
deltaZ > this.shakeThreshold) {
this.onShake();
}
// Letzte Werte aktualisieren
this.lastX = data.x;
this.lastY = data.y;
this.lastZ = data.z;
// UI aktualisieren
this.updateDisplay(data);
}
onShake() {
console.log('Device shaken!');
// Schüttel-Aktion auslösen
}
updateDisplay(data: any) {
console.log(`X: ${data.x.toFixed(2)} m/s²`);
console.log(`Y: ${data.y.toFixed(2)} m/s²`);
console.log(`Z: ${data.z.toFixed(2)} m/s²`);
// Magnitude berechnen
const magnitude = Math.sqrt(
data.x * data.x +
data.y * data.y +
data.z * data.z
);
console.log(`Magnitude: ${magnitude.toFixed(2)} m/s²`);
}
async cleanup() {
if (this.listener) {
this.listener.remove();
}
await Accelerometer.stop();
}
}
// Verwendung
const accelService = new AccelerometerService();
accelService.initialize();
// Aufräumen wenn fertig
// accelService.cleanup();
```
## Messwerte verstehen
[Section titled “Messwerte verstehen”](#messwerte-verstehen)
### Beschleunigungsachsen
[Section titled “Beschleunigungsachsen”](#beschleunigungsachsen)
* **X-Achse**: Links (-) bis Rechts (+)
* **Y-Achse**: Unten (-) bis Oben (+)
* **Z-Achse**: Hinten (-) bis Vorne (+)
### Schwerkraft
[Section titled “Schwerkraft”](#schwerkraft)
* Gerät in Ruhe zeigt \~9,8 m/s² auf einer Achse (Schwerkraft)
* Bewegtes Gerät zeigt Beschleunigung zusätzlich zur Schwerkraft
### Einheiten
[Section titled “Einheiten”](#einheiten)
* Gemessen in Meter pro Quadratsekunde (m/s²)
* Schwerkraft = 9,8 m/s²
## Häufige Anwendungsfälle
[Section titled “Häufige Anwendungsfälle”](#häufige-anwendungsfälle)
### Schüttel-Erkennung
[Section titled “Schüttel-Erkennung”](#schüttel-erkennung)
```typescript
class ShakeDetector {
private lastUpdate = 0;
private lastX = 0;
private lastY = 0;
private lastZ = 0;
detectShake(x: number, y: number, z: number): boolean {
const currentTime = Date.now();
if (currentTime - this.lastUpdate > 100) {
const deltaX = Math.abs(x - this.lastX);
const deltaY = Math.abs(y - this.lastY);
const deltaZ = Math.abs(z - this.lastZ);
this.lastUpdate = currentTime;
this.lastX = x;
this.lastY = y;
this.lastZ = z;
return deltaX + deltaY + deltaZ > 15;
}
return false;
}
}
```
### Neigungs-Erkennung
[Section titled “Neigungs-Erkennung”](#neigungs-erkennung)
```typescript
class TiltDetector {
getTiltAngles(x: number, y: number, z: number) {
const roll = Math.atan2(y, z) * (180 / Math.PI);
const pitch = Math.atan2(-x, Math.sqrt(y * y + z * z)) * (180 / Math.PI);
return { roll, pitch };
}
isDeviceFlat(z: number): boolean {
return Math.abs(z - 9.8) < 1.0;
}
isDeviceUpright(y: number): boolean {
return Math.abs(y - 9.8) < 2.0;
}
}
```
### Schrittzähler
[Section titled “Schrittzähler”](#schrittzähler)
```typescript
class StepCounter {
private steps = 0;
private lastMagnitude = 0;
private threshold = 11;
processAcceleration(x: number, y: number, z: number) {
const magnitude = Math.sqrt(x * x + y * y + z * z);
if (magnitude > this.threshold &&
this.lastMagnitude < this.threshold) {
this.steps++;
console.log('Steps:', this.steps);
}
this.lastMagnitude = magnitude;
}
}
```
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
1. **Geeignete Intervalle wählen**: Balance zwischen Reaktionsfähigkeit und Akkulaufzeit
* Gaming: 16-50ms
* Fitness: 100-200ms
* Allgemein: 200-500ms
2. **Listener entfernen**: Immer aufräumen, wenn fertig
3. **Rauschen filtern**: Gleitende Durchschnitte für glattere Daten verwenden
4. **Akku beachten**: Hochfrequente Abfragen entladen den Akku
5. **Auf echten Geräten testen**: Simulatoren liefern keine genauen Daten
## Leistungstipps
[Section titled “Leistungstipps”](#leistungstipps)
### Debouncing
[Section titled “Debouncing”](#debouncing)
```typescript
class AccelerometerDebouncer {
private timeout: any;
debounce(callback: Function, delay: number) {
return (...args: any[]) => {
clearTimeout(this.timeout);
this.timeout = setTimeout(() => callback(...args), delay);
};
}
}
```
### Datenglättung
[Section titled “Datenglättung”](#datenglättung)
```typescript
class AccelerometerFilter {
private alpha = 0.8;
private filteredX = 0;
private filteredY = 0;
private filteredZ = 0;
filter(x: number, y: number, z: number) {
this.filteredX = this.alpha * x + (1 - this.alpha) * this.filteredX;
this.filteredY = this.alpha * y + (1 - this.alpha) * this.filteredY;
this.filteredZ = this.alpha * z + (1 - this.alpha) * this.filteredZ;
return {
x: this.filteredX,
y: this.filteredY,
z: this.filteredZ
};
}
}
```
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
* Erkunden Sie die [API Reference](https://github.com/Cap-go/capacitor-accelerometer#api) für vollständige Methodendokumentation
* Sehen Sie sich die [Beispiel-App](https://github.com/Cap-go/capacitor-accelerometer/tree/main/example) für erweiterte Nutzung an
* Siehe das [Tutorial](/plugins/capacitor-accelerometer) für vollständige Implementierungsbeispiele
# @capgo/capacitor-admob
> Monetarisieren Sie Ihre Capacitor-App mit Google AdMob-Bannern, Interstitials und Belohnungsanzeigen, die vollständig über JavaScript verwaltet werden.
Das AdMob-Plugin von Capgo bietet eine erstklassige Brücke zum Google Mobile Ads SDK, damit Sie native Erlebnisse monetarisieren können, ohne die Einfachheit von Capacitor zu opfern.
Flexible Anzeigenformate
Schalten Sie Banner-, Interstitial-, Belohnungs- und App-Open-Anzeigen mit einer einheitlichen API.
Anforderungskonfiguration
Optimieren Sie Anzeigenanforderungen mit Flags für kinderfreundliche Inhalte, Inhaltsbewertungen und zusätzlichen Netzwerkparametern.
Lebenszyklus-Verwaltung
Erstellen, laden, anzeigen, ausblenden und zerstören Sie Anzeigen nach Bedarf und verfolgen Sie den Ladezustand.
Datenschutzgerecht
Verarbeiten Sie ATT-Eingabeaufforderungen und überwachen Sie den Status der Tracking-Autorisierung, um konform zu bleiben.
Verwenden Sie den Leitfaden für die ersten Schritte, um Ihre AdMob App-IDs zu konfigurieren, die Einwilligung einzurichten und das Anzeigeninventar direkt aus Ihrem Capacitor-Projekt zu verwalten.
# Erste Schritte
> Installieren und konfigurieren Sie das Capgo AdMob Plugin, um Anzeigen in Ihrer Capacitor-Anwendung zu schalten.
1. **Plugin installieren**
* npm
```sh
npm i @capgo/capacitor-admob
```
* pnpm
```sh
pnpm add @capgo/capacitor-admob
```
* yarn
```sh
yarn add @capgo/capacitor-admob
```
* bun
```sh
bun add @capgo/capacitor-admob
```
2. **Native Projekte synchronisieren**
* npm
```sh
npx cap sync
```
* pnpm
```sh
pnpm cap sync
```
* yarn
```sh
yarn cap sync
```
* bun
```sh
bunx cap sync
```
## SDK initialisieren
[Section titled “SDK initialisieren”](#sdk-initialisieren)
```typescript
import { AdMob, MaxAdContentRating } from '@capgo/capacitor-admob';
// Starten Sie das Mobile Ads SDK einmal beim Anwendungsstart
await AdMob.start();
// Optional: Globale Anforderungseinstellungen konfigurieren
await AdMob.configure({
appMuted: false,
appVolume: 1,
});
await AdMob.configRequest({
maxAdContentRating: MaxAdContentRating.T,
tagForChildDirectedTreatment: false,
tagForUnderAgeOfConsent: false,
});
```
## Banner-Anzeige anzeigen
[Section titled “Banner-Anzeige anzeigen”](#banner-anzeige-anzeigen)
```typescript
import { BannerAd } from '@capgo/capacitor-admob';
const banner = new BannerAd({
adUnitId: 'ca-app-pub-xxxxxxxxxxxxxxxx/banner',
position: 'bottom',
});
await banner.show();
```
## Interstitial- oder Belohnungsanzeigen
[Section titled “Interstitial- oder Belohnungsanzeigen”](#interstitial--oder-belohnungsanzeigen)
```typescript
import { InterstitialAd, RewardedAd } from '@capgo/capacitor-admob';
const interstitial = new InterstitialAd({
adUnitId: 'ca-app-pub-xxxxxxxxxxxxxxxx/interstitial',
});
await interstitial.load();
await interstitial.show();
const rewarded = new RewardedAd({
adUnitId: 'ca-app-pub-xxxxxxxxxxxxxxxx/rewarded',
});
await rewarded.load();
await rewarded.show();
```
## Auf Anzeigenereignisse lauschen
[Section titled “Auf Anzeigenereignisse lauschen”](#auf-anzeigenereignisse-lauschen)
```typescript
import { AdMob } from '@capgo/capacitor-admob';
const handle = await AdMob.addListener('adImpression', (event) => {
console.log('Ad impression', event);
});
// Später beim Aufräumen
await handle.remove();
```
## Plattformhinweise
[Section titled “Plattformhinweise”](#plattformhinweise)
* **iOS**: Fügen Sie Ihre AdMob App-ID zu `Info.plist` unter dem Schlüssel `GADApplicationIdentifier` hinzu und fügen Sie alle SKAdNetwork-IDs hinzu, auf die Sie angewiesen sind.
* **Android**: Deklarieren Sie Ihre AdMob App-ID in `AndroidManifest.xml`, indem Sie `com.google.android.gms.ads.APPLICATION_ID` innerhalb des ``-Tags hinzufügen.
* **Einwilligung & Datenschutz**: Verwenden Sie `requestTrackingAuthorization()` auf iOS 14+ und die `configRequest()` Flags für kinderfreundliche Inhalte, um die regionalen Datenschutzbestimmungen einzuhalten.
# @capgo/capacitor-android-age-signals
> Greifen Sie auf Google Play Age Signals zu, um überwachte Konten zu erkennen, Benutzeralter zu überprüfen und Kinderschutzbestimmungen in Ihrer Android-App einzuhalten.
Überwachte Konten
Erkennen Sie, wann Benutzer überwachte Google-Konten haben, die von Erziehungsberechtigten verwaltet werden
Altersüberprüfung
Identifizieren Sie verifizierte Benutzer, die 18+ sind, mit der Altersüberprüfung von Google
Compliance
Halten Sie Kinderschutzbestimmungen wie COPPA und GDPR ein
Elterngenehmigungen
Verfolgen Sie ausstehende Genehmigungen und den Zustimmungsstatus der Erziehungsberechtigten
Nur Android
Speziell für Android mit Google Play Services entwickelt
Einfache API
Einzelner Methodenaufruf zum Abrufen aller Alterssignale
# Erste Schritte
> Erfahren Sie, wie Sie das Age Signals Plugin installieren und verwenden, um überwachte Konten und verifizierte Benutzer in Ihrer Android-App zu erkennen.
Caution
Dieses Plugin ist **nur für Android** und erfordert Google Play Services. Es funktioniert nicht auf iOS, Web oder Android-Geräten ohne Google Play Store.
1. **Paket installieren**
* npm
```sh
npm i @capgo/capacitor-android-age-signals
```
* pnpm
```sh
pnpm add @capgo/capacitor-android-age-signals
```
* yarn
```sh
yarn add @capgo/capacitor-android-age-signals
```
* bun
```sh
bun add @capgo/capacitor-android-age-signals
```
2. **Mit Android-Projekt synchronisieren**
* npm
```sh
npx cap sync android
```
* pnpm
```sh
pnpm cap sync android
```
* yarn
```sh
yarn cap sync android
```
* bun
```sh
bunx cap sync android
```
## Voraussetzungen
[Section titled “Voraussetzungen”](#voraussetzungen)
* Android-Gerät mit Google Play Services
* Mindestens Android API Level 21 (Android 5.0)
* Google Play Store auf dem Gerät installiert
## Verwendung
[Section titled “Verwendung”](#verwendung)
### Alterssignale prüfen
[Section titled “Alterssignale prüfen”](#alterssignale-prüfen)
```typescript
import { AgeSignals, UserStatus } from '@capgo/capacitor-android-age-signals';
try {
const result = await AgeSignals.checkAgeSignals();
console.log('Benutzerstatus:', result.userStatus);
switch (result.userStatus) {
case UserStatus.Verified:
console.log('Benutzer ist 18+ und von Google verifiziert');
// Zugriff auf altersbeschränkte Inhalte erlauben
break;
case UserStatus.Supervised:
console.log(`Überwachter Benutzer im Alter von ${result.ageLower}-${result.ageUpper}`);
// Altersgerechte Einschränkungen anwenden
break;
case UserStatus.SupervisedApprovalPending:
console.log('Warten auf Genehmigung des Erziehungsberechtigten');
console.log('Ausstehend seit:', result.mostRecentApprovalDate);
// Benutzer informieren, auf Genehmigung des Erziehungsberechtigten zu warten
break;
case UserStatus.SupervisedApprovalDenied:
console.log('Erziehungsberechtigter hat Zugriff verweigert');
console.log('Letzte Genehmigung:', result.mostRecentApprovalDate);
// Zugriff blockieren oder alternative Inhalte anzeigen
break;
case UserStatus.Unknown:
console.log('Benutzerstatus unbekannt - zur Verifizierung im Play Store auffordern');
// Benutzer zur Altersverifizierung in Google Play anleiten
break;
case UserStatus.Empty:
console.log('Kein Alterssignal verfügbar');
// Als nicht verifizierter Benutzer behandeln
break;
}
} catch (error) {
console.error('Fehler beim Prüfen der Alterssignale:', error);
}
```
### Überwachte Benutzer behandeln
[Section titled “Überwachte Benutzer behandeln”](#überwachte-benutzer-behandeln)
```typescript
async function handleSupervisedUser() {
const result = await AgeSignals.checkAgeSignals();
if (result.userStatus === UserStatus.Supervised) {
const age = result.ageLower;
if (age < 13) {
// COPPA-Einschränkungen anwenden
console.log('Benutzer ist unter 13 - COPPA gilt');
disableDataCollection();
disableSocialFeatures();
requireParentalConsent();
} else if (age < 18) {
// Einschränkungen für Teenager anwenden
console.log('Benutzer ist 13-17 - Einschränkungen für Teenager gelten');
enableModeratedSocialFeatures();
restrictAds();
}
// Installations-ID für Widerrufbenachrichtigungen verfolgen
console.log('Installations-ID:', result.installId);
saveInstallId(result.installId);
}
}
```
### Alterssperre implementieren
[Section titled “Alterssperre implementieren”](#alterssperre-implementieren)
```typescript
async function ageGate() {
const result = await AgeSignals.checkAgeSignals();
// Verifizierte 18+ Benutzer erlauben
if (result.userStatus === UserStatus.Verified) {
return true;
}
// Alter überwachter Benutzer prüfen
if (result.userStatus === UserStatus.Supervised) {
return result.ageUpper >= 18;
}
// Benutzer mit ausstehenden oder abgelehnten Genehmigungen blockieren
if (
result.userStatus === UserStatus.SupervisedApprovalPending ||
result.userStatus === UserStatus.SupervisedApprovalDenied
) {
return false;
}
// Für unbekannt/leer, Fallback-Altersverifizierung implementieren
return await showAgeVerificationDialog();
}
```
### Genehmigungsstatus überwachen
[Section titled “Genehmigungsstatus überwachen”](#genehmigungsstatus-überwachen)
```typescript
async function checkApprovalStatus() {
const result = await AgeSignals.checkAgeSignals();
if (result.userStatus === UserStatus.SupervisedApprovalPending) {
console.log('Genehmigung des Erziehungsberechtigten ausstehend');
console.log('Altersbereich:', result.ageLower, '-', result.ageUpper);
console.log('Letzte Genehmigung:', result.mostRecentApprovalDate);
// Nachricht an Benutzer anzeigen
showMessage(
'Ihr Erziehungsberechtigter muss diese App genehmigen. ' +
'Wir haben ihn am ' + result.mostRecentApprovalDate + ' benachrichtigt'
);
} else if (result.userStatus === UserStatus.SupervisedApprovalDenied) {
console.log('Erziehungsberechtigter hat Genehmigung verweigert');
console.log('Zuletzt genehmigt am:', result.mostRecentApprovalDate);
// Blockierte Nachricht anzeigen
showMessage(
'Ihr Erziehungsberechtigter hat diese App nicht genehmigt. ' +
'Kontaktieren Sie ihn für weitere Informationen.'
);
}
}
```
## API-Referenz
[Section titled “API-Referenz”](#api-referenz)
### checkAgeSignals()
[Section titled “checkAgeSignals()”](#checkagesignals)
Fordern Sie die aktuellen Play Age Signals für den aktiven Benutzer an.
```typescript
const result = await AgeSignals.checkAgeSignals();
```
**Rückgabe:**
```typescript
interface CheckAgeSignalsResult {
userStatus: UserStatus;
ageLower?: number;
ageUpper?: number;
mostRecentApprovalDate?: string;
installId?: string;
}
```
### UserStatus Enum
[Section titled “UserStatus Enum”](#userstatus-enum)
```typescript
enum UserStatus {
Verified = 'VERIFIED', // 18+ verifiziert
Supervised = 'SUPERVISED', // Überwachtes Konto
SupervisedApprovalPending = 'SUPERVISED_APPROVAL_PENDING',
SupervisedApprovalDenied = 'SUPERVISED_APPROVAL_DENIED',
Unknown = 'UNKNOWN', // Unbekannter Status
Empty = 'EMPTY' // Kein Signal
}
```
## Ergebnisfelder
[Section titled “Ergebnisfelder”](#ergebnisfelder)
### userStatus
[Section titled “userStatus”](#userstatus)
Der Verifizierungsstatus des Benutzers, wie von Google Play gemeldet.
* **Verified**: Benutzer ist über 18 und von Google altersverifiziert
* **Supervised**: Benutzer hat ein überwachtes Google-Konto
* **SupervisedApprovalPending**: Ausstehende Genehmigung des Erziehungsberechtigten für Änderungen
* **SupervisedApprovalDenied**: Erziehungsberechtigter hat App-Zugriff verweigert
* **Unknown**: Benutzer sollte Status im Play Store verifizieren
* **Empty**: Alle anderen Benutzer (Standardzustand)
### ageLower
[Section titled “ageLower”](#agelower)
Inklusive Untergrenze der Altersspanne des überwachten Benutzers.
Nur vorhanden, wenn `userStatus` ist:
* `SUPERVISED`
* `SUPERVISED_APPROVAL_PENDING`
* `SUPERVISED_APPROVAL_DENIED`
### ageUpper
[Section titled “ageUpper”](#ageupper)
Inklusive Obergrenze der Altersspanne des überwachten Benutzers.
Nur vorhanden, wenn:
* `userStatus` einer der überwachten Status ist
* Das Alter des Benutzers als unter 18 gemeldet wird
### mostRecentApprovalDate
[Section titled “mostRecentApprovalDate”](#mostrecentapprovaldate)
Datumsstring für die letzte bedeutende Änderung, die eine Genehmigung des Erziehungsberechtigten erhalten hat.
Nur vorhanden, wenn `userStatus` ist:
* `SUPERVISED_APPROVAL_PENDING`
* `SUPERVISED_APPROVAL_DENIED`
Format: ISO 8601 Datumsstring
### installId
[Section titled “installId”](#installid)
Kennung, die überwachten Installationen in Google Play zugewiesen wird.
Wird für Widerrufbenachrichtigungen verwendet, wenn der Erziehungsberechtigte die App-Genehmigung widerruft.
Nur vorhanden, wenn `userStatus` ist:
* `SUPERVISED`
* `SUPERVISED_APPROVAL_PENDING`
* `SUPERVISED_APPROVAL_DENIED`
## Anwendungsfälle
[Section titled “Anwendungsfälle”](#anwendungsfälle)
### 1. COPPA-Compliance
[Section titled “1. COPPA-Compliance”](#1-coppa-compliance)
```typescript
async function applyCoppaRestrictions() {
const result = await AgeSignals.checkAgeSignals();
if (result.userStatus === UserStatus.Supervised && result.ageLower < 13) {
// Datenerfassung deaktivieren
disableAnalytics();
disableAdvertising();
// Social-Funktionen deaktivieren
hideChatFeatures();
disableUserProfiles();
// Überprüfbare elterliche Zustimmung erforderlich
await requestParentalConsent(result.installId);
}
}
```
### 2. Altersgerechte Inhalte
[Section titled “2. Altersgerechte Inhalte”](#2-altersgerechte-inhalte)
```typescript
async function filterContent() {
const result = await AgeSignals.checkAgeSignals();
let contentRating;
if (result.userStatus === UserStatus.Verified) {
contentRating = 'MATURE';
} else if (result.userStatus === UserStatus.Supervised) {
if (result.ageUpper < 13) {
contentRating = 'EVERYONE';
} else if (result.ageUpper < 18) {
contentRating = 'TEEN';
} else {
contentRating = 'MATURE';
}
} else {
contentRating = 'TEEN'; // Standard-Sicherheitsbewertung
}
loadContentForRating(contentRating);
}
```
### 3. Erziehungsberechtigten-Dashboard
[Section titled “3. Erziehungsberechtigten-Dashboard”](#3-erziehungsberechtigten-dashboard)
```typescript
async function getGuardianInfo() {
const result = await AgeSignals.checkAgeSignals();
if (
result.userStatus === UserStatus.Supervised ||
result.userStatus === UserStatus.SupervisedApprovalPending ||
result.userStatus === UserStatus.SupervisedApprovalDenied
) {
return {
isSupervised: true,
ageRange: `${result.ageLower}-${result.ageUpper}`,
approvalStatus: result.userStatus,
lastApprovalDate: result.mostRecentApprovalDate,
installId: result.installId,
};
}
return { isSupervised: false };
}
```
## Vollständiges Beispiel
[Section titled “Vollständiges Beispiel”](#vollständiges-beispiel)
```typescript
import { AgeSignals, UserStatus } from '@capgo/capacitor-android-age-signals';
export class AgeVerificationService {
async verifyAge(): Promise<{
allowed: boolean;
reason: string;
restrictions: string[];
}> {
try {
const result = await AgeSignals.checkAgeSignals();
switch (result.userStatus) {
case UserStatus.Verified:
return {
allowed: true,
reason: 'Benutzer ist verifiziert 18+',
restrictions: [],
};
case UserStatus.Supervised:
return this.handleSupervised(result);
case UserStatus.SupervisedApprovalPending:
return {
allowed: false,
reason: 'Warten auf Genehmigung des Erziehungsberechtigten',
restrictions: ['Genehmigung des Erziehungsberechtigten erforderlich'],
};
case UserStatus.SupervisedApprovalDenied:
return {
allowed: false,
reason: 'Erziehungsberechtigter hat Zugriff verweigert',
restrictions: ['Zugriff vom Erziehungsberechtigten verweigert'],
};
case UserStatus.Unknown:
return {
allowed: false,
reason: 'Altersverifizierung erforderlich',
restrictions: ['Alter im Google Play verifizieren'],
};
case UserStatus.Empty:
default:
return {
allowed: false,
reason: 'Kein Alterssignal verfügbar',
restrictions: ['Altersverifizierung erforderlich'],
};
}
} catch (error) {
console.error('Altersverifizierung fehlgeschlagen:', error);
return {
allowed: false,
reason: 'Verifizierungsfehler',
restrictions: ['Später erneut versuchen'],
};
}
}
private handleSupervised(result: any) {
const age = result.ageLower;
const restrictions: string[] = [];
if (age < 13) {
restrictions.push('Keine Datenerfassung (COPPA)');
restrictions.push('Keine Social-Funktionen');
restrictions.push('Elterliche Zustimmung erforderlich');
return {
allowed: false,
reason: `Benutzer ist unter 13 (${result.ageLower}-${result.ageUpper})`,
restrictions,
};
} else if (age < 18) {
restrictions.push('Nur altersgerechte Inhalte');
restrictions.push('Moderierte Social-Funktionen');
return {
allowed: true,
reason: `Teenager-Benutzer (${result.ageLower}-${result.ageUpper})`,
restrictions,
};
} else {
return {
allowed: true,
reason: `Erwachsener überwachter Benutzer (${result.ageLower}+)`,
restrictions: [],
};
}
}
async saveInstallId(installId: string) {
// Installations-ID für Widerrufbehandlung speichern
localStorage.setItem('ageSignalsInstallId', installId);
}
async checkRevocation() {
const result = await AgeSignals.checkAgeSignals();
const storedId = localStorage.getItem('ageSignalsInstallId');
if (result.installId && storedId && result.installId !== storedId) {
// Installations-ID hat sich geändert - wahrscheinlich widerrufen und neu installiert
console.log('App wurde widerrufen und neu installiert');
return true;
}
return false;
}
}
```
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
1. **Beim App-Start prüfen**: Alterssignale beim Start der App überprüfen
2. **Ergebnisse zwischenspeichern**: Ergebnisse zwischenspeichern, aber regelmäßig aktualisieren
3. **Alle Zustände behandeln**: Logik für alle UserStatus-Werte implementieren
4. **Ablehnungen respektieren**: Keinen Zugriff erlauben, wenn Erziehungsberechtigter Genehmigung verweigert
5. **Installations-ID speichern**: Installations-ID für Widerrufserkennung verfolgen
6. **Fallback-Logik**: Fallback-Altersverifizierung für Unknown/Empty-Zustände haben
7. **Datenschutz zuerst**: Keine unnötigen Daten von überwachten Benutzern sammeln
## Compliance-Richtlinien
[Section titled “Compliance-Richtlinien”](#compliance-richtlinien)
### COPPA (Children’s Online Privacy Protection Act)
[Section titled “COPPA (Children’s Online Privacy Protection Act)”](#coppa-childrens-online-privacy-protection-act)
Für Benutzer unter 13:
* Überprüfbare elterliche Zustimmung einholen
* Datenerfassung begrenzen
* Verhaltensbasierte Werbung deaktivieren
* Elternkontrollen bereitstellen
### GDPR (General Data Protection Regulation)
[Section titled “GDPR (General Data Protection Regulation)”](#gdpr-general-data-protection-regulation)
Für überwachte Benutzer:
* Daten rechtmäßig verarbeiten
* Zustimmungsmechanismen für Erziehungsberechtigte bereitstellen
* Datenzugriff und -löschung ermöglichen
* Datenschutz durch Design implementieren
## Plattformhinweise
[Section titled “Plattformhinweise”](#plattformhinweise)
### Android
[Section titled “Android”](#android)
* Erfordert Google Play Services
* Mindestens API Level 21 (Android 5.0+)
* Funktioniert nur auf Geräten mit Play Store
* Signale sind möglicherweise nicht in allen Regionen verfügbar
* Ergebnisse können sich ändern, wenn Erziehungsberechtigter Einstellungen ändert
### iOS / Web
[Section titled “iOS / Web”](#ios--web)
* **Nicht unterstützt** - Dies ist ein Android-exklusives Plugin
* Wirft einen Fehler, wenn auf nicht unterstützten Plattformen aufgerufen
## Fehlerbehebung
[Section titled “Fehlerbehebung”](#fehlerbehebung)
### Kein Signal zurückgegeben (Empty Status)
[Section titled “Kein Signal zurückgegeben (Empty Status)”](#kein-signal-zurückgegeben-empty-status)
Dies ist normal für:
* Benutzer außerhalb unterstützter Regionen
* Geräte ohne Google Play Services
* Benutzer, die Family Link nicht eingerichtet haben
* Neue Konten ohne Verifizierung
### Unknown Status
[Section titled “Unknown Status”](#unknown-status)
Benutzer sollte:
1. Google Play Store öffnen
2. Zu Einstellungen → Familie gehen
3. Altersverifizierungsprozess abschließen
### Berechtigungsprobleme
[Section titled “Berechtigungsprobleme”](#berechtigungsprobleme)
Sicherstellen:
* Google Play Services ist aktualisiert
* App hat korrekten Paketnamen in der Play Console
* Test auf echtem Gerät (nicht Emulator ohne Play Services)
## Ressourcen
[Section titled “Ressourcen”](#ressourcen)
* [Google Play Age Signals Dokumentation](https://developers.google.com/android/reference/com/google/android/gms/agesignals)
* [Family Link Entwicklerhandbuch](https://developers.google.com/families)
* [COPPA Compliance-Leitfaden](https://www.ftc.gov/business-guidance/resources/complying-coppa-frequently-asked-questions)
# @capgo/capacitor-alarm
> Verwalten Sie native Alarme auf iOS und Android direkt aus Ihrer Capacitor-App.
Native Integration
Verwendet natives AlarmKit auf iOS und AlarmClock-Intents auf Android
Einfache API
Benutzerfreundliche Methoden zum Erstellen und Verwalten von Alarmen
Berechtigungsverwaltung
Integrierte Unterstützung für die Anforderung notwendiger Berechtigungen
Umfassende Dokumentation
Schauen Sie sich die [Dokumentation](/docs/plugins/alarm/getting-started/) an, um das Plugin in nur wenigen Minuten zu meistern.
# Erste Schritte
> Erfahren Sie, wie Sie das Capacitor Alarm Plugin installieren und verwenden, um native Alarme auf iOS und Android zu verwalten.
## Installation
[Section titled “Installation”](#installation)
* npm
```bash
npm install @capgo/capacitor-alarm
npx cap sync
```
* yarn
```bash
yarn add @capgo/capacitor-alarm
npx cap sync
```
* pnpm
```bash
pnpm add @capgo/capacitor-alarm
npx cap sync
```
* bun
```bash
bun add @capgo/capacitor-alarm
npx cap sync
```
## Anforderungen
[Section titled “Anforderungen”](#anforderungen)
* **iOS**: Nur iOS 26+. Dieses Plugin basiert auf `AlarmKit`-APIs und meldet auf früheren Versionen oder wenn das Framework nicht verfügbar ist “nicht unterstützt”.
* **Android**: Verwendet `AlarmClock`-Intents; das Verhalten hängt von der Standard-Uhr-App und den OEM-Richtlinien ab.
Hinweis: Dieses Plugin stellt nur native Alarmaktionen (erstellen/öffnen) bereit. Es implementiert keine benutzerdefinierte In-App-Alarmplanung/CRUD.
## API
[Section titled “API”](#api)
### createAlarm(…)
[Section titled “createAlarm(…)”](#createalarm)
```typescript
createAlarm(options: NativeAlarmCreateOptions) => Promise
```
Erstellen Sie einen nativen OS-Alarm mit der Plattform-Uhr-App. Auf Android verwendet dies den Alarm Clock Intent; auf iOS verwendet dies AlarmKit, falls verfügbar (iOS 26+).
| Parameter | Typ |
| ------------- | -------------------------- |
| **`options`** | `NativeAlarmCreateOptions` |
**Rückgabe:** `Promise`
### openAlarms()
[Section titled “openAlarms()”](#openalarms)
```typescript
openAlarms() => Promise
```
Öffnen Sie die native Alarmlisten-UI der Plattform, falls verfügbar.
**Rückgabe:** `Promise`
### getOSInfo()
[Section titled “getOSInfo()”](#getosinfo)
```typescript
getOSInfo() => Promise
```
Informationen über das Betriebssystem und die Funktionen abrufen.
**Rückgabe:** `Promise`
### requestPermissions(…)
[Section titled “requestPermissions(…)”](#requestpermissions)
```typescript
requestPermissions(options?: { exactAlarm?: boolean | undefined; } | undefined) => Promise
```
Relevante Berechtigungen für die Alarmnutzung auf der Plattform anfordern. Auf Android kann dies zu den Einstellungen für exakte Alarme führen.
| Parameter | Typ |
| ------------- | --------------------------- |
| **`options`** | `{ exactAlarm?: boolean; }` |
**Rückgabe:** `Promise`
## Schnittstellen
[Section titled “Schnittstellen”](#schnittstellen)
### NativeActionResult
[Section titled “NativeActionResult”](#nativeactionresult)
| Eigenschaft | Typ |
| ------------- | --------- |
| **`success`** | `boolean` |
| **`message`** | `string` |
### NativeAlarmCreateOptions
[Section titled “NativeAlarmCreateOptions”](#nativealarmcreateoptions)
Optionen zum Erstellen eines nativen OS-Alarms über die Plattform-Uhr-App.
| Eigenschaft | Typ | Beschreibung |
| ------------- | --------- | -------------------------------------------- |
| **`hour`** | `number` | Stunde des Tages im 24-Stunden-Format (0-23) |
| **`minute`** | `number` | Minute der Stunde (0-59) |
| **`label`** | `string` | Optionale Beschriftung für den Alarm |
| **`skipUi`** | `boolean` | Nur Android: UI überspringen, wenn möglich |
| **`vibrate`** | `boolean` | Nur Android: Alarm auf Vibration setzen |
### OSInfo
[Section titled “OSInfo”](#osinfo)
Zurückgegebene Informationen über das aktuelle Betriebssystem und die Funktionen.
| Eigenschaft | Typ | Beschreibung |
| ------------------------------------ | --------- | --------------------------------------------------------- |
| **`platform`** | `string` | ’ios’ \| ‘android’ \| ‘web’ |
| **`version`** | `string` | Versionsstring des Betriebssystems |
| **`supportsNativeAlarms`** | `boolean` | Ob die Plattform eine native Alarm-App-Integration bietet |
| **`supportsScheduledNotifications`** | `boolean` | Ob das Planen lokaler Benachrichtigungen unterstützt wird |
| **`canScheduleExactAlarms`** | `boolean` | Nur Android: Ob exakte Alarme erlaubt sind |
### PermissionResult
[Section titled “PermissionResult”](#permissionresult)
Ergebnis einer Berechtigungsanforderung.
| Eigenschaft | Typ | Beschreibung |
| ------------- | ------------------------- | --------------------------------------------- |
| **`granted`** | `boolean` | Gesamtgenehmigung für angeforderten Bereich |
| **`details`** | `Record` | Optionale Details nach Berechtigungsschlüssel |
# @capgo/capacitor-android-inline-install
> Ermöglichen Sie nahtlose In-App-Installation und Updates für Android-Apps mit Inline-Installationsfunktionen und benutzerfreundlichen Abläufen.
## Übersicht
[Section titled “Übersicht”](#übersicht)
Das Capacitor Android Inline Install Plugin ermöglicht das Auslösen von Googles Play Inline Install Overlay für Android-Anwendungen. Dieses Plugin bietet eine nahtlose In-App-Installationserfahrung mit Googles Premium Growth Tools, sodass Benutzer Apps installieren können, ohne Ihre Anwendung zu verlassen.
Google Play Overlay
Natives Google Play Install Overlay auslösen
Nahtlose Erfahrung
Apps installieren, ohne Ihre App zu verlassen
Fallback-Unterstützung
Automatischer Fallback zur vollständigen Play Store-Seite
Kampagnen-Tracking
Unterstützung für Referrer-Tracking und Analytics
## Dokumentation
[Section titled “Dokumentation”](#dokumentation)
Schauen Sie sich die [vollständige Dokumentation](/docs/plugins/android-inline-install/getting-started/) für detaillierte Implementierungsanleitungen und erweiterte Integrationsmuster an.
# Erste Schritte
> Installations- und Verwendungsanleitung für @capgo/capacitor-android-inline-install
## Installation
[Section titled “Installation”](#installation)
* npm
```bash
npm install @capgo/capacitor-android-inline-install
npx cap sync
```
* yarn
```bash
yarn add @capgo/capacitor-android-inline-install
npx cap sync
```
* pnpm
```bash
pnpm add @capgo/capacitor-android-inline-install
npx cap sync
```
* bun
```bash
bun add @capgo/capacitor-android-inline-install
npx cap sync
```
## Verwendungsbeispiel
[Section titled “Verwendungsbeispiel”](#verwendungsbeispiel)
```typescript
import { AndroidInlineInstall } from '@capgo/capacitor-android-inline-install';
// Einfache Inline-Installation
await AndroidInlineInstall.startInlineInstall({
id: 'com.example.targetapp'
});
// Erweiterte Installation mit Tracking
await AndroidInlineInstall.startInlineInstall({
id: 'com.example.targetapp',
referrer: 'campaign=my-campaign&source=app',
overlay: true,
fallback: true
});
// Installationsablauf behandeln
try {
await AndroidInlineInstall.startInlineInstall({
id: 'com.spotify.music',
referrer: 'utm_source=myapp&utm_campaign=music_promotion'
});
console.log('Install-Overlay erfolgreich ausgelöst');
} catch (error) {
console.error('Installation fehlgeschlagen:', error);
}
```
## Kern-API-Methoden
[Section titled “Kern-API-Methoden”](#kern-api-methoden)
### Installationsverwaltung
[Section titled “Installationsverwaltung”](#installationsverwaltung)
* `startInlineInstall(options)` - Google Play Inline Install Overlay für angegebene App auslösen
## Konfigurationsoptionen
[Section titled “Konfigurationsoptionen”](#konfigurationsoptionen)
```typescript
interface InlineInstallOptions {
id: string; // Ziel-App-Paketname (erforderlich)
referrer?: string; // Tracking-Kampagnenstring (optional)
callerId?: string; // Aufrufer-App-Paketname (Standard: aktuelle App)
overlay?: boolean; // Play-Overlay aktivieren/deaktivieren (Standard: true)
fallback?: boolean; // Vollständige Store-Seite verwenden, wenn Overlay fehlschlägt (Standard: true)
}
```
## Google Play Anforderungen
[Section titled “Google Play Anforderungen”](#google-play-anforderungen)
### Berechtigung für Premium Growth Tools
[Section titled “Berechtigung für Premium Growth Tools”](#berechtigung-für-premium-growth-tools)
Ihre App muss für Googles Premium Growth Tools qualifiziert sein, um Inline-Installation zu verwenden:
* Apps mit signifikantem Benutzerengagement
* Gute Play Store-Bewertungen und Rezensionen
* Einhaltung der Google Play-Richtlinien
### Anforderungen an die Ziel-App
[Section titled “Anforderungen an die Ziel-App”](#anforderungen-an-die-ziel-app)
* Ziel-App muss im Google Play Store verfügbar sein
* Ziel-App muss Inline-Installation unterstützen
* Benutzer muss im Google Play Store angemeldet sein
## Verhalten und Fallbacks
[Section titled “Verhalten und Fallbacks”](#verhalten-und-fallbacks)
### Overlay-Modus (Standard)
[Section titled “Overlay-Modus (Standard)”](#overlay-modus-standard)
1. Versucht, Google Play Overlay innerhalb Ihrer App zu öffnen
2. Wenn Overlay nicht verfügbar ist, Fallback zur vollständigen Play Store-Seite
3. Wenn Play Store nicht verfügbar ist, Fehler anzeigen
### Vollständiger Store-Modus
[Section titled “Vollständiger Store-Modus”](#vollständiger-store-modus)
* Öffnet direkt die vollständige Google Play Store-Seite
* Umgeht Overlay-Versuch vollständig
## Plattformunterstützung
[Section titled “Plattformunterstützung”](#plattformunterstützung)
* **Android**: Volle Unterstützung mit Google Play Services
* **iOS**: Nicht unterstützt (Android-spezifische Funktion)
* **Web**: Nicht unterstützt (native Android-Funktion)
## Implementierungsdetails
[Section titled “Implementierungsdetails”](#implementierungsdetails)
Das Plugin verwendet Android-Intents zur Kommunikation mit dem Google Play Store:
* Intent-Aktion für Inline Install Overlay
* Fallback zu Standard-Play Store Intent
* Automatische Behandlung der Play Services-Verfügbarkeit
## Anwendungsfälle
[Section titled “Anwendungsfälle”](#anwendungsfälle)
* **App-Entdeckung**: Verwandte Apps in Ihrem Ökosystem bewerben
* **Cross-Promotion**: Installationen für Partner-Anwendungen fördern
* **Funktionsfreischaltung**: Zusätzliche Module oder Erweiterungen installieren
* **Begleit-Apps**: Unterstützende Anwendungen nahtlos installieren
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
* Immer Fallback-Optionen für Benutzer ohne Play Services bereitstellen
* Mit verschiedenen Gerätekonfigurationen und Play Store-Versionen testen
* Referrer-Tracking verwenden, um Konversionsraten zu messen
* Installationsfehler angemessen behandeln
* Benutzerwahl respektieren, wenn sie die Installation ablehnen
## Einschränkungen
[Section titled “Einschränkungen”](#einschränkungen)
* Nur Android-Funktionalität
* Erfordert Google Play Services
* Funktioniert nur mit Apps, die für Premium Growth Tools qualifiziert sind
* Unterliegt den Google Play Store-Richtlinien und der Verfügbarkeit
# @capgo/capacitor-android-kiosk
> Sperren Sie Ihr Android-Gerät in den Kiosk-Modus mit voller Kontrolle über Hardware-Tasten und Launcher-Funktionalität für Ihre Capacitor-Apps.
Kiosk-Modus
System-UI ausblenden und in immersiven Vollbildmodus wechseln
Launcher-Integration
Legen Sie Ihre App als Geräte-Launcher/Home-App fest
Hardware-Tastensteuerung
Hardware-Tasten blockieren oder erlauben (Zurück, Home, Kürzlich, Lautstärke, Power)
Statuserkennung
Prüfen Sie, ob der Kiosk-Modus aktiv ist oder die App als Launcher festgelegt ist
Android 6.0+
Unterstützt Android API 23 bis Android 15 (API 35)
Umfassende Dokumentation
Schauen Sie sich die [Dokumentation](/docs/plugins/android-kiosk/getting-started/) an, um den Kiosk-Modus in Minuten zu integrieren.
## Plattformunterstützung
[Section titled “Plattformunterstützung”](#plattformunterstützung)
Dieses Plugin ist **nur für Android**. Für die iOS-Kiosk-Modus-Funktionalität verwenden Sie bitte die integrierte Funktion [Geführter Zugriff](https://support.apple.com/en-us/HT202612) des Geräts.
# Erste Schritte
> Erfahren Sie, wie Sie das Android Kiosk Plugin installieren und verwenden, um Ihr Android-Gerät in den Kiosk-Modus zu sperren.
1. **Paket installieren**
* npm
```sh
npm i @capgo/capacitor-android-kiosk
```
* pnpm
```sh
pnpm add @capgo/capacitor-android-kiosk
```
* yarn
```sh
yarn add @capgo/capacitor-android-kiosk
```
* bun
```sh
bun add @capgo/capacitor-android-kiosk
```
2. **Mit nativen Projekten synchronisieren**
* npm
```sh
npx cap sync
```
* pnpm
```sh
pnpm cap sync
```
* yarn
```sh
yarn cap sync
```
* bun
```sh
bunx cap sync
```
## Plattformunterstützung
[Section titled “Plattformunterstützung”](#plattformunterstützung)
Dieses Plugin ist **nur für Android**. Für die iOS-Kiosk-Modus-Funktionalität verwenden Sie bitte die integrierte Funktion [Geführter Zugriff](https://support.apple.com/en-us/HT202612) des Geräts.
## Funktionen
[Section titled “Funktionen”](#funktionen)
* **Kiosk-Modus**: System-UI ausblenden und in immersiven Vollbildmodus wechseln
* **Launcher-Integration**: Legen Sie Ihre App als Geräte-Launcher/Home-App fest
* **Hardware-Tastensteuerung**: Blockieren oder erlauben Sie spezifische Hardware-Tasten
* **Statuserkennung**: Prüfen Sie, ob der Kiosk-Modus aktiv ist oder die App als Launcher festgelegt ist
* **Android 6.0+**: Unterstützt Android API 23 bis Android 15 (API 35)
## Grundlegende Verwendung
[Section titled “Grundlegende Verwendung”](#grundlegende-verwendung)
### Kiosk-Modus aktivieren und beenden
[Section titled “Kiosk-Modus aktivieren und beenden”](#kiosk-modus-aktivieren-und-beenden)
```typescript
import { CapacitorAndroidKiosk } from '@capgo/capacitor-android-kiosk';
// Kiosk-Modus aktivieren
await CapacitorAndroidKiosk.enterKioskMode();
// Kiosk-Modus beenden
await CapacitorAndroidKiosk.exitKioskMode();
// Prüfen, ob im Kiosk-Modus
const { isInKioskMode } = await CapacitorAndroidKiosk.isInKioskMode();
console.log('Kiosk-Modus aktiv:', isInKioskMode);
```
### Launcher-Funktionalität
[Section titled “Launcher-Funktionalität”](#launcher-funktionalität)
Für die vollständige Kiosk-Modus-Funktionalität müssen Sie Ihre App als Geräte-Launcher festlegen:
```typescript
// Home-Bildschirm-Einstellungen öffnen, damit der Benutzer Ihre App als Launcher auswählen kann
await CapacitorAndroidKiosk.setAsLauncher();
// Prüfen, ob die App als Launcher festgelegt ist
const { isLauncher } = await CapacitorAndroidKiosk.isSetAsLauncher();
console.log('App ist Launcher:', isLauncher);
```
### Hardware-Tastensteuerung
[Section titled “Hardware-Tastensteuerung”](#hardware-tastensteuerung)
Steuern Sie, welche Hardware-Tasten im Kiosk-Modus funktionieren dürfen:
```typescript
// Nur Lautstärketasten erlauben
await CapacitorAndroidKiosk.setAllowedKeys({
volumeUp: true,
volumeDown: true,
back: false,
home: false,
recent: false
});
// Alle Tasten blockieren (Standard)
await CapacitorAndroidKiosk.setAllowedKeys({});
```
## Vollständiges Beispiel
[Section titled “Vollständiges Beispiel”](#vollständiges-beispiel)
```typescript
async function setupKioskMode() {
try {
// Prüfen, ob bereits als Launcher festgelegt
const { isLauncher } = await CapacitorAndroidKiosk.isSetAsLauncher();
if (!isLauncher) {
// Benutzer auffordern, als Launcher festzulegen
await CapacitorAndroidKiosk.setAsLauncher();
alert('Bitte wählen Sie diese App als Ihre Home-App aus');
return;
}
// Erlaubte Tasten konfigurieren
await CapacitorAndroidKiosk.setAllowedKeys({
volumeUp: true,
volumeDown: true,
back: false,
home: false,
recent: false,
power: false
});
// Kiosk-Modus aktivieren
await CapacitorAndroidKiosk.enterKioskMode();
console.log('Kiosk-Modus aktiviert');
} catch (error) {
console.error('Fehler beim Einrichten des Kiosk-Modus:', error);
}
}
```
## API-Referenz
[Section titled “API-Referenz”](#api-referenz)
### isInKioskMode()
[Section titled “isInKioskMode()”](#isinkioskmode)
Prüft, ob die App derzeit im Kiosk-Modus läuft.
```typescript
const { isInKioskMode } = await CapacitorAndroidKiosk.isInKioskMode();
```
**Rückgabe:**
* `isInKioskMode` (boolean): Ob der Kiosk-Modus derzeit aktiv ist
***
### isSetAsLauncher()
[Section titled “isSetAsLauncher()”](#issetaslauncher)
Prüft, ob die App als Geräte-Launcher (Home-App) festgelegt ist.
```typescript
const { isLauncher } = await CapacitorAndroidKiosk.isSetAsLauncher();
```
**Rückgabe:**
* `isLauncher` (boolean): Ob die App als Geräte-Launcher festgelegt ist
***
### enterKioskMode()
[Section titled “enterKioskMode()”](#enterkioskmode)
Aktiviert den Kiosk-Modus, blendet die System-UI aus und blockiert Hardware-Tasten. Die App muss als Geräte-Launcher festgelegt sein, damit dies effektiv funktioniert.
```typescript
await CapacitorAndroidKiosk.enterKioskMode();
```
***
### exitKioskMode()
[Section titled “exitKioskMode()”](#exitkioskmode)
Beendet den Kiosk-Modus und stellt die normale System-UI und Hardware-Tastenfunktionalität wieder her.
```typescript
await CapacitorAndroidKiosk.exitKioskMode();
```
***
### setAsLauncher()
[Section titled “setAsLauncher()”](#setaslauncher)
Öffnet die Home-Bildschirm-Einstellungen des Geräts, damit der Benutzer diese App als Launcher festlegen kann. Dies ist für die vollständige Kiosk-Modus-Funktionalität erforderlich.
```typescript
await CapacitorAndroidKiosk.setAsLauncher();
```
***
### setAllowedKeys(options)
[Section titled “setAllowedKeys(options)”](#setallowedkeysoptions)
Legt fest, welche Hardware-Tasten im Kiosk-Modus funktionieren dürfen. Standardmäßig sind alle Hardware-Tasten im Kiosk-Modus blockiert.
```typescript
await CapacitorAndroidKiosk.setAllowedKeys({
volumeUp: true,
volumeDown: true,
back: false,
home: false,
recent: false,
power: false,
camera: false,
menu: false
});
```
**Parameter:**
* `volumeUp` (boolean, optional): Lautstärke-Plus-Taste erlauben (Standard: false)
* `volumeDown` (boolean, optional): Lautstärke-Minus-Taste erlauben (Standard: false)
* `back` (boolean, optional): Zurück-Taste erlauben (Standard: false)
* `home` (boolean, optional): Home-Taste erlauben (Standard: false)
* `recent` (boolean, optional): Kürzlich-verwendete-Apps-Taste erlauben (Standard: false)
* `power` (boolean, optional): Power-Taste erlauben (Standard: false)
* `camera` (boolean, optional): Kamera-Taste erlauben, falls vorhanden (Standard: false)
* `menu` (boolean, optional): Menü-Taste erlauben, falls vorhanden (Standard: false)
***
### getPluginVersion()
[Section titled “getPluginVersion()”](#getpluginversion)
Plugin-Version des nativen Capacitor-Plugins abrufen.
```typescript
const { version } = await CapacitorAndroidKiosk.getPluginVersion();
console.log('Plugin-Version:', version);
```
**Rückgabe:**
* `version` (string): Die Plugin-Versionsnummer
## Android-Konfiguration
[Section titled “Android-Konfiguration”](#android-konfiguration)
### 1. MainActivity-Einrichtung
[Section titled “1. MainActivity-Einrichtung”](#1-mainactivity-einrichtung)
Um die vollständige Hardware-Tastenblockierung zu aktivieren, müssen Sie `dispatchKeyEvent` in Ihrer `MainActivity.java` überschreiben:
```java
import android.view.KeyEvent;
import ee.forgr.plugin.android_kiosk.CapacitorAndroidKioskPlugin;
public class MainActivity extends BridgeActivity {
@Override
public boolean dispatchKeyEvent(KeyEvent event) {
// Kiosk-Plugin abrufen
CapacitorAndroidKioskPlugin kioskPlugin = (CapacitorAndroidKioskPlugin)
this.getBridge().getPlugin("CapacitorAndroidKiosk").getInstance();
if (kioskPlugin != null && kioskPlugin.shouldBlockKey(event.getKeyCode())) {
return true; // Taste blockieren
}
return super.dispatchKeyEvent(event);
}
@Override
public void onBackPressed() {
// super.onBackPressed() nicht aufrufen, um Zurück-Taste zu deaktivieren
// Oder handleOnBackPressed des Plugins aufrufen
}
}
```
### 2. AndroidManifest.xml
[Section titled “2. AndroidManifest.xml”](#2-androidmanifestxml)
Launcher-Intent-Filter hinzufügen, um Ihre App als Launcher auswählbar zu machen:
```xml
```
## Wichtige Hinweise
[Section titled “Wichtige Hinweise”](#wichtige-hinweise)
1. **Launcher-Anforderung**: Für die vollständige Kiosk-Modus-Funktionalität (Home-Taste blockieren, Task-Wechsel verhindern) muss Ihre App als Geräte-Launcher festgelegt sein.
2. **Testen**: Beim Testen können Sie den Kiosk-Modus programmatisch beenden oder eine andere App als Launcher festlegen.
3. **Android-Versionen**: Das Plugin verwendet moderne Android-APIs für Android 11+ und fällt für die Kompatibilität mit Android 6.0+ auf ältere Methoden zurück.
4. **Sicherheit**: Dieses Plugin ist für legitime Kiosk-Anwendungen konzipiert. Stellen Sie sicher, dass Sie Benutzern eine Möglichkeit bieten, den Kiosk-Modus zu beenden.
5. **Akku**: Der Kiosk-Modus hält den Bildschirm an. Erwägen Sie, Ihre eigene Bildschirm-Timeout- oder Helligkeitsverwaltung zu implementieren.
## iOS-Alternative
[Section titled “iOS-Alternative”](#ios-alternative)
Für iOS-Geräte verwenden Sie die integrierte Funktion [Geführter Zugriff](https://support.apple.com/en-us/HT202612):
1. Gehen Sie zu Einstellungen > Bedienungshilfen > Geführter Zugriff
2. Aktivieren Sie Geführter Zugriff
3. Legen Sie einen Code fest
4. Öffnen Sie Ihre App
5. Dreimal auf die Seitentaste klicken
6. Einstellungen anpassen und Geführten Zugriff starten
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
1. **Launcher-Status zuerst prüfen**
```typescript
const { isLauncher } = await CapacitorAndroidKiosk.isSetAsLauncher();
if (!isLauncher) {
// Benutzer zuerst auffordern, als Launcher festzulegen
await CapacitorAndroidKiosk.setAsLauncher();
}
```
2. **Ausstiegsmechanismus bereitstellen**
```typescript
// Spezifische Tastenkombination zum Beenden erlauben
// Oder geheime Geste/Muster implementieren
async function exitKioskWithConfirmation() {
const confirmed = confirm('Kiosk-Modus beenden?');
if (confirmed) {
await CapacitorAndroidKiosk.exitKioskMode();
}
}
```
3. **App-Lebenszyklus behandeln**
```typescript
// Kiosk-Modus erneut aktivieren, wenn App fortgesetzt wird
window.addEventListener('resume', async () => {
const { isInKioskMode } = await CapacitorAndroidKiosk.isInKioskMode();
if (!isInKioskMode) {
await CapacitorAndroidKiosk.enterKioskMode();
}
});
```
4. **Fehlerbehandlung**
```typescript
try {
await CapacitorAndroidKiosk.enterKioskMode();
} catch (error) {
console.error('Fehler beim Aktivieren des Kiosk-Modus:', error);
// Benutzer benachrichtigen und Alternative bereitstellen
}
```
# @capgo/capacitor-android-usagestatsmanager
> Zugriff auf Android-Nutzungsstatistiken zur Überwachung von App-Nutzung, Bildschirmzeit und Benutzerverhalten mit Daten auf Systemebene.
## Überblick
[Section titled “Überblick”](#überblick)
Das Capacitor Android Usage Stats Manager Plugin stellt das UsageStatsManager SDK von Android für Capacitor-Anwendungen bereit und ermöglicht den Zugriff auf detaillierte App-Nutzungsstatistiken und Gerätenutzungsdaten. Dieses Plugin ermöglicht es Entwicklern, App-Nutzungsmuster, Bildschirmzeit und Benutzerverhalten auf Android-Geräten zu verfolgen.
Nutzungsstatistiken
Zugriff auf Android UsageStatsManager SDK-Daten 📱
App-Überwachung
Verfolgen Sie individuelle App-Nutzungszeit und -Häufigkeit 🕐
Berechtigungsverwaltung
Nahtlose Verwaltung von Nutzungsstatistik-Berechtigungen 🛡️
Paketinformationen
Abfrage installierter Paketdetails und Metadaten 📦
## Installation
[Section titled “Installation”](#installation)
```bash
npm install @capgo/capacitor-android-usagestatsmanager
npx cap sync
```
## Erforderliche Berechtigungen
[Section titled “Erforderliche Berechtigungen”](#erforderliche-berechtigungen)
Fügen Sie diese Berechtigungen zu Ihrer `android/app/src/main/AndroidManifest.xml` hinzu:
```xml
```
## Kern-API-Methoden
[Section titled “Kern-API-Methoden”](#kern-api-methoden)
### Nutzungsstatistiken
[Section titled “Nutzungsstatistiken”](#nutzungsstatistiken)
* `queryAndAggregateUsageStats(options)` - Detaillierte Nutzungsstatistiken für installierte Apps abrufen
* `isUsageStatsPermissionGranted()` - Prüfen, ob die Berechtigung für Nutzungsstatistiken erteilt wurde
* `openUsageStatsSettings()` - Systemeinstellungen für Nutzungsstatistik-Berechtigung öffnen
### Paketinformationen
[Section titled “Paketinformationen”](#paketinformationen)
* `queryAllPackages()` - Informationen über alle installierten Pakete abrufen
## Verwendungsbeispiel
[Section titled “Verwendungsbeispiel”](#verwendungsbeispiel)
```typescript
import { AndroidUsageStatsManager } from '@capgo/capacitor-android-usagestatsmanager';
// Prüfen, ob die Berechtigung erteilt wurde
const permissionResult = await AndroidUsageStatsManager.isUsageStatsPermissionGranted();
if (!permissionResult.granted) {
// Einstellungen öffnen, um die Berechtigung zu erteilen
await AndroidUsageStatsManager.openUsageStatsSettings();
return;
}
// Nutzungsstatistiken abfragen
const statsOptions = {
intervalType: 0, // INTERVAL_DAILY
startTime: Date.now() - (7 * 24 * 60 * 60 * 1000), // vor 7 Tagen
endTime: Date.now()
};
const usageStats = await AndroidUsageStatsManager.queryAndAggregateUsageStats(statsOptions);
console.log('Nutzungsstatistiken:', usageStats);
// Alle installierten Pakete abrufen
const packages = await AndroidUsageStatsManager.queryAllPackages();
console.log('Installierte Pakete:', packages);
```
## Berechtigungsverwaltung
[Section titled “Berechtigungsverwaltung”](#berechtigungsverwaltung)
Das Plugin erfordert spezielle Berechtigungen, die nicht über normale Laufzeit-Berechtigungsanforderungen erteilt werden können:
1. **PACKAGE\_USAGE\_STATS**: Ermöglicht den Zugriff auf Nutzungsstatistiken
2. **QUERY\_ALL\_PACKAGES**: Erforderlich für Paketinformationen (Android 11+)
Benutzer müssen diese Berechtigungen manuell über die Systemeinstellungen erteilen. Verwenden Sie `openUsageStatsSettings()`, um Benutzer zur entsprechenden Einstellungsseite zu leiten.
## Datentypen
[Section titled “Datentypen”](#datentypen)
### Nutzungsstatistiken
[Section titled “Nutzungsstatistiken”](#nutzungsstatistiken-1)
* App-Nutzungszeit und -Häufigkeit
* Erste und letzte Verwendung
* Gesamtzeit im Vordergrund
* Anzahl der Starts
### Paketinformationen
[Section titled “Paketinformationen”](#paketinformationen-1)
* Paketname und Version
* Installationszeit
* App-Bezeichnungen und Icons
* System- vs. Benutzer-Apps
## Anwendungsfälle
[Section titled “Anwendungsfälle”](#anwendungsfälle)
* **Digital Wellbeing Apps**: Bildschirmzeit und App-Nutzung überwachen
* **Kindersicherung**: Gerätenutzung von Kindern verfolgen
* **Produktivitäts-Apps**: Arbeitsmuster und Fokuszeiten analysieren
* **Analytics**: Benutzerverhalten und App-Engagement verstehen
## Android-Kompatibilität
[Section titled “Android-Kompatibilität”](#android-kompatibilität)
* **Minimale Android-Version**: API Level 21 (Android 5.0)
* **Erweiterte Funktionen**: API Level 29+ (Android 10+) für erweiterte Statistiken
* **Paketabfragen**: API Level 30+ (Android 11+) erfordert QUERY\_ALL\_PACKAGES
## Sicherheitsüberlegungen
[Section titled “Sicherheitsüberlegungen”](#sicherheitsüberlegungen)
* Berechtigung für Nutzungsstatistiken ist sensibel und erfordert Benutzerzustimmung
* Berücksichtigen Sie die Privatsphäre der Benutzer beim Sammeln von Nutzungsdaten
* Implementieren Sie ordnungsgemäße Datenverarbeitungs- und Speicherpraktiken
* Befolgen Sie die Google Play-Richtlinien für die Erfassung von Nutzungsdaten
## Dokumentation
[Section titled “Dokumentation”](#dokumentation)
Siehe die [vollständige Dokumentation](/docs/plugins/android-usagestatsmanager/getting-started/) für detaillierte Implementierungsanleitungen und erweiterte Nutzungsmuster.
# Erste Schritte
> Erfahren Sie, wie Sie das Android Usage Stats Manager Plugin installieren und verwenden, um auf App-Nutzungsstatistiken und Gerätenutzungsdaten zuzugreifen.
## Installation
[Section titled “Installation”](#installation)
* npm
```bash
npm install @capgo/capacitor-android-usagestatsmanager
npx cap sync
```
* yarn
```bash
yarn add @capgo/capacitor-android-usagestatsmanager
npx cap sync
```
* pnpm
```bash
pnpm add @capgo/capacitor-android-usagestatsmanager
npx cap sync
```
* bun
```bash
bun add @capgo/capacitor-android-usagestatsmanager
npx cap sync
```
## Plattform-Konfiguration
[Section titled “Plattform-Konfiguration”](#plattform-konfiguration)
### Android
[Section titled “Android”](#android)
Fügen Sie die erforderlichen Berechtigungen zu Ihrer `android/app/src/main/AndroidManifest.xml` hinzu:
```xml
```
## Verwendungsbeispiel
[Section titled “Verwendungsbeispiel”](#verwendungsbeispiel)
```typescript
import { AndroidUsageStatsManager } from '@capgo/capacitor-android-usagestatsmanager';
// Prüfen, ob die Berechtigung erteilt wurde
const permissionResult = await AndroidUsageStatsManager.isUsageStatsPermissionGranted();
if (!permissionResult.granted) {
// Einstellungen öffnen, um die Berechtigung zu erteilen
await AndroidUsageStatsManager.openUsageStatsSettings();
return;
}
// Nutzungsstatistiken für die letzten 7 Tage abfragen
const statsOptions = {
intervalType: 0, // INTERVAL_DAILY
startTime: Date.now() - (7 * 24 * 60 * 60 * 1000), // vor 7 Tagen
endTime: Date.now()
};
const usageStats = await AndroidUsageStatsManager.queryAndAggregateUsageStats(statsOptions);
console.log('Nutzungsstatistiken:', usageStats);
// Alle installierten Pakete abrufen
const packages = await AndroidUsageStatsManager.queryAllPackages();
console.log('Installierte Pakete:', packages);
```
## API-Referenz
[Section titled “API-Referenz”](#api-referenz)
### isUsageStatsPermissionGranted()
[Section titled “isUsageStatsPermissionGranted()”](#isusagestatspermissiongranted)
```typescript
isUsageStatsPermissionGranted() => Promise<{ granted: boolean }>
```
Prüft, ob die PACKAGE\_USAGE\_STATS-Berechtigung erteilt wurde.
**Rückgabewert:** `Promise<{ granted: boolean }>`
### openUsageStatsSettings()
[Section titled “openUsageStatsSettings()”](#openusagestatssettings)
```typescript
openUsageStatsSettings() => Promise
```
Öffnet die Systemeinstellungsseite zum Erteilen der Berechtigung für Nutzungsstatistiken.
### queryAndAggregateUsageStats(options)
[Section titled “queryAndAggregateUsageStats(options)”](#queryandaggregateusagestatsoptions)
```typescript
queryAndAggregateUsageStats(options: UsageStatsOptions) => Promise
```
Ruft detaillierte Nutzungsstatistiken für installierte Apps ab.
| Parameter | Typ |
| ------------- | ------------------- |
| **`options`** | `UsageStatsOptions` |
**Rückgabewert:** `Promise`
### queryAllPackages()
[Section titled “queryAllPackages()”](#queryallpackages)
```typescript
queryAllPackages() => Promise
```
Ruft Informationen über alle auf dem Gerät installierten Pakete ab.
**Rückgabewert:** `Promise`
## Schnittstellen
[Section titled “Schnittstellen”](#schnittstellen)
### UsageStatsOptions
[Section titled “UsageStatsOptions”](#usagestatsoptions)
| Eigenschaft | Typ | Beschreibung |
| ------------------ | -------- | ---------------------------------------------------------- |
| **`intervalType`** | `number` | Intervalltyp (0=TÄGLICH, 1=WÖCHENTLICH, 2=MONATLICH, etc.) |
| **`startTime`** | `number` | Startzeit in Millisekunden |
| **`endTime`** | `number` | Endzeit in Millisekunden |
### UsageStatsResult
[Section titled “UsageStatsResult”](#usagestatsresult)
Enthält Nutzungsstatistikdaten für jede App:
* App-Nutzungszeit und -Häufigkeit
* Erste und letzte Verwendung
* Gesamtzeit im Vordergrund
* Anzahl der Starts
### PackagesResult
[Section titled “PackagesResult”](#packagesresult)
Enthält Informationen über installierte Pakete:
* Paketname und Version
* Installationszeit
* App-Bezeichnungen und Icons
* System- vs. Benutzer-Apps
## Berechtigungsverwaltung
[Section titled “Berechtigungsverwaltung”](#berechtigungsverwaltung)
Das Plugin erfordert spezielle Berechtigungen, die nicht über normale Laufzeit-Berechtigungsanforderungen erteilt werden können:
1. **PACKAGE\_USAGE\_STATS**: Ermöglicht den Zugriff auf Nutzungsstatistiken
2. **QUERY\_ALL\_PACKAGES**: Erforderlich für Paketinformationen (Android 11+)
Benutzer müssen diese Berechtigungen manuell über die Systemeinstellungen erteilen. Verwenden Sie `openUsageStatsSettings()`, um Benutzer zur entsprechenden Einstellungsseite zu leiten.
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
* Prüfen Sie immer den Berechtigungsstatus, bevor Sie Nutzungsstatistiken abfragen
* Gehen Sie mit Berechtigungsablehnungen benutzerfreundlich um
* Berücksichtigen Sie die Privatsphäre der Benutzer beim Sammeln von Nutzungsdaten
* Implementieren Sie ordnungsgemäße Datenverarbeitungs- und Speicherpraktiken
* Befolgen Sie die Google Play-Richtlinien für die Erfassung von Nutzungsdaten
## Anwendungsfälle
[Section titled “Anwendungsfälle”](#anwendungsfälle)
* **Digital Wellbeing Apps**: Bildschirmzeit und App-Nutzung überwachen
* **Kindersicherung**: Gerätenutzung von Kindern verfolgen
* **Produktivitäts-Apps**: Arbeitsmuster und Fokuszeiten analysieren
* **Analytics**: Benutzerverhalten und App-Engagement verstehen
# @capgo/capacitor-appinsights
> Verfolgen Sie App-Nutzung, Benutzerverhalten und Leistungsmetriken mit AppInsights-Integration für Ihre Capacitor-Apps.
Analytics-Tracking
Verfolgen Sie Benutzerverhalten und App-Nutzung mit AppInsights
Benutzeridentifikation
Legen Sie Benutzer-IDs fest und verwalten Sie diese für personalisiertes Tracking
SDK-Zustandsverwaltung
Überwachen Sie SDK-Initialisierung und Berechtigungsstatus
Umfassende Dokumentation
Schauen Sie sich die [Dokumentation](/docs/plugins/appinsights/getting-started/) an, um Analytics in Minuten zu integrieren.
# Erste Schritte
> Erfahren Sie, wie Sie das AppInsights Plugin für Anwendungsanalysen in Ihrer Capacitor-App installieren und verwenden.
1. **Paket installieren**
* npm
```sh
npm i @capgo/capacitor-appinsights
```
* pnpm
```sh
pnpm add @capgo/capacitor-appinsights
```
* yarn
```sh
yarn add @capgo/capacitor-appinsights
```
* bun
```sh
bun add @capgo/capacitor-appinsights
```
2. **Mit nativen Projekten synchronisieren**
* npm
```sh
npx cap sync
```
* pnpm
```sh
pnpm cap sync
```
* yarn
```sh
yarn cap sync
```
* bun
```sh
bunx cap sync
```
## Verwendung
[Section titled “Verwendung”](#verwendung)
Importieren Sie das Plugin und initialisieren Sie es mit Ihren AppInsights-Anmeldedaten:
```typescript
import { CapacitorAppinsights } from '@capgo/capacitor-appinsights';
// SDK initialisieren
const initializeAnalytics = async () => {
await CapacitorAppinsights.init({
partnerId: 'your-partner-id',
partnerKey: 'your-partner-key'
});
};
// Benutzer-ID für Tracking festlegen
const setUser = async (userId: string) => {
await CapacitorAppinsights.setUserId({ userId });
};
// SDK-Zustand abrufen
const checkSDKState = async () => {
const state = await CapacitorAppinsights.getState();
console.log('SDK-Zustand:', state);
};
// Plugin-Version abrufen
const checkVersion = async () => {
const { version } = await CapacitorAppinsights.getPluginVersion();
console.log('Plugin-Version:', version);
};
```
## API-Referenz
[Section titled “API-Referenz”](#api-referenz)
### init(options)
[Section titled “init(options)”](#initoptions)
Initialisieren Sie das AppInsights SDK mit Ihren Anmeldedaten.
```typescript
await CapacitorAppinsights.init({
partnerId: 'your-partner-id',
partnerKey: 'your-partner-key'
});
```
**Parameter:**
* `partnerId` (string): Ihre AppInsights Partner-ID
* `partnerKey` (string): Ihr AppInsights Partner-Schlüssel
### setUserId(options)
[Section titled “setUserId(options)”](#setuseridoptions)
Legen Sie die Benutzer-ID nach der Initialisierung fest oder aktualisieren Sie diese.
```typescript
await CapacitorAppinsights.setUserId({
userId: 'user-123'
});
```
**Parameter:**
* `userId` (string): Die Benutzer-ID, die für das Tracking festgelegt werden soll
### getState()
[Section titled “getState()”](#getstate)
Rufen Sie den aktuellen Zustand des SDK ab.
```typescript
const state = await CapacitorAppinsights.getState();
console.log(state);
// {
// initCompleted: true,
// jobScheduled: true,
// permissionAcquired: true
// }
```
**Rückgabe:**
* `initCompleted` (boolean): Ob die SDK-Initialisierung abgeschlossen ist
* `jobScheduled` (boolean): Ob der Datenerfassungsauftrag geplant ist
* `permissionAcquired` (boolean): Ob die erforderlichen Berechtigungen erworben wurden
### getPluginVersion()
[Section titled “getPluginVersion()”](#getpluginversion)
Rufen Sie die native Capacitor-Plugin-Version ab.
```typescript
const { version } = await CapacitorAppinsights.getPluginVersion();
console.log('Version:', version);
```
## Vollständiges Beispiel
[Section titled “Vollständiges Beispiel”](#vollständiges-beispiel)
```typescript
import { CapacitorAppinsights } from '@capgo/capacitor-appinsights';
export class AnalyticsService {
private initialized = false;
async initialize(partnerId: string, partnerKey: string) {
try {
await CapacitorAppinsights.init({
partnerId,
partnerKey
});
const state = await CapacitorAppinsights.getState();
this.initialized = state.initCompleted;
console.log('AppInsights initialisiert:', state);
} catch (error) {
console.error('Fehler beim Initialisieren von AppInsights:', error);
}
}
async identifyUser(userId: string) {
if (!this.initialized) {
throw new Error('AppInsights nicht initialisiert');
}
await CapacitorAppinsights.setUserId({ userId });
console.log('Benutzer identifiziert:', userId);
}
async getSDKStatus() {
const state = await CapacitorAppinsights.getState();
return {
ready: state.initCompleted && state.permissionAcquired,
tracking: state.jobScheduled,
state
};
}
}
```
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
1. **Früh initialisieren** Initialisieren Sie das SDK, sobald Ihre App startet, um genaues Tracking zu gewährleisten:
```typescript
// Bei der App-Initialisierung
await CapacitorAppinsights.init({
partnerId: process.env.APPINSIGHTS_PARTNER_ID,
partnerKey: process.env.APPINSIGHTS_PARTNER_KEY
});
```
2. **Benutzer-ID beim Login festlegen** Identifizieren Sie Benutzer nach der Authentifizierung:
```typescript
async function onUserLogin(user) {
await CapacitorAppinsights.setUserId({
userId: user.id
});
}
```
3. **SDK-Zustand prüfen** Überprüfen Sie, ob das SDK vor kritischen Operationen bereit ist:
```typescript
const state = await CapacitorAppinsights.getState();
if (!state.initCompleted) {
console.warn('AppInsights nicht bereit');
}
```
4. **Fehler angemessen behandeln**
```typescript
try {
await CapacitorAppinsights.init(config);
} catch (error) {
console.error('Analytics-Initialisierung fehlgeschlagen:', error);
// App-Betrieb auch bei Analytics-Fehler fortsetzen
}
```
## Plattformhinweise
[Section titled “Plattformhinweise”](#plattformhinweise)
### iOS
[Section titled “iOS”](#ios)
* Erfordert iOS 10.0+
* Stellen Sie sicher, dass Sie die erforderlichen Berechtigungen in Info.plist für das Tracking haben
### Android
[Section titled “Android”](#android)
* Erfordert Android 5.0 (API 21)+
* Kann je nach Tracking-Funktionen Nutzungsstatistik-Berechtigung erfordern
### Web
[Section titled “Web”](#web)
* Auf der Web-Plattform nicht unterstützt
# @capgo/capacitor-audio-recorder
> Hochwertige Audioaufnahmen für Ihre Capacitor-Anwendungen
Plattformübergreifend
Audio auf iOS, Android und Web mit einer einheitlichen API aufnehmen 🌐
Mehrere Formate
Unterstützung für AAC-, MP3- und WAV-Kodierung 🎵
Konfigurierbare Qualität
Steuern Sie Abtastrate, Bitrate und Kanäle für optimale Qualität 🎚️
Umfassende Dokumentation
Lesen Sie die [Dokumentation](/docs/plugins/audio-recorder/getting-started/), um das Plugin in wenigen Minuten zu beherrschen.
# Erste Schritte mit Audio Recorder
> Erfahren Sie, wie Sie Audioaufnahmen in Ihre Capacitor App integrieren
Diese Anleitung führt Sie durch die Integration des Capacitor Audio Recorder Plugins in Ihre Anwendung.
## Installation
[Section titled “Installation”](#installation)
Installieren Sie das Plugin mit npm:
```bash
npm install @capgo/capacitor-audio-recorder
npx cap sync
```
## iOS-Konfiguration
[Section titled “iOS-Konfiguration”](#ios-konfiguration)
Fügen Sie Folgendes zu Ihrer `Info.plist` hinzu:
```xml
NSMicrophoneUsageDescription
Diese App benötigt Zugriff auf das Mikrofon, um Audio aufzunehmen
```
## Android-Konfiguration
[Section titled “Android-Konfiguration”](#android-konfiguration)
Fügen Sie die folgenden Berechtigungen zu Ihrer `AndroidManifest.xml` hinzu:
```xml
```
## Web-Konfiguration
[Section titled “Web-Konfiguration”](#web-konfiguration)
Das Plugin verwendet die MediaRecorder API. Erfordert HTTPS in der Produktion.
## Grundlegende Verwendung
[Section titled “Grundlegende Verwendung”](#grundlegende-verwendung)
### Plugin importieren
[Section titled “Plugin importieren”](#plugin-importieren)
```typescript
import { AudioRecorder } from '@capgo/capacitor-audio-recorder';
```
### Berechtigungen anfordern
[Section titled “Berechtigungen anfordern”](#berechtigungen-anfordern)
```typescript
const requestPermission = async () => {
const permission = await AudioRecorder.requestPermissions();
console.log('Berechtigungsstatus:', permission.recordAudio);
};
```
### Aufnahme starten
[Section titled “Aufnahme starten”](#aufnahme-starten)
```typescript
const startRecording = async () => {
await AudioRecorder.startRecording();
console.log('Aufnahme gestartet');
};
```
### Aufnahme stoppen
[Section titled “Aufnahme stoppen”](#aufnahme-stoppen)
```typescript
const stopRecording = async () => {
const result = await AudioRecorder.stopRecording();
console.log('Aufnahmepfad:', result.filePath);
console.log('Dauer:', result.duration);
};
```
### Aufnahme pausieren/fortsetzen
[Section titled “Aufnahme pausieren/fortsetzen”](#aufnahme-pausierenfortsetzen)
```typescript
const pauseRecording = async () => {
await AudioRecorder.pauseRecording();
console.log('Aufnahme pausiert');
};
const resumeRecording = async () => {
await AudioRecorder.resumeRecording();
console.log('Aufnahme fortgesetzt');
};
```
### Status abrufen
[Section titled “Status abrufen”](#status-abrufen)
```typescript
const getStatus = async () => {
const status = await AudioRecorder.getStatus();
console.log('Nimmt auf:', status.isRecording);
console.log('Dauer:', status.currentTime);
};
```
## Vollständiges Beispiel
[Section titled “Vollständiges Beispiel”](#vollständiges-beispiel)
Hier ist eine vollständige Implementierung eines Sprachrekorders:
```typescript
import { AudioRecorder } from '@capgo/capacitor-audio-recorder';
class VoiceRecorder {
private isRecording = false;
private isPaused = false;
private recordingPath: string | null = null;
async initialize() {
const permission = await AudioRecorder.checkPermissions();
if (permission.recordAudio !== 'granted') {
const requested = await AudioRecorder.requestPermissions();
if (requested.recordAudio !== 'granted') {
throw new Error('Mikrofonberechtigung verweigert');
}
}
}
async startRecording() {
try {
await AudioRecorder.startRecording();
this.isRecording = true;
this.isPaused = false;
console.log('Aufnahme gestartet');
} catch (error) {
console.error('Aufnahme konnte nicht gestartet werden:', error);
throw error;
}
}
async pauseRecording() {
if (!this.isRecording || this.isPaused) {
return;
}
try {
await AudioRecorder.pauseRecording();
this.isPaused = true;
console.log('Aufnahme pausiert');
} catch (error) {
console.error('Aufnahme konnte nicht pausiert werden:', error);
throw error;
}
}
async resumeRecording() {
if (!this.isRecording || !this.isPaused) {
return;
}
try {
await AudioRecorder.resumeRecording();
this.isPaused = false;
console.log('Aufnahme fortgesetzt');
} catch (error) {
console.error('Aufnahme konnte nicht fortgesetzt werden:', error);
throw error;
}
}
async stopRecording() {
if (!this.isRecording) {
return null;
}
try {
const result = await AudioRecorder.stopRecording();
this.isRecording = false;
this.isPaused = false;
this.recordingPath = result.filePath;
console.log('Aufnahme gestoppt');
console.log('Dateipfad:', result.filePath);
console.log('Dauer:', result.duration, 'Sekunden');
return result;
} catch (error) {
console.error('Aufnahme konnte nicht gestoppt werden:', error);
throw error;
}
}
async getCurrentStatus() {
const status = await AudioRecorder.getStatus();
return {
isRecording: status.isRecording,
duration: status.currentTime,
isPaused: this.isPaused
};
}
formatDuration(seconds: number): string {
const mins = Math.floor(seconds / 60);
const secs = Math.floor(seconds % 60);
return `${mins}:${secs.toString().padStart(2, '0')}`;
}
getRecordingPath(): string | null {
return this.recordingPath;
}
}
// Verwendung
const recorder = new VoiceRecorder();
// Initialisieren
await recorder.initialize();
// Aufnahme starten
await recorder.startRecording();
// Pausieren
await recorder.pauseRecording();
// Fortsetzen
await recorder.resumeRecording();
// Stoppen und Ergebnis abrufen
const result = await recorder.stopRecording();
console.log('Aufnahme gespeichert:', result?.filePath);
```
## Erweiterte Konfiguration
[Section titled “Erweiterte Konfiguration”](#erweiterte-konfiguration)
### Audioqualität konfigurieren
[Section titled “Audioqualität konfigurieren”](#audioqualität-konfigurieren)
```typescript
const startHighQualityRecording = async () => {
await AudioRecorder.startRecording({
format: 'aac', // aac, mp3 oder wav
sampleRate: 44100, // 44100 Hz (CD-Qualität)
channels: 2, // Stereo
bitRate: 320000 // 320 kbps
});
};
```
### Für Sprache konfigurieren
[Section titled “Für Sprache konfigurieren”](#für-sprache-konfigurieren)
```typescript
const startVoiceRecording = async () => {
await AudioRecorder.startRecording({
format: 'aac',
sampleRate: 16000, // 16 kHz (für Sprache optimiert)
channels: 1, // Mono
bitRate: 64000 // 64 kbps
});
};
```
## UI-Integrationsbeispiel
[Section titled “UI-Integrationsbeispiel”](#ui-integrationsbeispiel)
```typescript
class AudioRecorderUI {
private recorder: VoiceRecorder;
private updateInterval: any;
constructor() {
this.recorder = new VoiceRecorder();
}
async init() {
await this.recorder.initialize();
this.setupEventListeners();
}
setupEventListeners() {
const recordButton = document.getElementById('record-btn');
const pauseButton = document.getElementById('pause-btn');
const stopButton = document.getElementById('stop-btn');
recordButton?.addEventListener('click', () => this.handleRecord());
pauseButton?.addEventListener('click', () => this.handlePause());
stopButton?.addEventListener('click', () => this.handleStop());
}
async handleRecord() {
await this.recorder.startRecording();
this.startDurationUpdate();
this.updateUI('recording');
}
async handlePause() {
const status = await this.recorder.getCurrentStatus();
if (status.isPaused) {
await this.recorder.resumeRecording();
this.updateUI('recording');
} else {
await this.recorder.pauseRecording();
this.updateUI('paused');
}
}
async handleStop() {
const result = await this.recorder.stopRecording();
this.stopDurationUpdate();
this.updateUI('stopped');
if (result) {
this.showRecordingResult(result);
}
}
startDurationUpdate() {
this.updateInterval = setInterval(async () => {
const status = await this.recorder.getCurrentStatus();
this.updateDurationDisplay(status.duration);
}, 100);
}
stopDurationUpdate() {
if (this.updateInterval) {
clearInterval(this.updateInterval);
}
}
updateDurationDisplay(duration: number) {
const display = document.getElementById('duration');
if (display) {
display.textContent = this.recorder.formatDuration(duration);
}
}
updateUI(state: 'recording' | 'paused' | 'stopped') {
// Button-Zustände, Farben usw. aktualisieren
console.log('UI-Status:', state);
}
showRecordingResult(result: any) {
console.log('Aufnahme abgeschlossen:', result);
// Wiedergabe-UI, Speicheroptionen usw. anzeigen
}
}
// UI initialisieren
const ui = new AudioRecorderUI();
ui.init();
```
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
1. **Berechtigungen frühzeitig anfordern**: Prüfen Sie Berechtigungen, bevor Sie die Aufnahme-UI anzeigen
2. **Unterbrechungen behandeln**: Telefonanrufe, Alarme können die Aufnahme unterbrechen
3. **Speicher verwalten**: Alte Aufnahmen löschen, um Speicherplatz zu sparen
4. **Feedback geben**: Aufnahmestatus, Dauer und Wellenform anzeigen
5. **Auf Geräten testen**: Simulatoren/Emulatoren haben eingeschränkte Audio-Unterstützung
## Häufige Probleme
[Section titled “Häufige Probleme”](#häufige-probleme)
### Berechtigung verweigert
[Section titled “Berechtigung verweigert”](#berechtigung-verweigert)
```typescript
const handlePermissionDenied = async () => {
const permission = await AudioRecorder.checkPermissions();
if (permission.recordAudio === 'denied') {
alert('Mikrofonberechtigung ist erforderlich, um Audio aufzunehmen. Bitte aktivieren Sie sie in den Einstellungen.');
}
};
```
### Aufnahme unterbrochen
[Section titled “Aufnahme unterbrochen”](#aufnahme-unterbrochen)
```typescript
// App im Hintergrund behandeln
document.addEventListener('pause', async () => {
const status = await recorder.getCurrentStatus();
if (status.isRecording) {
await recorder.pauseRecording();
// Benutzer benachrichtigen
}
});
```
### Speicherverwaltung
[Section titled “Speicherverwaltung”](#speicherverwaltung)
```typescript
const cleanupOldRecordings = async () => {
// Bereinigungslogik implementieren
// Aufnahmen löschen, die älter als X Tage sind
// Oder nur die letzten N Aufnahmen behalten
};
```
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
* Erkunden Sie die [API-Referenz](https://github.com/Cap-go/capacitor-audio-recorder#api) für vollständige Methodendokumentation
* Sehen Sie sich die [Beispiel-App](https://github.com/Cap-go/capacitor-audio-recorder/tree/main/example) für erweiterte Verwendung an
* Siehe das [Tutorial](/plugins/capacitor-audio-recorder) für vollständige Implementierungsbeispiele
# @capgo/capacitor-plugin-audiosession
> Hören Sie auf Audio-Routen-Änderungen, reagieren Sie auf Unterbrechungen und leiten Sie die Wiedergabe zum Lautsprecher um, ohne Capacitor zu verlassen.
Das AudioSession Plugin von Capgo gibt Ihnen eine feinkörnige Kontrolle über die iOS AVAudioSession-Ebene, sodass Sie Kopfhörer, Bluetooth-Geräte und unerwartete Unterbrechungen elegant handhaben können.
Routen-Awareness
Erkennen Sie, wenn Benutzer Headsets, AirPods, Bluetooth-Lautsprecher und mehr einstecken oder herausziehen.
Lautsprecher-Überschreibung
Erzwingen Sie die Wiedergabe über den eingebauten Lautsprecher, wenn Sie Freisprechton benötigen.
Unterbrechungsbehandlung
Reagieren Sie auf Unterbrechungsereignisse wie Telefonanrufe oder Siri, um Audio sicher zu pausieren und fortzusetzen.
Typsicherheit
Starke TypeScript-Definitionen erleichtern den Aufbau robuster Audio-Erlebnisse.
Dieses Plugin zielt auf iOS ab, wo AVAudioSession-Kontrolle erforderlich ist. Auf anderen Plattformen werden die Aufrufe ohne Auswirkung aufgelöst, sodass Sie einen gemeinsamen Code-Pfad beibehalten können.
# Erste Schritte
> Konfigurieren Sie das AudioSession Plugin, um auf iOS Audio-Route-Änderungen und Unterbrechungen zu reagieren.
> ℹ️ **Plattformunterstützung:** Die Audio-Session-API ist auf iOS verfügbar. Aufrufe auf Android und im Web werden ohne Auswirkung aufgelöst, sodass Sie gemeinsame Logik beibehalten können.
1. **Paket installieren**
* npm
```sh
npm i @capgo/capacitor-plugin-audiosession
```
* pnpm
```sh
pnpm add @capgo/capacitor-plugin-audiosession
```
* yarn
```sh
yarn add @capgo/capacitor-plugin-audiosession
```
* bun
```sh
bun add @capgo/capacitor-plugin-audiosession
```
2. **iOS-Plattform synchronisieren**
* npm
```sh
npx cap sync ios
```
* pnpm
```sh
pnpm cap sync ios
```
* yarn
```sh
yarn cap sync ios
```
* bun
```sh
bunx cap sync ios
```
## Verfügbare Ausgänge überprüfen
[Section titled “Verfügbare Ausgänge überprüfen”](#verfügbare-ausgänge-überprüfen)
```typescript
import { AudioSession, AudioSessionPorts } from '@capgo/capacitor-plugin-audiosession';
const outputs = await AudioSession.currentOutputs();
if (outputs.includes(AudioSessionPorts.BLUETOOTH_A2DP)) {
console.log('Bluetooth-Lautsprecher verbunden');
}
```
## Auf Lautsprecher-Modus umschalten
[Section titled “Auf Lautsprecher-Modus umschalten”](#auf-lautsprecher-modus-umschalten)
```typescript
import { AudioSession, OutputOverrideType } from '@capgo/capacitor-plugin-audiosession';
await AudioSession.overrideOutput(OutputOverrideType.speaker);
// System-Routing wiederherstellen, wenn Sie fertig sind
await AudioSession.overrideOutput(OutputOverrideType.default);
```
## Auf Routen- und Unterbrechungsereignisse hören
[Section titled “Auf Routen- und Unterbrechungsereignisse hören”](#auf-routen--und-unterbrechungsereignisse-hören)
```typescript
import { AudioSession, RouteChangeReasons, InterruptionTypes } from '@capgo/capacitor-plugin-audiosession';
const routeListener = await AudioSession.addListener('routeChanged', (reason) => {
if (reason === RouteChangeReasons.NEW_DEVICE_AVAILABLE) {
console.log('Benutzer hat eine neue Audio-Route verbunden');
}
});
const interruptionListener = await AudioSession.addListener('interruption', (type) => {
if (type === InterruptionTypes.BEGAN) {
// Wiedergabe während der Unterbrechung pausieren
} else {
// Wiedergabe fortsetzen
}
});
// Später während der Bereinigung
await routeListener.remove();
await interruptionListener.remove();
```
## Berechtigungen
[Section titled “Berechtigungen”](#berechtigungen)
* **iOS**: Fügen Sie alle erforderlichen Hintergrund-Audio-Modi (z.B. `audio`, `voice`) in `ios/App/App/Info.plist` hinzu, wenn Ihre App Audio im Hintergrund abspielt.
* **Andere Plattformen**: Keine zusätzliche Einrichtung erforderlich; Methoden werden mit leeren Ergebnissen aufgelöst.
# @capgo/capacitor-autofill-save-password
> Aktivieren Sie Passwort-Autofill und Anmeldedatenverwaltung mit Systemintegration für nahtlose Authentifizierungserlebnisse.
## Überblick
[Section titled “Überblick”](#überblick)
Das Capacitor Autofill Save Password Plugin bietet Passwort-Speicher- und Autofill-Funktionalität für Capacitor-Anwendungen. Dieses Plugin integriert sich mit der Anmeldedatenverwaltung auf Systemebene, um nahtlose Authentifizierungserlebnisse mit sicherer Passwortspeicherung und -abruf zu bieten.
Passwort-Speicherung
Anmeldedaten sicher im System-Keychain speichern 🔐
Autofill-Integration
Passwort-Autofill-Unterstützung auf Systemebene 🗝️
Plattformübergreifend
iOS-Unterstützung mit Android-Entwicklung in Arbeit 📱
Domain-Zuordnung
Associated Domains für nahtlose Authentifizierung ❤️
## Installation
[Section titled “Installation”](#installation)
```bash
npm install @capgo/capacitor-autofill-save-password
npx cap sync
```
## Plattformunterstützung
[Section titled “Plattformunterstützung”](#plattformunterstützung)
* **iOS**: Vollständige Unterstützung (funktioniert mit iOS 18.3 und älteren Versionen)
* **Android**: In Arbeit
## iOS-Konfiguration
[Section titled “iOS-Konfiguration”](#ios-konfiguration)
### 1. Associated Domains Einrichtung
[Section titled “1. Associated Domains Einrichtung”](#1-associated-domains-einrichtung)
Konfigurieren Sie Associated Domains in Ihrem Apple Developer Account und fügen Sie sie zu Ihrer `App.entitlements` Datei hinzu:
```xml
com.apple.developer.associated-domains
webcredentials:yourdomain.com
webcredentials:www.yourdomain.com
```
### 2. Web-Anmeldedaten-Konfiguration
[Section titled “2. Web-Anmeldedaten-Konfiguration”](#2-web-anmeldedaten-konfiguration)
Fügen Sie eine `.well-known/apple-app-site-association` Datei zu Ihrer Website hinzu:
```json
{
"webcredentials": {
"apps": [
"TEAMID.com.yourcompany.yourapp"
]
}
}
```
## Kern-API-Methoden
[Section titled “Kern-API-Methoden”](#kern-api-methoden)
### Passwortverwaltung
[Section titled “Passwortverwaltung”](#passwortverwaltung)
* `promptDialog(options)` - Passwort im System-Keychain speichern
* `readPassword()` - Gespeichertes Passwort aus Keychain lesen
## Verwendungsbeispiel
[Section titled “Verwendungsbeispiel”](#verwendungsbeispiel)
```typescript
import { SavePassword } from '@capgo/capacitor-autofill-save-password';
// Passwort nach erfolgreicher Anmeldung speichern
async function login(username: string, password: string) {
try {
// Führen Sie hier Ihre Anmeldelogik aus
const loginSuccess = await performLogin(username, password);
if (loginSuccess) {
// Benutzer zum Speichern des Passworts auffordern
await SavePassword.promptDialog({
username: username,
password: password,
url: 'https://yourdomain.com' // nur iOS
});
console.log('Passwort erfolgreich gespeichert');
}
} catch (error) {
console.error('Passwort konnte nicht gespeichert werden:', error);
}
}
// Gespeichertes Passwort für Autofill lesen
async function loadSavedCredentials() {
try {
const credentials = await SavePassword.readPassword();
if (credentials.username && credentials.password) {
console.log('Gespeicherte Anmeldedaten gefunden');
// Anmeldeformular vorab ausfüllen
return {
username: credentials.username,
password: credentials.password
};
}
} catch (error) {
console.error('Gespeichertes Passwort konnte nicht gelesen werden:', error);
}
return null;
}
```
## Android-Konfiguration (In Arbeit)
[Section titled “Android-Konfiguration (In Arbeit)”](#android-konfiguration-in-arbeit)
Für zukünftige Android-Unterstützung wird die folgende Konfiguration erforderlich sein:
### 1. Google Services Plugin
[Section titled “1. Google Services Plugin”](#1-google-services-plugin)
Fügen Sie zu `android/app/build.gradle` hinzu:
```kotlin
apply plugin: 'com.google.gms.google-services'
```
### 2. Domain-Konfiguration
[Section titled “2. Domain-Konfiguration”](#2-domain-konfiguration)
Fügen Sie zu `android/app/src/main/res/values/strings.xml` hinzu:
```xml
[{
"relation": ["delegate_permission/common.handle_all_urls"],
"target": {
"namespace": "web",
"site": "https://yourdomain.com"
}
}]
```
### 3. Google Services JSON
[Section titled “3. Google Services JSON”](#3-google-services-json)
Fügen Sie `google-services.json` zu Ihrem Android-Projekt hinzu.
## API-Referenz
[Section titled “API-Referenz”](#api-referenz)
### promptDialog(options)
[Section titled “promptDialog(options)”](#promptdialogoptions)
Speichert Benutzeranmeldedaten im System-Keychain.
```typescript
interface SavePasswordOptions {
username: string;
password: string;
url?: string; // Nur iOS - zugehörige Domain-URL
}
```
### readPassword()
[Section titled “readPassword()”](#readpassword)
Ruft gespeicherte Anmeldedaten aus dem System-Keychain ab.
```typescript
interface SavedCredentials {
username: string;
password: string;
}
```
## Integration mit dem Anmeldeablauf
[Section titled “Integration mit dem Anmeldeablauf”](#integration-mit-dem-anmeldeablauf)
```typescript
import { SavePassword } from '@capgo/capacitor-autofill-save-password';
class AuthService {
async login(username: string, password: string) {
try {
// Mit Ihrem Backend authentifizieren
const response = await fetch('/api/login', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ username, password })
});
if (response.ok) {
// Anmeldedaten zum Speichern anbieten
await this.offerToSavePassword(username, password);
return true;
}
} catch (error) {
console.error('Anmeldung fehlgeschlagen:', error);
}
return false;
}
private async offerToSavePassword(username: string, password: string) {
try {
await SavePassword.promptDialog({
username,
password,
url: 'https://yourdomain.com'
});
} catch (error) {
// Benutzer hat abgelehnt zu speichern oder Fehler aufgetreten
console.log('Passwort nicht gespeichert:', error);
}
}
async loadSavedCredentials() {
try {
return await SavePassword.readPassword();
} catch (error) {
console.log('Keine gespeicherten Anmeldedaten gefunden');
return null;
}
}
}
```
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
* Fordern Sie nur zum Speichern von Passwörtern nach erfolgreicher Authentifizierung auf
* Behandeln Sie Fälle, in denen Benutzer das Speichern von Passwörtern ablehnen, angemessen
* Implementieren Sie ordnungsgemäße Fehlerbehandlung für Keychain-Zugriffsfehler
* Verwenden Sie Associated Domains für nahtloses Web-App-Anmeldedaten-Sharing
* Testen Sie die Autofill-Funktionalität über verschiedene iOS-Versionen hinweg
## Sicherheitsüberlegungen
[Section titled “Sicherheitsüberlegungen”](#sicherheitsüberlegungen)
* Anmeldedaten werden im System-Keychain mit entsprechenden Sicherheitsflags gespeichert
* Associated Domains stellen sicher, dass Anmeldedaten nur für autorisierte Apps zugänglich sind
* Befolgen Sie die Plattform-Sicherheitsrichtlinien für die Anmeldedatenverwaltung
* Erwägen Sie die Implementierung zusätzlicher Sicherheitsmaßnahmen für sensible Anwendungen
## Einschränkungen
[Section titled “Einschränkungen”](#einschränkungen)
* Android-Unterstützung ist derzeit in Entwicklung
* iOS erfordert ordnungsgemäße Associated Domains-Konfiguration
* Autofill-Verhalten kann über verschiedene iOS-Versionen variieren
* Erfordert Benutzerzustimmung zum Speichern und Zugriff auf Anmeldedaten
## Dokumentation
[Section titled “Dokumentation”](#dokumentation)
Siehe die [vollständige Dokumentation](/docs/plugins/autofill-save-password/getting-started/) für detaillierte Implementierungsanleitungen und erweiterte Integrationsmuster.
# Erste Schritte
> Erfahren Sie, wie Sie das Autofill Save Password Plugin für nahtlose Passwortverwaltung in Ihrer Capacitor App installieren und konfigurieren.
## Installation
[Section titled “Installation”](#installation)
* npm
```bash
npm install @capgo/capacitor-autofill-save-password
npx cap sync
```
* yarn
```bash
yarn add @capgo/capacitor-autofill-save-password
npx cap sync
```
* pnpm
```bash
pnpm add @capgo/capacitor-autofill-save-password
npx cap sync
```
* bun
```bash
bun add @capgo/capacitor-autofill-save-password
npx cap sync
```
## Plattformunterstützung
[Section titled “Plattformunterstützung”](#plattformunterstützung)
* **iOS**: Vollständige Unterstützung (iOS 18.3 und ältere Versionen)
* **Android**: In Arbeit
## Plattform-Konfiguration
[Section titled “Plattform-Konfiguration”](#plattform-konfiguration)
### iOS
[Section titled “iOS”](#ios)
#### 1. Associated Domains Einrichtung
[Section titled “1. Associated Domains Einrichtung”](#1-associated-domains-einrichtung)
Konfigurieren Sie Associated Domains in Ihrem Apple Developer Account und fügen Sie sie zu Ihrer `App.entitlements` Datei hinzu:
```xml
com.apple.developer.associated-domains
webcredentials:yourdomain.com
webcredentials:www.yourdomain.com
```
#### 2. Web-Anmeldedaten-Konfiguration
[Section titled “2. Web-Anmeldedaten-Konfiguration”](#2-web-anmeldedaten-konfiguration)
Fügen Sie eine `.well-known/apple-app-site-association` Datei zu Ihrer Website hinzu:
```json
{
"webcredentials": {
"apps": [
"TEAMID.com.yourcompany.yourapp"
]
}
}
```
### Android (Zukünftige Unterstützung)
[Section titled “Android (Zukünftige Unterstützung)”](#android-zukünftige-unterstützung)
#### 1. Google Services Plugin
[Section titled “1. Google Services Plugin”](#1-google-services-plugin)
Fügen Sie zu `android/app/build.gradle` hinzu:
```kotlin
apply plugin: 'com.google.gms.google-services'
```
#### 2. Domain-Konfiguration
[Section titled “2. Domain-Konfiguration”](#2-domain-konfiguration)
Fügen Sie zu `android/app/src/main/res/values/strings.xml` hinzu:
```xml
[{
"relation": ["delegate_permission/common.handle_all_urls"],
"target": {
"namespace": "web",
"site": "https://yourdomain.com"
}
}]
```
## Verwendungsbeispiel
[Section titled “Verwendungsbeispiel”](#verwendungsbeispiel)
```typescript
import { SavePassword } from '@capgo/capacitor-autofill-save-password';
// Passwort nach erfolgreicher Anmeldung speichern
async function login(username: string, password: string) {
try {
// Führen Sie hier Ihre Anmeldelogik aus
const loginSuccess = await performLogin(username, password);
if (loginSuccess) {
// Benutzer zum Speichern des Passworts auffordern
await SavePassword.promptDialog({
username: username,
password: password,
url: 'https://yourdomain.com' // nur iOS
});
console.log('Passwort erfolgreich gespeichert');
}
} catch (error) {
console.error('Passwort konnte nicht gespeichert werden:', error);
}
}
// Gespeichertes Passwort für Autofill lesen
async function loadSavedCredentials() {
try {
const credentials = await SavePassword.readPassword();
if (credentials.username && credentials.password) {
console.log('Gespeicherte Anmeldedaten gefunden');
// Anmeldeformular vorab ausfüllen
return {
username: credentials.username,
password: credentials.password
};
}
} catch (error) {
console.error('Gespeichertes Passwort konnte nicht gelesen werden:', error);
}
return null;
}
```
## API-Referenz
[Section titled “API-Referenz”](#api-referenz)
### promptDialog(options)
[Section titled “promptDialog(options)”](#promptdialogoptions)
```typescript
promptDialog(options: SavePasswordOptions) => Promise
```
Speichert Benutzeranmeldedaten im System-Keychain.
| Parameter | Typ |
| ------------- | --------------------- |
| **`options`** | `SavePasswordOptions` |
### readPassword()
[Section titled “readPassword()”](#readpassword)
```typescript
readPassword() => Promise
```
Ruft gespeicherte Anmeldedaten aus dem System-Keychain ab.
**Rückgabewert:** `Promise`
## Schnittstellen
[Section titled “Schnittstellen”](#schnittstellen)
### SavePasswordOptions
[Section titled “SavePasswordOptions”](#savepasswordoptions)
| Eigenschaft | Typ | Beschreibung |
| -------------- | -------- | ------------------------------------------ |
| **`username`** | `string` | Der zu speichernde Benutzername |
| **`password`** | `string` | Das zu speichernde Passwort |
| **`url`** | `string` | Nur iOS - zugehörige Domain-URL (optional) |
### SavedCredentials
[Section titled “SavedCredentials”](#savedcredentials)
| Eigenschaft | Typ | Beschreibung |
| -------------- | -------- | ----------------------------- |
| **`username`** | `string` | Der gespeicherte Benutzername |
| **`password`** | `string` | Das gespeicherte Passwort |
## Integration mit dem Anmeldeablauf
[Section titled “Integration mit dem Anmeldeablauf”](#integration-mit-dem-anmeldeablauf)
```typescript
import { SavePassword } from '@capgo/capacitor-autofill-save-password';
class AuthService {
async login(username: string, password: string) {
try {
// Mit Ihrem Backend authentifizieren
const response = await fetch('/api/login', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ username, password })
});
if (response.ok) {
// Anmeldedaten zum Speichern anbieten
await this.offerToSavePassword(username, password);
return true;
}
} catch (error) {
console.error('Anmeldung fehlgeschlagen:', error);
}
return false;
}
private async offerToSavePassword(username: string, password: string) {
try {
await SavePassword.promptDialog({
username,
password,
url: 'https://yourdomain.com'
});
} catch (error) {
// Benutzer hat abgelehnt zu speichern oder Fehler aufgetreten
console.log('Passwort nicht gespeichert:', error);
}
}
async loadSavedCredentials() {
try {
return await SavePassword.readPassword();
} catch (error) {
console.log('Keine gespeicherten Anmeldedaten gefunden');
return null;
}
}
}
```
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
* Fordern Sie nur zum Speichern von Passwörtern nach erfolgreicher Authentifizierung auf
* Behandeln Sie Fälle, in denen Benutzer das Speichern von Passwörtern ablehnen, angemessen
* Implementieren Sie ordnungsgemäße Fehlerbehandlung für Keychain-Zugriffsfehler
* Verwenden Sie Associated Domains für nahtloses Web-App-Anmeldedaten-Sharing
* Testen Sie die Autofill-Funktionalität über verschiedene iOS-Versionen hinweg
## Sicherheitsüberlegungen
[Section titled “Sicherheitsüberlegungen”](#sicherheitsüberlegungen)
* Anmeldedaten werden im System-Keychain mit entsprechenden Sicherheitsflags gespeichert
* Associated Domains stellen sicher, dass Anmeldedaten nur für autorisierte Apps zugänglich sind
* Befolgen Sie die Plattform-Sicherheitsrichtlinien für die Anmeldedatenverwaltung
* Erwägen Sie die Implementierung zusätzlicher Sicherheitsmaßnahmen für sensible Anwendungen
# Background Geolocation
> Erhalten Sie genaue Standortaktualisierungen, auch wenn die App im Hintergrund läuft.
Genaue Verfolgung
Priorisiert Genauigkeit für Anwendungsfälle wie Wandern und Navigation 🎯
Hintergrund-Updates
Erhält weiterhin Standortaktualisierungen, auch wenn die App im Hintergrund ist 🏃
Akkueffizient
Optimiert, um Genauigkeit und Akkuverbrauch auszugleichen 🔋
Erste Schritte
Lesen Sie die [Erste Schritte Anleitung](/docs/plugins/background-geolocation/getting-started/), um das Plugin zu installieren und zu konfigurieren.
## Plugin-Vergleich
[Section titled “Plugin-Vergleich”](#plugin-vergleich)
Ein kurzer Vergleich zwischen den drei Haupt-Hintergrund-Geolokalisierungs-Plugins, die häufig in Capacitor Apps verwendet werden.
| Plugin | Genauigkeit | Hintergrund | HTTP Upload | Preisgestaltung |
| --------------------------------------------------------- | ----------- | ----------- | -------------------------------------------- | --------------- |
| `@capacitor-community/background-geolocation` (Community) | Nicht genau | Ja | Nein | Kostenlos |
| `@capgo/background-geolocation` (dieses Plugin) | Genau | Ja | Nein | Kostenlos |
| Transistorsoft (Original) | Genau | Ja | Ja — integrierter HTTP-Uploader zu Ihrer API | Kostenpflichtig |
**Hinweise:**
* Das Community-Plugin ist leichtgewichtig und funktioniert weiterhin im Hintergrund, ist aber bekanntermaßen weniger genau als die unten aufgeführten Optionen.
* Dieses Capgo-Plugin ist optimiert, um genaue Standortfixierungen und zuverlässigen Hintergrundbetrieb ohne kostenpflichtige Lizenz zu bieten.
* Transistorsoft bietet eine vollständige kommerzielle Lösung, die auch integrierte HTTP-Upload-Funktionen zum Senden von Standortdaten an Ihr Backend umfasst.
# Erste Schritte
> Erfahren Sie, wie Sie das Background Geolocation Plugin installieren und verwenden, um den Gerätestandort im Hintergrund zu verfolgen.
## Installation
[Section titled “Installation”](#installation)
Dieses Plugin unterstützt Capacitor v7:
| Capacitor | Plugin |
| --------- | ------ |
| v7 | v7 |
* npm
```bash
npm install @capgo/background-geolocation
npx cap update
```
* yarn
```bash
yarn add @capgo/background-geolocation
npx cap update
```
* pnpm
```bash
pnpm add @capgo/background-geolocation
npx cap update
```
* bun
```bash
bun add @capgo/background-geolocation
npx cap update
```
## Plattform-Einrichtung
[Section titled “Plattform-Einrichtung”](#plattform-einrichtung)
### iOS
[Section titled “iOS”](#ios)
Fügen Sie die folgenden Schlüssel zu `Info.plist.` hinzu:
```xml
...
NSLocationWhenInUseUsageDescription
Wir müssen Ihren Standort verfolgen
NSLocationAlwaysAndWhenInUseUsageDescription
Wir müssen Ihren Standort verfolgen, während Ihr Gerät gesperrt ist.
UIBackgroundModes
location
...
```
### Android
[Section titled “Android”](#android)
Setzen Sie die Option `android.useLegacyBridge` in Ihrer Capacitor-Konfiguration auf `true`. Dies verhindert, dass Standortaktualisierungen nach 5 Minuten im Hintergrund anhalten. Siehe und .
Ab Android 13+ benötigt die App die Laufzeitberechtigung `POST_NOTIFICATIONS`, um die dauerhafte Benachrichtigung anzuzeigen, die den Benutzer darüber informiert, dass sein Standort im Hintergrund verwendet wird. Diese Laufzeitberechtigung wird nach Erteilung der Standortberechtigung angefordert.
Wenn Ihre App Standortaktualisierungen in Echtzeit an einen Server weiterleitet, beachten Sie, dass Android nach 5 Minuten im Hintergrund HTTP-Anfragen drosselt, die von der WebView initiiert werden. Die Lösung besteht darin, ein natives HTTP-Plugin wie [CapacitorHttp](https://capacitorjs.com/docs/apis/http) zu verwenden. Siehe .
Android-spezifische Konfiguration kann in `strings.xml` vorgenommen werden:
```xml
Background Tracking
drawable/ic_tracking
yellow
```
## Verwendung
[Section titled “Verwendung”](#verwendung)
```javascript
import { BackgroundGeolocation } from "@capgo/background-geolocation";
BackgroundGeolocation.start(
{
backgroundMessage: "Abbrechen, um Akkuverbrauch zu verhindern.",
backgroundTitle: "Verfolge Sie.",
requestPermissions: true,
stale: false,
distanceFilter: 50
},
(location, error) => {
if (error) {
if (error.code === "NOT_AUTHORIZED") {
if (window.confirm(
"Diese App benötigt Ihren Standort, " +
"hat aber keine Berechtigung.\n\n" +
"Einstellungen jetzt öffnen?"
)) {
// Es kann nützlich sein, den Benutzer zu den Einstellungen seines Geräts
// zu leiten, wenn Standortberechtigungen verweigert wurden. Das
// Plugin bietet die 'openSettings' Methode, um genau
// dies zu tun.
BackgroundGeolocation.openSettings();
}
}
return console.error(error);
}
return console.log(location);
}
).then(() => {
// Wenn Standortaktualisierungen nicht mehr benötigt werden, sollte das Plugin durch Aufruf gestoppt werden
BackgroundGeolocation.stop();
});
// Setzen Sie eine geplante Route, um einen Benachrichtigungston zu erhalten, wenn ein neuer Standort ankommt und nicht auf der Route liegt:
BackgroundGeolocation.setPlannedRoute({soundFile: "assets/myFile.mp3", route: [[1,2], [3,4]], distance: 30 });
// Wenn Sie nur den aktuellen Standort wollen, versuchen Sie etwas wie dies. Je länger
// das Timeout, desto genauer wird die Schätzung sein. Ich würde nicht unter ca. 100ms gehen.
function guessLocation(callback, timeout) {
let last_location;
BackgroundGeolocation.start(
{
requestPermissions: false,
stale: true
},
(location) => {
last_location = location || undefined;
}
).then(() => {
setTimeout(() => {
callback(last_location);
BackgroundGeolocation.stop();
}, timeout);
});
}
```
## API
[Section titled “API”](#api)
### start(…)
[Section titled “start(…)”](#start)
```typescript
start(options: StartOptions, callback: (position?: Location | undefined, error?: CallbackError | undefined) => void) => Promise
```
Um mit dem Lauschen auf Änderungen am Standort des Geräts zu beginnen, rufen Sie diese Methode auf. Ein Promise wird zurückgegeben, um anzuzeigen, dass der Aufruf abgeschlossen wurde. Der Callback wird jedes Mal aufgerufen, wenn ein neuer Standort verfügbar ist, oder wenn bei Aufruf dieser Methode ein Fehler aufgetreten ist. Verlassen Sie sich nicht auf Promise-Ablehnung dafür.
| Parameter | Typ | Beschreibung |
| -------------- | ------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------- |
| **`options`** | `StartOptions` | Die Konfigurationsoptionen |
| **`callback`** | `(position?: Location, error?: CallbackError) => void` | Die Callback-Funktion, die aufgerufen wird, wenn ein neuer Standort verfügbar ist oder ein Fehler auftritt |
### stop()
[Section titled “stop()”](#stop)
```typescript
stop() => Promise
```
Stoppt Standortaktualisierungen.
### openSettings()
[Section titled “openSettings()”](#opensettings)
```typescript
openSettings() => Promise
```
Öffnet die Standorteinstellungsseite des Geräts. Nützlich, um Benutzer zu leiten, Standortdienste zu aktivieren oder Berechtigungen anzupassen.
### setPlannedRoute(…)
[Section titled “setPlannedRoute(…)”](#setplannedroute)
```typescript
setPlannedRoute(options: SetPlannedRouteOptions) => Promise
```
Spielt eine Audiodatei ab, wenn der Benutzer von der geplanten Route abweicht. Dies sollte verwendet werden, um einen Ton abzuspielen (auch im Hintergrund, nur für native).
| Parameter | Typ | Beschreibung |
| ------------- | ------------------------ | ------------------------------------------------------------- |
| **`options`** | `SetPlannedRouteOptions` | Die Optionen zum Festlegen der geplanten Route und Audiodatei |
## Schnittstellen
[Section titled “Schnittstellen”](#schnittstellen)
### StartOptions
[Section titled “StartOptions”](#startoptions)
Die Optionen zum Konfigurieren von Standortaktualisierungen.
| Eigenschaft | Typ | Beschreibung | Standard |
| ------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------- |
| **`backgroundMessage`** | `string` | Wenn die Option “backgroundMessage” definiert ist, stellt das Plugin Standortaktualisierungen bereit, egal ob die App im Hintergrund oder Vordergrund ist. Wenn es nicht definiert ist, werden Standortaktualisierungen nur im Vordergrund garantiert. Dies gilt für beide Plattformen. Auf Android muss eine Benachrichtigung angezeigt werden, um Standortaktualisierungen im Hintergrund weiter zu erhalten. Diese Option gibt den Text dieser Benachrichtigung an. | |
| **`backgroundTitle`** | `string` | Der Titel der oben genannten Benachrichtigung. | `"Using your location"` |
| **`requestPermissions`** | `boolean` | Ob Berechtigungen automatisch vom Benutzer angefordert werden sollen, wenn sie nicht bereits erteilt wurden. | `true` |
| **`stale`** | `boolean` | Wenn “true”, können veraltete Standorte geliefert werden, während das Gerät eine GPS-Fixierung erhält. Sie sind dafür verantwortlich, die “time” Eigenschaft zu überprüfen. Wenn “false”, sind Standorte garantiert aktuell. | `false` |
| **`distanceFilter`** | `number` | Die Entfernung in Metern, die sich das Gerät bewegen muss, bevor eine neue Standortaktualisierung ausgelöst wird. Dies wird verwendet, um kleine Bewegungen herauszufiltern und die Anzahl der Aktualisierungen zu reduzieren. | `0` |
### Location
[Section titled “Location”](#location)
Repräsentiert einen geografischen Standort mit verschiedenen Attributen. Enthält alle standardmäßigen Standorteigenschaften, die von GPS/Netzwerkanbietern zurückgegeben werden.
| Eigenschaft | Typ | Beschreibung |
| ---------------------- | ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **`latitude`** | `number` | Breitengrad in Grad. Bereich: -90.0 bis +90.0 |
| **`longitude`** | `number` | Längengrad in Grad. Bereich: -180.0 bis +180.0 |
| **`accuracy`** | `number` | Radius der horizontalen Unsicherheit in Metern, mit 68% Konfidenz. Niedrigere Werte zeigen einen genaueren Standort an. |
| **`altitude`** | `number \| null` | Meter über dem Meeresspiegel (oder null, wenn nicht verfügbar). |
| **`altitudeAccuracy`** | `number \| null` | Vertikale Unsicherheit in Metern, mit 68% Konfidenz (oder null, wenn nicht verfügbar). |
| **`simulated`** | `boolean` | `true`, wenn der Standort durch Software simuliert wurde, anstatt durch GPS. Nützlich zum Erkennen von Mock-Standorten in der Entwicklung oder beim Testen. |
| **`bearing`** | `number \| null` | Abweichung vom wahren Norden in Grad (oder null, wenn nicht verfügbar). Bereich: 0.0 bis 360.0 |
| **`speed`** | `number \| null` | Geschwindigkeit in Metern pro Sekunde (oder null, wenn nicht verfügbar). |
| **`time`** | `number \| null` | Zeit, zu der der Standort produziert wurde, in Millisekunden seit der Unix-Epoche. Verwenden Sie dies, um zu prüfen, ob ein Standort veraltet ist, wenn stale: true verwendet wird. |
### CallbackError
[Section titled “CallbackError”](#callbackerror)
Fehlerobjekt, das möglicherweise an den Standort-Start-Callback übergeben wird. Erweitert den Standard-Error mit optionalen Fehlercodes.
| Eigenschaft | Typ | Beschreibung |
| ----------- | -------- | --------------------------------------------------------- |
| **`code`** | `string` | Optionaler Fehlercode für spezifischere Fehlerbehandlung. |
### SetPlannedRouteOptions
[Section titled “SetPlannedRouteOptions”](#setplannedrouteoptions)
| Eigenschaft | Typ | Beschreibung | Standard |
| --------------- | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- |
| **`soundFile`** | `string` | Der Name der abzuspielenden Audiodatei. Muss ein gültiger relativer Pfad im öffentlichen Ordner der App sein, um sowohl für Web- als auch für native Plattformen zu funktionieren. Es ist nicht erforderlich, den öffentlichen Ordner im Pfad anzugeben. | |
| **`route`** | `[number, number][]` | Die geplante Route als Array von Längen- und Breitengradpaaren. Jedes Paar repräsentiert einen Punkt auf der Route. Dies wird verwendet, um eine Route zu definieren, der der Benutzer folgen kann. Die Route wird verwendet, um einen Ton abzuspielen, wenn der Benutzer davon abweicht. | |
| **`distance`** | `number` | Die Entfernung in Metern, die der Benutzer von der geplanten Route abweichen muss, um den Ton auszulösen. Dies wird verwendet, um zu bestimmen, wie weit der Benutzer von der Route entfernt sein kann, bevor der Ton abgespielt wird. Wenn nicht angegeben, wird ein Standardwert von 50 Metern verwendet. | `50` |
# @capgo/capacitor-barometer
> Zugriff auf barometrischen Druck und Höhendaten von Gerätesensoren für Wetter- und Fitness-Anwendungen.
Drucküberwachung
Echtzeit-Messungen des atmosphärischen Drucks
Höhenberechnung
Relative Höhe aus Druckänderungen ableiten
Event-Listener
Auf Druckänderungsereignisse abonnieren
Plattformübergreifend
Funktioniert auf iOS- und Android-Geräten mit Barometer-Sensoren
Erste Schritte
Schauen Sie sich die [Erste Schritte Anleitung](/docs/plugins/barometer/getting-started/) an, um das Plugin zu installieren und zu konfigurieren.
# Erste Schritte
> Erfahren Sie, wie Sie die Barometer-Messung in Ihre Capacitor App integrieren
Diese Anleitung führt Sie durch die Integration des Capacitor Barometer Plugins in Ihre Anwendung.
## Installation
[Section titled “Installation”](#installation)
Installieren Sie das Plugin mit npm:
```bash
npm install @capgo/capacitor-barometer
npx cap sync
```
## iOS-Konfiguration
[Section titled “iOS-Konfiguration”](#ios-konfiguration)
Fügen Sie Folgendes zu Ihrer `Info.plist` hinzu:
```xml
NSMotionUsageDescription
Diese App nutzt das Barometer, um den atmosphärischen Druck zu messen
```
## Android-Konfiguration
[Section titled “Android-Konfiguration”](#android-konfiguration)
Keine zusätzliche Konfiguration erforderlich. Das Plugin fordert automatisch die notwendigen Berechtigungen an.
## Grundlegende Verwendung
[Section titled “Grundlegende Verwendung”](#grundlegende-verwendung)
### Plugin importieren
[Section titled “Plugin importieren”](#plugin-importieren)
```typescript
import { Barometer } from '@capgo/capacitor-barometer';
```
### Sensorverfügbarkeit prüfen
[Section titled “Sensorverfügbarkeit prüfen”](#sensorverfügbarkeit-prüfen)
```typescript
const checkBarometer = async () => {
const { available } = await Barometer.isAvailable();
console.log('Barometer verfügbar:', available);
};
```
### Drucküberwachung starten
[Section titled “Drucküberwachung starten”](#drucküberwachung-starten)
```typescript
const startMonitoring = async () => {
await Barometer.start({
interval: 1000 // Aktualisierungsintervall in Millisekunden
});
console.log('Barometer-Überwachung gestartet');
};
```
### Auf Druckereignisse lauschen
[Section titled “Auf Druckereignisse lauschen”](#auf-druckereignisse-lauschen)
```typescript
Barometer.addListener('pressureChange', (data) => {
console.log('Druck (hPa):', data.pressure);
console.log('Relative Höhe (m):', data.relativeAltitude);
console.log('Zeitstempel:', data.timestamp);
});
```
### Aktuelle Messung abrufen
[Section titled “Aktuelle Messung abrufen”](#aktuelle-messung-abrufen)
```typescript
const getCurrentPressure = async () => {
const reading = await Barometer.getCurrentReading();
console.log('Aktueller Druck:', reading.pressure, 'hPa');
console.log('Relative Höhe:', reading.relativeAltitude, 'm');
};
```
### Überwachung stoppen
[Section titled “Überwachung stoppen”](#überwachung-stoppen)
```typescript
const stopMonitoring = async () => {
await Barometer.stop();
console.log('Barometer-Überwachung gestoppt');
};
```
## Vollständiges Beispiel
[Section titled “Vollständiges Beispiel”](#vollständiges-beispiel)
Hier ist ein vollständiges Beispiel zur Barometer-Integration:
```typescript
import { Barometer } from '@capgo/capacitor-barometer';
class BarometerService {
private listener: any;
async initialize() {
// Verfügbarkeit prüfen
const { available } = await Barometer.isAvailable();
if (!available) {
console.error('Barometer auf diesem Gerät nicht verfügbar');
return;
}
// Überwachung starten
await Barometer.start({ interval: 1000 });
// Listener hinzufügen
this.listener = Barometer.addListener('pressureChange', (data) => {
this.handlePressureChange(data);
});
}
handlePressureChange(data: any) {
console.log('Druck:', data.pressure, 'hPa');
console.log('Höhe:', data.relativeAltitude, 'm');
// UI aktualisieren oder Daten verarbeiten
this.updateDisplay(data);
}
updateDisplay(data: any) {
// hPa in andere Einheiten umrechnen
const inHg = (data.pressure * 0.02953).toFixed(2);
const mmHg = (data.pressure * 0.750062).toFixed(1);
console.log(`Druck: ${data.pressure.toFixed(1)} hPa`);
console.log(` ${inHg} inHg`);
console.log(` ${mmHg} mmHg`);
console.log(`Höhe: ${data.relativeAltitude.toFixed(1)} m`);
}
async cleanup() {
// Listener entfernen
if (this.listener) {
this.listener.remove();
}
// Überwachung stoppen
await Barometer.stop();
}
}
// Verwendung
const barometerService = new BarometerService();
barometerService.initialize();
// Aufräumen wenn fertig
// barometerService.cleanup();
```
## Messwerte verstehen
[Section titled “Messwerte verstehen”](#messwerte-verstehen)
### Atmosphärischer Druck
[Section titled “Atmosphärischer Druck”](#atmosphärischer-druck)
* Gemessen in Hektopascal (hPa) oder Millibar (mb)
* Standard-Meeresspiegel-Druck: 1013,25 hPa
* Höhere Höhe = niedrigerer Druck
* Wettersysteme beeinflussen Druckmessungen
### Relative Höhe
[Section titled “Relative Höhe”](#relative-höhe)
* Berechnet aus Druckänderungen
* Relativ zum Startbezugspunkt
* Genauigkeit: ±10-30 Meter
* Funktioniert am besten für kurzfristige Verfolgung
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
1. **Verfügbarkeit prüfen**: Immer Sensorverfügbarkeit vor Verwendung überprüfen
2. **Angemessene Intervalle**: Nicht zu häufig abfragen (1000ms ist gut)
3. **Listener entfernen**: Listener aufräumen, wenn nicht benötigt
4. **Kalibrierung**: Bekannte Höhe für genaue Messungen verwenden
5. **Akkuauswirkung**: Akkuverbrauch bei kontinuierlicher Messung überwachen
## Häufige Probleme
[Section titled “Häufige Probleme”](#häufige-probleme)
### Sensor nicht verfügbar
[Section titled “Sensor nicht verfügbar”](#sensor-nicht-verfügbar)
```typescript
try {
const { available } = await Barometer.isAvailable();
if (!available) {
// Auf GPS-Höhe oder manuelle Eingabe zurückfallen
showAlternativeMethod();
}
} catch (error) {
console.error('Barometer-Prüfung fehlgeschlagen:', error);
}
```
### Verrauschte Daten
[Section titled “Verrauschte Daten”](#verrauschte-daten)
```typescript
class PressureFilter {
private readings: number[] = [];
private maxReadings = 5;
addReading(pressure: number): number {
this.readings.push(pressure);
if (this.readings.length > this.maxReadings) {
this.readings.shift();
}
// Gleitenden Durchschnitt zurückgeben
const sum = this.readings.reduce((a, b) => a + b, 0);
return sum / this.readings.length;
}
}
```
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
* Erkunden Sie die [API-Referenz](https://github.com/Cap-go/capacitor-barometer#api) für die vollständige Methodendokumentation
* Schauen Sie sich die [Beispiel-App](https://github.com/Cap-go/capacitor-barometer/tree/main/example) für erweiterte Verwendung an
* Sehen Sie das [Tutorial](/plugins/capacitor-barometer) für vollständige Implementierungsbeispiele
# @capgo/camera-preview
> Zeigen Sie Kameravorschau in Ihrer App mit voller Kontrolle über Kameraeinstellungen an, nehmen Sie Fotos und Videos direkt aus der Vorschau auf.
Echtzeit-Vorschau
Zeigen Sie Live-Kamera-Feed direkt in Ihrer App-UI an
Volle Kontrolle
Steuern Sie Blitz, Zoom, Fokus und wechseln Sie zwischen Kameras
Aufnahmefähigkeiten
Machen Sie Fotos und nehmen Sie Videos aus der Vorschau auf
Umfassende Dokumentation
Schauen Sie sich die [Dokumentation](/docs/plugins/camera-preview/getting-started/) an, um das Plugin in nur wenigen Minuten zu meistern.
# Erste Schritte
> Erfahren Sie, wie Sie das Camera Preview Plugin installieren und verwenden, um Echtzeit-Kamera-Feeds anzuzeigen und Fotos/Videos in Ihrer Capacitor App aufzunehmen.
1. **Paket installieren**
* npm
```sh
npm i @capgo/camera-preview
```
* pnpm
```sh
pnpm add @capgo/camera-preview
```
* yarn
```sh
yarn add @capgo/camera-preview
```
* bun
```sh
bun add @capgo/camera-preview
```
2. **Mit nativen Projekten synchronisieren**
* npm
```sh
npx cap sync
```
* pnpm
```sh
pnpm cap sync
```
* yarn
```sh
yarn cap sync
```
* bun
```sh
bunx cap sync
```
3. **Berechtigungen konfigurieren**
### iOS
[Section titled “iOS”](#ios)
Fügen Sie die Kamera-Nutzungsbeschreibung zu Ihrer `Info.plist` hinzu:
```xml
NSCameraUsageDescription
Um Fotos und Videos aufzunehmen
NSMicrophoneUsageDescription
Um Audio mit Videos aufzunehmen
NSPhotoLibraryUsageDescription
Um Fotos und Videos zu speichern
```
### Android
[Section titled “Android”](#android)
Fügen Sie Kamera-Berechtigungen zu Ihrer `AndroidManifest.xml` hinzu:
```xml
```
## Verwendung
[Section titled “Verwendung”](#verwendung)
Importieren Sie das Plugin und verwenden Sie seine Methoden zur Steuerung der Kamera:
```typescript
import { CameraPreview } from '@capgo/camera-preview';
import { CameraPreviewOptions, CameraPreviewPictureOptions } from '@capgo/camera-preview';
// Kameravorschau starten
const startCamera = async () => {
const cameraPreviewOptions: CameraPreviewOptions = {
position: 'rear',
height: 1920,
width: 1080,
quality: 50,
toBack: false,
paddingBottom: 0,
rotateWhenOrientationChanged: true,
x: 0,
y: 0
};
await CameraPreview.start(cameraPreviewOptions);
};
// Kameravorschau stoppen
const stopCamera = async () => {
await CameraPreview.stop();
};
// Foto aufnehmen
const takePicture = async () => {
const pictureOptions: CameraPreviewPictureOptions = {
quality: 90,
width: 1920,
height: 1080
};
const result = await CameraPreview.capture(pictureOptions);
const base64PictureData = result.value;
// Base64-Bilddaten verwenden
console.log(base64PictureData);
};
// Kamera wechseln
const flipCamera = async () => {
await CameraPreview.flip();
};
// Blitz steuern
const setFlashMode = async (mode: 'on' | 'off' | 'auto' | 'torch') => {
await CameraPreview.setFlashMode({ flashMode: mode });
};
// Videoaufnahme starten
const startRecording = async () => {
await CameraPreview.startRecordVideo({
storeToFile: true,
fileName: 'myvideo'
});
};
// Aufnahme stoppen
const stopRecording = async () => {
const result = await CameraPreview.stopRecordVideo();
console.log('Videopfad:', result.videoFilePath);
};
```
## API-Referenz
[Section titled “API-Referenz”](#api-referenz)
### start(options)
[Section titled “start(options)”](#startoptions)
Startet die Kameravorschau.
```typescript
interface CameraPreviewOptions {
position?: 'rear' | 'front';
height?: number;
width?: number;
x?: number;
y?: number;
toBack?: boolean;
paddingBottom?: number;
rotateWhenOrientationChanged?: boolean;
storeToFile?: boolean;
disableExifHeaderStripping?: boolean;
enableHighResolution?: boolean;
disableAudio?: boolean;
lockAndroidOrientation?: boolean;
enableOpacity?: boolean;
enableZoom?: boolean;
}
```
### stop()
[Section titled “stop()”](#stop)
Stoppt die Kameravorschau.
### capture(options)
[Section titled “capture(options)”](#captureoptions)
Macht ein Foto und gibt es als Base64-codierten String zurück.
```typescript
interface CameraPreviewPictureOptions {
height?: number;
width?: number;
quality?: number;
}
```
### flip()
[Section titled “flip()”](#flip)
Wechselt zwischen Front- und Rückkamera.
### setFlashMode(options)
[Section titled “setFlashMode(options)”](#setflashmodeoptions)
Setzt den Blitzmodus.
```typescript
interface CameraPreviewFlashMode {
flashMode: 'off' | 'on' | 'auto' | 'torch';
}
```
### startRecordVideo(options)
[Section titled “startRecordVideo(options)”](#startrecordvideooptions)
Startet die Videoaufnahme.
```typescript
interface CameraPreviewVideoOptions {
storeToFile?: boolean;
fileName?: string;
width?: number;
height?: number;
quality?: number;
withFlash?: boolean;
}
```
### stopRecordVideo()
[Section titled “stopRecordVideo()”](#stoprecordvideo)
Stoppt die Videoaufnahme und gibt den Videopfad zurück.
## Erweiterte Funktionen
[Section titled “Erweiterte Funktionen”](#erweiterte-funktionen)
### Fokussteuerung
[Section titled “Fokussteuerung”](#fokussteuerung)
```typescript
// Fokus setzen
await CameraPreview.setFocusCoordinate({
x: 100,
y: 100
});
// Unterstützte Fokusmodi abrufen
const focusModes = await CameraPreview.getFocusModes();
// Fokusmodus setzen
await CameraPreview.setFocusMode({
focusMode: 'continuous-picture'
});
```
### Zoomsteuerung
[Section titled “Zoomsteuerung”](#zoomsteuerung)
```typescript
// Maximalen Zoom abrufen
const maxZoom = await CameraPreview.getMaxZoom();
// Zoom setzen
await CameraPreview.setZoom({
zoom: 2.0
});
// Aktuellen Zoom abrufen
const currentZoom = await CameraPreview.getZoom();
```
### Belichtungssteuerung
[Section titled “Belichtungssteuerung”](#belichtungssteuerung)
```typescript
// Belichtungskorrekturbereich abrufen
const range = await CameraPreview.getExposureCompensationRange();
// Belichtungskorrektur setzen
await CameraPreview.setExposureCompensation({
exposureCompensation: 0.5
});
```
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
1. **Berechtigungen zuerst anfordern**
```typescript
import { Camera } from '@capacitor/camera';
const requestPermissions = async () => {
const permissions = await Camera.requestPermissions();
if (permissions.camera === 'granted') {
// Kameravorschau starten
}
};
```
2. **Orientierungsänderungen handhaben** Setzen Sie `rotateWhenOrientationChanged: true`, um die Vorschau automatisch anzupassen.
3. **Leistung optimieren**
* Verwenden Sie angemessene Auflösungseinstellungen
* Stoppen Sie die Vorschau, wenn sie nicht verwendet wird
* Deaktivieren Sie Funktionen, die Sie nicht benötigen
4. **Fehlerbehandlung**
```typescript
try {
await CameraPreview.start(options);
} catch (error) {
console.error('Kamera konnte nicht gestartet werden:', error);
}
```
## Plattform-Hinweise
[Section titled “Plattform-Hinweise”](#plattform-hinweise)
### iOS
[Section titled “iOS”](#ios-1)
* Erfordert iOS 10.0+
* Verwendet AVFoundation Framework
* Hardware-Beschleunigung unterstützt
### Android
[Section titled “Android”](#android-1)
* Erfordert Android 5.0 (API 21)+
* Verwendet Camera2 API
* Unterstützt verschiedene Kamerafunktionen basierend auf Gerätefähigkeiten
# Capacitor+
> Capacitor+ ist ein automatisierter Fork von Capacitor, der Community-PRs schneller merged, mit sicherheitsgeprüften Releases.
Tip
**Warum Capacitor+?** Großartige PRs liegen monatelang ungemergt im offiziellen Capacitor-Repository. Capacitor+ merged diese Community-Beiträge aktiv, damit Sie nicht warten müssen.
Community-PRs schneller gemergt
Bug-Fixes und Features stecken in Upstream fest? Wir mergen sie, damit Sie sofort profitieren können.
Täglich automatisch synchronisiert
Jede Änderung vom offiziellen Capacitor wird automatisch abgerufen, getestet und verifiziert.
Sicherheitsgeprüft
Jedes Release wird von KI auf Sicherheitslücken, Breaking Changes und Stabilitätsrisiken analysiert.
Drop-in-Ersatz
Gleiche API wie offizielles Capacitor - ändern Sie einfach den Paket-Scope und fertig.
## Philosophie
[Section titled “Philosophie”](#philosophie)
Das Ionic-Team wartet Capacitor mit ihren eigenen Prioritäten und Release-Zeitplänen. Community-Beiträge können Monate oder sogar Jahre warten, bis sie gemergt werden. Capacitor+ verfolgt einen anderen Ansatz:
1. **PRs von Forks mergen** - Wertvolle PRs, die in der Upstream-Warteschlange feststecken, werden aktiv gemergt
2. **Kontinuierliche Synchronisierung** - Jede Upstream-Änderung wird automatisch abgerufen und getestet
3. **Schnelle Releases** - Änderungen werden auf npm veröffentlicht, sobald sie CI bestehen
4. **Community-First** - Ihre Beiträge zählen und werden priorisiert
5. **Transparenz** - Alle Automatisierung ist Open Source und sichtbar
## Pakete
[Section titled “Pakete”](#pakete)
| Paket | npm |
| ------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| `@capacitor-plus/core` | [](https://www.npmjs.com/package/@capacitor-plus/core) |
| `@capacitor-plus/cli` | [](https://www.npmjs.com/package/@capacitor-plus/cli) |
| `@capacitor-plus/android` | [](https://www.npmjs.com/package/@capacitor-plus/android) |
| `@capacitor-plus/ios` | [](https://www.npmjs.com/package/@capacitor-plus/ios) |
# Erste Schritte
> Erfahren Sie, wie Sie Capacitor+ als Drop-in-Ersatz für offizielle Capacitor-Pakete installieren.
## Installation für neue Projekte
[Section titled “Installation für neue Projekte”](#installation-für-neue-projekte)
1. **Kernpakete installieren**
```bash
npm install @capacitor-plus/core @capacitor-plus/cli
```
2. **Plattformpakete hinzufügen**
```bash
npm install @capacitor-plus/android # für Android
npm install @capacitor-plus/ios # für iOS
```
3. **Capacitor initialisieren**
* npm
```sh
npx cap init
```
* pnpm
```sh
pnpm cap init
```
* yarn
```sh
yarn cap init
```
* bun
```sh
bunx cap init
```
4. **Plattformen hinzufügen**
* npm
```sh
npx cap add android
```
* pnpm
```sh
pnpm cap add android
```
* yarn
```sh
yarn cap add android
```
* bun
```sh
bunx cap add android
```
- npm
```sh
npx cap add ios
```
- pnpm
```sh
pnpm cap add ios
```
- yarn
```sh
yarn cap add ios
```
- bun
```sh
bunx cap add ios
```
## Migration von offiziellem Capacitor
[Section titled “Migration von offiziellem Capacitor”](#migration-von-offiziellem-capacitor)
Wenn Sie ein bestehendes Capacitor-Projekt haben, ist die Migration zu Capacitor+ einfach:
1. **Offizielle Pakete entfernen**
```bash
npm uninstall @capacitor/core @capacitor/cli @capacitor/android @capacitor/ios
```
2. **Capacitor+ Pakete installieren**
```bash
npm install @capacitor-plus/core @capacitor-plus/cli
npm install @capacitor-plus/android # wenn Android verwendet wird
npm install @capacitor-plus/ios # wenn iOS verwendet wird
```
3. **Projekt synchronisieren**
* npm
```sh
npx cap sync
```
* pnpm
```sh
pnpm cap sync
```
* yarn
```sh
yarn cap sync
```
* bun
```sh
bunx cap sync
```
Note
Keine Code-Änderungen erforderlich! Capacitor+ hat die gleiche API wie offizielles Capacitor. Ihre Imports und Ihr Code bleiben genau gleich.
## Verwendung
[Section titled “Verwendung”](#verwendung)
Da Capacitor+ API-kompatibel ist, funktioniert Ihr bestehender Code ohne Änderungen:
```typescript
import { Capacitor } from '@capacitor/core';
import { registerPlugin } from '@capacitor/core';
// Plattform prüfen
const platform = Capacitor.getPlatform();
console.log('Läuft auf:', platform);
// Prüfen ob nativ
if (Capacitor.isNativePlatform()) {
console.log('Läuft auf nativer Plattform');
}
// Eigenes Plugin registrieren
const MyPlugin = registerPlugin('MyPlugin');
```
### Mit offiziellen Capacitor Plugins
[Section titled “Mit offiziellen Capacitor Plugins”](#mit-offiziellen-capacitor-plugins)
Alle offiziellen Capacitor Plugins funktionieren nahtlos:
```typescript
import { Camera, CameraResultType } from '@capacitor/camera';
import { Geolocation } from '@capacitor/geolocation';
import { Storage } from '@capacitor/preferences';
// Kamera
const photo = await Camera.getPhoto({
quality: 90,
resultType: CameraResultType.Uri
});
// Geolokalisierung
const position = await Geolocation.getCurrentPosition();
// Speicher
await Storage.set({ key: 'name', value: 'John' });
```
### Mit Capgo Plugins
[Section titled “Mit Capgo Plugins”](#mit-capgo-plugins)
Capgo Plugins funktionieren perfekt mit Capacitor+:
```typescript
import { CapacitorUpdater } from '@capgo/capacitor-updater';
import { ScreenOrientation } from '@capgo/capacitor-screen-orientation';
import { CapacitorFlash } from '@capgo/capacitor-flash';
// Live-Updates
await CapacitorUpdater.notifyAppReady();
// Bildschirmorientierung
await ScreenOrientation.lock({ orientation: 'portrait' });
// Taschenlampe
await CapacitorFlash.toggle();
```
## Wie die Synchronisierung funktioniert
[Section titled “Wie die Synchronisierung funktioniert”](#wie-die-synchronisierung-funktioniert)
```plaintext
┌─────────────────────┐ ┌──────────────────┐ ┌──────────────────┐ ┌─────────────────┐
│ ionic-team/ │ │ CI/CD │ │ Claude Code │ │ npm publish │
│ capacitor │────▶│ Pipeline │────▶│ Sicherheitsprüfung │────▶│ @capacitor-plus│
│ (upstream) │ │ (täglich sync) │ │ (AI-Analyse) │ │ Pakete │
└─────────────────────┘ └──────────────────┘ └──────────────────┘ └─────────────────┘
```
1. **Tägliche Synchronisierung**: GitHub Actions holen die neuesten Änderungen von `ionic-team/capacitor`
2. **PR-Erstellung**: Änderungen werden als Pull Requests für den `plus` Branch vorgeschlagen
3. **CI-Validierung**: Vollständige Test-Suite läuft (Lint, Unit-Tests, iOS-Build, Android-Build)
4. **Sicherheitsprüfung**: KI-gestützte Analyse prüft auf Schwachstellen und Breaking Changes
5. **Auto-Merge**: Nur wenn CI besteht UND Sicherheitsprüfung genehmigt
6. **Auto-Publish**: Neue Version wird auf npm unter `@capacitor-plus/*` veröffentlicht
## Details zur Sicherheitsprüfung
[Section titled “Details zur Sicherheitsprüfung”](#details-zur-sicherheitsprüfung)
Jede Upstream-Synchronisierung wird analysiert auf:
| Prüfung | Was erkannt wird |
| -------------------- | -------------------------------------------------------------------------------- |
| **Sicherheit** | Command Injection, XSS, Path Traversal, hardcodierte Secrets |
| **Breaking Changes** | Entfernte/umbenannte APIs, geänderte Signaturen, Konfigurationsänderungen |
| **Stabilität** | Null-Dereferenzierungen, unbehandelte Exceptions, Race Conditions, Speicherlecks |
| **Datensicherheit** | Datenverlust-Szenarien, Datenschutzverletzungen, unsichere Speicherung |
| **Code-Integrität** | Verschleierter Code, verdächtige Netzwerkaufrufe, Backdoors |
Caution
Wenn Probleme erkannt werden, wird der PR zur manuellen Überprüfung markiert und wird NICHT automatisch gemergt. Dies stellt sicher, dass Sie immer stabile, sichere Releases erhalten.
## Ihren PR einreichen
[Section titled “Ihren PR einreichen”](#ihren-pr-einreichen)
Haben Sie einen PR, der im offiziellen Capacitor-Repo feststeckt? Lassen Sie ihn in Capacitor+ mergen:
1. **Öffnen Sie ein Issue** im [Capacitor+ Repo](https://github.com/Cap-go/capacitor-plus/issues) mit Link zu Ihrem Upstream-PR
2. **Oder reichen Sie direkt** als PR für den `plus` Branch ein
3. Das Team wird überprüfen, CI ausführen und mergen, wenn es besteht
Auf diese Weise können Sie und andere sofort von Ihrer Arbeit profitieren, ohne auf den Upstream-Release-Zyklus zu warten.
## FAQ
[Section titled “FAQ”](#faq)
### Ist das produktionsreif?
[Section titled “Ist das produktionsreif?”](#ist-das-produktionsreif)
Ja. Capacitor+ wird in Produktions-Apps verwendet. Jedes Release besteht die gleiche Test-Suite wie offizielles Capacitor, plus zusätzliche Sicherheitsanalyse.
### Werden meine offiziellen Plugins noch funktionieren?
[Section titled “Werden meine offiziellen Plugins noch funktionieren?”](#werden-meine-offiziellen-plugins-noch-funktionieren)
Ja. Alle `@capacitor/*` Plugins funktionieren out of the box mit Capacitor+.
### Was passiert, wenn Upstream einen Breaking Change released?
[Section titled “Was passiert, wenn Upstream einen Breaking Change released?”](#was-passiert-wenn-upstream-einen-breaking-change-released)
Die KI-Sicherheitsprüfung markiert Breaking Changes zur manuellen Überprüfung. Sie sehen die Änderungen dokumentiert, bevor sie gemergt werden.
### Wie melde ich Probleme?
[Section titled “Wie melde ich Probleme?”](#wie-melde-ich-probleme)
Melden Sie Probleme im [Capacitor+ GitHub Repo](https://github.com/Cap-go/capacitor-plus/issues). Für Probleme, die auch offizielles Capacitor betreffen, helfen wir bei der Koordination mit Upstream.
### Kann ich beitragen?
[Section titled “Kann ich beitragen?”](#kann-ich-beitragen)
Absolut! PRs sind willkommen. Sie können Fixes direkt einreichen oder anfordern, dass spezifische Upstream-PRs gemergt werden.
# @capgo/capacitor-compass
> Greifen Sie auf den Kompass-Sensor des Geräts zu, um Richtungsdaten mit Echtzeit-Updates auf iOS und Android zu erhalten.
Echtzeit-Richtung
Erhalten Sie kontinuierliche Kompass-Richtungsupdates in Grad (0-360)
Cross-Plattform
Funktioniert auf iOS- und Android-Geräten mit nativem Sensor-Zugriff
Berechtigungsverwaltung
Integrierte Berechtigungsverwaltung für Ortungsdienste (iOS)
Ereignisgesteuert
Abonnieren Sie Richtungsänderungen mit effizienten Event-Listenern
# Erste Schritte
> Erfahren Sie, wie Sie das Compass Plugin installieren und verwenden, um die Gerätekompassrichtung in Ihrer Capacitor App auszulesen.
1. **Paket installieren**
* npm
```sh
npm i @capgo/capacitor-compass
```
* pnpm
```sh
pnpm add @capgo/capacitor-compass
```
* yarn
```sh
yarn add @capgo/capacitor-compass
```
* bun
```sh
bun add @capgo/capacitor-compass
```
2. **Mit nativen Projekten synchronisieren**
* npm
```sh
npx cap sync
```
* pnpm
```sh
pnpm cap sync
```
* yarn
```sh
yarn cap sync
```
* bun
```sh
bunx cap sync
```
## iOS-Einrichtung
[Section titled “iOS-Einrichtung”](#ios-einrichtung)
Unter iOS erfordert der Kompasszugriff Standortberechtigung. Fügen Sie Folgendes zu Ihrer `Info.plist` hinzu:
```xml
NSLocationWhenInUseUsageDescription
Wir benötigen Standortberechtigung, um auf den Kompass zuzugreifen
```
## Android-Einrichtung
[Section titled “Android-Einrichtung”](#android-einrichtung)
Keine zusätzliche Einrichtung erforderlich. Das Plugin verwendet die Magnetometer- und Beschleunigungssensoren des Geräts.
## Verwendung
[Section titled “Verwendung”](#verwendung)
Importieren Sie das Plugin und verwenden Sie seine Methoden zum Auslesen der Kompassrichtung:
```typescript
import { CapgoCompass } from '@capgo/capacitor-compass';
// Aktuelle Richtung einmalig abrufen
const getCurrentHeading = async () => {
const { value } = await CapgoCompass.getCurrentHeading();
console.log('Aktuelle Richtung:', value, 'Grad');
};
// Kontinuierliche Richtungsaktualisierungen starten
const startCompass = async () => {
// Lauschen auf Updates starten
await CapgoCompass.startListening();
// Listener für Richtungsänderungen hinzufügen
const handle = await CapgoCompass.addListener('headingChange', (event) => {
console.log('Richtung:', event.value, 'Grad');
});
// Später zum Stoppen:
// await CapgoCompass.stopListening();
// await handle.remove();
};
// Berechtigungen prüfen
const checkPermission = async () => {
const status = await CapgoCompass.checkPermissions();
console.log('Berechtigungsstatus:', status.compass);
};
// Berechtigungen anfordern
const requestPermission = async () => {
const status = await CapgoCompass.requestPermissions();
if (status.compass === 'granted') {
console.log('Kompasszugriff gewährt');
}
};
```
## API-Referenz
[Section titled “API-Referenz”](#api-referenz)
### getCurrentHeading()
[Section titled “getCurrentHeading()”](#getcurrentheading)
Ruft die aktuelle Kompassrichtung in Grad ab.
```typescript
const result = await CapgoCompass.getCurrentHeading();
// Gibt zurück: { value: number } - Richtung in Grad (0-360)
```
### startListening()
[Section titled “startListening()”](#startlistening)
Startet das Lauschen auf Kompassrichtungsänderungen. Muss aufgerufen werden, bevor Richtungsereignisse ausgegeben werden.
```typescript
await CapgoCompass.startListening();
```
### stopListening()
[Section titled “stopListening()”](#stoplistening)
Stoppt das Lauschen auf Kompassrichtungsänderungen.
```typescript
await CapgoCompass.stopListening();
```
### addListener(‘headingChange’, callback)
[Section titled “addListener(‘headingChange’, callback)”](#addlistenerheadingchange-callback)
Fügt einen Listener für Richtungsänderungsereignisse hinzu.
```typescript
const handle = await CapgoCompass.addListener('headingChange', (event) => {
console.log('Richtung:', event.value);
});
// Listener entfernen wenn fertig
await handle.remove();
```
### removeAllListeners()
[Section titled “removeAllListeners()”](#removealllisteners)
Entfernt alle registrierten Listener.
```typescript
await CapgoCompass.removeAllListeners();
```
### checkPermissions()
[Section titled “checkPermissions()”](#checkpermissions)
Prüft den aktuellen Berechtigungsstatus.
```typescript
const status = await CapgoCompass.checkPermissions();
// Gibt zurück: { compass: 'prompt' | 'granted' | 'denied' }
```
### requestPermissions()
[Section titled “requestPermissions()”](#requestpermissions)
Fordert Berechtigung zum Zugriff auf Kompassdaten an.
```typescript
const status = await CapgoCompass.requestPermissions();
```
### getPluginVersion()
[Section titled “getPluginVersion()”](#getpluginversion)
Ruft die native Plugin-Version ab.
```typescript
const { version } = await CapgoCompass.getPluginVersion();
```
## Vollständiges Beispiel
[Section titled “Vollständiges Beispiel”](#vollständiges-beispiel)
```typescript
import { CapgoCompass } from '@capgo/capacitor-compass';
export class CompassService {
private listenerHandle: any = null;
async init() {
// Berechtigungen prüfen und anfordern
const status = await CapgoCompass.checkPermissions();
if (status.compass !== 'granted') {
const result = await CapgoCompass.requestPermissions();
if (result.compass !== 'granted') {
throw new Error('Kompassberechtigung verweigert');
}
}
}
async startTracking(onHeadingChange: (heading: number) => void) {
// Lauschen auf Updates starten
await CapgoCompass.startListening();
// Event-Listener hinzufügen
this.listenerHandle = await CapgoCompass.addListener(
'headingChange',
(event) => {
onHeadingChange(event.value);
}
);
}
async stopTracking() {
if (this.listenerHandle) {
await this.listenerHandle.remove();
this.listenerHandle = null;
}
await CapgoCompass.stopListening();
}
async getHeading(): Promise {
const { value } = await CapgoCompass.getCurrentHeading();
return value;
}
getCardinalDirection(heading: number): string {
const directions = ['N', 'NO', 'O', 'SO', 'S', 'SW', 'W', 'NW'];
const index = Math.round(heading / 45) % 8;
return directions[index];
}
}
```
## Plattform-Hinweise
[Section titled “Plattform-Hinweise”](#plattform-hinweise)
### iOS
[Section titled “iOS”](#ios)
* Erfordert iOS 10.0+
* Verwendet Core Location für Richtungsdaten
* Erfordert Standortberechtigung (NSLocationWhenInUseUsageDescription)
* Richtungsaktualisierungen sind kontinuierlich, wenn Lauschen aktiv ist
### Android
[Section titled “Android”](#android)
* Erfordert Android 6.0 (API 23)+
* Verwendet Beschleunigungs- und Magnetometersensoren
* Keine speziellen Berechtigungen für Kompasssensoren erforderlich
* Richtung wird aus Sensorfusion berechnet
### Web
[Section titled “Web”](#web)
* Nicht auf Web-Plattform unterstützt
* Methoden werfen Fehler, wenn aufgerufen
# @capgo/capacitor-contacts
> Greifen Sie auf Gerätekontakte zu, durchsuchen und verwalten Sie sie in Ihrer Capacitor-App mit vollständigen CRUD-Operationen und Berechtigungsverwaltung.
Kontakte lesen
Zugriff auf Gerätekontaktliste mit vollständigen Details
Suchfunktionalität
Finden Sie Kontakte nach Name, E-Mail oder Telefon
Erstellen & Aktualisieren
Fügen Sie neue Kontakte hinzu oder ändern Sie bestehende
Kontakte löschen
Entfernen Sie Kontakte sicher vom Gerät
Berechtigungsverwaltung
Behandeln Sie Kontaktberechtigungen ordnungsgemäß mit Privacy Manifest-Konformität
Erste Schritte
Schauen Sie sich die [Anleitung für erste Schritte](/docs/plugins/contacts/getting-started/) an, um das Plugin zu installieren und zu konfigurieren.
# Erste Schritte mit Contacts
> Erfahren Sie, wie Sie die Kontaktverwaltung in Ihre Capacitor-App integrieren
Diese Anleitung führt Sie durch die Integration des Capacitor Contacts Plugins in Ihre Anwendung.
## Installation
[Section titled “Installation”](#installation)
Installieren Sie das Plugin mit npm:
```bash
npm install @capgo/capacitor-contacts
npx cap sync
```
## iOS Konfiguration
[Section titled “iOS Konfiguration”](#ios-konfiguration)
Fügen Sie Folgendes zu Ihrer `Info.plist` hinzu:
```xml
NSContactsUsageDescription
Diese App benötigt Zugriff auf Kontakte, damit Sie Empfänger auswählen können
```
## Android Konfiguration
[Section titled “Android Konfiguration”](#android-konfiguration)
Fügen Sie die folgenden Berechtigungen zu Ihrer `AndroidManifest.xml` hinzu:
```xml
```
## Grundlegende Verwendung
[Section titled “Grundlegende Verwendung”](#grundlegende-verwendung)
### Plugin importieren
[Section titled “Plugin importieren”](#plugin-importieren)
```typescript
import { Contacts } from '@capgo/capacitor-contacts';
```
### Berechtigungen anfordern
[Section titled “Berechtigungen anfordern”](#berechtigungen-anfordern)
```typescript
const requestPermissions = async () => {
const permission = await Contacts.requestPermissions();
console.log('Berechtigungsstatus:', permission.contacts);
};
```
### Alle Kontakte abrufen
[Section titled “Alle Kontakte abrufen”](#alle-kontakte-abrufen)
```typescript
const getAllContacts = async () => {
const result = await Contacts.getContacts({
projection: {
name: true,
phones: true,
emails: true,
image: true
}
});
console.log('Kontakte:', result.contacts);
};
```
### Kontakte suchen
[Section titled “Kontakte suchen”](#kontakte-suchen)
```typescript
const searchContacts = async (query: string) => {
const result = await Contacts.getContacts({
projection: {
name: true,
phones: true,
emails: true
},
query: query
});
console.log('Suchergebnisse:', result.contacts);
};
```
### Kontakt erstellen
[Section titled “Kontakt erstellen”](#kontakt-erstellen)
```typescript
const createContact = async () => {
const newContact = {
name: {
given: 'John',
family: 'Doe'
},
phones: [{
type: 'mobile',
number: '+1234567890'
}],
emails: [{
type: 'work',
address: 'john.doe@example.com'
}]
};
const result = await Contacts.createContact(newContact);
console.log('Kontakt erstellt:', result);
};
```
### Kontakt aktualisieren
[Section titled “Kontakt aktualisieren”](#kontakt-aktualisieren)
```typescript
const updateContact = async (contactId: string) => {
const updates = {
contactId: contactId,
name: {
given: 'Jane',
family: 'Doe'
}
};
await Contacts.updateContact(updates);
console.log('Kontakt aktualisiert');
};
```
### Kontakt löschen
[Section titled “Kontakt löschen”](#kontakt-löschen)
```typescript
const deleteContact = async (contactId: string) => {
await Contacts.deleteContact({ contactId });
console.log('Kontakt gelöscht');
};
```
## Vollständiges Beispiel
[Section titled “Vollständiges Beispiel”](#vollständiges-beispiel)
Hier ist ein vollständiges Beispiel mit einem Kontakt-Service:
```typescript
import { Contacts } from '@capgo/capacitor-contacts';
interface Contact {
contactId: string;
name: {
display?: string;
given?: string;
family?: string;
};
phones?: Array<{ type: string; number: string }>;
emails?: Array<{ type: string; address: string }>;
image?: { base64String: string };
}
class ContactsService {
async checkPermissions(): Promise {
const permission = await Contacts.checkPermissions();
if (permission.contacts === 'granted') {
return true;
}
const requested = await Contacts.requestPermissions();
return requested.contacts === 'granted';
}
async getAllContacts(): Promise {
const hasPermission = await this.checkPermissions();
if (!hasPermission) {
throw new Error('Kontaktberechtigung verweigert');
}
const result = await Contacts.getContacts({
projection: {
name: true,
phones: true,
emails: true,
image: true
}
});
return result.contacts;
}
async searchContacts(query: string): Promise {
if (!query || query.length < 2) {
return [];
}
const result = await Contacts.getContacts({
projection: {
name: true,
phones: true,
emails: true
},
query: query
});
return result.contacts;
}
async getContactById(contactId: string): Promise {
const result = await Contacts.getContacts({
projection: {
name: true,
phones: true,
emails: true,
image: true,
organization: true,
birthday: true,
note: true,
urls: true,
postalAddresses: true
},
contactId: contactId
});
return result.contacts.length > 0 ? result.contacts[0] : null;
}
async createContact(contact: Partial): Promise {
const hasPermission = await this.checkPermissions();
if (!hasPermission) {
throw new Error('Kontaktberechtigung verweigert');
}
const result = await Contacts.createContact(contact);
return result.contactId;
}
async updateContact(contactId: string, updates: Partial): Promise {
await Contacts.updateContact({
contactId,
...updates
});
}
async deleteContact(contactId: string): Promise {
await Contacts.deleteContact({ contactId });
}
formatPhoneNumber(phone: string): string {
// Nicht-numerische Zeichen entfernen
const cleaned = phone.replace(/\D/g, '');
// Als (XXX) XXX-XXXX formatieren
if (cleaned.length === 10) {
return `(${cleaned.slice(0, 3)}) ${cleaned.slice(3, 6)}-${cleaned.slice(6)}`;
}
return phone;
}
getContactInitials(contact: Contact): string {
const given = contact.name?.given || '';
const family = contact.name?.family || '';
if (given && family) {
return `${given[0]}${family[0]}`.toUpperCase();
}
const display = contact.name?.display || '';
const parts = display.split(' ');
if (parts.length >= 2) {
return `${parts[0][0]}${parts[1][0]}`.toUpperCase();
}
return display.slice(0, 2).toUpperCase();
}
}
// Verwendung
const contactsService = new ContactsService();
// Alle Kontakte abrufen
const contacts = await contactsService.getAllContacts();
console.log('Kontakte:', contacts);
// Kontakte suchen
const results = await contactsService.searchContacts('john');
console.log('Suchergebnisse:', results);
// Kontakt erstellen
const newContactId = await contactsService.createContact({
name: { given: 'Jane', family: 'Smith' },
phones: [{ type: 'mobile', number: '+1234567890' }]
});
// Kontakt aktualisieren
await contactsService.updateContact(newContactId, {
emails: [{ type: 'work', address: 'jane@example.com' }]
});
```
## Projektion verstehen
[Section titled “Projektion verstehen”](#projektion-verstehen)
Der Parameter `projection` steuert, welche Felder abgerufen werden:
```typescript
const result = await Contacts.getContacts({
projection: {
name: true, // Kontaktname
phones: true, // Telefonnummern
emails: true, // E-Mail-Adressen
image: true, // Kontaktfoto
organization: true, // Firma/Organisation
birthday: true, // Geburtsdatum
note: true, // Notizen
urls: true, // Webseiten
postalAddresses: true // Postanschriften
}
});
```
**Tipp**: Fordern Sie nur die Felder an, die Sie tatsächlich benötigen, um die Leistung zu verbessern.
## Kontaktauswahl-UI
[Section titled “Kontaktauswahl-UI”](#kontaktauswahl-ui)
Viele Apps bevorzugen die native Kontaktauswahl:
```typescript
const pickContact = async () => {
try {
const result = await Contacts.pickContact({
projection: {
name: true,
phones: true,
emails: true
}
});
if (result.contacts.length > 0) {
const contact = result.contacts[0];
console.log('Ausgewählter Kontakt:', contact);
}
} catch (error) {
console.error('Kontaktauswahl abgebrochen oder fehlgeschlagen:', error);
}
};
```
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
1. **Minimale Berechtigungen anfordern**: Fordern Sie Kontaktberechtigung nur bei Bedarf an
2. **Projektion verwenden**: Rufen Sie nur die Felder ab, die Sie tatsächlich verwenden
3. **Ablehnungen behandeln**: Bieten Sie eine Alternative, wenn Berechtigungen verweigert werden
4. **Weise zwischenspeichern**: Kontakte können sich ändern, speichern Sie nicht zu lange zwischen
5. **Privatsphäre respektieren**: Seien Sie transparent über die Kontaktnutzung
6. **Asynchrone Operationen**: Alle Kontaktoperationen sind asynchron
## Häufige Probleme
[Section titled “Häufige Probleme”](#häufige-probleme)
### Berechtigung verweigert
[Section titled “Berechtigung verweigert”](#berechtigung-verweigert)
```typescript
const handlePermissionDenied = async () => {
const permission = await Contacts.checkPermissions();
if (permission.contacts === 'denied') {
// Dialog anzeigen, der erklärt, warum die Berechtigung benötigt wird
showPermissionDialog();
// Benutzer zu den Einstellungen leiten
// Auf iOS: Einstellungen > [App] > Kontakte
// Auf Android: Einstellungen > Apps > [App] > Berechtigungen
}
};
```
### Große Kontaktlisten
[Section titled “Große Kontaktlisten”](#große-kontaktlisten)
```typescript
const loadContactsInBatches = async () => {
// Zuerst Anzahl abrufen (leichtgewichtig)
const projection = { name: true }; // Minimale Projektion
// Paginierung implementieren, falls nötig
const allContacts = await Contacts.getContacts({ projection });
// In Blöcken verarbeiten
const chunkSize = 100;
for (let i = 0; i < allContacts.contacts.length; i += chunkSize) {
const chunk = allContacts.contacts.slice(i, i + chunkSize);
await processContactChunk(chunk);
}
};
```
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
* Erkunden Sie die [API-Referenz](https://github.com/Cap-go/capacitor-contacts#api) für vollständige Methodendokumentation
* Schauen Sie sich die [Beispiel-App](https://github.com/Cap-go/capacitor-contacts/tree/main/example) für erweiterte Verwendung an
* Sehen Sie sich das [Tutorial](/plugins/capacitor-contacts) für vollständige Implementierungsbeispiele an
# @capgo/capacitor-crisp
> Integrieren Sie das native Crisp Chat SDK in Ihre Capacitor-App für nahtlosen In-App-Kundensupport und Echtzeit-Messaging.
Native Performance
Native SDK-Integration für reibungslose Chat-Erfahrung
Echtzeit-Messaging
Live-Chat mit Kunden direkt in Ihrer App
Umfangreiche Funktionen
Unterstützung für Benutzerdaten, Ereignisse und benutzerdefiniertes Styling
Umfassende Dokumentation
Schauen Sie sich die [Dokumentation](/docs/plugins/crisp/getting-started/) an, um das Plugin in nur wenigen Minuten zu beherrschen.
# Erste Schritte
> Erfahren Sie, wie Sie das Crisp Chat SDK Plugin für In-App-Kundensupport in Ihrer Capacitor-App installieren und verwenden.
1. **Paket installieren**
* npm
```sh
npm i @capgo/capacitor-crisp
```
* pnpm
```sh
pnpm add @capgo/capacitor-crisp
```
* yarn
```sh
yarn add @capgo/capacitor-crisp
```
* bun
```sh
bun add @capgo/capacitor-crisp
```
2. **Mit nativen Projekten synchronisieren**
* npm
```sh
npx cap sync
```
* pnpm
```sh
pnpm cap sync
```
* yarn
```sh
yarn cap sync
```
* bun
```sh
bunx cap sync
```
3. **Ihre Crisp Website-ID abrufen**
* Melden Sie sich bei [crisp.chat](https://crisp.chat) an
* Erstellen Sie eine Website/ein Projekt
* Finden Sie Ihre Website-ID unter Einstellungen > Setup-Anleitung
## Grundlegende Verwendung
[Section titled “Grundlegende Verwendung”](#grundlegende-verwendung)
Importieren Sie das Plugin und konfigurieren Sie es mit Ihrer Website-ID:
```typescript
import { CapacitorCrisp } from '@capgo/capacitor-crisp';
// Crisp mit Ihrer Website-ID konfigurieren
const configureCrisp = async () => {
await CapacitorCrisp.configure({
websiteID: 'YOUR_WEBSITE_ID'
});
};
// Den Chat öffnen
const openChat = async () => {
await CapacitorCrisp.openMessenger();
};
// Benutzerinformationen festlegen
const setUserInfo = async () => {
await CapacitorCrisp.setUser({
email: 'user@example.com',
nickname: 'John Doe',
phone: '+1234567890',
avatar: 'https://example.com/avatar.jpg'
});
};
// Benutzersitzung zurücksetzen (Abmelden)
const logout = async () => {
await CapacitorCrisp.resetChatSession();
};
```
## API-Referenz
[Section titled “API-Referenz”](#api-referenz)
### configure(options)
[Section titled “configure(options)”](#configureoptions)
Konfigurieren Sie Crisp mit Ihrer Website-ID und optionalen Einstellungen.
```typescript
interface ConfigureOptions {
websiteID: string;
locale?: string; // z.B., 'en', 'fr', 'es'
tokenID?: string; // Für authentifizierte Sitzungen
}
await CapacitorCrisp.configure({
websiteID: 'YOUR_WEBSITE_ID',
locale: 'de'
});
```
### openMessenger()
[Section titled “openMessenger()”](#openmessenger)
Öffnet die Crisp-Chat-Oberfläche.
```typescript
await CapacitorCrisp.openMessenger();
```
### setUser(options)
[Section titled “setUser(options)”](#setuseroptions)
Setzt Benutzerinformationen für die Chat-Sitzung.
```typescript
interface UserOptions {
email?: string;
nickname?: string;
phone?: string;
avatar?: string;
}
await CapacitorCrisp.setUser({
email: 'user@example.com',
nickname: 'John Doe'
});
```
### setUserCompany(options)
[Section titled “setUserCompany(options)”](#setusercompanyoptions)
Setzt Firmeninformationen für Geschäftskunden.
```typescript
interface CompanyOptions {
name: string;
url?: string;
description?: string;
employment?: {
title?: string;
role?: string;
};
geolocation?: {
city?: string;
country?: string;
};
}
await CapacitorCrisp.setUserCompany({
name: 'Acme Corp',
url: 'https://acme.com',
employment: {
title: 'CEO',
role: 'Leadership'
}
});
```
### pushEvent(options)
[Section titled “pushEvent(options)”](#pusheventoptions)
Senden Sie benutzerdefinierte Ereignisse, um Benutzeraktionen zu verfolgen.
```typescript
interface EventOptions {
name: string;
color?: 'red' | 'orange' | 'yellow' | 'green' | 'blue' | 'purple' | 'pink' | 'brown' | 'grey' | 'black';
data?: { [key: string]: any };
}
await CapacitorCrisp.pushEvent({
name: 'checkout_completed',
color: 'green',
data: {
price: 99.99,
currency: 'USD'
}
});
```
### setSessionSegment(segment)
[Section titled “setSessionSegment(segment)”](#setsessionsegmentsegment)
Setzen Sie ein Segment, um die Chat-Sitzung zu kategorisieren.
```typescript
await CapacitorCrisp.setSessionSegment('premium_customer');
```
### resetChatSession()
[Section titled “resetChatSession()”](#resetchatsession)
Setzen Sie die aktuelle Chat-Sitzung zurück (nützlich für Abmeldung).
```typescript
await CapacitorCrisp.resetChatSession();
```
## Erweiterte Funktionen
[Section titled “Erweiterte Funktionen”](#erweiterte-funktionen)
### Benutzerdefinierte Benutzerdaten
[Section titled “Benutzerdefinierte Benutzerdaten”](#benutzerdefinierte-benutzerdaten)
```typescript
// Mehrere benutzerdefinierte Datenfelder festlegen
await CapacitorCrisp.setSessionData({
key: 'plan',
value: 'premium'
});
await CapacitorCrisp.setSessionData({
key: 'signup_date',
value: '2024-01-15'
});
```
### Nachrichtenvorlage
[Section titled “Nachrichtenvorlage”](#nachrichtenvorlage)
Setzen Sie eine vorgefüllte Nachricht in das Chat-Eingabefeld:
```typescript
await CapacitorCrisp.setMessageText(
"Hallo, ich benötige Hilfe bei meiner Bestellung #12345"
);
```
### Chat-Verfügbarkeit
[Section titled “Chat-Verfügbarkeit”](#chat-verfügbarkeit)
Steuern Sie, wann das Chat-Widget verfügbar ist:
```typescript
// Chat vorübergehend ausblenden
await CapacitorCrisp.setTokenID('user_token_12345');
```
## Vollständiges Beispiel
[Section titled “Vollständiges Beispiel”](#vollständiges-beispiel)
```typescript
import { CapacitorCrisp } from '@capgo/capacitor-crisp';
export class ChatService {
async initialize() {
// Crisp konfigurieren
await CapacitorCrisp.configure({
websiteID: 'YOUR_WEBSITE_ID',
locale: 'de'
});
}
async loginUser(user: any) {
// Benutzerinformationen festlegen
await CapacitorCrisp.setUser({
email: user.email,
nickname: user.name,
phone: user.phone,
avatar: user.avatarUrl
});
// Benutzerdefinierte Daten festlegen
await CapacitorCrisp.setSessionData({
key: 'user_id',
value: user.id
});
await CapacitorCrisp.setSessionData({
key: 'account_type',
value: user.accountType
});
// Segment festlegen
if (user.isPremium) {
await CapacitorCrisp.setSessionSegment('premium');
}
// Login-Ereignis verfolgen
await CapacitorCrisp.pushEvent({
name: 'user_login',
color: 'blue',
data: {
method: 'email'
}
});
}
async openSupport(context?: string) {
if (context) {
await CapacitorCrisp.setMessageText(
`Ich benötige Hilfe bei: ${context}`
);
}
await CapacitorCrisp.openMessenger();
}
async logout() {
await CapacitorCrisp.resetChatSession();
}
}
```
## Styling und Anpassung
[Section titled “Styling und Anpassung”](#styling-und-anpassung)
Crisp passt sich automatisch dem Theme Ihrer App an, aber Sie können es über das Crisp-Dashboard weiter anpassen:
1. Gehen Sie zu Ihrem Crisp-Dashboard
2. Navigieren Sie zu Einstellungen > Website-Einstellungen > Chatbox & E-Mail-Einstellungen
3. Passen Sie Farben, Position und Verhalten an
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
1. **Früh initialisieren** Konfigurieren Sie Crisp während der App-Initialisierung für sofortige Verfügbarkeit:
```typescript
import { App } from '@capacitor/app';
App.addListener('appStateChange', async ({ isActive }) => {
if (isActive) {
await CapacitorCrisp.configure({
websiteID: 'YOUR_WEBSITE_ID'
});
}
});
```
2. **Benutzerkontext festlegen** Geben Sie immer Benutzerinformationen an, wenn verfügbar, für besseren Support:
```typescript
if (user.isAuthenticated) {
await CapacitorCrisp.setUser({
email: user.email,
nickname: user.name
});
}
```
3. **Wichtige Ereignisse verfolgen** Verwenden Sie Ereignisse, um Support-Agenten Kontext zu bieten:
```typescript
await CapacitorCrisp.pushEvent({
name: 'error_occurred',
color: 'red',
data: {
error: error.message,
screen: 'checkout'
}
});
```
4. **Abmeldung ordnungsgemäß behandeln** Setzen Sie die Sitzung immer zurück, wenn Benutzer sich abmelden:
```typescript
async logout() {
await CapacitorCrisp.resetChatSession();
// Ihre andere Abmeldelogik
}
```
## Plattform-Hinweise
[Section titled “Plattform-Hinweise”](#plattform-hinweise)
### iOS
[Section titled “iOS”](#ios)
* Erfordert iOS 10.0+
* Verwendet natives Crisp iOS SDK
* Unterstützt Push-Benachrichtigungen (im Crisp-Dashboard konfigurieren)
### Android
[Section titled “Android”](#android)
* Erfordert Android 5.0 (API 21)+
* Verwendet natives Crisp Android SDK
* Material Design-konform
### Web
[Section titled “Web”](#web)
* Verwendet als Fallback Crisp JavaScript SDK
* Vollständige Feature-Parität mit nativen Plattformen
# @capgo/capacitor-data-storage-sqlite
> Schneller und zuverlässiger SQLite-basierter Schlüssel-Wert-Speicher für Ihre Capacitor-Apps mit Verschlüsselungsunterstützung.
SQLite-betrieben
Schneller und zuverlässiger Datenspeicher mit SQLite
Verschlüsselungsunterstützung
Optionale Verschlüsselung für sensible Daten
Schlüssel-Wert-Einfachheit
Einfache Schlüssel-Wert-API mit leistungsstarken Funktionen
Umfassende Dokumentation
Schauen Sie sich die [Dokumentation](/docs/plugins/data-storage-sqlite/getting-started/) an, um das Plugin in nur wenigen Minuten zu beherrschen.
# Erste Schritte
> Erfahren Sie, wie Sie das Capacitor Data Storage SQLite Plugin für schnellen Schlüssel-Wert-Speicher mit optionaler Verschlüsselung installieren und konfigurieren.
1. **Paket installieren**
* npm
```sh
npm i @capgo/capacitor-data-storage-sqlite
```
* pnpm
```sh
pnpm add @capgo/capacitor-data-storage-sqlite
```
* yarn
```sh
yarn add @capgo/capacitor-data-storage-sqlite
```
* bun
```sh
bun add @capgo/capacitor-data-storage-sqlite
```
2. **Mit nativen Projekten synchronisieren**
* npm
```sh
npx cap sync
```
* pnpm
```sh
pnpm cap sync
```
* yarn
```sh
yarn cap sync
```
* bun
```sh
bunx cap sync
```
3. **Plugin konfigurieren**
**Grundlegendes Speicherbeispiel:**
```typescript
import { CapacitorDataStorageSqlite } from '@capgo/capacitor-data-storage-sqlite';
// Eine Speicherdatenbank öffnen
await CapacitorDataStorageSqlite.openStore({
database: 'myapp_storage'
});
// Daten speichern
await CapacitorDataStorageSqlite.set({
key: 'user_preferences',
value: JSON.stringify({ theme: 'dark' })
});
```
**Verschlüsseltes Speicherbeispiel:**
```typescript
// Verschlüsselten Speicher öffnen
await CapacitorDataStorageSqlite.openStore({
database: 'secure_storage',
encrypted: true,
mode: 'encryption'
});
// Sensible Daten speichern
await CapacitorDataStorageSqlite.set({
key: 'api_token',
value: 'secret_token_value'
});
```
* iOS
Keine zusätzliche Einrichtung für iOS erforderlich.
* Android
Keine zusätzliche Einrichtung für Android erforderlich.
4. **Grundlegende Operationen**
```typescript
import { CapacitorDataStorageSqlite } from '@capgo/capacitor-data-storage-sqlite';
// Einen Wert setzen
await CapacitorDataStorageSqlite.set({
key: 'username',
value: 'john_doe'
});
// Einen Wert abrufen
const { value } = await CapacitorDataStorageSqlite.get({
key: 'username'
});
console.log('Benutzername:', value); // "john_doe"
// Einen Wert entfernen
await CapacitorDataStorageSqlite.remove({
key: 'username'
});
// Alle Daten löschen
await CapacitorDataStorageSqlite.clear();
// Prüfen, ob Schlüssel existiert
const { result } = await CapacitorDataStorageSqlite.iskey({
key: 'username'
});
console.log('Schlüssel existiert:', result); // true oder false
// Alle Schlüssel abrufen
const { keys } = await CapacitorDataStorageSqlite.keys();
console.log('Alle Schlüssel:', keys);
// Alle Werte abrufen
const { values } = await CapacitorDataStorageSqlite.values();
console.log('Alle Werte:', values);
```
5. **Erweiterte Verwendung**
```typescript
import { CapacitorDataStorageSqlite } from '@capgo/capacitor-data-storage-sqlite';
export class StorageService {
private dbName = 'app_storage';
private isEncrypted = false;
async initialize(encrypted = false) {
this.isEncrypted = encrypted;
// Speicher mit Optionen öffnen
await CapacitorDataStorageSqlite.openStore({
database: this.dbName,
encrypted: encrypted,
mode: encrypted ? 'encryption' : 'no-encryption',
version: 1
});
}
// Generische Speichermethoden
async setObject(key: string, data: T): Promise {
const value = JSON.stringify(data);
await CapacitorDataStorageSqlite.set({ key, value });
}
async getObject(key: string): Promise {
try {
const { value } = await CapacitorDataStorageSqlite.get({ key });
return value ? JSON.parse(value) : null;
} catch (error) {
console.error('Fehler beim Abrufen des Objekts:', error);
return null;
}
}
// Batch-Operationen
async setMultiple(items: Record): Promise {
for (const [key, value] of Object.entries(items)) {
await CapacitorDataStorageSqlite.set({
key,
value: typeof value === 'string' ? value : JSON.stringify(value)
});
}
}
async getMultiple(keys: string[]): Promise> {
const results: Record = {};
for (const key of keys) {
try {
const { value } = await CapacitorDataStorageSqlite.get({ key });
results[key] = value;
} catch (error) {
results[key] = null;
}
}
return results;
}
// Tabellenverwaltung
async getTables(): Promise {
const { tables } = await CapacitorDataStorageSqlite.tables();
return tables;
}
async deleteTable(table: string): Promise {
await CapacitorDataStorageSqlite.deleteTable({ table });
}
// Import/Export-Funktionalität
async exportToJson(): Promise {
const { keys } = await CapacitorDataStorageSqlite.keys();
const { values } = await CapacitorDataStorageSqlite.values();
return keys.map((key, index) => ({
key,
value: values[index]
}));
}
async importFromJson(data: Array<{ key: string; value: string }>): Promise {
// Vorhandene Daten löschen
await CapacitorDataStorageSqlite.clear();
// Neue Daten importieren
for (const item of data) {
await CapacitorDataStorageSqlite.set({
key: item.key,
value: item.value
});
}
}
// Filtern und Suchen
async keysStartingWith(prefix: string): Promise {
const { keys } = await CapacitorDataStorageSqlite.keys();
return keys.filter(key => key.startsWith(prefix));
}
async filterByPrefix(prefix: string): Promise> {
const { keys } = await CapacitorDataStorageSqlite.keys();
const { values } = await CapacitorDataStorageSqlite.values();
const filtered: Array<{ key: string; value: string }> = [];
keys.forEach((key, index) => {
if (key.startsWith(prefix)) {
filtered.push({ key, value: values[index] });
}
});
return filtered;
}
// Datenbank schließen, wenn fertig
async close(): Promise {
await CapacitorDataStorageSqlite.closeStore({
database: this.dbName
});
}
}
// Verwendungsbeispiel
const storage = new StorageService();
await storage.initialize(true); // Verschlüsselung verwenden
// Benutzerdaten speichern
await storage.setObject('user_profile', {
id: 123,
name: 'John Doe',
email: 'john@example.com'
});
// Benutzerdaten abrufen
const profile = await storage.getObject('user_profile');
console.log('Benutzerprofil:', profile);
```
## API-Referenz
[Section titled “API-Referenz”](#api-referenz)
### Methoden
[Section titled “Methoden”](#methoden)
#### `openStore(options: OpenStoreOptions)`
[Section titled “openStore(options: OpenStoreOptions)”](#openstoreoptions-openstoreoptions)
Eine Speicherdatenbank öffnen.
**Parameter:**
* `options.database`: string - Datenbankname
* `options.encrypted`: boolean - Verschlüsselung aktivieren
* `options.mode`: string - ‘encryption’ oder ‘no-encryption’
* `options.version`: number - Datenbankversion
#### `closeStore(options: CloseStoreOptions)`
[Section titled “closeStore(options: CloseStoreOptions)”](#closestoreoptions-closestoreoptions)
Die Speicherdatenbank schließen.
#### `set(options: SetOptions)`
[Section titled “set(options: SetOptions)”](#setoptions-setoptions)
Ein Schlüssel-Wert-Paar speichern.
**Parameter:**
* `options.key`: string - Speicherschlüssel
* `options.value`: string - Zu speichernder Wert
#### `get(options: GetOptions)`
[Section titled “get(options: GetOptions)”](#getoptions-getoptions)
Einen Wert nach Schlüssel abrufen.
**Rückgabe:** `Promise<{ value: string }>`
#### `remove(options: RemoveOptions)`
[Section titled “remove(options: RemoveOptions)”](#removeoptions-removeoptions)
Ein Schlüssel-Wert-Paar entfernen.
#### `clear()`
[Section titled “clear()”](#clear)
Alle Daten aus dem Speicher löschen.
#### `iskey(options: IskeyOptions)`
[Section titled “iskey(options: IskeyOptions)”](#iskeyoptions-iskeyoptions)
Prüfen, ob ein Schlüssel existiert.
**Rückgabe:** `Promise<{ result: boolean }>`
#### `keys()`
[Section titled “keys()”](#keys)
Alle Speicherschlüssel abrufen.
**Rückgabe:** `Promise<{ keys: string[] }>`
#### `values()`
[Section titled “values()”](#values)
Alle Speicherwerte abrufen.
**Rückgabe:** `Promise<{ values: string[] }>`
#### `tables()`
[Section titled “tables()”](#tables)
Alle Tabellennamen abrufen.
**Rückgabe:** `Promise<{ tables: string[] }>`
#### `deleteTable(options: DeleteTableOptions)`
[Section titled “deleteTable(options: DeleteTableOptions)”](#deletetableoptions-deletetableoptions)
Eine bestimmte Tabelle löschen.
### Schnittstellen
[Section titled “Schnittstellen”](#schnittstellen)
```typescript
interface OpenStoreOptions {
database: string;
encrypted?: boolean;
mode?: string;
version?: number;
}
interface SetOptions {
key: string;
value: string;
}
interface GetOptions {
key: string;
}
interface RemoveOptions {
key: string;
}
```
## Plattform-Hinweise
[Section titled “Plattform-Hinweise”](#plattform-hinweise)
### iOS
[Section titled “iOS”](#ios)
* Verwendet SQLite3 mit optionalem SQLCipher für Verschlüsselung
* Daten bleiben über App-Updates hinweg erhalten
* Unterstützt iOS 11.0+
### Android
[Section titled “Android”](#android)
* Verwendet SQLite mit optionalem SQLCipher
* Daten bleiben über App-Updates hinweg erhalten
* Unterstützt Android 5.0 (API 21)+
## Häufige Anwendungsfälle
[Section titled “Häufige Anwendungsfälle”](#häufige-anwendungsfälle)
1. **Benutzereinstellungen**: App-Einstellungen und Präferenzen speichern
2. **Cache-Verwaltung**: API-Antworten und Daten zwischenspeichern
3. **Offline-Speicher**: Daten für Offline-Zugriff speichern
4. **Sitzungsverwaltung**: Benutzersitzungen sicher verwalten
5. **Token-Speicher**: Authentifizierungs-Token sicher speichern
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
1. **Verschlüsselung für sensible Daten verwenden**
```typescript
// Für sensible Daten wie Token
await openStore({
database: 'secure_db',
encrypted: true,
mode: 'encryption'
});
```
2. **Schlüssel mit Präfixen organisieren**
```typescript
// Präfixe zur Organisation verwenden
await set({ key: 'user:123:profile', value: userData });
await set({ key: 'cache:api:users', value: apiData });
```
3. **Große Daten vorsichtig behandeln**
```typescript
// Für große Objekte Kompression in Betracht ziehen
const compressed = compress(largeData);
await set({ key: 'large_data', value: compressed });
```
4. **Regelmäßige Bereinigung**
```typescript
// Abgelaufene Cache-Einträge entfernen
const keys = await keys();
for (const key of keys.keys) {
if (key.startsWith('cache:') && isExpired(key)) {
await remove({ key });
}
}
```
## Fehlerbehebung
[Section titled “Fehlerbehebung”](#fehlerbehebung)
**Datenbank wird nicht geöffnet:**
* Prüfen Sie, ob der Datenbankname gültig ist (alphanumerisch, Unterstriche)
* Stellen Sie sicher, dass keine Sonderzeichen im Datenbanknamen enthalten sind
* Überprüfen Sie, ob der Verschlüsselungsmodus mit der vorhandenen Datenbank übereinstimmt
**Daten werden nicht gespeichert:**
* Stellen Sie sicher, dass `openStore` vor Operationen aufgerufen wird
* Überprüfen Sie auf Fehler in der Konsole
* Überprüfen Sie, ob Schlüsselnamen Strings sind
**Leistungsprobleme:**
* Vermeiden Sie das Speichern sehr großer Werte
* Verwenden Sie Batch-Operationen, wenn möglich
* Erwägen Sie die Verwendung mehrerer Datenbanken für verschiedene Datentypen
# @capgo/capacitor-document-scanner
> Starten Sie eine ausgefeilte Dokumentenscan-Erfahrung mit automatischem Zuschneiden, mehrseitigem Erfassen und konfigurierbaren Ausgabeformaten.
Das Document Scanner Plugin bietet Ihrer Capacitor-App einen nativen Scan-Workflow in Qualität, der auf iOS- und Android-Geräten funktioniert.
Automatische Erkennung
Erkennen Sie Seitenkanten, schneiden Sie automatisch zu und lassen Sie Benutzer vor dem Speichern anpassen.
Mehrseitiges Erfassen
Erfassen Sie eine oder mehrere Seiten in einer einzigen Scan-Sitzung mit anpassbaren Limits.
Benutzerdefinierte Ausgabe
Geben Sie entweder Dateipfade oder Base64-Strings mit der von Ihnen gewählten Bildqualität zurück.
Einheitliche API
Eine TypeScript-Schnittstelle umfasst sowohl iOS- als auch Android-Implementierungen.
Verwenden Sie die Anleitung für erste Schritte, um Kameraberechtigungen zu aktivieren, Qualitätseinstellungen zu konfigurieren und gescannte Dateien in Ihren Speicher-Workflow zu exportieren.
# Erste Schritte
> Fügen Sie natives Dokumentenscannen in Qualität mit Kantenerkennung und anpassbaren Ausgabeformaten hinzu.
1. **Plugin installieren**
* npm
```sh
npm i @capgo/capacitor-document-scanner
```
* pnpm
```sh
pnpm add @capgo/capacitor-document-scanner
```
* yarn
```sh
yarn add @capgo/capacitor-document-scanner
```
* bun
```sh
bun add @capgo/capacitor-document-scanner
```
2. **Native Plattformen synchronisieren**
* npm
```sh
npx cap sync
```
* pnpm
```sh
pnpm cap sync
```
* yarn
```sh
yarn cap sync
```
* bun
```sh
bunx cap sync
```
## Einen Scan auslösen
[Section titled “Einen Scan auslösen”](#einen-scan-auslösen)
```typescript
import {
DocumentScanner,
ResponseType,
ScanDocumentResponseStatus,
} from '@capgo/capacitor-document-scanner';
const result = await DocumentScanner.scanDocument({
croppedImageQuality: 90,
letUserAdjustCrop: true,
maxNumDocuments: 10,
responseType: ResponseType.ImageFilePath,
});
if (result.status === ScanDocumentResponseStatus.Success) {
console.log('Gescannte Dateien:', result.scannedImages);
} else {
console.log('Scan vom Benutzer abgebrochen');
}
```
## Base64-Daten zurückgeben
[Section titled “Base64-Daten zurückgeben”](#base64-daten-zurückgeben)
```typescript
const result = await DocumentScanner.scanDocument({
responseType: ResponseType.Base64,
});
const [firstPage] = result.scannedImages ?? [];
if (firstPage) {
const dataUrl = `data:image/jpeg;base64,${firstPage}`;
// Vorschau anzeigen oder auf Server hochladen
}
```
## Plattformanforderungen
[Section titled “Plattformanforderungen”](#plattformanforderungen)
* **iOS**: Fügen Sie `NSCameraUsageDescription` zu `ios/App/App/Info.plist` hinzu und erklären Sie, wie Sie die Kamera verwenden.
* **Android**: Bestätigen Sie, dass die `CAMERA`-Berechtigung deklariert ist (Capacitor fügt sie automatisch hinzu) und passen Sie `croppedImageQuality`, `letUserAdjustCrop` und `maxNumDocuments` an Ihre Benutzeroberfläche an.
* **Speicher**: Wenn Sie `ResponseType.ImageFilePath` verwenden, verschieben oder kopieren Sie die gescannten Dateien an Ihren gewünschten Speicherort, bevor die App-Sitzung endet.
# @capgo/capacitor-downloader
> Laden Sie Dateien mit Hintergrundunterstützung, Fortschrittsverfolgung, Pausieren/Fortsetzen-Funktionen und effizienter Download-Verwaltung herunter.
## Übersicht
[Section titled “Übersicht”](#übersicht)
Das Capacitor Downloader Plugin bietet leistungsstarke Datei-Download-Funktionen mit Unterstützung für Hintergrund-Downloads, Fortschrittsverfolgung und umfassende Download-Verwaltung. Dieses Plugin ermöglicht robustes Herunterladen von Dateien mit Pausieren/Fortsetzen-Funktionalität und detaillierter Fortschrittsüberwachung.
> **In Entwicklung**: Dieses Plugin befindet sich derzeit in der Entwicklung und ist noch nicht für den Produktionseinsatz bereit.
Hintergrund-Downloads
Downloads fortsetzen, wenn die App im Hintergrund ist
Fortschrittsverfolgung
Echtzeit-Download-Fortschritt und Statusüberwachung
Download-Steuerung
Downloads dynamisch pausieren, fortsetzen und stoppen
Netzwerkoptionen
Netzwerkpräferenzen und Prioritäten konfigurieren
## Entwicklungsstatus
[Section titled “Entwicklungsstatus”](#entwicklungsstatus)
Dieses Plugin ist inspiriert von react-native-background-downloader und befindet sich derzeit in der Entwicklung. Funktionen können sich im Laufe der Entwicklung ändern.
# Erste Schritte
> Installations- und Verwendungsanleitung für @capgo/capacitor-downloader
## Installation
[Section titled “Installation”](#installation)
* npm
```bash
npm install @capgo/capacitor-downloader
npx cap sync
```
* yarn
```bash
yarn add @capgo/capacitor-downloader
npx cap sync
```
* pnpm
```bash
pnpm add @capgo/capacitor-downloader
npx cap sync
```
* bun
```bash
bun add @capgo/capacitor-downloader
npx cap sync
```
## Verwendungsbeispiel
[Section titled “Verwendungsbeispiel”](#verwendungsbeispiel)
```typescript
import { CapacitorDownloader } from '@capgo/capacitor-downloader';
// Einen Download starten
const downloadId = 'my-download-001';
await CapacitorDownloader.download({
id: downloadId,
url: 'https://example.com/large-file.zip',
destination: '/downloads/large-file.zip',
headers: {
'Authorization': 'Bearer token123'
},
network: 'wifi-only',
priority: 'high'
});
// Auf Fortschritts-Updates hören
CapacitorDownloader.addListener('downloadProgress', (data) => {
console.log(`Download ${data.id}: ${data.progress}% abgeschlossen`);
console.log(`Heruntergeladen: ${data.bytesDownloaded}/${data.totalBytes} Bytes`);
});
// Abschluss behandeln
CapacitorDownloader.addListener('downloadCompleted', (data) => {
console.log(`Download abgeschlossen: ${data.id}`);
console.log(`Datei gespeichert in: ${data.path}`);
});
// Fehler behandeln
CapacitorDownloader.addListener('downloadFailed', (error) => {
console.error(`Download fehlgeschlagen: ${error.id}`, error.message);
});
// Einen Download pausieren
await CapacitorDownloader.pause(downloadId);
// Den Download fortsetzen
await CapacitorDownloader.resume(downloadId);
// Download-Status prüfen
const status = await CapacitorDownloader.checkStatus(downloadId);
console.log('Download-Status:', status);
// Den Download stoppen
await CapacitorDownloader.stop(downloadId);
```
## Kern-API-Methoden
[Section titled “Kern-API-Methoden”](#kern-api-methoden)
### Download-Verwaltung
[Section titled “Download-Verwaltung”](#download-verwaltung)
* `download(options)` - Neuen Datei-Download starten
* `pause(id)` - Laufenden Download pausieren
* `resume(id)` - Pausierten Download fortsetzen
* `stop(id)` - Download stoppen und abbrechen
* `checkStatus(id)` - Aktuellen Download-Status abrufen
### Dateioperationen
[Section titled “Dateioperationen”](#dateioperationen)
* `getFileInfo(path)` - Dateiinformationen und Metadaten abrufen
## Download-Konfiguration
[Section titled “Download-Konfiguration”](#download-konfiguration)
```typescript
interface DownloadOptions {
id: string; // Eindeutige Download-Kennung
url: string; // Download-Quell-URL
destination: string; // Lokaler Speicherpfad
headers?: Record; // Benutzerdefinierte HTTP-Header
network?: 'cellular' | 'wifi-only'; // Netzwerkbeschränkungen
priority?: 'high' | 'normal' | 'low'; // Download-Priorität
}
```
## Event-Listener
[Section titled “Event-Listener”](#event-listener)
Das Plugin bietet umfassende Ereignisbehandlung:
* `downloadProgress` - Echtzeit-Download-Fortschritt verfolgen
* `downloadCompleted` - Erfolgreichen Download-Abschluss behandeln
* `downloadFailed` - Download-Fehler und -Ausfälle behandeln
## Netzwerkkonfiguration
[Section titled “Netzwerkkonfiguration”](#netzwerkkonfiguration)
### Nur-WiFi-Downloads
[Section titled “Nur-WiFi-Downloads”](#nur-wifi-downloads)
```typescript
await CapacitorDownloader.download({
id: 'large-file',
url: 'https://example.com/video.mp4',
destination: '/downloads/video.mp4',
network: 'wifi-only' // Beschränkt auf WiFi-Netzwerke
});
```
### Prioritätsverwaltung
[Section titled “Prioritätsverwaltung”](#prioritätsverwaltung)
```typescript
// Download mit hoher Priorität
await CapacitorDownloader.download({
id: 'urgent-update',
url: 'https://example.com/update.zip',
destination: '/downloads/update.zip',
priority: 'high'
});
```
## Download-Zustände
[Section titled “Download-Zustände”](#download-zustände)
Downloads können verschiedene Zustände haben:
* **Pending**: In Warteschlange für Download
* **Running**: Wird gerade heruntergeladen
* **Paused**: Vorübergehend gestoppt
* **Completed**: Erfolgreich abgeschlossen
* **Failed**: Fehler aufgetreten
* **Stopped**: Manuell abgebrochen
## Dateiinformationen
[Section titled “Dateiinformationen”](#dateiinformationen)
```typescript
// Dateidetails abrufen
const fileInfo = await CapacitorDownloader.getFileInfo('/downloads/my-file.pdf');
console.log('Dateigröße:', fileInfo.size);
console.log('Zuletzt geändert:', fileInfo.lastModified);
console.log('MIME-Typ:', fileInfo.mimeType);
```
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
* Verwenden Sie eindeutige Download-IDs, um Konflikte zu vermeiden
* Implementieren Sie ordnungsgemäße Fehlerbehandlung für Netzwerkausfälle
* Berücksichtigen Sie Speicherplatz vor dem Starten großer Downloads
* Verwenden Sie den Nur-WiFi-Modus für große Dateien, um mobile Daten zu schonen
* Bereinigen Sie abgeschlossene Downloads, um Speicher zu verwalten
# @capgo/capacitor-env
> Liefern Sie mandantenspezifische Einstellungen ohne neue Builds, indem Sie sichere Konfigurationswerte direkt von Capacitor lesen.
Mit Capgo Env können Sie Secrets und Build-spezifische Konfigurationen in `capacitor.config.*` speichern und zur Laufzeit durch eine einfache API auflösen.
Laufzeitkonfiguration
Lesen Sie Werte aus nativen Konfigurationsdateien, ohne sie in Ihrem JavaScript-Bundle zu versenden.
Build-spezifische Overrides
Erstellen Sie mehrere App-Varianten oder Mandanten, indem Sie unterschiedliche Konfigurationsdateien bereitstellen.
Typsicherer Zugriff
Rufen Sie Schlüssel mit TypeScript-Unterstützung ab und zentralisieren Sie Fallback-Logik.
Standardmäßig sicher
Halten Sie API-Schlüssel und Secrets aus Git heraus, während Sie sie dennoch mit nativen Binärdateien versenden.
Folgen Sie dem Leitfaden für Erste Schritte, um Schlüssel in Ihrer Capacitor-Konfiguration zu deklarieren und diese sicher auf allen Plattformen abzurufen.
# Erste Schritte
> Konfigurieren Sie Build-spezifische Umgebungswerte und rufen Sie sie zur Laufzeit mit dem Env-Plugin ab.
1. **Paket installieren**
* npm
```sh
npm i @capgo/capacitor-env
```
* pnpm
```sh
pnpm add @capgo/capacitor-env
```
* yarn
```sh
yarn add @capgo/capacitor-env
```
* bun
```sh
bun add @capgo/capacitor-env
```
2. **Native Plattformen synchronisieren**
* npm
```sh
npx cap sync
```
* pnpm
```sh
pnpm cap sync
```
* yarn
```sh
yarn cap sync
```
* bun
```sh
bunx cap sync
```
## Konfigurationswerte deklarieren
[Section titled “Konfigurationswerte deklarieren”](#konfigurationswerte-deklarieren)
Fügen Sie Schlüssel zur Capacitor-Konfiguration hinzu, damit sie in Ihre nativen Builds eingebettet werden. Sie können mehrere Konfigurationsvarianten (`capacitor.config.prod.ts`, `capacitor.config.dev.ts`, etc.) erstellen, um Werte pro Umgebung auszutauschen.
capacitor.config.ts
```ts
import { CapacitorConfig } from '@capacitor/cli';
const config: CapacitorConfig = {
appId: 'com.example.app',
appName: 'Example',
webDir: 'dist',
plugins: {
Env: {
API_URL: 'https://api.example.com',
PUBLIC_KEY: 'pk_live_123',
},
},
};
export default config;
```
Auf nativen Plattformen werden die Werte in den generierten Konfigurationsdateien gespeichert (`ios/App/App/capacitor.config.json` und `android/app/src/main/assets/capacitor.config.json`). Aktualisieren Sie diese Dateien pro Variante, wenn Sie mandantenspezifische Werte benötigen.
## Werte im Code lesen
[Section titled “Werte im Code lesen”](#werte-im-code-lesen)
```typescript
import { Env } from '@capgo/capacitor-env';
const apiUrl = await Env.getKey({ key: 'API_URL' }).then((result) => result.value);
if (!apiUrl) {
throw new Error('Fehlende API_URL-Konfiguration');
}
```
## Fallbacks bereitstellen
[Section titled “Fallbacks bereitstellen”](#fallbacks-bereitstellen)
```typescript
const loadConfig = async () => {
const { value: endpoint } = await Env.getKey({ key: 'API_URL' });
return endpoint || 'https://staging.example.com';
};
```
## Tipps
[Section titled “Tipps”](#tipps)
* Verwenden Sie unterschiedliche `capacitor.config`-Dateien pro Umgebung und verweisen Sie die CLI mit `npx cap run ios --configuration=prod` auf die richtige.
* Kombinieren Sie mit Capgo Updater-Kanälen, um mandantenspezifische Werte zu liefern, ohne neue Binärdateien zu veröffentlichen.
* Halten Sie Geheimnisse aus der Versionskontrolle heraus, indem Sie sie während Ihres CI-Builds vor `npx cap sync` ersetzen.
# @capgo/capacitor-fast-sql
> Ultra-schnelles natives SQLite mit benutzerdefiniertem Protokoll für Synchronisierungssysteme und große Datensätze, mit bis zu 25-fach höherer Leistung.
Benutzerdefiniertes HTTP-Protokoll
Umgeht die Capacitor-Bridge für bis zu 25-fach höhere Leistung ⚡
Vollständige SQLite-Unterstützung
Vollständige SQL-Unterstützung mit Transaktionen und Batch-Operationen 📊
Synchronisierungsfreundlich
Entwickelt für lokale Synchronisierungssysteme wie CRDTs und operative Transformationen 🔄
Plattformübergreifend
iOS, Android und Web mit sql.js + IndexedDB 🌐
Transaktionsunterstützung
ACID-Transaktionen mit konfigurierbaren Isolationsstufen 🔒
Binärdaten
Native Unterstützung für Uint8Array/BLOB-Speicherung 📁
Erste Schritte
Schauen Sie sich die [Anleitung für erste Schritte](/docs/plugins/fast-sql/getting-started/) an, um das Plugin zu installieren und zu konfigurieren.
# Erste Schritte mit Fast SQL
> Installieren und konfigurieren Sie das Fast SQL Plugin für leistungsstarken nativen SQLite-Datenbankzugriff
Diese Anleitung hilft Ihnen bei der Installation und Konfiguration des **@capgo/capacitor-fast-sql** Plugins für leistungsstarken SQLite-Datenbankzugriff.
## Warum Fast SQL?
[Section titled “Warum Fast SQL?”](#warum-fast-sql)
Traditionelle SQLite-Plugins für Capacitor verwenden die Standard-JavaScript-Bridge zur Kommunikation zwischen Ihrem Web-Code und nativem Code. Während dies für kleine Operationen gut funktioniert, wird die Bridge zu einem erheblichen Engpass, wenn große Datenmengen übertragen werden müssen. Jedes Datenstück muss in JSON serialisiert, über die Bridge gesendet und auf der anderen Seite wieder deserialisiert werden. Dieser Serialisierungs-Overhead macht Operationen mit Tausenden von Zeilen oder großen Binärdaten unglaublich langsam.
**Fast SQL löst dieses Problem**, indem es einen lokalen HTTP-Server auf dem Gerät einrichtet, der direkt mit der nativen SQLite-Datenbank kommuniziert. Dieses benutzerdefinierte Protokoll umgeht Capacitors Bridge vollständig, eliminiert den Serialisierungs-Overhead und ermöglicht:
* **Bis zu 25x schnellere Leistung** für Batch-Operationen und große Datensätze
* **Effizienten binären Datentransfer** ohne base64-Kodierung
* **Streaming großer Ergebnisse** ohne Speicherprobleme
* **Optimale Leistung für Sync-Systeme** wie CRDTs und Operational Transforms
Dies macht Fast SQL ideal für Local-First-Anwendungen, Offline-Sync-Systeme und Szenarien, in denen Sie IndexedDB durch eine zuverlässigere und leistungsstärkere Lösung ersetzen müssen.
## Installation
[Section titled “Installation”](#installation)
```bash
npm install @capgo/capacitor-fast-sql
npx cap sync
```
## Plattform-Konfiguration
[Section titled “Plattform-Konfiguration”](#plattform-konfiguration)
### iOS-Konfiguration
[Section titled “iOS-Konfiguration”](#ios-konfiguration)
Fügen Sie Folgendes zu Ihrer `Info.plist` hinzu, um lokale Netzwerkverbindungen zu erlauben:
ios/App/App/Info.plist
```xml
NSAppTransportSecurity
NSAllowsLocalNetworking
```
### Android-Konfiguration
[Section titled “Android-Konfiguration”](#android-konfiguration)
Falls erforderlich, fügen Sie dies zu Ihrer `AndroidManifest.xml` hinzu:
android/app/src/main/AndroidManifest.xml
```xml
...
```
### Web-Konfiguration
[Section titled “Web-Konfiguration”](#web-konfiguration)
Für die Unterstützung der Web-Plattform installieren Sie sql.js:
```bash
npm install sql.js
```
## Grundlegende Verwendung
[Section titled “Grundlegende Verwendung”](#grundlegende-verwendung)
### Verbindung zu einer Datenbank herstellen
[Section titled “Verbindung zu einer Datenbank herstellen”](#verbindung-zu-einer-datenbank-herstellen)
```typescript
import { FastSQL } from '@capgo/capacitor-fast-sql';
// Verbindung zur Datenbank herstellen (erstellt Datei, falls sie nicht existiert)
const db = await FastSQL.connect({
database: 'myapp'
});
console.log('Mit Datenbank auf Port verbunden:', db.port);
```
### Tabellen erstellen
[Section titled “Tabellen erstellen”](#tabellen-erstellen)
```typescript
// Eine Tabelle erstellen
await db.execute(`
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
email TEXT UNIQUE,
created_at INTEGER DEFAULT (strftime('%s', 'now'))
)
`);
```
### Daten einfügen
[Section titled “Daten einfügen”](#daten-einfügen)
```typescript
// Einzelne Zeile einfügen
const result = await db.run(
'INSERT INTO users (name, email) VALUES (?, ?)',
['John Doe', 'john@example.com']
);
console.log('Eingefügte Zeilen-ID:', result.insertId);
console.log('Betroffene Zeilen:', result.rowsAffected);
```
### Daten abfragen
[Section titled “Daten abfragen”](#daten-abfragen)
```typescript
// Abfrage mit Parametern
const users = await db.query(
'SELECT * FROM users WHERE name LIKE ?',
['John%']
);
console.log('Gefundene Benutzer:', users);
// users ist ein Array von Objekten:
// [{ id: 1, name: 'John Doe', email: 'john@example.com', created_at: 1234567890 }]
```
### Daten aktualisieren
[Section titled “Daten aktualisieren”](#daten-aktualisieren)
```typescript
const result = await db.run(
'UPDATE users SET email = ? WHERE id = ?',
['newemail@example.com', 1]
);
console.log('Aktualisierte Zeilen:', result.rowsAffected);
```
### Daten löschen
[Section titled “Daten löschen”](#daten-löschen)
```typescript
const result = await db.run(
'DELETE FROM users WHERE id = ?',
[1]
);
console.log('Gelöschte Zeilen:', result.rowsAffected);
```
## Transaktionen
[Section titled “Transaktionen”](#transaktionen)
Transaktionen gewährleisten Atomarität - entweder werden alle Operationen erfolgreich ausgeführt oder alle werden zurückgesetzt:
```typescript
try {
await db.transaction(async (tx) => {
// Alle Operationen in diesem Block sind Teil der Transaktion
await tx.run('INSERT INTO accounts (name, balance) VALUES (?, ?)', ['Alice', 1000]);
await tx.run('INSERT INTO accounts (name, balance) VALUES (?, ?)', ['Bob', 500]);
// Geld überweisen
await tx.run('UPDATE accounts SET balance = balance - 100 WHERE name = ?', ['Alice']);
await tx.run('UPDATE accounts SET balance = balance + 100 WHERE name = ?', ['Bob']);
});
console.log('Transaktion erfolgreich abgeschlossen!');
} catch (error) {
console.error('Transaktion zurückgesetzt:', error);
// Alle Änderungen werden bei einem Fehler automatisch zurückgesetzt
}
```
### Transaktions-Isolationsstufen
[Section titled “Transaktions-Isolationsstufen”](#transaktions-isolationsstufen)
```typescript
import { FastSQL, IsolationLevel } from '@capgo/capacitor-fast-sql';
await db.transaction(async (tx) => {
// Ihre Operationen
}, IsolationLevel.Serializable);
```
Verfügbare Isolationsstufen:
* `ReadUncommitted` - Niedrigste Isolation, höchste Leistung
* `ReadCommitted` - Verhindert Dirty Reads
* `RepeatableRead` - Verhindert nicht wiederholbare Lesevorgänge
* `Serializable` - Höchste Isolation, verhindert alle Anomalien
## Batch-Operationen
[Section titled “Batch-Operationen”](#batch-operationen)
Führen Sie mehrere Anweisungen effizient aus:
```typescript
const results = await db.executeBatch([
{
statement: 'INSERT INTO logs (message, level) VALUES (?, ?)',
params: ['App started', 'INFO']
},
{
statement: 'INSERT INTO logs (message, level) VALUES (?, ?)',
params: ['User logged in', 'INFO']
},
{
statement: 'INSERT INTO logs (message, level) VALUES (?, ?)',
params: ['Error occurred', 'ERROR']
},
]);
console.log('Ausgeführt', results.length, 'Anweisungen');
```
## Binärdaten (BLOBs)
[Section titled “Binärdaten (BLOBs)”](#binärdaten-blobs)
Speichern und abrufen Sie Binärdaten mit Uint8Array:
```typescript
// Binärdaten speichern
const imageData = new Uint8Array([0xFF, 0xD8, 0xFF, 0xE0, /* ... */]);
await db.run(
'INSERT INTO images (name, data) VALUES (?, ?)',
['photo.jpg', imageData]
);
// Binärdaten abrufen
const rows = await db.query('SELECT data FROM images WHERE name = ?', ['photo.jpg']);
const retrievedData = rows[0].data; // Uint8Array
```
## Verschlüsselung (iOS/Android)
[Section titled “Verschlüsselung (iOS/Android)”](#verschlüsselung-iosandroid)
Aktivieren Sie SQLCipher-Verschlüsselung für sichere Speicherung:
```typescript
const db = await FastSQL.connect({
database: 'secure_db',
encrypted: true,
encryptionKey: 'your-secure-encryption-key'
});
```
Caution
* Verschlüsselung ist nur auf iOS und Android verfügbar
* Speichern Sie Verschlüsselungsschlüssel sicher (verwenden Sie Keychain/Keystore)
* Verschlüsselte Datenbanken können nicht ohne den richtigen Schlüssel geöffnet werden
* Die Web-Plattform unterstützt keine Verschlüsselung
## Nur-Lese-Modus
[Section titled “Nur-Lese-Modus”](#nur-lese-modus)
Öffnen Sie Datenbanken im Nur-Lese-Modus, um Änderungen zu verhindern:
```typescript
const db = await FastSQL.connect({
database: 'myapp',
readOnly: true
});
```
## Verbindungen schließen
[Section titled “Verbindungen schließen”](#verbindungen-schließen)
Schließen Sie Datenbankverbindungen immer, wenn Sie fertig sind:
```typescript
await FastSQL.disconnect('myapp');
```
## Direktes HTTP-Protokoll
[Section titled “Direktes HTTP-Protokoll”](#direktes-http-protokoll)
Für maximale Leistung bei großen Datensätzen verwenden Sie das HTTP-Protokoll direkt:
```typescript
const { port, token } = await FastSQL.getServerInfo({ database: 'myapp' });
// Direkte HTTP-Anfragen an localhost:port stellen
// Token im Authorization-Header einschließen
const response = await fetch(`http://localhost:${port}/execute`, {
method: 'POST',
headers: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
statement: 'SELECT * FROM users',
params: []
})
});
const result = await response.json();
```
## Fehlerbehandlung
[Section titled “Fehlerbehandlung”](#fehlerbehandlung)
```typescript
import { FastSQL } from '@capgo/capacitor-fast-sql';
try {
const db = await FastSQL.connect({ database: 'myapp' });
await db.run('INSERT INTO users (name, email) VALUES (?, ?)', ['John', 'john@example.com']);
} catch (error) {
if (error.message.includes('UNIQUE constraint failed')) {
console.error('E-Mail existiert bereits');
} else if (error.message.includes('no such table')) {
console.error('Tabelle existiert nicht');
} else {
console.error('Datenbankfehler:', error);
}
}
```
## Gängige SQL-Muster
[Section titled “Gängige SQL-Muster”](#gängige-sql-muster)
### Prüfen, ob Tabelle existiert
[Section titled “Prüfen, ob Tabelle existiert”](#prüfen-ob-tabelle-existiert)
```typescript
const result = await db.query(
"SELECT name FROM sqlite_master WHERE type='table' AND name=?",
['users']
);
const tableExists = result.length > 0;
```
### Tabellenschema abrufen
[Section titled “Tabellenschema abrufen”](#tabellenschema-abrufen)
```typescript
const schema = await db.query('PRAGMA table_info(users)');
console.log('Spalten:', schema);
```
### Zeilen zählen
[Section titled “Zeilen zählen”](#zeilen-zählen)
```typescript
const result = await db.query('SELECT COUNT(*) as count FROM users');
const count = result[0].count;
```
### Paginierung
[Section titled “Paginierung”](#paginierung)
```typescript
const pageSize = 20;
const page = 1;
const offset = (page - 1) * pageSize;
const users = await db.query(
'SELECT * FROM users ORDER BY created_at DESC LIMIT ? OFFSET ?',
[pageSize, offset]
);
```
## Leistungstipps
[Section titled “Leistungstipps”](#leistungstipps)
1. **Verwenden Sie Transaktionen** für mehrere Operationen - deutlich schneller als einzelne Commits
2. **Verwenden Sie Batch-Operationen** für Masseneinfügungen - effizienter als Schleifen
3. **Erstellen Sie Indizes** für häufig abgefragte Spalten
4. **Verwenden Sie vorbereitete Anweisungen** mit Parametern (?) - verhindert SQL-Injection und verbessert Leistung
5. **Verwenden Sie HTTP-Protokoll direkt** für sehr große Ergebnismengen
6. **Schließen Sie Verbindungen** wenn nicht in Verwendung, um Ressourcen freizugeben
## Nächste Schritte
[Section titled “Nächste Schritte”](#nächste-schritte)
Schauen Sie sich das [vollständige Tutorial](/plugins/capacitor-fast-sql) an für fortgeschrittene Muster einschließlich:
* Datenbank-Service-Architektur
* Migrationssysteme
* Sync-Engines
* Komplexe Abfragen und Joins
* Leistungsoptimierung
# @capgo/capacitor-ffmpeg
> Codieren Sie Videos mit benutzerdefinierter Auflösung und Bitrate neu, indem Sie die leistungsstarke FFmpeg-Bibliothek in Ihren Capacitor-Apps verwenden.
Video-Neucodierung
Videos mit FFmpeg konvertieren und komprimieren
Benutzerdefinierte Auflösung
Videos auf beliebige Breite und Höhe skalieren
Bitrate-Steuerung
Videoqualität und Dateigröße kontrollieren
Umfassende Dokumentation
Schauen Sie sich die [Dokumentation](/docs/plugins/ffmpeg/getting-started/) an, um mit der Videoverarbeitung zu beginnen.
# Erste Schritte
> Erfahren Sie, wie Sie das FFmpeg-Plugin für die Videoverarbeitung in Ihrer Capacitor-App installieren und verwenden.
1. **Paket installieren**
* npm
```sh
npm i @capgo/capacitor-ffmpeg
```
* pnpm
```sh
pnpm add @capgo/capacitor-ffmpeg
```
* yarn
```sh
yarn add @capgo/capacitor-ffmpeg
```
* bun
```sh
bun add @capgo/capacitor-ffmpeg
```
2. **Mit nativen Projekten synchronisieren**
* npm
```sh
npx cap sync
```
* pnpm
```sh
pnpm cap sync
```
* yarn
```sh
yarn cap sync
```
* bun
```sh
bunx cap sync
```
## Verwendung
[Section titled “Verwendung”](#verwendung)
Importieren Sie das Plugin und verwenden Sie es zur Neucodierung von Videos:
```typescript
import { CapacitorFFmpeg } from '@capgo/capacitor-ffmpeg';
// Video mit benutzerdefinierten Einstellungen neu codieren
const processVideo = async () => {
await CapacitorFFmpeg.reencodeVideo({
inputPath: '/pfad/zur/eingabe/video.mp4',
outputPath: '/pfad/zur/ausgabe/video.mp4',
width: 1280,
height: 720,
bitrate: 2000000 // Optional: 2 Mbps
});
};
// Plugin-Version abrufen
const checkVersion = async () => {
const { version } = await CapacitorFFmpeg.getPluginVersion();
console.log('FFmpeg-Plugin-Version:', version);
};
```
## API-Referenz
[Section titled “API-Referenz”](#api-referenz)
### reencodeVideo(options)
[Section titled “reencodeVideo(options)”](#reencodevideooptions)
Codiert eine Videodatei mit angegebenen Abmessungen und Bitrate neu.
```typescript
await CapacitorFFmpeg.reencodeVideo({
inputPath: '/pfad/zur/eingabe.mp4',
outputPath: '/pfad/zur/ausgabe.mp4',
width: 1920,
height: 1080,
bitrate: 5000000 // Optional: 5 Mbps
});
```
**Parameter:**
* `inputPath` (string): Vollständiger Pfad zur Eingabevideodatei
* `outputPath` (string): Vollständiger Pfad, wo das Ausgabevideo gespeichert wird
* `width` (number): Zielbreite in Pixeln
* `height` (number): Zielhöhe in Pixeln
* `bitrate` (number, optional): Ziel-Bitrate in Bits pro Sekunde
### getPluginVersion()
[Section titled “getPluginVersion()”](#getpluginversion)
Ruft die native Capacitor-Plugin-Version ab.
```typescript
const { version } = await CapacitorFFmpeg.getPluginVersion();
```
## Vollständiges Beispiel
[Section titled “Vollständiges Beispiel”](#vollständiges-beispiel)
```typescript
import { CapacitorFFmpeg } from '@capgo/capacitor-ffmpeg';
import { Filesystem, Directory } from '@capacitor/filesystem';
export class VideoProcessor {
/**
* Video komprimieren, um Dateigröße zu reduzieren
*/
async compressVideo(inputPath: string, quality: 'low' | 'medium' | 'high') {
const qualitySettings = {
low: { width: 640, height: 360, bitrate: 500000 },
medium: { width: 1280, height: 720, bitrate: 2000000 },
high: { width: 1920, height: 1080, bitrate: 5000000 }
};
const settings = qualitySettings[quality];
const outputPath = inputPath.replace('.mp4', `_${quality}.mp4`);
try {
await CapacitorFFmpeg.reencodeVideo({
inputPath,
outputPath,
width: settings.width,
height: settings.height,
bitrate: settings.bitrate
});
console.log(`Video auf ${quality}-Qualität komprimiert:`, outputPath);
return outputPath;
} catch (error) {
console.error('Videokomprimierung fehlgeschlagen:', error);
throw error;
}
}
/**
* Video auf bestimmte Abmessungen skalieren
*/
async resizeVideo(
inputPath: string,
width: number,
height: number
): Promise {
const outputPath = inputPath.replace('.mp4', '_resized.mp4');
await CapacitorFFmpeg.reencodeVideo({
inputPath,
outputPath,
width,
height
});
return outputPath;
}
/**
* Miniaturansicht-Qualität eines Videos erstellen
*/
async createThumbnailVideo(inputPath: string): Promise {
return this.compressVideo(inputPath, 'low');
}
/**
* Mehrere Videos stapelweise verarbeiten
*/
async processMultipleVideos(
videoPaths: string[],
width: number,
height: number,
bitrate?: number
): Promise {
const outputPaths: string[] = [];
for (const inputPath of videoPaths) {
const outputPath = inputPath.replace('.mp4', '_processed.mp4');
try {
await CapacitorFFmpeg.reencodeVideo({
inputPath,
outputPath,
width,
height,
bitrate
});
outputPaths.push(outputPath);
} catch (error) {
console.error(`Verarbeitung von ${inputPath} fehlgeschlagen:`, error);
}
}
return outputPaths;
}
}
```
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
1. **Geeignete Bitraten verwenden** Wählen Sie die Bitrate basierend auf Auflösung und Anwendungsfall:
```typescript
// Mobiles Teilen (niedrige Bandbreite)
const lowQuality = { width: 640, height: 360, bitrate: 500000 };
// Standardqualität
const standardQuality = { width: 1280, height: 720, bitrate: 2000000 };
// Hohe Qualität
const highQuality = { width: 1920, height: 1080, bitrate: 5000000 };
```
2. **Seitenverhältnis beibehalten** Berechnen Sie Abmessungen, um das Seitenverhältnis zu erhalten:
```typescript
function calculateDimensions(originalWidth: number, originalHeight: number, targetWidth: number) {
const aspectRatio = originalWidth / originalHeight;
return {
width: targetWidth,
height: Math.round(targetWidth / aspectRatio)
};
}
```
3. **Dateipfade korrekt handhaben** Verwenden Sie Capacitor Filesystem für plattformübergreifende Pfadbehandlung:
```typescript
import { Filesystem, Directory } from '@capacitor/filesystem';
const inputPath = await Filesystem.getUri({
directory: Directory.Documents,
path: 'input.mp4'
});
```
4. **Fortschritt für Benutzer anzeigen** Videoverarbeitung kann langsam sein - informieren Sie Benutzer:
```typescript
async function processWithProgress(inputPath: string) {
// Ladeindikator anzeigen
showLoading('Video wird verarbeitet...');
try {
await CapacitorFFmpeg.reencodeVideo({
inputPath,
outputPath: '/pfad/zur/ausgabe.mp4',
width: 1280,
height: 720
});
showSuccess('Video erfolgreich verarbeitet!');
} catch (error) {
showError('Videoverarbeitung fehlgeschlagen');
} finally {
hideLoading();
}
}
```
5. **Temporäre Dateien aufräumen** Entfernen Sie Zwischendateien, um Speicherplatz zu sparen:
```typescript
async function processAndCleanup(inputPath: string) {
const outputPath = inputPath.replace('.mp4', '_output.mp4');
await CapacitorFFmpeg.reencodeVideo({
inputPath,
outputPath,
width: 1280,
height: 720
});
// Original entfernen, wenn nicht mehr benötigt
await Filesystem.deleteFile({ path: inputPath });
return outputPath;
}
```
## Plattformhinweise
[Section titled “Plattformhinweise”](#plattformhinweise)
### iOS
[Section titled “iOS”](#ios)
* Erfordert iOS 11.0+
* Große Videoverarbeitung kann Hintergrund-Task-Berechtigungen erfordern
* Verwendet natives iOS VideoToolbox für Hardwarebeschleunigung
### Android
[Section titled “Android”](#android)
* Erfordert Android 5.0 (API 21)+
* Hardwarebeschleunigung variiert je nach Gerät
* Kann WRITE\_EXTERNAL\_STORAGE-Berechtigung für Dateizugriff erfordern
### Web
[Section titled “Web”](#web)
* Nicht auf Web-Plattform unterstützt
## Leistungstipps
[Section titled “Leistungstipps”](#leistungstipps)
1. **Niedrigere Auflösung für schnellere Verarbeitung**: Kleinere Abmessungen = schnellere Codierung
2. **Hardwarebeschleunigung verwenden**: Lassen Sie die native Plattform die Codierung optimieren
3. **Im Hintergrund verarbeiten**: Blockieren Sie nicht die UI während der Videoverarbeitung
4. **Speicherverbrauch überwachen**: Große Videos können erheblichen Speicher verbrauchen
5. **Auf echten Geräten testen**: Emulatoren spiegeln möglicherweise nicht die tatsächliche Leistung wider
# @capgo/capacitor-file
> Vollständige Dateisystem-Operationen mit Lesen, Schreiben, Kopieren, Verschieben und Verzeichnisverwaltung für iOS und Android.
Vollständige Dateioperationen
Dateien einfach lesen, schreiben, anhängen, kopieren, verschieben und löschen
Verzeichnisverwaltung
Verzeichnisse mit rekursiver Unterstützung erstellen, auflisten und entfernen
Mehrere Kodierungen
Unterstützung für UTF-8, ASCII, UTF-16 und binäre (base64) Daten
Plattformübergreifend
Funktioniert auf iOS und Android mit konsistenter API über alle Plattformen hinweg
# @capgo/capacitor-file-compressor
> Komprimieren Sie Bilder effizient mit Unterstützung für PNG-, JPEG- und WebP-Formate auf iOS, Android und Web.
Mehrere Formate
Unterstützung für JPEG- und WebP-Komprimierung plattformübergreifend 🖼️
Qualitätskontrolle
Einstellbare Komprimierungsqualität von 0.0 bis 1.0 für perfekte Balance ⚙️
Intelligente Größenänderung
Automatische Beibehaltung des Seitenverhältnisses während der Größenänderung 📐
Kein Backend
Alle Komprimierung erfolgt auf dem Gerät - kein Server erforderlich 🚀
Plattformübergreifend
Konsistente API über iOS-, Android- und Web-Plattformen 📱
Umfassende Dokumentation
Schauen Sie sich die [Dokumentation](/docs/plugins/file-compressor/getting-started/) an, um das Plugin in nur wenigen Minuten zu meistern.
# Erste Schritte
> Erfahren Sie, wie Sie das File Compressor-Plugin installieren und verwenden, um Bilder in Ihrer Capacitor-App zu komprimieren.
1. **Paket installieren**
* npm
```sh
npm i @capgo/capacitor-file-compressor
```
* pnpm
```sh
pnpm add @capgo/capacitor-file-compressor
```
* yarn
```sh
yarn add @capgo/capacitor-file-compressor
```
* bun
```sh
bun add @capgo/capacitor-file-compressor
```
2. **Mit nativen Projekten synchronisieren**
* npm
```sh
npx cap sync
```
* pnpm
```sh
pnpm cap sync
```
* yarn
```sh
yarn cap sync
```
* bun
```sh
bunx cap sync
```
## Plattformunterstützung
[Section titled “Plattformunterstützung”](#plattformunterstützung)
| Plattform | Unterstützte Formate | Hinweise |
| --------- | -------------------- | ------------------------------------- |
| iOS | JPEG | Nur JPEG-Komprimierung unterstützt |
| Android | JPEG, WebP | Beide Formate vollständig unterstützt |
| Web | JPEG, WebP | Canvas-API-basierte Komprimierung |
Hinweis: EXIF-Metadaten werden während der Komprimierung auf allen Plattformen entfernt.
## Verwendung
[Section titled “Verwendung”](#verwendung)
Importieren Sie das Plugin und komprimieren Sie Bilder:
```typescript
import { FileCompressor } from '@capgo/capacitor-file-compressor';
// Bild komprimieren
const compressImage = async () => {
const result = await FileCompressor.compressImage({
source: 'file:///pfad/zum/bild.jpg',
quality: 0.8,
width: 1920,
height: 1080
});
console.log('Komprimierter Bildpfad:', result.path);
console.log('Originalgröße:', result.originalSize);
console.log('Komprimierte Größe:', result.size);
};
```
## API-Referenz
[Section titled “API-Referenz”](#api-referenz)
### compressImage(options)
[Section titled “compressImage(options)”](#compressimageoptions)
Komprimiert eine Bilddatei mit angegebenen Abmessungen und Qualitätseinstellungen.
```typescript
interface CompressImageOptions {
source: string; // Pfad zur Bilddatei
quality?: number; // 0.0 bis 1.0 (Standard: 0.8)
width?: number; // Zielbreite in Pixeln
height?: number; // Zielhöhe in Pixeln
format?: 'jpeg' | '.webp'; // Ausgabeformat
}
interface CompressImageResult {
path: string; // Pfad zum komprimierten Bild
size: number; // Komprimierte Dateigröße in Bytes
originalSize: number; // Original-Dateigröße in Bytes
}
const result = await FileCompressor.compressImage(options);
```
**Wichtige Hinweise:**
* EXIF-Metadaten werden während der Komprimierung auf allen Plattformen entfernt
* Seitenverhältnis wird automatisch beibehalten, wenn nur eine Dimension angegeben wird
* Komprimierte Dateien werden auf nativen Plattformen in temporären Verzeichnissen gespeichert
### getPluginVersion()
[Section titled “getPluginVersion()”](#getpluginversion)
Ruft die native Plugin-Version ab.
```typescript
const { version } = await FileCompressor.getPluginVersion();
console.log('Plugin-Version:', version);
```
## Vollständiges Beispiel
[Section titled “Vollständiges Beispiel”](#vollständiges-beispiel)
```typescript
import { FileCompressor } from '@capgo/capacitor-file-compressor';
import { Camera } from '@capacitor/camera';
export class ImageCompressionService {
async captureAndCompress() {
try {
// Foto aufnehmen
const photo = await Camera.getPhoto({
quality: 100,
allowEditing: false,
resultType: 'uri'
});
if (!photo.path) {
throw new Error('Kein Bildpfad');
}
// Foto komprimieren
const compressed = await FileCompressor.compressImage({
source: photo.path,
quality: 0.7,
width: 1920,
height: 1080,
format: 'jpeg'
});
console.log(`Komprimierungsverhältnis: ${
((1 - compressed.size / compressed.originalSize) * 100).toFixed(1)
}%`);
return compressed.path;
} catch (error) {
console.error('Komprimierung fehlgeschlagen:', error);
throw error;
}
}
async batchCompress(imagePaths: string[]) {
const results = [];
for (const path of imagePaths) {
try {
const result = await FileCompressor.compressImage({
source: path,
quality: 0.8,
width: 1280
});
results.push(result);
} catch (error) {
console.error(`Komprimierung von ${path} fehlgeschlagen:`, error);
}
}
return results;
}
}
```
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
1. **Qualitätseinstellungen**: Beginnen Sie mit Qualität 0.8 für eine gute Balance zwischen Dateigröße und Bildqualität
2. **Größenänderungsabmessungen**: Geben Sie nur Abmessungen an, wenn nötig - Seitenverhältnis wird automatisch beibehalten
3. **Formatauswahl**: Verwenden Sie JPEG für Fotos und WebP für bessere Komprimierung (nur Android/Web)
4. **Fehlerbehandlung**: Umschließen Sie Komprimierungsaufrufe immer mit try-catch-Blöcken
5. **Aufräumen**: Denken Sie daran, temporäre Dateien nach Gebrauch zu bereinigen
## Fehlerbehebung
[Section titled “Fehlerbehebung”](#fehlerbehebung)
### Häufige Probleme
[Section titled “Häufige Probleme”](#häufige-probleme)
**Bild wird nicht komprimiert**: Stellen Sie sicher, dass der Quellpfad gültig und zugänglich ist **Nicht genügend Speicher**: Reduzieren Sie die Zielabmessungen oder komprimieren Sie Bilder einzeln **Format nicht unterstützt**: Überprüfen Sie die Plattformunterstützungstabelle oben
# Erste Schritte
> Erfahren Sie, wie Sie das File-Plugin für Dateisystemoperationen in Ihrer Capacitor-App installieren und verwenden.
1. **Paket installieren**
* npm
```sh
npm i @capgo/capacitor-file
```
* pnpm
```sh
pnpm add @capgo/capacitor-file
```
* yarn
```sh
yarn add @capgo/capacitor-file
```
* bun
```sh
bun add @capgo/capacitor-file
```
2. **Mit nativen Projekten synchronisieren**
* npm
```sh
npx cap sync
```
* pnpm
```sh
pnpm cap sync
```
* yarn
```sh
yarn cap sync
```
* bun
```sh
bunx cap sync
```
## Verwendung
[Section titled “Verwendung”](#verwendung)
Importieren Sie das Plugin und verwenden Sie seine Methoden für Dateioperationen:
```typescript
import { CapacitorFile, Directory, Encoding } from '@capgo/capacitor-file';
// Textdatei schreiben
const writeFile = async () => {
const result = await CapacitorFile.writeFile({
path: 'meine-datei.txt',
directory: Directory.Documents,
data: 'Hallo, Welt!',
encoding: Encoding.UTF8,
recursive: true, // Elternverzeichnisse erstellen, falls erforderlich
});
console.log('Datei geschrieben in:', result.uri);
};
// Textdatei lesen
const readFile = async () => {
const result = await CapacitorFile.readFile({
path: 'meine-datei.txt',
directory: Directory.Documents,
encoding: Encoding.UTF8,
});
console.log('Dateiinhalt:', result.data);
};
// Prüfen, ob Datei existiert
const checkExists = async () => {
const result = await CapacitorFile.exists({
path: 'meine-datei.txt',
directory: Directory.Documents,
});
console.log('Datei existiert:', result.exists);
};
// Datei löschen
const deleteFile = async () => {
await CapacitorFile.deleteFile({
path: 'meine-datei.txt',
directory: Directory.Documents,
});
};
```
## Verzeichnisspeicherorte
[Section titled “Verzeichnisspeicherorte”](#verzeichnisspeicherorte)
Das Plugin stellt mehrere Verzeichniskonstanten bereit:
```typescript
import { Directory } from '@capgo/capacitor-file';
// Verfügbare Verzeichnisse
Directory.Documents // Benutzersichtbare Dokumente (gesichert)
Directory.Data // Private App-Datenspeicherung
Directory.Library // App-Support-Dateien (iOS) / files (Android)
Directory.Cache // Temporärer Cache (kann vom OS gelöscht werden)
Directory.External // Externer Speicher (nur Android)
Directory.Application // Schreibgeschütztes App-Bundle
```
## Kodierungsoptionen
[Section titled “Kodierungsoptionen”](#kodierungsoptionen)
```typescript
import { Encoding } from '@capgo/capacitor-file';
Encoding.UTF8 // UTF-8-Textkodierung
Encoding.ASCII // ASCII-Textkodierung
Encoding.UTF16 // UTF-16-Textkodierung
// Kodierung weglassen für Binärdaten (gibt base64 zurück)
```
## API-Referenz
[Section titled “API-Referenz”](#api-referenz)
### writeFile(options)
[Section titled “writeFile(options)”](#writefileoptions)
Daten in eine Datei schreiben.
```typescript
const result = await CapacitorFile.writeFile({
path: 'ordner/datei.txt',
directory: Directory.Documents,
data: 'Dateiinhalt',
encoding: Encoding.UTF8,
recursive: true, // Verzeichnisse erstellen, falls erforderlich
append: false, // Vorhandene Datei überschreiben
position: 0, // Byte-Position für zufällige Zugriffschreibvorgänge
});
// Gibt zurück: { uri: string }
```
### readFile(options)
[Section titled “readFile(options)”](#readfileoptions)
Inhalt einer Datei lesen.
```typescript
const result = await CapacitorFile.readFile({
path: 'datei.txt',
directory: Directory.Documents,
encoding: Encoding.UTF8,
offset: 0, // Lesen ab Byte-Offset beginnen
length: 100, // Nur diese Anzahl von Bytes lesen
});
// Gibt zurück: { data: string }
```
### appendFile(options)
[Section titled “appendFile(options)”](#appendfileoptions)
Daten an eine Datei anhängen.
```typescript
await CapacitorFile.appendFile({
path: 'datei.txt',
directory: Directory.Documents,
data: '\nNeue Zeile',
encoding: Encoding.UTF8,
});
```
### deleteFile(options)
[Section titled “deleteFile(options)”](#deletefileoptions)
Datei löschen.
```typescript
await CapacitorFile.deleteFile({
path: 'datei.txt',
directory: Directory.Documents,
});
```
### mkdir(options)
[Section titled “mkdir(options)”](#mkdiroptions)
Verzeichnis erstellen.
```typescript
await CapacitorFile.mkdir({
path: 'mein-ordner/unterordner',
directory: Directory.Documents,
recursive: true, // Elternverzeichnisse erstellen
});
```
### rmdir(options)
[Section titled “rmdir(options)”](#rmdiroptions)
Verzeichnis löschen.
```typescript
await CapacitorFile.rmdir({
path: 'mein-ordner',
directory: Directory.Documents,
recursive: true, // Inhalte rekursiv löschen
});
```
### readdir(options)
[Section titled “readdir(options)”](#readdiroptions)
Verzeichnisinhalt auflisten.
```typescript
const result = await CapacitorFile.readdir({
path: '', // Leer für Wurzel des Verzeichnisses
directory: Directory.Documents,
});
// Gibt zurück: { entries: Entry[] }
// Jeder Eintrag hat: { name, isFile, isDirectory, fullPath, nativeURL }
```
### stat(options)
[Section titled “stat(options)”](#statoptions)
Datei- oder Verzeichnismetadaten abrufen.
```typescript
const result = await CapacitorFile.stat({
path: 'datei.txt',
directory: Directory.Documents,
});
// Gibt zurück: { type, size, mtime, ctime, uri }
```
### exists(options)
[Section titled “exists(options)”](#existsoptions)
Prüfen, ob eine Datei oder ein Verzeichnis existiert.
```typescript
const result = await CapacitorFile.exists({
path: 'datei.txt',
directory: Directory.Documents,
});
// Gibt zurück: { exists: boolean, type?: 'file' | 'directory' }
```
### copy(options)
[Section titled “copy(options)”](#copyoptions)
Datei oder Verzeichnis kopieren.
```typescript
const result = await CapacitorFile.copy({
from: 'quelle.txt',
to: 'ziel.txt',
directory: Directory.Documents,
toDirectory: Directory.Documents,
});
// Gibt zurück: { uri: string }
```
### rename(options) / move(options)
[Section titled “rename(options) / move(options)”](#renameoptions--moveoptions)
Datei oder Verzeichnis umbenennen oder verschieben.
```typescript
await CapacitorFile.rename({
from: 'alter-name.txt',
to: 'neuer-name.txt',
directory: Directory.Documents,
toDirectory: Directory.Documents,
});
```
### truncate(options)
[Section titled “truncate(options)”](#truncateoptions)
Datei auf bestimmte Größe kürzen.
```typescript
await CapacitorFile.truncate({
path: 'datei.txt',
directory: Directory.Documents,
size: 100, // Auf 100 Bytes kürzen
});
```
### getUri(options)
[Section titled “getUri(options)”](#geturioptions)
Native URI für eine Datei abrufen.
```typescript
const result = await CapacitorFile.getUri({
path: 'datei.txt',
directory: Directory.Documents,
});
// Gibt zurück: { uri: string }
```
### getDirectories()
[Section titled “getDirectories()”](#getdirectories)
Alle verfügbaren Verzeichnispfade abrufen.
```typescript
const dirs = await CapacitorFile.getDirectories();
// Gibt Pfade zurück für: documents, data, cache, external, etc.
```
### getFreeDiskSpace()
[Section titled “getFreeDiskSpace()”](#getfreediskspace)
Verfügbaren Speicherplatz abrufen.
```typescript
const result = await CapacitorFile.getFreeDiskSpace();
console.log('Freier Speicherplatz:', result.free, 'bytes');
```
### checkPermissions() / requestPermissions()
[Section titled “checkPermissions() / requestPermissions()”](#checkpermissions--requestpermissions)
Speicherberechtigungen handhaben (Android).
```typescript
const status = await CapacitorFile.checkPermissions();
if (status.publicStorage !== 'granted') {
await CapacitorFile.requestPermissions();
}
```
## Vollständiges Beispiel
[Section titled “Vollständiges Beispiel”](#vollständiges-beispiel)
```typescript
import { CapacitorFile, Directory, Encoding } from '@capgo/capacitor-file';
export class FileService {
async saveJson(filename: string, data: object): Promise {
await CapacitorFile.writeFile({
path: filename,
directory: Directory.Documents,
data: JSON.stringify(data, null, 2),
encoding: Encoding.UTF8,
recursive: true,
});
}
async loadJson(filename: string): Promise {
try {
const { exists } = await CapacitorFile.exists({
path: filename,
directory: Directory.Documents,
});
if (!exists) return null;
const result = await CapacitorFile.readFile({
path: filename,
directory: Directory.Documents,
encoding: Encoding.UTF8,
});
return JSON.parse(result.data) as T;
} catch (error) {
console.error('JSON konnte nicht geladen werden:', error);
return null;
}
}
async listFiles(folder: string = ''): Promise {
const result = await CapacitorFile.readdir({
path: folder,
directory: Directory.Documents,
});
return result.entries
.filter(entry => entry.isFile)
.map(entry => entry.name);
}
async deleteAll(folder: string): Promise {
const { exists } = await CapacitorFile.exists({
path: folder,
directory: Directory.Documents,
});
if (exists) {
await CapacitorFile.rmdir({
path: folder,
directory: Directory.Documents,
recursive: true,
});
}
}
async copyToBackup(filename: string): Promise {
const timestamp = Date.now();
const backupName = `backup/${timestamp}-${filename}`;
const result = await CapacitorFile.copy({
from: filename,
to: backupName,
directory: Directory.Documents,
toDirectory: Directory.Documents,
});
return result.uri;
}
}
```
## Plattformhinweise
[Section titled “Plattformhinweise”](#plattformhinweise)
### iOS
[Section titled “iOS”](#ios)
* Erfordert iOS 13.0+
* Documents-Verzeichnis ist in der Dateien-App sichtbar
* Library-Verzeichnis ist für App-Support-Dateien
* Cache kann gelöscht werden, wenn der Gerätespeicher knapp wird
### Android
[Section titled “Android”](#android)
* Erfordert Android 6.0 (API 23)+
* Externer Speicher erfordert Laufzeitberechtigungen auf älteren Android-Versionen
* Documents-Verzeichnis wird auf das files-Verzeichnis der App gemappt
* Verwenden Sie External-Verzeichnis für gemeinsamen Speicherzugriff
### Web
[Section titled “Web”](#web)
* Nicht auf Web-Plattform unterstützt
# @capgo/capacitor-flash
> Schalten Sie die Taschenlampe/Blitz Ihres Geräts programmatisch ein und aus mit diesem leichtgewichtigen Capacitor-Plugin.
Einfache API
Taschenlampe ein/aus mit nur einem Methodenaufruf 🚀
Plattformübergreifend
Funktioniert auf iOS-, Android- und Web-Plattformen 📱
Leichtgewichtig
Minimaler Footprint ohne Abhängigkeiten ⚡
Umfassende Dokumentation
Schauen Sie sich die [Dokumentation](/docs/plugins/flash/getting-started/) an, um das Plugin in nur wenigen Minuten zu meistern.
# Erste Schritte
> Erfahren Sie, wie Sie das Flash-Plugin installieren und verwenden, um die Taschenlampe Ihres Geräts in Ihrer Capacitor-App zu steuern.
1. **Paket installieren**
* npm
```sh
npm i @capgo/capacitor-flash
```
* pnpm
```sh
pnpm add @capgo/capacitor-flash
```
* yarn
```sh
yarn add @capgo/capacitor-flash
```
* bun
```sh
bun add @capgo/capacitor-flash
```
2. **Mit nativen Projekten synchronisieren**
* npm
```sh
npx cap sync
```
* pnpm
```sh
pnpm cap sync
```
* yarn
```sh
yarn cap sync
```
* bun
```sh
bunx cap sync
```
## Verwendung
[Section titled “Verwendung”](#verwendung)
Importieren Sie das Plugin und verwenden Sie seine Methoden zur Steuerung der Taschenlampe:
```typescript
import { CapacitorFlash } from '@capgo/capacitor-flash';
// Verfügbarkeit der Taschenlampe prüfen
const checkFlashlight = async () => {
const { value } = await CapacitorFlash.isAvailable();
console.log('Taschenlampe verfügbar:', value);
};
// Taschenlampe einschalten
const turnOn = async () => {
await CapacitorFlash.switchOn();
};
// Taschenlampe ausschalten
const turnOff = async () => {
await CapacitorFlash.switchOff();
};
// Prüfen, ob Taschenlampe eingeschaltet ist
const checkStatus = async () => {
const { value } = await CapacitorFlash.isSwitchedOn();
console.log('Taschenlampe ist an:', value);
};
// Taschenlampe umschalten
const toggle = async () => {
await CapacitorFlash.toggle();
};
```
## API-Referenz
[Section titled “API-Referenz”](#api-referenz)
### isAvailable()
[Section titled “isAvailable()”](#isavailable)
Prüft, ob eine Taschenlampe auf dem Gerät verfügbar ist.
```typescript
const result = await CapacitorFlash.isAvailable();
// Gibt zurück: { value: boolean }
```
### switchOn(options?)
[Section titled “switchOn(options?)”](#switchonoptions)
Schaltet die Taschenlampe ein.
```typescript
interface SwitchOnOptions {
intensity?: number; // 0.0 bis 1.0 (nur iOS)
}
await CapacitorFlash.switchOn({ intensity: 0.5 });
```
### switchOff()
[Section titled “switchOff()”](#switchoff)
Schaltet die Taschenlampe aus.
```typescript
await CapacitorFlash.switchOff();
```
### isSwitchedOn()
[Section titled “isSwitchedOn()”](#isswitchedon)
Prüft, ob die Taschenlampe derzeit eingeschaltet ist.
```typescript
const result = await CapacitorFlash.isSwitchedOn();
// Gibt zurück: { value: boolean }
```
### toggle()
[Section titled “toggle()”](#toggle)
Schaltet die Taschenlampe ein/aus.
```typescript
await CapacitorFlash.toggle();
```
## Vollständiges Beispiel
[Section titled “Vollständiges Beispiel”](#vollständiges-beispiel)
```typescript
import { CapacitorFlash } from '@capgo/capacitor-flash';
export class FlashlightService {
private isOn = false;
async init() {
const { value } = await CapacitorFlash.isAvailable();
if (!value) {
throw new Error('Taschenlampe auf diesem Gerät nicht verfügbar');
}
}
async toggle() {
if (this.isOn) {
await CapacitorFlash.switchOff();
} else {
await CapacitorFlash.switchOn();
}
this.isOn = !this.isOn;
}
async turnOn(intensity?: number) {
await CapacitorFlash.switchOn({ intensity });
this.isOn = true;
}
async turnOff() {
await CapacitorFlash.switchOff();
this.isOn = false;
}
async strobe(intervalMs: number = 100, duration: number = 3000) {
const endTime = Date.now() + duration;
while (Date.now() < endTime) {
await CapacitorFlash.toggle();
await new Promise(resolve => setTimeout(resolve, intervalMs));
}
// Sicherstellen, dass die Taschenlampe nach dem Stroboskop ausgeschaltet ist
await CapacitorFlash.switchOff();
this.isOn = false;
}
}
```
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
1. **Verfügbarkeit zuerst prüfen** Überprüfen Sie immer die Verfügbarkeit der Taschenlampe, bevor Sie sie verwenden:
```typescript
const { value } = await CapacitorFlash.isAvailable();
if (!value) {
// Alternative UI anzeigen oder Taschenlampenfunktionen deaktivieren
}
```
2. **Fehler elegant behandeln**
```typescript
try {
await CapacitorFlash.switchOn();
} catch (error) {
console.error('Taschenlampe konnte nicht eingeschaltet werden:', error);
}
```
3. **Ausschalten, wenn nicht benötigt** Schalten Sie die Taschenlampe immer aus, wenn Ihre App in den Hintergrund geht oder wenn die Funktion nicht mehr benötigt wird, um Batterie zu sparen.
4. **Schnelles Umschalten vermeiden** Implementieren Sie Debouncing, um schnelles Ein-/Ausschalten zu verhindern, das die LED beschädigen oder die Batterie entleeren könnte.
## Plattformhinweise
[Section titled “Plattformhinweise”](#plattformhinweise)
### iOS
[Section titled “iOS”](#ios)
* Erfordert iOS 10.0+
* Verwendet `AVCaptureDevice` Taschenlampen-Modus
* Unterstützt Intensitätssteuerung (0.0 bis 1.0)
### Android
[Section titled “Android”](#android)
* Erfordert Android 6.0 (API 23)+
* Verwendet Camera2 API
* Intensitätssteuerung nicht unterstützt (verwendet Standardhelligkeit)
### Web
[Section titled “Web”](#web)
* Unterstützt auf Browsern mit MediaDevices API und Taschenlampenfähigkeit
* Verwendet den Kamera-Stream, um auf die Taschenlampe des Geräts zuzugreifen
* Erfordert Benutzerberechtigung für Kamerazugriff
* Funktioniert am besten auf mobilen Browsern (Chrome auf Android)
* Desktop-Browser geben normalerweise `isAvailable: false` zurück (keine Taschenlampenhardware)
* Intensitätssteuerung nicht auf Web unterstützt
# @capgo/capacitor-gtm
> Integrieren Sie Google Tag Manager in Ihre mobilen Anwendungen mit dem offiziellen SDK für umfassendes Analytics-Tracking.
Offizielles SDK
Verwendet offizielles Google Tag Manager SDK für iOS und Android 🏆
Ereignisverfolgung
Ereignisse mit benutzerdefinierten Parametern an dataLayer senden 📊
Benutzereigenschaften
Benutzereigenschaften für Segmentierung festlegen und verwalten 👤
Container-Verwaltung
GTM-Container einfach initialisieren und verwalten 📦
DataLayer-Zugriff
Werte aus der Container-Konfiguration abrufen 🔍
Erste Schritte
Schauen Sie sich die [Anleitung für erste Schritte](/docs/plugins/gtm/getting-started/) an, um das Plugin zu installieren und zu konfigurieren.
# Erste Schritte
> Erfahren Sie, wie Sie Google Tag Manager mit dem offiziellen SDK in Ihre Capacitor-App installieren und integrieren.
## Installation
[Section titled “Installation”](#installation)
* npm
```bash
npm install @capgo/capacitor-gtm
npx cap sync
```
* yarn
```bash
yarn add @capgo/capacitor-gtm
npx cap sync
```
* pnpm
```bash
pnpm add @capgo/capacitor-gtm
npx cap sync
```
* bun
```bash
bun add @capgo/capacitor-gtm
npx cap sync
```
## Plattformkonfiguration
[Section titled “Plattformkonfiguration”](#plattformkonfiguration)
### iOS
[Section titled “iOS”](#ios)
1. Laden Sie Ihre GTM-Container-Konfigurationsdatei von der Google Tag Manager-Konsole herunter
2. Fügen Sie die Container-JSON-Datei zu Ihrem iOS-Projekt in Xcode hinzu
3. Die Datei sollte etwa `GTM-XXXXXX.json` heißen
### Android
[Section titled “Android”](#android)
1. Laden Sie Ihre GTM-Container-Konfigurationsdatei von der Google Tag Manager-Konsole herunter
2. Fügen Sie die Container-JSON-Datei zu `android/app/src/main/assets/` hinzu
3. Die Datei sollte etwa `GTM-XXXXXX.json` heißen
## Verwendungsbeispiel
[Section titled “Verwendungsbeispiel”](#verwendungsbeispiel)
```typescript
import { CapacitorGTM } from '@capgo/capacitor-gtm';
// GTM mit Ihrer Container-ID initialisieren
await CapacitorGTM.init({
containerId: 'GTM-XXXXXX'
});
// Ereignisse an dataLayer senden
await CapacitorGTM.pushEvent({
event: 'screen_view',
parameters: {
screen_name: 'Home',
screen_class: 'HomeScreen'
}
});
// Benutzerdefinierte Ereignisse mit Parametern senden
await CapacitorGTM.pushEvent({
event: 'purchase',
parameters: {
transaction_id: 'T12345',
value: 25.00,
currency: 'USD',
items: [
{
item_id: 'SKU_12345',
item_name: 'Produktname',
quantity: 1,
price: 25.00
}
]
}
});
// Benutzereigenschaften festlegen
await CapacitorGTM.setUserProperty({
key: 'user_type',
value: 'premium'
});
// Werte aus dataLayer abrufen
const result = await CapacitorGTM.getVariable({
key: 'config_value'
});
console.log('Konfigurationswert:', result.value);
```
## API-Referenz
[Section titled “API-Referenz”](#api-referenz)
### init(options)
[Section titled “init(options)”](#initoptions)
```typescript
init(options: { containerId: string }) => Promise
```
Initialisiert Google Tag Manager mit Ihrer Container-ID.
| Param | Typ |
| ------------- | ------------------------- |
| **`options`** | `{ containerId: string }` |
### pushEvent(options)
[Section titled “pushEvent(options)”](#pusheventoptions)
```typescript
pushEvent(options: GTMEvent) => Promise
```
Sendet ein Ereignis mit optionalen Parametern an den dataLayer.
| Param | Typ |
| ------------- | ---------- |
| **`options`** | `GTMEvent` |
### setUserProperty(options)
[Section titled “setUserProperty(options)”](#setuserpropertyoptions)
```typescript
setUserProperty(options: { key: string; value: string }) => Promise
```
Legt eine Benutzereigenschaft für Segmentierung und Targeting fest.
| Param | Typ |
| ------------- | -------------------------------- |
| **`options`** | `{ key: string; value: string }` |
### getVariable(options)
[Section titled “getVariable(options)”](#getvariableoptions)
```typescript
getVariable(options: { key: string }) => Promise<{ value: any }>
```
Ruft einen Wert aus der GTM-Container-Konfiguration ab.
| Param | Typ |
| ------------- | ----------------- |
| **`options`** | `{ key: string }` |
**Gibt zurück:** `Promise<{ value: any }>`
## Schnittstellen
[Section titled “Schnittstellen”](#schnittstellen)
### GTMEvent
[Section titled “GTMEvent”](#gtmevent)
| Prop | Typ | Beschreibung |
| ---------------- | --------------------- | -------------------------------------- |
| **`event`** | `string` | Der Ereignisname |
| **`parameters`** | `Record` | Optionale Ereignisparameter (optional) |
## Häufige Ereignisbeispiele
[Section titled “Häufige Ereignisbeispiele”](#häufige-ereignisbeispiele)
### Bildschirmansichten
[Section titled “Bildschirmansichten”](#bildschirmansichten)
```typescript
await CapacitorGTM.pushEvent({
event: 'screen_view',
parameters: {
screen_name: 'Produktdetails',
screen_class: 'ProductScreen'
}
});
```
### Benutzeraktionen
[Section titled “Benutzeraktionen”](#benutzeraktionen)
```typescript
await CapacitorGTM.pushEvent({
event: 'button_click',
parameters: {
button_name: 'add_to_cart',
product_id: 'SKU_12345'
}
});
```
### E-Commerce-Ereignisse
[Section titled “E-Commerce-Ereignisse”](#e-commerce-ereignisse)
```typescript
await CapacitorGTM.pushEvent({
event: 'begin_checkout',
parameters: {
currency: 'USD',
value: 75.00,
items: [
{
item_id: 'SKU_12345',
item_name: 'Produkt 1',
quantity: 2,
price: 25.00
},
{
item_id: 'SKU_67890',
item_name: 'Produkt 2',
quantity: 1,
price: 25.00
}
]
}
});
```
## Bewährte Methoden
[Section titled “Bewährte Methoden”](#bewährte-methoden)
* Initialisieren Sie GTM früh im Lebenszyklus Ihrer App
* Verwenden Sie konsistente Ereignisbenennungskonventionen
* Fügen Sie relevante Parameter zu jedem Ereignis hinzu
* Testen Sie Ihre GTM-Konfiguration im Vorschaumodus
* Überwachen Sie Daten in der Google Tag Manager-Konsole
* Verwenden Sie Benutzereigenschaften für sinnvolle Segmentierung
## Debugging
[Section titled “Debugging”](#debugging)
Aktivieren Sie den Debug-Modus in der Google Tag Manager-Konsole, um Ihre Implementierung zu testen:
1. Öffnen Sie die GTM-Konsole
2. Gehen Sie in den Vorschaumodus
3. Verbinden Sie sich mit Ihrer App über die Container-ID
4. Überprüfen Sie, ob Ereignisse korrekt verfolgt werden
## Anwendungsfälle
[Section titled “Anwendungsfälle”](#anwendungsfälle)
* Benutzerinteraktionen und -verhalten verfolgen
* App-Leistungsmetriken überwachen
* E-Commerce-Daten sammeln
* Drittanbieter-Tags ohne Codeänderungen verwalten
* A/B-Tests und Personalisierung implementieren
* Mit Google Analytics und anderen Diensten integrieren
# @capgo/capacitor-health
> Lesen und schreiben Sie Fitnessmetriken auf iOS und Android, während Sie einen konsistenten TypeScript-Vertrag beibehalten.
Das Capgo Health-Plugin vereinheitlicht den Zugriff auf HealthKit und Health Connect, sodass Sie Aktivität, biometrische Metriken und Körpermessungen mit einer Capacitor-Integration verfolgen können.
Plattformübergreifende Gesundheitsdaten
Unterstützen Sie Apple HealthKit und Android Health Connect sofort einsatzbereit.
Granulare Berechtigungen
Fordern Sie separate Lese-/Schreibbereiche an und reagieren Sie auf Autorisierungsänderungen.
Konsistente Einheiten
Arbeiten Sie mit normalisierten Datentypen wie `steps`, `heartRate` und `weight`.
Echtzeit-Schreibvorgänge
Speichern Sie Proben zurück im Gesundheitsspeicher des Benutzers, wenn er Aktivitäten protokolliert.
Folgen Sie der Anleitung für erste Schritte, um Plattformfähigkeiten zu aktivieren, Zustimmung einzuholen und mit dem Synchronisieren von Metriken zu beginnen.
# Erste Schritte
> Aktivieren Sie HealthKit- und Health Connect-Zugriff mit dem Capgo Health-Plugin.
1. **Plugin installieren**
* npm
```sh
npm i @capgo/capacitor-health
```
* pnpm
```sh
pnpm add @capgo/capacitor-health
```
* yarn
```sh
yarn add @capgo/capacitor-health
```
* bun
```sh
bun add @capgo/capacitor-health
```
2. **Native Projekte synchronisieren**
* npm
```sh
npx cap sync
```
* pnpm
```sh
pnpm cap sync
```
* yarn
```sh
yarn cap sync
```
* bun
```sh
bunx cap sync
```
## iOS-Konfiguration
[Section titled “iOS-Konfiguration”](#ios-konfiguration)
* Öffnen Sie `ios/App/App.xcworkspace` in Xcode und aktivieren Sie die **HealthKit**-Fähigkeit.
* Geben Sie Nutzungsbeschreibungen in `Info.plist` an:
```xml