Versionierung in Capacitor-Anwendungen

Die Versionierung ist unerlässlich für die Verwaltung Capacitor apps. Es sichert eine glatte Aktualisierung, verfolgt Änderungen und verbessert die Zuverlässigkeit der Apps auf den Plattformen iOS, Android und Web. Hier ist eine kurze Übersicht:

• Warum es wichtig ist: Verfolgt Aktualisierungen, ermöglicht Rollover und sichert stabile Bereitstellungen.
• Semantische Versionsnummerierung: Verwende MAJOR.MINOR.PATCH um Bruchlinien zu kennzeichnen, neue Funktionen oder Bugfixes anzuzeigen.
• Synchronisierung über Plattformen: Passen die Versionsnummern in package.json, iOS Info.plist, und Android an. build.gradle.
• Automatisierung: Automatisieren Sie Updates mit npm-Skripten und CI/CD-Tools.
• Live-Updates: Werkzeuge wie Capgo liefern Updates an 95% der Benutzer innerhalb von 24 Stunden.
• Beta-Management: Verwenden Sie strukturierte Kanäle für Alpha-, Beta- und Produktionsversionen.

Schnelle Vergleich

Versionstagging vereinfacht App-Updates, hält die Benutzer glücklich und stellt sicher, dass Entwickler Releases effektiv verwalten können.

Wie Sie Ihre Capacitor Projekt automatisch einrichten

Versionseinrichtung in Capacitor

Folgen Sie diesen Schritten, um eine konsistente Versionsverwaltung auf allen Plattformen in Ihrem Capacitor-App zu gewährleisten.

Version in package.json

Die package.json Datei dient als Hauptquelle für die Versionsdetails Ihres Apps. Hier ist ein Beispiel, wie Sie sie einrichten können:

{
  "name": "your-app-name",
  "version": "1.2.3",
  "private": true,
  "dependencies": {
    "@capacitor/core": "5.5.0",
    "@capacitor/ios": "5.5.0",
    "@capacitor/android": "5.5.0"
  }
}

Wenn Sie die Versionsnummer aktualisieren, verwenden Sie die Regeln für semantische Versionierung (SemVer):

• Hauptversion (1.x.x): Einführung von Änderungen, die den Codebruch verursachen.
• Minor version (x.2.x): Hinzufügen neuer Funktionen, die rückwärts kompatibel sind.
• Patch version (x.x.3): Behebung von Fehlern oder kleine Verbesserungen.

Versionspflege für Plattformen

Es ist wichtig, dass die Versionsnummern auf allen Plattformen übereinstimmen, um eine glatte App-Veröffentlichung zu gewährleisten. Jede Plattform hat ihre eigene Konfigurationsdatei für die Versionsverwaltung:

Nachdem Sie die Version in __CAPGO_KEEP_0__ __CAPGO_KEEP_1__ aktualisiert haben, verwenden Sie diesen Befehl, um die Änderungen mit den nativen Plattformkonfigurationen zu synchronisieren: package.jsonVerwenden Sie __CAPGO_KEEP_0__ __CAPGO_KEEP_1__ für die Versionsverwaltung

npx cap sync

Verwenden Sie Capacitor CLI für die Versionsverwaltung

Die Capacitor CLI bietet hilfreiche Befehle, um Versionen zu verwalten:

# Check the current version of Capacitor
npx cap --version

# Update Capacitor core and platform dependencies
npm install @capacitor/core@latest
npm install @capacitor/ios@latest
npm install @capacitor/android@latest

# Sync version changes to native platforms
npx cap sync

Das Halten Ihrer Capacitor CLI auf dem neuesten Stand sichert die Kompatibilität mit versionsspezifischen Funktionen und reduziert potenzielle Inkonsistenzen. Durch die Befolgung dieser Schritte können Sie eine ordnungsgemäße Versionsverwaltung in Ihrer App sicherstellen.

Semantische Versionierung einrichten

Grundlagen der semantischen Versionierung

Semantische Versionierung (SemVer) verwendet die Formatierung Version-KomponenteZweck

Behebt Fehler oder verbessert die Leistung ohne die Kompatibilität zu brechen 1.2.3 Dieses System ermöglicht es Entwicklern, Updates klar zu kommunizieren, während die Kompatibilität zwischen Anwendungsversionen erhalten bleibt. Zum Beispiel beim Wechsel von 2.0.0 zu

signalisiert ein großer, brechender Update, das sorgfältige Planung erfordert.

Wann Versionsnummern aktualisieren

“We practice agile development and @Capgo is mission-critical in delivering continuously to our users!” - Rodrigo Mantica [1]

Wir praktizieren agiles Entwicklung und @__CAPGO_KEEP_0__ ist mission-kritisch bei der ständigen Lieferung an unsere Benutzer!

Lassen Sie uns nun diese Updates automatisieren, um die Release-Verwaltung zu vereinfachen.

Automatisierung von Versionsaktualisierungen Die Automatisierung von Versionsaktualisierungen kann Zeit sparen und Fehler in Ihrem Capacitor-Projekt reduzieren. Hier ist, wie Sie es einrichten können:

1. NPM-Versionsskripte

Fügen Sie diese Skripte Ihrem package.json Datei zum einfachen Verwalten von Versionsupdates:

{
  "scripts": {
    "version:patch": "npm version patch",
    "version:minor": "npm version minor",
    "version:major": "npm version major"
  }
}

2. CI/CD-Integration
   Fügen Sie Versionsupdates in Ihren CI/CD-Pipeline ein. Capgo unterstützt Tools wie GitHub Actions, GitLab CI, und Jenkins, was es einfach macht, den Prozess zu automatisieren.

“@Capgo ist ein Muss-Werkzeug für Entwickler, die Produktivität durch das Umgehen langwieriger Bugfix-Reviews suchen.” - Bessie Cooper [1]

Version-Tag-Methode

Git-Version-Tag

Git-Version-Tags sind eine zuverlässige Möglichkeit, die Versionsverwaltung zu überwachen Capacitor App-VeröffentlichungenUm klare und informative Tags zu erstellen, kombinieren Sie die semantische Versionsnummer mit einer kurzen Beschreibung:

git tag -a v1.2.3 -m "Release v1.2.3: Added offline mode support"

Um eine konsistente Tag-Formatierung innerhalb Ihres Teams zu gewährleisten, verwenden Sie ein standardisiertes Tag-Format:

Build Number Integration

Buildzahlen helfen dabei, einzelne Builds innerhalb jeder Version zu verfolgen. Für beide iOS und Android sollte die Buildzahl mit jeder Einreichung erhöht werden:

{
  "ios": {
    "version": "1.2.3",
    "build": "10234"
  },
  "android": {
    "version": "1.2.3",
    "versionCode": "10234"
  }
}

Die Buildzahl sollte immer erhöht werden, selbst wenn die Version gleich bleibt. So wird jeder App-Store-Einreichung eindeutig identifiziert, während die Versionsnummer für die Benutzer klar bleibt.

Beta Version Management

Die Verwaltung von Beta-Versionen erfordert einen strukturierten Prozess, um Testbuilds zu verteilen. Capgo’s Kanal-System erleichtert dies mit den folgenden Schritten:

1. Kanal-Setup

Erstellen Sie separate Kanäle für jeden Testphasen:

{
  "beta": {
    "version": "1.3.0-beta.1",
    "users": "beta-testers"
  },
  "production": {
    "version": "1.2.3",
    "users": "all"
  }
}

2. Benutzeroberflächenzugriff kontrollieren

Ermächtige die Zugriffssteuerung, um zu bestimmen, wer Zugriff auf Beta-Versionen erhält. So stellen Sie sicher, dass nur genehmigte Tester Beta-Versionen erhalten, während Produktionsbenutzer stabile Releases erhalten.

3. Versionenfolge

Verwenden Sie ein klares Versionsfolgesystem, um die Entwicklungsstufen zu verfolgen:

Diese Vorgehensweise sichert eine umfassende Prüfung und glatte Übergänge zwischen den Entwicklungsstufen, wobei die Versionsverwaltung organisiert und transparent bleibt.

Anzeige der App-Version

Die Anzeige genauer Versionsinformationen in Ihrer App ist entscheidend, um Benutzer über Updates zu informieren und diese effektiv zu verwalten.

Abrufen der Version mit Capacitor

Sie können Versionsdetails mit Capacitor abrufen, indem Sie code verwenden:

import { App } from '@capacitor/app';

async function getAppInfo() {
  const info = await App.getInfo();
  console.log(`Version: ${info.version}`);
  console.log(`Build: ${info.build}`);
}

Für eine noch effizientere Vorgehensweise erstellen Sie eine wiederverwendbare Funktion:

export const getVersionString = async () => {
  const info = await App.getInfo();
  return `v${info.version} (${info.build})`;
};

Diese Funktion vereinfacht den Prozess der Anzeige von Versionsinformationen in der Schnittstelle Ihres Apps.

Version UI-Implementierung

Hier ist ein Beispiel dafür, wie Sie die Versionsanzeige in einem Einstellungs-Komponenten integrieren können:

@Component({
  selector: 'app-settings',
  template: `
    <div class="version-info">
      <span>Version: {{ versionString }}</span>
      <span *ngIf="updateAvailable" class="update-badge">
        Update Available
      </span>
    </div>
  `
})

Gemeinsame Orte, an denen Sie Versionsdetails anzeigen können:

Neben der Anzeige der Versionsinformationen kann die Integration eines Update-Prüfungssystems die Benutzererfahrung verbessern.

Update-Prüfungssystem

Ein Update-Prüfungssystem stellt sicher, dass Benutzer Zugriff auf die neuesten Funktionen und Korrekturen haben. Capgo bietet Echtzeitbenachrichtigungen und kontrollierte Updatekanäle, um diesen Prozess zu verwalten:

import { CapacitorUpdater } from '@capgo/capacitor-updater';

async function checkForUpdates() {
  const current = await CapacitorUpdater.current();
  const latest = await CapacitorUpdater.getLatest();

  if (current.version !== latest.version) {
    await CapacitorUpdater.download({
      version: latest.version
    });
  }
}

„Wir praktizieren agiles Entwicklung und @Capgo ist mission-kritisch bei der ständigen Lieferung an unsere Benutzer!“ - Rodrigo Mantica [1]

Sie können auch eine Benutzerfreundliche Updatebenachrichtigung hinzufügen, wie folgt:

@Component({
  template: `
    <update-modal 
      [version]="newVersion"
      [features]="updateFeatures"
      (updateNow)="performUpdate()"
    />
  `
})

Für Enterprise-Apps ermöglicht Capgo's Kanal-System die Kontrolle der Updateverteilung:

Mit dieser Methode wird die App- Zuverlässigkeit gewährleistet, während die Update-Leistung über Capgo’s Analytics-Dashboard verfolgt wird.

Versionen-Verwaltungslösungen

Eintauchen Sie tiefer in fortschrittliche Lösungen für die effektive Verwaltung von App-Versionen.

Versionstool-Optionen

Bei der Auswahl von Versionskontrolltools ist es wichtig, sich auf solche zu konzentrieren, die Updates vereinfachen, Ihre code sicherstellen und sowohl App-Store-Veröffentlichungen als auch Live-Updates unterstützen.

Hier sind einige wichtige Funktionen, auf die Sie achten sollten:

Ein hervorragendes Werkzeug in diesem Bereich ist Capgo, das spezielle Funktionen für Capacitor-Apps anbietet.

Capgo Funktionsweise der Versionskontrolle

Capgo bietet robuste Funktionen für die Versionsverwaltung, einschließlich:

• 23,5 Mio. erfolgreiche Updates geliefert
• 95% der Benutzer wurden innerhalb von 24 Stunden aktualisiert
• 82% globale Erfolgsrate
• 434 ms Durchschnittszeit für API-Antworten weltweit

Hier ist ein Beispiel dafür, wie Capgo für die Versionskontrolle verwendet werden kann:

// Capgo version control example
import { CapacitorUpdater } from '@capgo/capacitor-updater';

const versionControl = {
  async checkVersion() {
    const current = await CapacitorUpdater.current();
    return current.version;
  },

  async deployUpdate(version: string) {
    await CapacitorUpdater.setChannel({
      channel: 'production',
      version: version
    });
  }
};

“We are currently giving a try to @Capgo since Appcenter stopped live updates support on hybrid apps and @AppFlow is way too expensive.” - Simon Flack [1]

Wir probieren gerade __CAPGO_KEEP_0__ aus, seit Appcenter die Live-Updates-Unterstützung für hybride Apps eingestellt hat und @AppFlow ist viel zu teuer.

Capgo offers flexible plans to accommodate teams of all sizes, making version management scalable and efficient.

Für größere Teams ermöglicht Capgo’s Kanal-System eine genaue Kontrolle über die Versionen:

const enterpriseVersionControl = {
  channels: {
    production: 'stable-releases',
    beta: 'early-access',
    internal: 'development'
  },

  async deployToChannel(channel: string, version: string) {
    await CapacitorUpdater.setChannel({
      channel: channel,
      version: version
    });
  }
};

“Wir praktizieren agiles Entwicklung und @Capgo ist mission-kritisch bei der ständigen Lieferung an unsere Benutzer!” - Rodrigo Mantica [1]

Capgo umfasst auch ein Analytics-Dashboard, um die Versionsanpassungs-Raten zu überwachen und potenzielle Probleme frühzeitig zu erkennen. Mit eingebauter Verschlüsselung und anpassbaren Hosting-Optionen können Teams die Sicherheit aufrechterhalten, während sie ihre Bereitstellungs-Workflows skalieren.

Zusammenfassung

Das Verständnis von Versionsbezeichnungen ist der Schlüssel zum Vereinfachen der Entwicklung und Bereitstellungsvorgänge. Hier ist ein schneller Abriss der wichtigsten Ideen und Schritte, um loszulegen.

Hauptergebnisse

Versionsbezeichnungen helfen Entwicklern, glatte und zuverlässige Updates zu gewährleisten. Eine ordnungsgemäße Versionskontrolle bietet klare Vorteile:

Diese Ergebnisse unterstreichen die Bedeutung der Verwendung effektiver Versionsverwaltungstools.

Wie man beginnt

Um diese Vorteile in die Tat umzusetzen, folgen Sie diesen Schritten:

• Einstellung der Versionsverfolgung: Verwenden Sie semantische Versionsverwaltung in Ihrem Datei und integrieren Sie notwendige Plugins. package.json Hinzufügen von Aktualisierungsprüfungen
• : Implementieren Sie Systeme, um Versionen zu überprüfen und zu verfolgen.Konfiguration von Verteilungskanälen
• : Erstellen Sie separate Umgebungen für Produktion, Beta und Entwicklung.Zuletzt sollten Sie einen Live-Update-System hinzufügen, um sicherzustellen, dass Bereitstellungen schnell und sicher sind.

__CAPGO_KEEP_0__