Étiquetage de version dans les applications Capacitor

La gestion des versions est essentielle pour gérer les applications __CAPGO_KEEP_0__. Capacitor Les applications __CAPGO_KEEP_0__ garantissent des mises à jour fluides, suivent les changements et améliorent la fiabilité des applications sur les plateformes iOS, Android et web. Voici un aperçu rapide :

• Pourquoi cela compteSuivi des mises à jour, permet le retraitement et garantit des déploiements stables.
• Gestion sémantique des versionsUtilisez MAJOR.MINOR.PATCH pour indiquer les modifications majeures, les nouvelles fonctionnalités ou les correctifs de bogues. Synchronisation sur les plateformes Synchronisation sur les plateformes
• Synchronisation sur les plateformes: Synchronisez les numéros de version package.json, iOS Info.plist, et Android build.gradle.
• Automatisation: Automatisez les mises à jour avec des scripts npm et des outils CI/CD.
• Mises à jour en temps réel: Les outils comme Capgo envoient des mises à jour à 95 % des utilisateurs en 24 heures.
• Gestion de la bêta: Utilisez des canaux structurés pour les versions alpha, bêta et de production.

Comparaison Rapide

La balise de version simplifie Mise à jour d'applications, qui rend les utilisateurs heureux et permet aux développeurs de gérer les versions efficacement.

Comment configurer automatiquement votre Capacitor projet ⚡️

Configuration de version dans Capacitor

Suivez ces étapes pour vous assurer d'une gestion cohérente des versions sur tous les plateformes dans votre Capacitor application.

Définir la version dans package.json

Le package.json Le fichier sert de source principale pour les détails de version de votre application. Voici un exemple de mise en œuvre :

{
  "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"
  }
}

Lors de la mise à jour du numéro de version, utilisez les règles de versionnement semantique (SemVer) :

• Version majeure (1.x.x) : Introduit des changements de rupture.
• Version mineure (x.2.x) : Ajoute de nouvelles fonctionnalités qui sont compatibles avec les versions précédentes.
• Version de maintenance (x.x.3) : Corrige des bogues ou apporte des améliorations mineures.

Maintenir les versions des plateformes synchronisées

Il est important d'aligner les numéros de version sur tous les plateformes pour un déploiement d'applications fluide. Chaque plateforme a son propre fichier de configuration pour la versionnage :

Après mise à jour de la version dans package.json, utilisez cette commande pour synchroniser les modifications avec les configurations de plateforme native :

npx cap sync

En utilisant Capacitor CLI pour la gestion de version

La commande Capacitor CLI offre des commandes utiles pour gérer les versions :

# 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

Maintenir votre Capacitor CLI à jour garantit la compatibilité avec les fonctionnalités spécifiques aux versions et réduit les éventuelles incohérences. Suivre ces étapes vous aidera à maintenir une version correcte dans votre application.

Configuration de la version Sémantique

Principes de la version Sémantique

Versionnement Sémantique (SemVer) utilise la forme MAJOR.MINOR.PATCH, où chaque partie indique un type spécifique de changement :

Cette système permet aux développeurs de communiquer clairement les mises à jour tout en préservant la compatibilité entre les versions de l'application. Par exemple, passer de 1.2.3 à 2.0.0 indique des mises à jour majeures, rompant la compatibilité, qui nécessitent une planification soigneuse.

When to Update Version Numbers

Voici comment décider quel numéro de version mettre à jour :

"Nous pratiquons le développement agile et @Capgo est essentiel à la livraison continue à nos utilisateurs !" - Rodrigo Mantica [1]

Voilà, passons maintenant à l'automatisation de ces mises à jour pour simplifier la gestion des versions.

Mise à jour de version Automatisée

Automatiser les mises à jour de version peut économiser du temps et réduire les erreurs dans votre projet Capacitor. Voici comment l'installer :

1. Scripts de version NPM

Ajoutez ces scripts à votre package.json fichier pour gérer les mises à jour de version facilement :

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

2. Intégration CI/CD
   Incorporate version updates into your CI/CD pipeline. Capgo supports tools like GitHub Actions, GitLab CI, et Jenkinsen faisant simple l'automatisation.

“@Capgo est un outil indispensable pour les développeurs cherchant à gagner en productivité en évitant les longues revues de bugs.” - Bessie Cooper [1]

Méthodes de Tag de Version

Tags de Version Git

Les tags de version Git sont un moyen fiable de suivre les Capacitor sorties d'applications. Pour créer des tags clairs et informatifs, combinez la versionnement sémantique avec une brève description :

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

Pour maintenir la cohérence au sein de votre équipe, utilisez un format de balisage standardisé :

Intégration du numéro de build

Les numéros de build aident à suivre les builds individuels dans chaque version. Pour les deux iOS et Android, augmentez le numéro de build avec chaque soumission :

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

Le numéro de build doit toujours augmenter, même si la version reste la même. Cela garantit que chaque soumission de magasin d'applications est identifiée de manière unique tout en maintenant la versionnage clair pour les utilisateurs.

Gestion de la version bêta

La gestion des versions bêta nécessite un processus structuré pour distribuer les builds de test. Capgo’s le système de canal simplifie cela avec les étapes suivantes :

1. Configuration du canal

Créez des canaux séparés pour chaque phase de test :

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

2. Gestion de l'accès des utilisateurs

Configurez les permissions pour contrôler qui a accès aux versions bêta. Cela garantit que seuls les testeurs approuvés reçoivent les builds bêta tandis que les utilisateurs de production reçoivent des versions stables.

3. Avancement de la version

Utilisez un système d'avancement de version clair pour suivre les étapes de développement :

Cette approche garantit des tests approfondis et des transitions fluides entre les différentes étapes de développement, tout en maintenant la gestion des versions organisée et transparente tout au long du processus.

Version de l'Application

Afficher des informations de version précises dans votre application est essentiel pour tenir informés les utilisateurs et gérer les mises à jour efficacement.

Obtenir la Version avec Capacitor

Vous pouvez récupérer les détails de version en utilisant Capacitor avec ce code:

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

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

Pour une approche plus fluide, créez une fonction réutilisable :

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

Cette fonction simplifie le processus d'affichage des informations de version dans l'interface de votre application.

Mise en œuvre de l'interface de version

Voici un exemple d'intégration de l'affichage de la version dans un composant de paramètres :

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

Les endroits courants pour afficher les détails de version incluent :

En plus de l'affichage des informations de version, l'intégration d'un système de vérification de mise à jour peut améliorer l'expérience utilisateur.

Système de vérification de mise à jour

Un système de vérification de mise à jour garantit aux utilisateurs l'accès aux dernières fonctionnalités et corrections. Capgo fournit des notifications en temps réel et des canaux de mise à jour contrôlés pour gérer ce processus :

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
    });
  }
}

“Nous pratiquons le développement agile et @Capgo est essentiel à la livraison continue à nos utilisateurs !” - Rodrigo Mantica [1]

Vous pouvez également ajouter une mise à jour de notification utilisateur, comme ceci :

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

Pour les applications d'entreprise, le système de canal de Capgo permet de contrôler la distribution des mises à jour :

Cette méthode garantit la fiabilité de l'application tout en suivant les performances des mises à jour à travers le tableau de bord d'analytique de Capgo.

Solutions de gestion de versions

Découvrons ensemble des solutions avancées pour gérer efficacement les versions d'applications.

Options de gestion de versions

Lors du choix des outils de gestion de versions, il est important de se concentrer sur ceux qui simplifient les mises à jour, sécurisent votre code et supportent à la fois les lancements d'applications et les mises à jour en direct.

Voici quelques fonctionnalités clés à rechercher :

Un outil de premier plan dans ce domaine est Capgo, qui propose des fonctionnalités spécifiquement conçues pour applications Capacitor.

Capgo Fonctionnalités de Contrôle de Version

Capgo fournit des capacités de gestion de version robustes, notamment :

• 23,5 millions d'actualisations réussies
• 95 % des utilisateurs mis à jour en 24 heures
• 82 % de taux de réussite mondial
• 434ms average API response time worldwide

Voici un exemple de l'utilisation de Capgo pour la gestion de version :

// 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
    });
  }
};

“Nous essayons actuellement @Capgo depuis que Appcenter a arrêté le support des mises à jour en temps réel pour les applications hybrides et @AppFlow est trop coûteux.” - Simon Flack [1]

Taille de l'équipe Solutions

Capgo propose des plans flexibles pour s'adapter à toutes les tailles d'équipe, ce qui permet une gestion de version scalable et efficace.

Pour les équipes plus grandes, le système de canal de Capgo permet un contrôle précis sur la mise en production des versions :

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

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

“Nous pratiquons le développement agile et @Capgo est essentiel pour livrer continuellement à nos utilisateurs !” - Rodrigo Mantica [1]

Capgo comprend également un tableau de bord d'analyse pour suivre les taux d'adoption des versions et détecter les problèmes potentiels en amont. Avec une encryption intégrée et des options d'hébergement personnalisables, les équipes peuvent maintenir la sécurité tout en élargissant leurs flux de déploiement.

Conclusion

La compréhension de la gestion des versions est essentielle pour simplifier les processus de développement et de déploiement.

Principaux points clés

La gestion des versions aide les développeurs à maintenir des mises à jour fluides et fiables. Un contrôle de version approprié offre des avantages clairs :

Ces résultats mettent en évidence l'importance d'utiliser des outils de gestion de versions efficaces.

Comment Commencer

Pour mettre ces avantages en action, suivez ces étapes :

• Configurer le suivi des versions: Utilisez la versionnement semantique dans votre package.json fichier et intégrez les plugins nécessaires.
• Ajoutez des contrôles d'actualisation : Mettez en œuvre des systèmes pour vérifier et suivre les mises à jour de version.
• Configurez les canaux de distribution : Créez des environnements séparés pour la production, la bêta et le développement.

Enfin, considérez l'ajout d'un système d'actualisation en temps réel pour garantir que les déploiements soient à la fois rapides et sécurisés.

Continuez de la mise en œuvre de la balise de version dans les Capacitor Applications

Si vous utilisez la mise en œuvre de la balise de version dans les Capacitor Applications pour planifier le retrait et le contrôle de version, connectez-le avec les retraits pour les détails d'implémentation dans les retraits, la cible de version pour les détails d'implémentation dans la cible de version, Comportement de mise à jour pour les détails d'implémentation dans le Comportement de mise à jour, bundle pour les détails d'implémentation dans bundle, et Capgo Mises à jour en temps réel pour le flux de travail du produit dans Capgo Mises à jour en temps réel.