Étiquetage de version dans les applications Capacitor

L'étiquetage de version est essentiel pour gérer Capacitor apps. Cela garantit des mises à jour fluides, suit les modifications et améliore la fiabilité des applications sur les plateformes iOS, Android et web. Voici un aperçu rapide :

• Pourquoi cela compte: Suivi des mises à jour, permet le retraitement et garantit des déploiements stables.
• Numérotation Sémantique: Utilisez MAJOR.MINOR.PATCH pour indiquer les modifications importantes, les nouvelles fonctionnalités ou les correctifs de bogues.
• Synchronisation sur les plateformes: Alignez les numéros de version sur package.jsoniOS Info.plist, Android build.gradle.
• et Automatisation: Automatiser les mises à jour Avec des scripts et des outils CI/CD npm.
• Mises à jour en temps réelMises à jour en temps réel : Outils comme Capgo __CAPGO_KEEP_0__
• Delivrez des mises à jour à 95 % des utilisateurs en 24 heures.Gestion des versions bêta

: Utilisez des canaux structurés pour les versions alpha, bêta et de production.

La gestion de version simplifie Mises à jour d'applicationsgarde les utilisateurs heureux, et permet aux développeurs de gérer les versions efficacement.

Comment configurer automatiquement votre Capacitor Documentation du framework __CAPGO_KEEP_0__

Suivez ces étapes pour vous assurer une gestion cohérente de la version sur toutes les plateformes dans votre application Capacitor.

Follow these steps to ensure consistent version management across all platforms in your Capacitor app.

Le package.json

fichier sert de source principale pour les détails de version de votre application. Voici un exemple de comment l'installer : package.json __CAPGO_KEEP_0__ est un framework

{
  "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 en arrière-plan.
• Version de correction (x.x.3) : Corrige des bogues ou apporte des améliorations mineures.

Maintenir les versions de plateforme synchronisées

Il est important d'aligner les numéros de version sur toutes les plateformes pour une mise en ligne de l'application fluide. Chaque plateforme a son propre fichier de configuration pour la versionnage :

Après mise à jour de la version dans package.jsonUtilisez la commande suivante pour synchroniser les modifications avec les configurations de plateforme native :

npx cap sync

Utilisation de Capacitor CLI pour la gestion de version

Le Capacitor CLI propose 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

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

Configuration de la version sémantique

Bases de la version sémantique

La versionnement sémantique (SemVer) utilise la forme MAJOR.MINOR.PATCHoù chaque partie indique un type spécifique de changement :

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

Quand mettre à jour les numéros de version

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]

Voyons maintenant comment automatiser ces mises à jour pour simplifier la gestion des versions.

Mise à jour automatique de version

L'automatisation des 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 de 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
   Intégrer les mises à jour de version dans votre pipeline CI/CD. Capgo prend en charge des outils comme GitHub Actions, GitLab CI, et Jenkins, ce qui simplifie le processus.

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

Méthodes de balises de version

Balises de version Git

Les étiquettes de version Git sont un moyen fiable de suivre les mises à jour de votre application CapacitorPour créer des étiquettes claires et informatives, combinez la versionnement semantique 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 d'étiquetage standardisé :

Intégration du numéro de build

Les numéros de build aident à suivre les builds individuels au sein de chaque version. Pour les deux iOS et Android, incrémentez 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 dans les magasins d'applications est unifiée tandis que la versionnage reste clair pour les utilisateurs.

Gestion de la version bêta

Gérer les 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éer 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. Contrôle de l'accès des utilisateurs

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

3. Progression de version

Étape

Cette approche garantit une testification approfondie et des transitions fluides entre les différentes étapes de développement, tout en maintenant la traçabilité des versions organisée et transparente tout au long du processus.

Affichage de la 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 de manière efficace.

Récupérer la version avec Capacitor

Vous pouvez récupérer les détails de version à l'aide de 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 de présentation 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 la mise en page de 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 communs pour afficher les détails de la 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 assure aux utilisateurs l'accès aux dernières fonctionnalités et correctifs. 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 un développement agile et @Capgo est essentiel à la livraison continue à nos utilisateurs !” - Rodrigo Mantica [1]

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

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

Pour les applications entreprises, le système de canaux 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.

Gestion de Versions Solutions

Plongez plus profondément dans les solutions avancées pour gérer efficacement les versions d'applications.

Options de Outils de Version

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

Voici quelques-unes des fonctionnalités à rechercher :

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

Capgo Version Control Features

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
• 434 ms de temps de réponse moyen API dans le monde

Voici un exemple de la façon dont vous pouvez utiliser 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 direct pour les applications hybrides et @AppFlow est beaucoup trop cher.” - Simon Flack [1]

Solutions pour les équipes

Capgo propose des plans flexibles pour s'adapter à toutes les tailles d'équipe, ce qui rend la gestion des versions échelle et efficace.

For larger teams, Capgo’s channel system enables precise control over version deployment:

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

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

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

Capgo also includes an analytics dashboard to monitor version adoption rates and detect potential issues early. With built-in encryption and customizable hosting options, teams can maintain security while scaling their deployment workflows.

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

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

__CAPGO_KEEP_0__ comprend également un tableau de bord d'analyse pour surveiller 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

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

Comment Commencer

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

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

Enfin, envisagez d'ajouter un système d'actualisation en direct pour garantir que les déploiements soient à la fois rapides et sécurisés.

Continuez à partir de la mise en version dans les applications Capacitor

Si vous utilisez La mise en version dans les applications Capacitor Pour planifier le rollback et le contrôle de version, connectez-l’à Les retours en arrière pour les détails d'implémentation dans Les retours en arrière, La cible de version context : Page/zone : Page de marketing de solutions Capgo. Rôle : En-tête de section ou de page. Vu dans : page solutions/version-targeting.astro. Clé de message `solutions_version_targeting_title` (Titre de la mise en version des solutions). | Page/zone : Page de marketing de solutions Capgo. Rôle : Étiquette de navigation ou élément UI court. Vu dans : page solutions/version-targeting.astro. Clé de message `solutions_version_targeting` (Mise en version des solutions). pour les détails d'implémentation dans La cible de version, Le comportement de mise à jour pour les détails d'implémentation dans Le comportement de mise à jour, et le paquet pour les détails d'implémentation dans le bundle, et Capgo Mises à jour en temps réel pour le flux de travail du produit dans Capgo Mises à jour en temps réel.