Crashlytics Firebase pour les applications Capacitor

Firebase Crashlytics vous aide à suivre les crashes d'applications en temps réel, en fournissant des rapports détaillés pour résoudre les problèmes rapidement. Il s'intègre de manière fluide avec Capacitor pour les applications iOS et Android. Voici ce dont vous avez besoin de savoir :

Pourquoi Utiliser Crashlytics ?
- Obtenez Alertes de crash en temps réel.
- Analysez les rapports de crash détaillés avec Groupement automatique des problèmes.
- Surveillez les erreurs critiques pour maintenir les applications stables.
Exigences de configuration :
- Installer Node.js (v16+), Capacitor (v4+), et outils comme Xcode 14+ et Android Studio Électric Eel.
- Télécharger Firebase les fichiers de configuration (GoogleService-Info.plist pour iOS, google-services.json pour Android).
- Mettre à jour les fichiers spécifiques à la plateforme comme Podfile (iOS) et build.gradle (Android).

Étapes Clés :

Installer Crashlytics :

npm install @capgo/capacitor-firebase-crashlytics && npx cap sync

Initialisez Crashlytics dans votre application :

import { FirebaseCrashlytics } from '@capgo/capacitor-firebase-crashlytics';
await FirebaseCrashlytics.initialize();

Testez votre configuration :
- Déclenchez un test de crash :
```
await FirebaseCrashlytics.crash();
```
Conseil bonus : Combinez Crashlytics avec Capgo pour des mises à jour en direct instantanées sans retard de l'App Store.

Cette guide vous garantit que votre application est exempte de plantages et conviviale. Commencez par configurer Firebase Crashlytics aujourd'hui !

Guide Android 2021 : Firebase Crashlytics - crash … personnalisé

Firebase Crashlytics

Exigences de configuration

Avant de vous lancer, assurez-vous d'avoir terminé les étapes suivantes :

Logiciels et comptes requis

Vous devrez installer les éléments suivants :

Node.js (v16 ou supérieur) et Capacitor (v4 ou supérieur)
Un compte Firebase avec un projet actif une adresse e-mail
Xcode 14+ pour le développement iOS
Android Studio Electric Eel ou une version plus récente pour le développement Android
La dernière version de CocoaPods (obligatoire pour iOS)

Fichiers de configuration de plateforme

Pour iOS :

Téléchargez le GoogleService-Info.plist fichier depuis le Console Firebase.
Met à jour votre Podfile pour inclure les dépendances de Crashlytics.
Ajoutez les clés de confidentialité nécessaires à votre Info.plist fichier.

Pour Android :

Obtenez le google-services.json fichier à partir du Console Firebase.
Apportez des modifications aux fichiers de niveau de projet et de niveau d'application. build.gradle Mettez à jour le
pour y inclure les permissions requises. AndroidManifest.xml Console Firebase de configuration.

Console Firebase de configuration. Console Firebase de configuration.

Plateforme de dashboard Firebase

Configurez Firebase et activez Crashlytics à l'aide de ces étapes :

Créez un projet Firebase et activez Crashlytics.
Inscrivez vos applications dans le console Firebase :
- Utilisez le ID de bundle pour iOS et le nom de package pour Android.
- Téléchargez les fichiers de configuration : GoogleService-Info.plist et (iOS) et google-services.json et (Android).

Intégrez les SDK Firebase dans votre application en ajoutant ces dépendances :

Pour Android (niveau d'application build.gradle):

dependencies {
    implementation platform('com.google.firebase:firebase-bom:32.0.0')
    implementation 'com.google.firebase:firebase-crashlytics'
    implementation 'com.google.firebase:firebase-analytics'
}

Pour iOS (Podfile):

pod 'Firebase/Crashlytics'
pod 'Firebase/Analytics'

Une fois ces étapes terminées, vous êtes prêt à passer à la section d'installation des plugins.

Étapes d'installation

Installation des plugins

Ensuite, synchronisez le plugin avec vos plateformes natives et consultez la @capgo/capacitor-firebase-crashlytics page du plugin pour la référence complète de API :

npm install @capgo/capacitor-firebase-crashlytics && npx cap sync

Ensuite, initialisez Crashlytics dans votre application. Ajoutez le code suivant app.component.ts ou main.ts:

import { FirebaseCrashlytics } from '@capgo/capacitor-firebase-crashlytics';
await FirebaseCrashlytics.initialize();

Configuration de la plateforme

Configurez les configurations requises pour les plateformes Android et iOS.

Configuration Android

Ajoutez le plugin Gradle Crashlytics à votre niveau d'application build.gradle fichier :

buildscript { 
    dependencies { 
        classpath 'com.google.firebase:firebase-crashlytics-gradle:2.9.5' 
    } 
}
apply plugin: 'com.google.firebase.crashlytics'

Activer la collecte de crash dans AndroidManifest.xml:

<meta-data
    android:name="firebase_crashlytics_collection_enabled"
    android:value="true" />

Configuration iOS

Configurez Firebase dans AppDelegate.swift:
```
import Firebase
FirebaseApp.configure()
```

Testez votre configuration

Vérifiez que Crashlytics fonctionne en exécutant un test de crash et en vérifiant le Console Firebase :

Déclenchez un crash de test avec une clé personnalisée :

await FirebaseCrashlytics.setCustomKey({key: 'test_scenario', value: 'manual_crash'});
await FirebaseCrashlytics.crash();

Optionnellement, identifiez un utilisateur :

await FirebaseCrashlytics.setUserId({userId: 'user123'});

Enregistrez des événements personnalisés :

await FirebaseCrashlytics.log({message: 'Test crash triggered'});

Les rapports, y compris les traces de pile, les détails du dispositif et les clés personnalisées, devraient apparaître dans le Console Firebase dans environ 5 minutes.

Important : Supprimez les appels de crash avant de rendre votre application disponible. Pour désactiver la collecte de crash pendant le développement, utilisez :

await FirebaseCrashlytics.setCrashlyticsCollectionEnabled({enabled: false});

Guide de suivi

Une fois que vous avez confirmé votre configuration avec un crash de test, utilisez la Console Firebase pour suivre les crashs et les erreurs réels dans votre application en production.

Lecture des Rapports de Crash

Vous pouvez trouver les rapports de crash dans la Console Firebase sous la section Crashlytics. Voici ce que vous verrez :

Utilisateurs sans crash: Le pourcentage d'utilisateurs qui n'ont pas connu de crash.
Stabilité des problèmes: Combien de fois les crashes se produisent.
Analyse d'impact: Le nombre d'utilisateurs affectés.

Cliquez sur n'importe quel problème pour plonger plus en profondeur dans les détails comme les traces de pile, les informations sur le dispositif (par exemple, la version du système d'exploitation, la mémoire), les clés personnalisées, les journaux et le parcours de l'utilisateur qui a conduit à la panne.

Conseil avancé: Activez la fonctionnalité « alertes de vitesse » pour vous faire notifier lorsque les taux de crash augmentent soudainement. Cela peut vous aider à résoudre les problèmes avant qu'ils n'affectent trop d'utilisateurs.

Conseils de gestion des erreurs

Prioriser par Impact: Concentrez-vous sur les crashes qui affectent le plus d'utilisateurs ou se produisent dans des parties critiques de votre application. Suivre les tendances peut vous aider à identifier les problèmes urgents.
Utiliser des clés personnalisées: Ajoutez du contexte à vos rapports de panne avec des clés personnalisées. Par exemple :
```
await FirebaseCrashlytics.setCustomKey({
  key: 'current_view',
  value: 'payment_processing'
});
```
Grouper des problèmes similaires: Profitez des groupes automatiques de problèmes Firebase. Vous pouvez également étiqueter les crashes liés avec des clés personnalisées cohérentes et utiliser des titres clairs et descriptifs pour une traçabilité plus facile.

La protection de la vie privée des utilisateurs

Pour s'assurer du respect des réglementations et protéger les données des utilisateurs, suivez ces lignes directrices :

Les autorisations:
- Mentionnez le rapport des crashes dans votre politique de confidentialité.
- Obtenez le consentement des utilisateurs pour la collecte de données dans les régions soumises à la réglementation GDPR.
- Fournissez aux utilisateurs l'option de se désinscrire du rapport des crashes.

Les contrôles de collecte de données:

await FirebaseCrashlytics.setCrashlyticsCollectionEnabled({enabled: false});
await FirebaseCrashlytics.setCrashlyticsCollectionEnabled({enabled: true});

La conservation des données:
- Configurez la suppression automatique des données après 90 jours.
- Nettoyez les informations sensibles de vos rapports.
- Utilisez des clés personnalisées non identifiables pour maintenir la vie privée des utilisateurs pendant la débogage.

Capgo Intégration

Capgo Interface de tableau de bord de mise à jour en direct

Facilitez le processus de la détection de crash à la mise en production de la correction en associant le système de mise à jour en direct de Capgo à Crashlytics.

À propos de Capgo

Capgo est un outil de mise à jour en direct conçu spécifiquement pour les applications Capacitor. Avec plus de 1 900 applications en production et un taux d'actualisation de 95 % en 24 heures, il garantit des corrections rapides sans les retards des approbations des magasins d'applications [1].

Les fonctionnalités clés incluent :

Chiffrement de bout en bout pour des mises à jour sécurisées
Un roulage d'un clic vers les versions précédentes vers les versions précédentes
Distribution basée sur le canal pour des sorties ciblées
Intégration CI/CD sans heurts
A Une plateforme 100% open-source

Crashlytics et Capgo Ensemble

L'utilisation de Crashlytics avec Capgo crée un flux de travail efficace pour identifier et résoudre les problèmes rapidement.

Voici comment cela fonctionne :

Détection et réponse aux crashs
Crashlytics identifie un crash, et Capgo vous permet de déployer des correctifs instantanément sans attendre l'approbation des magasins d'applications.
Mises à jour ciblées
- Tests de version bêta: Tester les correctifs avec un groupe spécifique pour s'assurer qu'ils sont efficaces.
- Déploiement étalé : Déployer progressivement les mises à jour pour réduire les risques.
- Correctif d'urgence : Pousser rapidement des correctifs critiques pour résoudre les problèmes urgents.
Surveillance et Vérification
Après avoir déployé des mises à jour avec Capgo, utilisez Crashlytics pour suivre les taux de crash et confirmer que le problème est résolu.

Règles de sécurité et de l'App Store

Capgo respecte les politiques d'Apple et de Google tout en fournissant des fonctionnalités de sécurité solides :

82 % de taux de réussite mondial pour la livraison des mises à jour [1]
Contrôle de version automatique pour une meilleure organisation
Conformité aux lignes directrices de mise à jour en direct des magasins d'applications

Pour une intégration sécurisée avec Crashlytics :

Activer la suivi des erreurs dans les deux systèmes.
Utilisez les outils de suivi de Capgo aux côtés des rapports de Crashlytics.
Maintenir le contrôle de version pour toutes les mises à jour.
Consigner des journaux détaillés des mises à jour à des fins de vérification.

Continuez à la section Options du Plugin pour explorer d'autres outils de mise à jour en direct.

Options du Plugin

La sélection du bon plugin de signalement de panne peut avoir un impact considérable sur la façon dont vous identifiez et corrigez les erreurs dans votre application.

Voici une comparaison rapide de Crashlytics avec d'autres outils populaires de signalement d'erreurs pour Capacitor:

Sentry: Propose un niveau gratuit avec des plans payants à partir de 26 $/mois. Supporte plus de 30 plateformes et fournit une surveillance en temps réel des erreurs avec un contexte détaillé.
Bugsnag: Démarre à 47 $/mois. Couvre les deux plateformes mobiles et web, avec des groupes d'erreurs automatiques et un suivi des releases.
Rollbar: Prixé à partir de 31 $/mois. Fonctionne sur plusieurs plateformes, avec des fonctionnalités comme le suivi des déploiements et le suivi des personnes.

Crashlytics est particulièrement attractif pour les équipes déjà utilisant Firebase, grâce à son intégration fluide et à un niveau gratuit.

Résumé

Ici, voici un aperçu rapide de ce que vous avez accompli et de ce qui vient ensuite :

Étapes de configuration Récapitulatif

Vous avez complété trois étapes clés pour vous lancer :

Créé un projet Firebase et enregistré vos applications iOS/Android.
Installé et configuré le plugin Crashlytics.
Mise à jour des fichiers de plateforme iOS et Android nécessaires.

Pourquoi Intégrer Ces Outils ?

L'association de Firebase Crashlytics avec Capgo vous offre un système puissant pour le suivi des erreurs et la gestion des mises à jour. mise à jour. Voici ce que cette combinaison offre :

Réparations rapides: Envoyez des mises à jour instantanées et annulez les changements avec un seul clic.
Déploiements fiables: Assurez-vous que les mises à jour soient largement adoptées et livrées de manière fluide aux utilisateurs.

Qu’est-ce qui suit ?

Activez les analyses de crash détaillées dans le Console Firebase.
Ajoutez Capgo à votre pipeline CI/CD pour des mises à jour rationalisées.
Utilisez Capgo canaux pour tester et lancer des correctifs étape par étape.

Avec Crashlytics et Capgo en place, vous êtes prêt à garder votre application en cours de fonctionnement et à l'améliorer au fil du temps.

Continuez à partir de Firebase Crashlytics pour les applications Capacitor

Si vous utilisez Firebase Crashlytics pour les applications Capacitor pour planifier le travail de plugin natif, connectez-le avec Capgo Répertoire de plugin pour le flux de travail du produit dans Capgo Répertoire de plugin, Capacitor Plugins par Capgo pour les détails d'implémentation dans Capacitor Plugins par Capgo, Ajouter ou Mettre à Jour les Plugins pour les détails d'implémentation dans Ajouter ou Mettre à Jour les Plugins, Alternatives de Plugins Entreprise Ionic pour le flux de travail du produit dans Alternatives de Plugins Entreprise Ionic, et Capgo Développements Natives pour le flux de travail du produit dans Capgo Développements Natives.

Firebase Crashlytics pour les Capacitor Applications