Zum Hauptinhalt springen

Firebase Crashlytics für Capacitor Apps

Erfahre in dieser Schritt-für-Schritt-Anleitung, wie du Echtzeit-Crash-Reporting mit Crashlytics für iOS und Android in deine mobilen Apps integrierst.

Firebase Crashlytics für Capacitor-Apps Capgo Blog-Illustration

Firebase Crashlytics hilft dir, App-Crashes in Echtzeit zu verfolgen und liefert detaillierte Berichte, um Probleme schnell zu beheben. Es integriert sich nahtlos mit Capacitor für iOS- und Android-Apps. Hier ist, was Sie wissen müssen:

  • Warum Crashlytics nutzen?

    • Node.js Echtzeit-Crash-Alerts.
    • Detaillierte Crash-Reports analysieren mit automatischer Fehlergruppierung.
    • Kritische Fehler überwachen, um Apps stabil zu halten.
  • Voraussetzungen:

    • Installieren (v16+) (v16+), Capacitor (v4+), sowie Tools wie Xcode 14+ und Android Studio Elektro-Aal.
    • Download Firebase Konfigurationsdateien (GoogleService-Info.plist für iOS, google-services.json für Android).
    • Aktualisiere plattformspezifische Dateien wie Podfile (iOS) und build.gradle (Android).
  • Wichtige Schritte:

    • Crashlytics installieren:

      npm install @capgo/capacitor-firebase-crashlytics && npx cap sync
    • Crashlytics in deiner App initialisieren:

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

    • Einen Test-Crash auslösen:

      await FirebaseCrashlytics.crash();
  • Bonus-Tipp: Crashlytics mit kombinieren Capgo für sofortige Live Updates ohne App-Store-Wartezeiten.

Dieser Guide stellt sicher, dass deine App crashfrei und benutzerfreundlich ist. Starte noch heute mit der Einrichtung von Firebase Crashlytics!

Android-Guide 2021: Firebase Crashlytics - Custom-Crash …

Firebase Crashlytics

Voraussetzungen für das Setup

Bevor du loslegst, stelle sicher, dass du die folgenden Schritte abgeschlossen hast:

Erforderliche Software und Konten

Du musst Folgendes installieren:

  • Node.js (v16 oder höher) und Capacitor (v4 oder höher)
  • Ein Firebase-Konto mit einem aktiven Projekt
  • Xcode 14+ für die iOS-Entwicklung
  • Android Studio Electric Eel oder eine neuere Version für die Android-Entwicklung
  • Die neueste Version von CocoaPods (für iOS erforderlich)

Plattform-Konfigurationsdateien

Für iOS:

  • Laden Sie GoogleService-Info.plist Datei aus der Firebase Console herunter.
  • Aktualisiere dein Podfile um die Crashlytics-Abhängigkeiten einzubinden.
  • Ergänze die erforderlichen Privacy-Keys in deiner Info.plist Datei.

Für Android:

  • Hole die google-services.json Datei aus der Firebase Console herunter.
  • Ändere sowohl die projekt- als auch die app-spezifischen build.gradle Dateien.
  • Aktualisiere die AndroidManifest.xml um die erforderlichen Berechtigungen hinzuzufügen.

Firebase Konsolen-Setup

Firebase-Plattform-Dashboard

Richten Sie Firebase ein und aktivieren Sie Crashlytics mit diesen Schritten:

  1. Firebase-Projekt erstellen und Crashlytics aktivieren.

  2. Apps registrieren in der Firebase-Konsole:

    • Nutze das Bundle-ID für iOS und den Paketname für Android.
    • Lade die Konfigurationsdateien herunter: GoogleService-Info.plist (iOS) und google-services.json (Android).
  3. Firebase-SDKs integrieren in deine App, indem du diese Abhängigkeiten hinzufügst:

    Für Android (App-Ebene 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'
    }

    Für iOS (Podfile):

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

Sobald diese Schritte abgeschlossen sind, können Sie mit dem Abschnitt „Plugin Installation“ fortfahren.

Installationsschritte

Plugin-Installation

Synchronisiere anschließend das Plugin mit deinen nativen Plattformen und sieh dir die @capgo/capacitor-firebase-crashlytics Plugin-Seite für die vollständige API-Referenz an:

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

Initialisiere anschließend Crashlytics in deiner App. Füge den folgenden code hinzu app.component.ts oder main.ts:

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

Plattformkonfiguration

Richte die erforderlichen Konfigurationen für die Android- und iOS-Plattformen ein.

Android-Setup

  1. Füge das Crashlytics Gradle-Plugin auf App-Ebene hinzu build.gradle Datei:

    buildscript { 
        dependencies { 
            classpath 'com.google.firebase:firebase-crashlytics-gradle:2.9.5' 
        } 
    }
    apply plugin: 'com.google.firebase.crashlytics'
  2. Aktiviere die Crash-Erfassung in AndroidManifest.xml:

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

iOS-Setup

  1. Konfiguriere Firebase in AppDelegate.swift:

    import Firebase
    FirebaseApp.configure()

Dein Setup testen

Überprüfe, ob Crashlytics funktioniert, indem du einen Test-Crash auslöst und in der Firebase Console nachschaust:

  • Löse einen Test-Crash mit einem Custom Key aus:

    await FirebaseCrashlytics.setCustomKey({key: 'test_scenario', value: 'manual_crash'});
    await FirebaseCrashlytics.crash();
  • Optional kannst du einen User identifizieren:

    await FirebaseCrashlytics.setUserId({userId: 'user123'});
  • Custom Events loggen:

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

Berichte inklusive Stacktraces, Gerätedetails und Custom Keys sollten innerhalb von ca. 5 Minuten in der Firebase Console erscheinen.

Wichtig: Entferne die Crash-Aufrufe vor dem App-Release. Um das Crash-Logging während der Entwicklung zu deaktivieren, nutze:

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

Monitoring-Guide

Sobald du dein Setup mit einem Test-Crash bestätigt hast, kannst du die Firebase Console nutzen, um echte Crashes und Fehler in deiner Live-App zu tracken.

Crash-Reports lesen

Crash-Reports findest du in der Firebase Console im Bereich Crashlytics. Das wird dir dort angezeigt:

  • Crash-freie User: Der Prozentsatz der User, die keine Crashes erlebt haben.
  • Issue-Stabilität: Wie häufig Crashes auftreten.
  • Auswirkungsanalyse: Die Anzahl der betroffenen Nutzer.

Klicken Sie auf ein Issue, um tiefer in Details wie Stack Traces, Geräteinformationen (z. B. OS-Version, Speicher), benutzerdefinierte Keys, Logs und die User Journey bis zum Crash einzutauchen.

Pro-Tipp: Aktivieren Sie die Funktion „Velocity Alerts“, um benachrichtigt zu werden, wenn die Crash-Rate plötzlich steigt. So können Sie Probleme beheben, bevor sie zu viele Nutzer betreffen.

Tipps zum Fehlermanagement

  • Nach Auswirkung priorisieren: Konzentrieren Sie sich auf Crashes, die die meisten Nutzer betreffen oder in kritischen Bereichen Ihrer App auftreten. Das Verfolgen von Trends hilft Ihnen, dringende Probleme zu identifizieren.

  • Custom Keys verwenden: Fügen Sie Ihren Crash-Reports mit Custom Keys Kontext hinzu. Zum Beispiel:

    await FirebaseCrashlytics.setCustomKey({
      key: 'current_view',
      value: 'payment_processing'
    });
  • Ähnliche Issues gruppieren: Nutze die automatische Issue-Gruppierung von Firebase. Du kannst zudem verwandte Crashes mit konsistenten Custom Keys taggen und aussagekräftige Titel verwenden, um die Nachverfolgung zu erleichtern.

Nutzerdatenschutz gewährleisten

Um Compliance sicherzustellen und Nutzerdaten zu schützen, beachte diese Richtlinien:

  • Berechtigungen:

    • Erwähne das Crash-Reporting in deiner Datenschutzerklärung.
    • Hol dir in Regionen mit DSGVO-Vorgaben die Einwilligung der Nutzer zur Datenerhebung ein.
    • Biete Nutzern die Option, das Crash-Reporting zu deaktivieren.
  • Kontrolle der Datenerhebung:

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

    • Richte eine automatische Datenlöschung nach 90 Tagen ein.
    • Entferne sensible Informationen aus deinen Reports.
    • Nutze nicht identifizierende Custom Keys, um die Nutzerprivatsphäre beim Debugging zu wahren.

Capgo Integration

Capgo Live Update Dashboard-Interface

Kombinieren Sie das live update-System von Capgo mit Crashlytics, um den Weg von der Crash-Erkennung bis zum Fix-Deployment zu beschleunigen.

Über Capgo

Capgo ist ein live update-Tool, das speziell für Capacitor Apps entwickelt wurde. Mit über 1.900 Apps in Produktion und einer Update-Rate von 95 % innerhalb von 24 Stunden stellt es schnelle Fixes ohne die Verzögerungen durch App-Store-Prüfungen sicher. [1].

Zu den wichtigsten Funktionen gehören:

  • Ende-zu-Ende-Verschlüsselung für sichere Updates
  • One-Click-Rollback zu früheren Versionen
  • Channel-basierte Distribution für gezielte Releases
  • Nahtlose CI/CD-Integration
  • Ein 100 % Open-Source-Plattform

Crashlytics und Capgo im Zusammenspiel

Die Nutzung von Crashlytics mit Capgo schafft einen effizienten Workflow, um Probleme schnell zu identifizieren und zu lösen.

So funktioniert es:

  1. Crash-Erkennung und Reaktion
    Crashlytics erkennt einen Crash, und Capgo ermöglicht es dir, Fixes sofort zu deployen, ohne auf die Freigabe im App Store zu warten.

  2. Gezielte Updates

    • Beta-Testing: Teste Fixes mit einer bestimmten Gruppe, um ihre Wirksamkeit sicherzustellen.
    • Stufenweises Rollout: Rolle Updates schrittweise aus, um Risiken zu minimieren.
    • Notfall-Fix: Pushe kritische Patches schnell, um dringende Probleme zu lösen.
  3. Monitoring und Verifizierung
    Nachdem du Updates mit Capgo ausgerollt hast, nutze Crashlytics, um Crash-Raten zu verfolgen und zu bestätigen, dass das Problem behoben ist.

Sicherheit und App-Store-Regeln

Capgo hält die Richtlinien von Apple und Google ein und bietet gleichzeitig starke Sicherheitsfeatures:

  • 82 % globale Erfolgsrate bei der Auslieferung von Updates [1]
  • Automatische Versionskontrolle für bessere Organisation
  • Konformität mit den live update-Richtlinien der App-Stores

Für die sichere Integration mit Crashlytics:

  • Aktiviere die Fehlerverfolgung in beiden Systemen.
  • Nutze die Monitoring-Tools von Capgo parallel zu den Crashlytics-Reports.
  • Halte die Versionskontrolle für alle Updates aufrecht.
  • Führe detaillierte Logs der Updates für Audit-Zwecke.

Gehe zum Abschnitt „Plugin-Optionen“, um weitere live update-Tools zu erkunden.

Plugin-Optionen

Die Wahl des richtigen Crash-Reporting-Plugins kann einen großen Einfluss darauf haben, wie du Fehler in deiner App identifizierst und behebst.

Hier ist ein kurzer Vergleich von Crashlytics mit anderen beliebten Error-Reporting-Tools für Capacitor:

  • Sentry: Bietet einen kostenlosen Tarif mit kostenpflichtigen Plänen ab 26 $/Monat. Unterstützt über 30 Plattformen und bietet Echtzeit-Fehlerüberwachung mit detailliertem Kontext.
  • Bugsnag: Startet bei 47 $/Monat. Deckt sowohl Mobile- als auch Web-Plattformen ab, mit automatischer Fehlergruppierung und Release-Tracking.
  • Rollbar: Ab 31 $/Monat. Funktioniert auf mehreren Plattformen, mit Funktionen wie Deployment-Tracking und Person-Tracking.

Crashlytics ist besonders attraktiv für Teams, die bereits Firebase nutzen – dank nahtloser Integration und eines kostenlosen Tarifs.

Zusammenfassung

Hier ein kurzer Blick darauf, was du erreicht hast und wie es weitergeht:

Setup-Schritte im Überblick

Sie haben drei wichtige Schritte abgeschlossen:

  • Ein Firebase-Projekt erstellt und Ihre iOS-/Android-Apps registriert.
  • Das Crashlytics-Plugin installiert und konfiguriert.
  • Die erforderlichen iOS- und Android-Plattformdateien aktualisiert.

Warum diese Tools integrieren?

Die Kombination aus Firebase Crashlytics und Capgo bietet ein leistungsfähiges System für das Fehler-Tracking und Update-Management. Das bietet diese Kombination:

  • Schnelle Fixes: Pushen Sie sofortige Updates und rollen Sie Änderungen mit nur einem Klick zurück.
  • Zuverlässige Rollouts: Stellen Sie sicher, dass Updates breit akzeptiert und reibungslos an die Nutzer ausgeliefert werden.

Was kommt als Nächstes?

  1. Aktivieren Sie detaillierte Crash-Analysen in der Firebase-Konsole.
  2. Fügen Sie Capgo in Ihre CI/CD-Pipeline ein, um Updates zu vereinfachen.
  3. Nutzt Capgo Channels um Fixes schrittweise zu testen und zu veröffentlichen.

Mit Crashlytics und Capgo ist alles bereit, damit Ihre App reibungslos läuft und sich kontinuierlich verbessert.

Weiter geht's: Firebase Crashlytics für Capacitor-Apps

Wenn du es nutzt Firebase Crashlytics für Capacitor Apps Um die Arbeit an nativen Plugins zu planen, verbinde sie mit Capgo Plugin-Verzeichnis für den Produkt-Workflow im Capgo Plugin-Verzeichnis, Capacitor Plugins von Capgo für das Implementierungsdetail in Capacitor Plugins von Capgo, Plugins hinzufügen oder aktualisieren für die Implementierungsdetails unter „Plugins hinzufügen oder aktualisieren“, Ionic Enterprise Plugin-Alternativen für den Produkt-Workflow in Ionic Enterprise Plugin-Alternativen und Capgo Native Builds optimieren für den Produkt-Workflow in Capgo Native Builds.

Live-Updates für Capacitor-Apps

Wenn ein Bug im Web-Layer live ist, liefere den Fix über Capgo aus, statt Tage auf die App-Store-Freigabe zu warten. Nutzer bekommen das Update im Hintergrund, während native Änderungen im normalen Review-Prozess bleiben.

Neues aus unserem Blog

Capgo gibt dir die besten Insights, um eine wirklich professionelle Mobile App zu erstellen.