Beschreibendes Bild für Seite: Firebase Tracking für Android

Firebase Tracking für Android

In der Regel interessieren sich Unternehmen und Entwickler für die Leistung ihrer Produkte oder Dienstleistungen und dafür, wie der Benutzer mit ihnen interagiert. Die grundlegendsten Dinge, die einem in den Sinn kommen, sind Bildschirm-/Seitenaufrufe und Abstürze sowie Interaktionen wie das Klicken auf einen Link oder eine Schaltfläche. Um diese Werte zu messen, gibt es verschiedene Lösungen. Wir könnten das serverseitige Tracking verwenden und prüfen, wie oft eine Seite aufgerufen wird, oder das clientseitige Tracking, um Ereignisse an einen Server zu senden.

Eine der Lösungen für clientseitiges Tracking ist Google Firebase Analytics/Crashlytics, die wir uns heute ansehen werden. Wir werden einige grundlegende Schritte lernen, um es für eine Android-Anwendung einzurichten und uns danach ansehen, wie wir unsere einfachste Implementierung verbessern können.

Einrichtung für Analytics and Crashlytics

Der erste Schritt besteht darin, alles einzurichten und zum Laufen zu bringen. Du kannst diesen Teil überspringen, wenn du nur wegen der “sauberen und benutzerfreundlichen Nachverfolgung” diesen Beitrag liest.

Außerdem müssen wir die Einschränkungen für unsere Projekte beachten:

  • com.android.tools.build:gradle v3.2.1+
  • compileSdkVersion 28+
  • Gradle 4.1+

Ich werde nun alles zur Einrichtung kurz zusammenfassen. Eine detaillierte Anleitung für die Einrichtung findest du hier.

1. Hinzufügen der Dependencies

Top level build.gradle:

buildscript {

  repositories {
    ...
    google()
    ...
  }

  dependencies {
    ...
    classpath 'com.google.gms:google-services:4.3.3'
    ...
  }
}

allprojects {
  ...
  repositories {
    ...
    google()
    ...
  }
  ...
}

App level build.gradle:

dependencies {
    implementation 'com.google.firebase:firebase-analytics-ktx:x.x.x'
    implementation 'com.google.firebase:firebase-crashlytics:x.x.x'
}

2. Registriere dein Projekt und füge die google-services.json hinzu

Um Google Firebase zu nutzen, musst du deine Anwendung registrieren und die google-services.json herunterladen.

Tracken von Interaktionen und Abstürzen

Da wir nun Firebase Crashlytics und Analytics zu unserem Projekt hinzugefügt haben, können wir Informationen über Abstürze und Benutzerinteraktionen erhalten.

Abstürze sollten nun automatisch verfolgt werden und du kannst eine Initialisierungsmeldung in logcat sehen.

Um Ereignisse zu verfolgen, kannst du nun Analytics wie folgt verwenden:

Firebase.analytics.logEvent(FirebaseAnalytics.Event.SELECT_ITEM)) {
    param(FirebaseAnalytics.Param.ITEM_ID, "product-1337")
    param(FirebaseAnalytics.Param.ITEM_NAME, "Cool product")
    param(FirebaseAnalytics.Param.CONTENT_TYPE, "product")
}

Das Problem: Wir verfolgen die Daten jetzt ohne die Zustimmung der Nutzer

Um in einigen Ländern nicht gegen das Gesetz zu verstoßen oder einfach um zu zeigen, dass wir uns um unsere Nutzer kümmern, wollen wir sicherstellen, dass wir Ereignisse und Abstürze nur dann aufzeichnen, wenn der Nutzer uns dazu ermächtigt. Um dies zu erreichen, müssen wir einige Änderungen an unseren Analytics- und Crashlytics-Implementierungen vornehmen.

1. Tracking standardmäßig deaktiviert

Fügen Sie die folgenden Zeilen in Ihre AndroidManifest.xml-Datei ein, um die Verfolgung standardmäßig zu deaktivieren.

<manifest ...>
    <application ... >

        <meta-data
            android:name="firebase_analytics_collection_enabled"
            android:value="false" />

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

    </application>
</manifest>

2. Zustimmung einholen und Tracking aktivieren

Um den Benutzer um seine Zustimmung zu bitten, können wir ihm einfach einen Dialog zeigen und bei positivem oder negativem Tastendruck unsere Maßnahmen ergreifen.

MaterialAlertDialogBuilder(this).apply {

    setTitle(R.string.title)
    setMessage(R.string.summary)

    setPositiveButton(android.R.string.yes) { dialogInterface: DialogInterface, _: Int ->

        //Enable tracking and crash collection
        Firebase.analytics.setAnalyticsCollectionEnabled(true)
        FirebaseCrashlytics.getInstance().setCrashlyticsCollectionEnabled(true)

        dialogInterface.dismiss()
    }

    setNegativeButton(android.R.string.no) { dialogInterface: DialogInterface, _: Int ->

        //Disable tracking and crash collection
        Firebase.analytics.setAnalyticsCollectionEnabled(false)
        FirebaseCrashlytics.getInstance().setCrashlyticsCollectionEnabled(false)

        dialogInterface.dismiss()
    }
}.create().show()

Wrap it up

Da wir nun wissen, wie man Tracking hinzufügt, aktiviert und deaktiviert, ist es an der Zeit, unseren Code zu bereinigen und die Dinge für uns in Zukunft einfacher zu machen. Da wir vielleicht irgendwann den Tracking-Anbieter wechseln wollen, um andere Funktionen, bessere Preise oder bessere Integrationen mit anderen Systemen zu erhalten, sollten wir uns auf diesen Fall vorbereiten. Wir sollten unseren Code zu keinem Zeitpunkt mit Aufrufen zu Firebase aufblähen.

Was wir stattdessen tun können, ist, eine einfache Wrapper-Klasse zu erstellen, die die Implementierungsdetails von Firebase verbirgt. Eine einfache Implementierung könnte wie folgt aussehen:

class AppTracker(
    private val resources: Resources,
    private val preferences: SharedPreferences,
    private val firebaseAnalytics: FirebaseAnalytics,
    private val crashlytics: FirebaseCrashlytics
) {

    private var isEnabled: Boolean = preferences.getBoolean(
        resources.getString(R.string.preference_tracking_enabled), false
    )

    fun setTrackingAndCrashReportsEnabled(enabled: Boolean) {
        isEnabled = enabled
        preferences.edit {
            putBoolean(resources.getString(R.string.preference_tracking_enabled), enabled)
        }
        firebaseAnalytics.setAnalyticsCollectionEnabled(enabled)
        crashlytics.setCrashlyticsCollectionEnabled(enabled)
    }

    fun setCurrentScreen(activity: Activity, screenName: String) {
        if (!isEnabled) return
        firebaseAnalytics.setCurrentScreen(activity, screenName, null)
    }

    fun trackEvent(eventType: String, eventName: String, eventParameter: Map<String, String>) {
        if (!isEnabled) return
        firebaseAnalytics.logEvent(eventType) {
            param(eventName, eventName)
            eventParameter.forEach { 
                param(it.key, it.value)
            }
        }
    }

    fun trackException(
        priority: Int,
        tag: String?,
        message: String,
        throwable: Throwable?
    ) {
        if (!isEnabled) return
        crashlytics.apply {
            setCustomKey(CRASHLYTICS_KEY_PRIORITY, priority)
            setCustomKey(CRASHLYTICS_KEY_TAG, tag ?: "")
            log(message)
            throwable?.let { recordException(it) }
        }
    }

    fun shouldAskForUserConsent(): Boolean {
        return !preferences.getBoolean(
            resources.getString(R.string.preference_tracking_enabled),
            false
        ) && !preferences.getBoolean(
            resources.getString(R.string.preference_tracking_enabled_do_not_show_dialog),
            false
        )
    }
}

Zusätzliche Hinweise

Ich verwende das obrige Muster jedes Mal, wenn ich Tracking oder Logging in einer App benötige, da es die Dinge einfach macht, sobald man die verwendete Bibliothek ändern will. Achte auch darauf, dass du immer deine Nutzer um ihre Zustimmung bittest, bevor du mit dem Tracking beginnst. Schätze die Daten deiner Nutzer so sehr, wie du ihr Geld schätzt.

Mehr Beiträge