Aller au contenu principal

Comment ajouter des dépendances dans les plugins Capacitor

Apprenez à simplifier la gestion des dépendances dans les plugins Capacitor multiplateformes, avec des étapes concrètes et les bonnes pratiques.

Comment ajouter des dépendances dans les plugins Capacitor Capgo : illustration du blog

Ajouter des dépendances aux Capacitor plugins peut sembler intimidant, mais c’est plus simple en découpant en étapes claires. Voici ce qu’il faut savoir :

  1. Comprendre les outils:

    • JavaScript : Utilisez npm pour gérer les dépendances.
    • iOS : Utilisez CocoaPods ou Swift Package Manager (SPM).
    • Android : Utilisez Gradle pour la gestion des dépendances.
  2. Configurer votre environnement de développement:

  3. Lancez votre projet de plugin Capacitor:

    • Utiliser npm init @capacitor/plugin pour créer un nouveau plugin.
  4. Ajouter des dépendances JavaScript:

    • Utiliser npm install pour les dépendances de production et de développement.
    • Mise à jour package.json pour inclure des dépendances peer comme @capacitor/core.
  5. Gérer les dépendances spécifiques à la plateforme:

    • iOS: configurez CocoaPods ou SPM avec des bibliothèques comme Alamofire ou SwiftyJSON.
    • Android: utilisez Gradle pour ajouter des dépendances comme Gson ou AppCompat.
  6. Optimiser les performances:

    • Épingler les versions, auditer les dépendances et résoudre les conflits pour garantir la stabilité.
  7. Utilisez des outils comme Capgo pour les live updates:

    • Publiez des mises à jour instantanément, sans validation des stores.

Comparatif rapide des outils:

Plateforme Outil Exemple de dépendance
JavaScript npm npm install lodash --save
iOS CocoaPods/SPM pod 'Alamofire', '~> 5.6.4'
Android Gradle implementation 'com.google.code.gson:gson:2.10.1'

Pourquoi c'est important: Gérer efficacement les dépendances garantit que votre plugin fonctionne parfaitement sur toutes les plateformes, vous fait gagner du temps et évite les erreurs. Voyons les étapes en détail.

Comment créer un Capacitor plugin pour iOS/Android

Site de documentation du framework Capacitor

Configurer votre environnement de développement

Préparez votre environnement avec les outils nécessaires pour gérer Plugin Capacitor les dépendances efficacement.

Outils de développement requis

Voici la liste des outils dont vous aurez besoin :

Outil Version Objectif
Node.js 16.0.0+ Environnement d’exécution JavaScript
npm 8.0.0+ Gestion de paquets
Xcode 14.0+ Développement iOS (Mac uniquement)
Android Studio Electric Eel+ Développement Android
CocoaPods 1.11.0+ Gestion des dépendances iOS
JDK 11+ Outils de build Android

Créer un nouveau plugin

Utilisez le Capacitor CLI pour démarrer votre projet de plugin. Cela inclut la configuration des plateformes et le nommage de votre plugin au format de domaine inversé (par ex., com.mycompany.plugin):

  1. Exécutez la commande suivante :
    npm init @capacitor/plugin
  2. Choisissez vos plateformes cibles (iOS/Android).
  3. Donnez un nom à votre plugin au format domaine inversé.

Étapes de configuration du projet

  1. Mise à jour package.json

    Modifiez votre package.json pour inclure les éléments suivants :

    {
      "capacitor": {
        "ios": {
          "src": "ios"
        },
        "android": {
          "src": "android"
        }
      },
      "peerDependencies": {
        "@capacitor/core": "^5.0.0"
      }
    }
  2. Configuration spécifique à la plateforme

    • Pour iOS, assurez-vous que votre Podfile contient :

      platform :ios, '13.0'
      use_frameworks!
    • Pour Android, vérifiez que votre build.gradle contient :

      android {
          compileSdkVersion 33
          defaultConfig {
              minSdkVersion 22
          }
      }
  3. Configurer les variables d'environnement

    Configurez les variables d’environnement suivantes pour vos outils de développement :

    Variable Objectif Valeur d'exemple
    ANDROID_HOME Emplacement d’Android SDK /Users/username/Library/Android/sdk
    JAVA_HOME Chemin d’installation du JDK /Library/Java/JavaVirtualMachines/jdk-11.0.12.jdk/Contents/Home
    XCODE_SELECT Outils en ligne de commande Xcode /Applications/Xcode.app/Contents/Developer

Une fois votre projet configuré, vous pouvez passer à la gestion des dépendances JavaScript.

Dépendances JavaScript

Une gestion efficace des dépendances JavaScript est essentielle pour garantir des performances stables aux plugins.

npm Installation des packages

npm

Pour installer les dépendances, utilisez les commandes suivantes :

# Add a production dependency
npm install lodash --save

# Add a development dependency
npm install @types/lodash --save-dev

Assurez-vous d’inclure manuellement les peer dependencies dans votre package.json fichier. Testez toutes les dépendances pour confirmer la compatibilité sur les plateformes web et natives.

Gestion du package.json

Voici un exemple package.json configuration :

{
  "name": "my-capacitor-plugin",
  "version": "1.0.0",
  "dependencies": {
    "lodash": "^4.17.21"
  },
  "devDependencies": {
    "@types/lodash": "^4.14.195",
    "@capacitor/core": "^5.0.0"
  },
  "peerDependencies": {
    "@capacitor/core": "^5.0.0"
  }
}

Pour maintenir la cohérence, verrouillez les versions des dépendances de manière appropriée :

Type de contrainte Exemple Cas d’usage
Exacte “5.0.0” Pour les dépendances critiques nécessitant une version spécifique
Caret “^5.0.0” Autorise les mises à jour mineures et les correctifs
Tilde “~5.0.0” Limite les mises à jour aux correctifs uniquement

Utilisation de bibliothèques JavaScript

Lors de l’importation de bibliothèques, veillez à réduire la taille du bundle :

// Import only the required function
import { isEqual } from 'lodash';

export class MyPlugin {
  async compare(options: { value1: any, value2: any }): Promise<boolean> {
    return isEqual(options.value1, options.value2);
  }
}

Assurez-vous également d’une bonne gestion des erreurs et d’un contrôle des types :

import { Plugin } from '@capacitor/core';
import { validate } from 'your-validation-library';

@Plugin({
  name: 'MyPlugin',
  platforms: ['web', 'ios', 'android']
})
export class MyPlugin {
  async validateData(data: unknown): Promise<void> {
    try {
      if (!validate(data)) {
        throw new Error('Invalid data format');
      }
      // Continue processing if valid
    } catch (error) {
      throw new Error(`Validation failed: ${error.message}`);
    }
  }
}

Dans la suite, découvrez comment gérer les dépendances spécifiques à la plateforme iOS.

Dépendances iOS

Cette section explique comment gérer les dépendances natives iOS dans Plugins Capacitor. Une fois vos dépendances JavaScript configurées, l’étape suivante consiste à gérer les dépendances natives iOS.

CocoaPods Configuration

CocoaPods

Commencez par initialiser CocoaPods dans votre répertoire iOS :

cd ios
pod init

Puis, mettez à jour votre Plugin.podspec fichier avec les configurations suivantes :

Pod::Spec.new do |s|
  s.name = 'MyCapacitorPlugin'
  s.version = '1.0.0'
  s.summary = 'Your plugin description'
  s.platform = :ios, '13.0'
  s.dependency 'Capacitor'
  # Include your iOS dependencies here
  s.dependency 'Alamofire', '~> 5.6.4'
end

Configuration du Podfile

Après l’initialisation de CocoaPods, configurez le Podfile pour inclure Capacitor et toute autre bibliothèque tierce :

platform :ios, '13.0'
use_frameworks!

def capacitor_pods
  pod 'Capacitor', :path => '../../node_modules/@capacitor/ios'
  pod 'CapacitorCordova', :path => '../../node_modules/@capacitor/ios'
end

target 'Plugin' do
  capacitor_pods
  # Add third-party dependencies
  pod 'KeychainAccess', '~> 4.2.2'
  pod 'SwiftyJSON', '~> 5.0.1'
end

target 'PluginTests' do
  capacitor_pods
end

Voici quelques modèles courants de configuration des dépendances :

Type de contrainte Exemple Cas d’usage
Version exacte pod 'KeychainAccess', '4.2.2' Lorsqu’un contrôle précis est nécessaire, par exemple pour des composants de sécurité
Version mineure pod 'Alamofire', '~> 5.6' Pour les API stables susceptibles de recevoir des correctifs
Version majeure pod 'SwiftyJSON', '> 5.0' Lorsque la flexibilité entre les mises à jour est acceptable

Dépendances Swift Package

Si vous préférez éviter CocoaPods, Swift Package Manager (SPM) est une bonne alternative. Ajoutez les dépendances SPM directement dans Xcode avec la configuration suivante dans votre Package.swift fichier :

// Package.swift
dependencies: [
    .package(url: "https://github.com/Alamofire/Alamofire.git", .upToNextMajor(from: "5.6.4")),
    .package(url: "https://github.com/SwiftyJSON/SwiftyJSON.git", from: "5.0.1")
]

Pour utiliser les dépendances SPM dans votre plugin code, importez-les et intégrez-les selon vos besoins. Par exemple :

import Capacitor
import Alamofire

@objc(MyPlugin)
public class MyPlugin: CAPPlugin {
    @objc func makeRequest(_ call: CAPPluginCall) {
        AF.request("https://api.example.com/data").response { response in
            // Process the response
            call.resolve([
                "data": response.data
            ])
        }
    }
}

Cette approche vous permet de choisir entre CocoaPods et Swift Package Manager en fonction des exigences de votre projet.

Dépendances Android

Configurez les dépendances Android pour garantir une intégration native fluide. Voici comment gérer les dépendances de votre plugin Capacitor.

Gradle Dépendances

Interface de l'outil de build Gradle

Ajoutez les configurations suivantes à votre build.gradle fichier :

android {
    defaultConfig {
        minSdkVersion 22
        targetSdkVersion 33
    }
}

dependencies {
    implementation "androidx.appcompat:appcompat:1.6.1"
    implementation "com.google.code.gson:gson:2.10.1"
    implementation "org.jetbrains.kotlin:kotlin-stdlib:1.8.20"
    implementation project(':capacitor-android')
}

Définissez des versions supplémentaires dans le buildscript bloc :

buildscript {
    ext {
        androidxCoreVersion = '1.10.1'
        kotlinVersion = '1.8.20'
    }
}

Une fois les dépendances configurées, assurez-vous de définir les dépôts nécessaires.

Configuration du dépôt

Dans votre projet build.gradle, incluez les dépôts Maven requis :

allprojects {
    repositories {
        google()
        mavenCentral()
        maven { url "https://jitpack.io" }
    }
}

Si vous utilisez des dépôts Maven personnalisés ou privés, ajoutez les identifiants comme ceci :

maven {
    url "https://maven.example.com/releases"
    credentials {
        username = project.findProperty("mavenUsername") ?: System.getenv("MAVEN_USERNAME")
        password = project.findProperty("mavenPassword") ?: System.getenv("MAVEN_PASSWORD")
    }
}

Les dépôts étant configurés, résolvez les conflits de dépendances qui peuvent survenir.

Résolution des problèmes de compatibilité

Pour gérer les conflits de dépendances, appliquez des résolutions de versions dans votre build.gradle:

configurations.all {
    resolutionStrategy {
        force "org.jetbrains.kotlin:kotlin-stdlib:1.8.20"
        force "androidx.core:core-ktx:1.10.1"
    }
}

Voici des stratégies pour résoudre les problèmes de dépendances courants :

Type de problème Stratégie Exemple
Conflit de version Forcer une version spécifique force 'com.google.code.gson:gson:2.10.1'
Versions multiples Exclure un module exclude group: 'org.json', module: 'json'
Problèmes transitifs Utiliser des versions strictes strictly 'androidx.core:core-ktx:1.10.1'

Par exemple, vous pouvez exclure les modules en conflit ainsi :

dependencies {
    implementation('library:name:1.0.0') {
        exclude group: 'com.conflicting.dependency'
    }
}

Enfin, optimisez votre processus de build en activant le cache et l’exécution parallèle dans gradle.properties:

org.gradle.caching=true
org.gradle.parallel=true
org.gradle.jvmargs=-Xmx2048m

Capgo Intégration

Interface du dashboard Capgo Live Update

Utiliser Capgo avec la gestion des dépendances natives et JavaScript rend la mise à jour de votre plugin plus rapide et plus simple.

À propos de Capgo

Capgo est une plateforme live update conçue pour les plugins et applications Capacitor. Plus de 23,5 millions de mises à jour livrées sur 750 applications en production [1], Capgo permet aux développeurs de pousser instantanément des mises à jour pour les dépendances et les code – sans passage par la revue du store. Les mises à jour sont sécurisées par un chiffrement de bout en bout et respectent les normes de conformité Apple et Android.

Fonctionnalités des mises à jour Capgo

Capgo simplifie la gestion des dépendances des plugins grâce à ces fonctionnalités :

Fonctionnalité Fonctionnement Métrique clé
Live Update(s) Déployez des mises à jour en quelques minutes 95 % des utilisateurs mis à jour en 24 heures
Mises à jour partielles Téléchargez uniquement les fichiers modifiés temps de réponse moyen de API de 434 ms
Gestion des versions Gérez plusieurs versions 82 % de réussite globale
Système de canaux Cibler des groupes d'utilisateurs spécifiques Prend en charge plusieurs canaux de déploiement

Source : [1]

Capgo fonctionne parfaitement avec les outils CI/CD comme GitHub Actions, GitLab CI et Jenkins : il automatise les mises à jour de dépendances et garantit des versions de plugins cohérentes. Ces outils facilitent l'intégration de Capgo dans votre workflow.

Configuration de Capgo

Suivez ces étapes pour intégrer Capgo à votre projet :

  1. Installer le Capgo CLI

    Exécutez la commande suivante dans votre terminal :

    npx @capgo/cli init
  2. Configurer les préférences de mise à jour

    Utilisez le dashboard Capgo pour configurer vos canaux de déploiement et vos préférences. Les configurations cloud et auto-hébergées sont prises en charge.

  3. Ajouter la logique de mise à jour

    Ajoutez ce code à votre fichier de plugin principal pour activer les mises à jour :

    import { Capgo } from '@capgo/capacitor-updater';
    
    // Initialize Capgo
    const capgo = new Capgo({
      appId: 'YOUR_APP_ID',
      channel: 'production'
    });
    
    // Check for updates
    await capgo.checkForUpdate();

« Nous pratiquons le développement agile et @Capgo est essentiel pour livrer en continu à nos utilisateurs ! » - Rodrigo Mantica

Capgo propose aussi un dashboard analytics pour suivre en temps réel le taux de réussite des mises à jour et l'activité des utilisateurs. Le rollback en un clic et le suivi des erreurs vous aident à résoudre rapidement les problèmes et à garder des mises à jour de plugins fluides.

Conclusion

Revue du processus

La gestion des dépendances pour les plugins Capacitor consiste à aligner les composants natifs (iOS et Android) sur leurs équivalents JavaScript afin de garantir une intégration fluide. Ce processus implique des configurations spécifiques à chaque plateforme et la gestion des paquets JavaScript pour obtenir les meilleures performances. Suivre les étapes décrites ci-dessus permet de maintenir une fonctionnalité de plugin stable et efficace.

Bonnes pratiques

Pour gérer efficacement les dépendances, adoptez ces bonnes pratiques :

Pratique Avantage Comment l'implémenter
Verrouillage des versions Évite les problèmes inattendus Utilisez des versions fixes dans package.json
Isolation des plateformes Réduit les conflits Sépare les dépendances natives
Mises à jour régulières Améliore la sécurité Appliquez les correctifs critiques rapidement
Audit des dépendances Détecte les risques Exécutez npm audit fréquemment

L’utilisation d’outils live update comme Capgo permet de simplifier et d’améliorer ces pratiques en activant des mises à jour en temps réel.

Avantages de Capgo

Capgo simplifie la gestion des dépendances tout en offrant de bonnes performances. Il atteint un 95 % des utilisateurs à jour sous 24 h et maintient un temps de réponse API global de 434 ms [1]. Grâce au chiffrement de bout en bout, il garantit des mises à jour sécurisées conformes aux directives d'Apple et d'Android. Pour les équipes gérant plusieurs versions de plugins, le système de canaux de Capgo permet des déploiements ciblés pour des groupes d'utilisateurs spécifiques.

Voici un aperçu des performances de Capgo :

Indicateur Valeur
Temps de réponse global API 434 ms
Taux de réussite des mises à jour 82%
Taux de mise à jour des utilisateurs (24 heures) 95%

Continuer la lecture : Comment ajouter des dépendances dans les plugins Capacitor

Si vous utilisez Comment ajouter des dépendances dans les plugins Capacitor pour planifier le travail sur les plugins natifs, connectez-l’à Capgo Répertoire des plugins pour le workflow produit dans Capgo Plugin Directory, Plugins Capacitor par Capgo pour les détails d'implémentation dans Plugins Capacitor par Capgo, Ajouter ou mettre à jour des plugins pour les détails d'implémentation dans Adding or Updating Plugins, Alternatives aux plugins Ionic Enterprise pour le workflow produit dans les alternatives aux plugins Ionic Enterprise, et Capgo Native Build pour le workflow produit dans Capgo Native Builds.

Live updates pour les apps Capacitor

Lorsqu'un bug de la couche web est en ligne, déployez le correctif via Capgo au lieu d'attendre des jours l'approbation des stores. Les utilisateurs reçoivent la mise à jour en arrière-plan, tandis que les changements natifs suivent le circuit de validation habituel.

Les derniers articles du blog

Capgo vous offre les meilleures informations pour créer une application mobile vraiment professionnelle.