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 :
-
Comprendre les outils:
-
Configurer votre environnement de développement:
- Installer des outils comme Node.js, npm, Xcode, Android Studio, CocoaPods et JDK.
-
Lancez votre projet de plugin Capacitor:
- Utiliser
npm init @capacitor/pluginpour créer un nouveau plugin.
- Utiliser
-
Ajouter des dépendances JavaScript:
- Utiliser
npm installpour les dépendances de production et de développement. - Mise à jour
package.jsonpour inclure des dépendances peer comme@capacitor/core.
- Utiliser
-
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.
-
Optimiser les performances:
- Épingler les versions, auditer les dépendances et résoudre les conflits pour garantir la stabilité.
-
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

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):
- Exécutez la commande suivante :
npm init @capacitor/plugin - Choisissez vos plateformes cibles (iOS/Android).
- Donnez un nom à votre plugin au format domaine inversé.
Étapes de configuration du projet
-
Mise à jour
package.jsonModifiez votre
package.jsonpour inclure les éléments suivants :{ "capacitor": { "ios": { "src": "ios" }, "android": { "src": "android" } }, "peerDependencies": { "@capacitor/core": "^5.0.0" } } -
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.gradlecontient :android { compileSdkVersion 33 defaultConfig { minSdkVersion 22 } }
-
-
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

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

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

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

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 :
-
Installer le Capgo CLI
Exécutez la commande suivante dans votre terminal :
npx @capgo/cli init -
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.
-
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.