AdMob+Firebase 101 Android: Einrichtung & Grundlagen von Analytics

1. Einführung

Anzeigen sind ein wichtiger Bestandteil der Nutzerfreundlichkeit Ihrer App. Gute Anzeigenimplementierungen können die Nutzerfreundlichkeit Ihrer App insgesamt verbessern und sogar die Nutzerbindung und das Nutzer-Engagement steigern. Mit Anzeigen mit Prämie können Sie Nutzern beispielsweise In-App-Währung oder ‑Artikel zur Verfügung stellen, wenn sie sich Videoanzeigen ansehen. So können Nutzer neue Höhen erreichen, an denen sie sonst vielleicht gescheitert wären und die App verlassen hätten.

Es ist jedoch nicht einfach, eine optimale Nutzerfreundlichkeit von Werbeanzeigen zu erreichen. Sie haben vielleicht Fragen wie: Wie oft sollten diese Anzeigen ausgeliefert werden? Wo und wann sollten Sie sie präsentieren? Was soll der Preis sein? Leider ist die Antwort von App zu App und von Placement zu Placement unterschiedlich. Es gibt keine einheitliche Antwort.

Mit Google Analytics for Firebase, AdMob und den vielen anderen leistungsstarken und benutzerfreundlichen Tools von Firebase ist es jetzt viel einfacher, Ihre App datengestützt zu optimieren. Heute zeigen wir Ihnen, wie Sie loslegen können.

Umfang

Dieses Codelab ist das erste von drei Codelabs, in denen Sie eine App namens Awesome Drawing Quiz entwickeln. In diesem Spiel müssen die Spieler den Namen der Zeichnung erraten. Darin wird gezeigt, wie Sie Anzeigen mit Prämie und Firebase-Dienste in Ihr Spiel einbinden können.

In diesem Codelab integrieren Sie Google Analytics for Firebase, um einige wichtige App-Ereignisse aufzuzeichnen. Außerdem erfahren Sie, wie Sie die in der Firebase Console angezeigten App-Analysen lesen.

Zugehörige Codelabs finden Sie unter:

• AdMob+Firebase 102 Android: App-Verhalten ohne App-Update optimieren

Wenn Sie bei der Bearbeitung dieses Codelabs auf Probleme stoßen (z. B. Codefehler, Grammatikfehler oder unklare Formulierungen), melden Sie das Problem bitte über den Link Fehler melden unten links im Codelab.

Lerninhalte

• Google Analytics for Firebase in Ihrer App einrichten
• App-Ereignisse erfassen
• App-Analysen in der Firebase Console lesen

Voraussetzungen

• Android Studio ab Version 4.1
• Ein Google-Konto
• Ein Testgerät mit Android 5.0 oder höher und ein USB-Kabel zum Verbinden des Geräts oder ein Android-Emulator mit einem AVD (Android Virtual Device) mit einem System-Image, das den Play Store bzw. Google APIs unterstützt

Wie würden Sie Ihre Erfahrung mit AdMob bewerten?

Anfänger Mittelstufe Fortgeschrittene

Wie würden Sie Ihre Erfahrung mit Firebase bewerten?

Anfänger Mittelstufe Fortgeschritten

2. Entwicklungsumgebung einrichten

Code herunterladen

Klicken Sie auf die folgende Schaltfläche, um den gesamten Code für dieses Codelab herunterzuladen:

Quellcode herunterladen

Entpacken Sie die heruntergeladene ZIP-Datei. Dadurch wird ein Stammordner mit dem Namen admob-firebase-codelabs-android entpackt.

… oder klonen Sie das GitHub-Repository über die Befehlszeile.

$ git clone https://github.com/googlecodelabs/admob-firebase-codelabs-android

Das Repository enthält vier Ordner:

• 101-base: Der Startcode, auf dem Sie in diesem Codelab aufbauen.
• 101-complete_and_102-base: Der vollständige Code für dieses Codelab und der Starter für das Codelab 102.
• 102-complete: Der vollständige Code für das Codelab 102.

Start-App importieren

Starten Sie Android Studio und wählen Sie auf dem Begrüßungsbildschirm Projekt importieren aus. Wählen Sie dann das Verzeichnis 101-base aus dem heruntergeladenen Code aus.

Das Projekt sollte jetzt in Android Studio geöffnet sein.

3. Anzeigenblock für Videoanzeigen mit Prämie einrichten (optional)

Die Starter-App enthält bereits einen dedizierten Anzeigenblock für Videoanzeigen mit Prämie. Sie können diesen Schritt überspringen, wenn Sie kein neues Konto in Ihrem AdMob-Konto erstellen möchten.

Wichtig:Wenn Sie das Codelab mit einem neu erstellten Anzeigenblock durchführen, kann es einige Stunden dauern, bis Anzeigen in einem neuen Anzeigenblock ausgeliefert werden können.

So erstellen Sie eine neue AdMob-App in Ihrem Konto:

1. Rufen Sie die AdMob Console auf.
2. Klicken Sie im Menü Apps auf App hinzufügen.
3. Wenn Sie gefragt werden, ob Sie Ihre App bei Google Play oder im App Store veröffentlicht haben, antworten Sie mit NEIN.
4. Geben Sie der App den Namen Awesome Drawing Quiz, wählen Sie Android als Plattform aus und klicken Sie dann auf Hinzufügen.

Nachdem Sie eine AdMob-App in Ihrem Konto erstellt haben, können Sie so einen neuen Anzeigenblock für Videoanzeigen mit Prämie erstellen:

1. Klicken Sie im AdMob-Frontend auf das Menü Apps und wählen Sie dann Awesome Drawing Quiz aus der App-Liste aus.
2. Klicken Sie auf ANZEIGENBLOCK HINZUFÜGEN, um einen neuen Anzeigenblock für Anzeigen mit Prämie zu erstellen.
3. Wählen Sie als Anzeigenformat Mit Prämie aus.

4. Geben Sie den gewünschten Namen für den Anzeigenblock ein. Legen Sie dann die Prämienanzahl auf 1 und den Prämienartikel auf „Tipp“ fest. Das ist die Prämie, die die App derzeit Nutzern gewährt. Klicken Sie auf ANZEIGENBLOCK ERSTELLEN, um einen neuen Anzeigenblock für Anzeigen mit Prämie zu erstellen.

5. Wenn die Anleitung erfolgreich erstellt wurde, sehen Sie eine Meldung wie die folgende:
6. Kehren Sie zum Android-Projekt zurück und aktualisieren Sie die Konstanten für die AdMob-App-ID und die Anzeigenblock-ID mit den Werten, die Sie im vorherigen Schritt erstellt haben.

strings.xml

<!-- Update the value with your AdMob app id -->
<string name="admob_app_id">YOUR_ADMOB_APP_ID</string>

GameActivity.kt

// Update the value with your Rewarded Video ad unit id
private const val AD_UNIT_ID = "<YOUR_AD_UNIT_ID>";

4. Firebase-Projekt einrichten

Tipp: Sie können auch ein Firebase-Projekt mit dem Firebase Assistant in Android Studio einrichten. (Tools > Firebase)

Neues Projekt in der Firebase Console erstellen

1. Rufen Sie die Firebase Console auf.
2. Wählen Sie Projekt hinzufügen aus und geben Sie dem Projekt den Namen „Awesome Drawing Quiz“. Achten Sie darauf, dass das Optionsfeld Google Analytics für dieses Projekt aktivieren aktiviert ist.
3. Wählen Sie das Google Analytics-Konto aus, das Sie verwenden möchten. In den meisten Fällen reicht es aus, die Option Default Account for Firebase auszuwählen. Wenn Sie jedoch ein anderes Google Analytics-Konto verwenden möchten, wählen Sie es hier aus.
4. Klicken Sie auf Projekt erstellen.

Android-App hinzufügen

1. Klicken Sie auf der Übersichtsseite Ihres neuen Projekts auf Firebase zu meiner Android-App hinzufügen.
2. Geben Sie den Paketnamen des Codelabs ein: com.codelab.awesomedrawingquiz
3. Legen Sie einen Alias für Ihre App fest: Awesome Drawing Quiz
4. Lassen Sie das SHA-1-Feld leer, da SHA-1 für dieses Projekt nicht erforderlich ist.
5. Wählen Sie App registrieren aus, um Ihre App zu registrieren.

Datei „google-services.json“ Ihrer App hinzufügen

Als Nächstes werden Sie aufgefordert, eine Konfigurationsdatei herunterzuladen, die alle erforderlichen Firebase-Metadaten für Ihre App enthält. Klicken Sie auf google-service.json herunterladen und kopieren Sie die Datei in das Verzeichnis app in Ihrem Projekt.

Abhängigkeitsversionen deklarieren

Fügen wir zuerst die Version jeder Abhängigkeit hinzu, die für die Integration von Firebase in das Projekt erforderlich ist. Öffnen Sie die Datei dependencies.gradle im Stammverzeichnis des Projekts und fügen Sie das google-services-Plug-in, das Firebase Analytics SDK und die Version des Firebase Core SDK hinzu.

dependencies.gradle

ext {
    ...

    // TODO: Declare google-services plugin version (101)
    googleServicesPluginVersion = '4.3.4'

    ...

    // TODO: Declare Firebase BOM version (101)                                                                                                                                                                                                   
    firebaseBomVersion = '26.2.0'

    ...
}

„google-services“-Plug-in auf Ihre App anwenden

Das google-services-Plug-in verwendet die Datei google-services.json, um Ihre Anwendung für die Verwendung von Firebase zu konfigurieren.

Fügen Sie google-services als Klassenpfad in die Datei build.gradle ein, die sich im Stammverzeichnis des Projekts befindet.

build.gradle

// Top-level build file where you can add configuration options common to all sub-projects/modules.

buildscript {
    ...
    
    dependencies {
        classpath "com.android.tools.build:gradle:$androidPluginVersion"

        // TODO: Add google-services plugin (101)
        classpath "com.google.gms:google-services:$googleServicesPluginVersion"

        ...
    }
}

...

Wenden Sie dann das Plug-in google-services an, indem Sie der Datei app/build.gradle eine Zeile wie folgt hinzufügen:

app/build.gradle

apply plugin: 'com.android.application'

// TODO: Apply google-services plugin (101)
apply plugin: 'com.google.gms.google-services'

android {
    ...
}

dependencies {
    ...
}

Firebase SDK zum Projekt hinzufügen

Fügen Sie in der Datei app/build.gradle den App-Abhängigkeiten das Analytics SDK hinzu.

app/build.gradle

apply plugin: 'com.android.application'

android {
    ...
}

dependencies {
    ...

    // TODO: Import the Firebase BoM (101)
    implementation platform("com.google.firebase:firebase-bom:$firebaseBomVersion")

    // COMPLETE: Add Firebase Analytics dependency (101)
    implementation 'com.google.firebase:firebase-analytics-ktx'

    ...
}

...

Projekt mit Gradle-Dateien synchronisieren

Damit alle Abhängigkeiten für Ihre App verfügbar sind, synchronisieren Sie Ihr Projekt mit Gradle-Dateien. Wählen Sie das Menü Datei > Projekt mit Gradle-Dateien synchronisieren aus, um Ihr Projekt mit Gradle-Dateien zu synchronisieren.

5. AdMob mit einem Firebase-Projekt verknüpfen

Hinweis:Wenn Sie den in diesem Codelab bereitgestellten Anzeigenblock für Anzeigen mit Prämie verwenden möchten, können Sie diesen Schritt überspringen.

So verknüpfen Sie Ihre Apps mit Firebase:

1. Melden Sie sich unter https://apps.admob.com in Ihrem AdMob-Konto an.
2. Klicken Sie in der Seitenleiste auf „Apps“.
3. Wählen Sie Awesome Drawing Quiz aus. Falls die App nicht in der Liste der zuletzt verwendeten Apps aufgeführt ist, können Sie auf Alle Apps anzeigen klicken, um eine Liste aller Apps zu durchsuchen, die Sie AdMob hinzugefügt haben.
4. Klicken Sie in der Seitenleiste auf App-Einstellungen.
5. Klicken Sie auf Mit Firebase verknüpfen.
6. Wählen Sie die Option Mit einem bestehenden Firebase-Projekt verknüpfen und eine neue Firebase-App erstellen aus. Wählen Sie dann im Drop-down-Menü das Projekt Awesome Drawing Quiz aus.
7. Nachdem Sie auf die Schaltfläche WEITER geklickt haben, wird die Meldung Erfolgreich verknüpft angezeigt. Klicken Sie zum Beenden auf die Schaltfläche FERTIG.

Wenn Sie Ihre AdMob-App mit einem Firebase-Projekt verknüpfen, werden in der AdMob- und der Firebase Console zusätzliche Funktionen freigeschaltet:

Hinweis:Es dauert einige Stunden, bis die folgenden Statistiken in der AdMob Console und der Google Analytics for Firebase Console angezeigt werden.

Karte „Einnahmen“ (AdMob)

Auf der Karte „Einnahmen“ können Sie sich alle möglichen Einnahmequellen an einem Ort ansehen. Folgende Umsatzquellen werden unterstützt:

• AdMob (geschätzt)
• Vermittlungsnetzwerke (beobachtet)
• In-App-Käufe
• E-Commerce-Käufe

Karte mit Nutzermesswerten (AdMob)

Auf der Karte mit Nutzermesswerten sehen Sie, wie sich Änderungen an der Anzeigendarstellung auf das Nutzerverhalten auswirken.

Bericht zu Anzeigen mit Prämie (AdMob)

Der Bericht zu Anzeigen mit Prämie enthält eine Vielzahl von Messwerten, mit denen Publisher nachvollziehen können, wie Nutzer mit ihren Anzeigen mit Prämie interagieren.

Karte „Gesamtumsatz“ (Firebase)

Nachdem Sie Ihre AdMob-App mit Firebase verknüpft haben, wird auf der Karte „Gesamtumsatz“ im Firebase-Dashboard der Umsatz aus AdMob zusammen mit In-App-Käufen und E-Commerce-Käufen angezeigt.

Berichte zu Werbeereignissen (Firebase)

Anzeigenspezifische Ereignisse (Klick-, Impression- und Prämienevents) werden automatisch erfasst und können in Google Analytics for Firebase verwendet werden.

6. Projekt ausführen

Nachdem Sie das Projekt kompiliert und ausgeführt haben, wird beim Starten der App der folgende Bildschirm angezeigt.

Wenn Sie auf SPIEL STARTEN klicken,wird eine Zeichnung auf dem Bildschirm angezeigt. Ihre Aufgabe ist es, den Namen der Zeichnung anhand des Hinweises oben zu erraten. Daraus können Sie den ersten Buchstaben und die Länge des Namens der Zeichnung ableiten.

Wenn Sie keine Ahnung haben, wie die Zeichnung heißt, können Sie das Level überspringen, indem Sie auf die Schaltfläche ÜBERSPRINGEN klicken.

Vielleicht möchten Sie einen zusätzlichen Hinweis, der Ihnen hilft, die Antwort zu erraten. Wenn Sie auf die Schaltfläche HINWEIS klicken und sich eine Videoanzeige mit Prämie ansehen, erhalten Sie einen zusätzlichen Hinweis. Nachdem Sie sich die Anzeige angesehen haben, wird als Belohnung ein zusätzlicher Buchstabe enthüllt.

7. App-Ereignisse hinzufügen

Um die User Journey im Awesome Drawing Quiz besser nachvollziehen zu können, definieren Sie einige benutzerdefinierte Ereignisse, mit denen das Nutzerverhalten im Spiel erfasst wird:

Ereignisname	Ausgelöst…	Parameter
game_start	Ein Nutzer startet ein neues Spiel.	Keine
level_start	Ein Nutzer beginnt ein neues Level (ein neues Zeichenquiz) in einer Phase. (es gibt 6 Level in einer Phase)	level_name
level_wrong_answer	Ein Nutzer gibt eine falsche Antwort ein.	level_name
ad_reward_prompt	wenn ein Nutzer auf die Schaltfläche für den Hinweis tippt und aufgefordert wird, sich eine Videoanzeige mit Prämie anzusehen	ad_unit_id
ad_reward_impression	wenn ein Nutzer sich eine Videoanzeige mit Prämie ansieht	ad_unit_id
level_success	Ein Nutzer gibt eine richtige Antwort (schließt ein Level ab).	level_name, number_of_attempts, elapsed_time_sec, hint_used
level_fail	Ein Nutzer überspringt ein Level.	level_name, number_of_attempts, elapsed_time_sec, hint_used
game_complete	wenn das Spiel vorbei ist.	number_of_correct_answers

Im Folgenden finden Sie eine Beschreibung der einzelnen Parameter, die mit den einzelnen Ereignissen verknüpft sind:

Ereignisname	Parametername	Beschreibung
level_start	level_name	Name der Zeichnung, die im Level angezeigt wird (z.B. „Banane“)
level_wrong_answer	level_name	Ein Nutzer gibt eine falsche Antwort ein.
ad_reward_prompt	ad_unit_id	Eine Anzeigenblock-ID, die zum Ausliefern von Videoanzeigen mit Prämie verwendet wird
ad_reward_impression	ad_unit_id	Eine Anzeigenblock-ID, die zum Ausliefern von Videoanzeigen mit Prämie verwendet wird
level_success	level_name	Name der Zeichnung, die im Level angezeigt wird (z.B. „Banane“)
level_success	number_of_attempts	Anzahl der Versuche, ein Level zu bestehen
level_success	elapsed_time_sec	Verstrichene Zeit zum Abschließen eines Levels in Sekunden
level_success	hint_used	Gibt an, ob ein Nutzer einen Hinweis (Anzeige mit Prämie) verwendet hat, um ein Level zu bestehen (1: Hinweis verwendet / 0: Level ohne Hinweis bestanden)
level_fail	level_name	Name der Zeichnung, die im Level angezeigt wird (z.B. „Banane“)
level_fail	number_of_attempts	Anzahl der Versuche, ein Level zu bestehen
level_fail	elapsed_time_sec	Verstrichene Zeit zum Abschließen eines Levels in Sekunden
level_fail	hint_used	Gibt an, ob ein Nutzer einen Hinweis (Anzeige mit Prämie) verwendet hat, um ein Level zu bestehen (1: Hinweis verwendet / 0: Level ohne Hinweis bestanden)
game_complete	number_of_correct_answers	Anzahl der im Spiel abgeschlossenen Level

Hinweis: In Google Analytics für Firebase lassen sich maximal 25 benutzerdefinierte Parameter pro Ereignis festlegen.

Helferklasse zum Protokollieren benutzerdefinierter Ereignisse erstellen

Um das Analytics-Ereignis einfach zu erfassen, erstellen Sie eine Hilfsklasse zur Verwaltung benutzerdefinierter Ereignisse.

Erstellen Sie zuerst eine neue Kotlin-Datei (keine Kotlin-Klasse) und nennen Sie sie QuizAnalytics.kt im Paket com.codelab.awesomedrawingquiz. Felder erstellen, in denen der Name Ihrer benutzerdefinierten Ereignisse und deren Parameter definiert werden

QuizAnalytics.kt

private const val EVENT_AD_REWARD_PROMPT = "ad_reward_prompt"

private const val EVENT_AD_REWARD_IMPRESSION = "ad_reward_impression"

private const val EVENT_LEVEL_FAIL = "level_fail"

private const val EVENT_LEVEL_SUCCESS = "level_success"

private const val EVENT_LEVEL_WRONG_ANSWER = "level_wrong_answer"

private const val EVENT_GAME_START = "game_start"

private const val EVENT_GAME_COMPLETE = "game_complete"

private const val PARAM_AD_UNIT_ID = "ad_unit_id"

private const val PARAM_ELAPSED_TIME_SEC = "elapsed_time_sec"

private const val PARAM_HINT_USED = "hint_used"

private const val PARAM_NUMBER_OF_ATTEMPTS = "number_of_attempts"

private const val PARAM_NUMBER_OF_CORRECT_ANSWERS = "number_of_correct_answers"

Fügen Sie als Nächstes Erweiterungsfunktionen hinzu, mit denen Sie benutzerdefinierte Ereignisse in Ihrem Spiel protokollieren können. Die meisten benutzerdefinierten Ereignisse enthalten Parameter, damit Sie mehr Kontext zu den einzelnen Ereignissen haben. Einige Ereignisnamen und ‑parameter (FirebaseAnalytics.Event.LEVEL_NAME und FirebaseAnalytics.Event.LEVEL_START) sind bereits in Analytics definiert. Wir verwenden diese.

QuizAnalytics.kt

...

fun FirebaseAnalytics.logGameStart() = logEvent(EVENT_GAME_START, null)

fun FirebaseAnalytics.logLevelStart(levelName: String) {
    logEvent(FirebaseAnalytics.Event.LEVEL_START) {
        param(FirebaseAnalytics.Param.LEVEL_NAME, levelName)
    }
}

fun FirebaseAnalytics.logLevelWrongAnswer(levelName: String) {
    logEvent(EVENT_LEVEL_WRONG_ANSWER) {
        param(FirebaseAnalytics.Param.LEVEL_NAME, levelName)
    }
}

fun FirebaseAnalytics.logAdRewardPrompt(adUnitId: String) {
    logEvent(EVENT_AD_REWARD_PROMPT) {
        param(PARAM_AD_UNIT_ID, adUnitId)
    }
}

fun FirebaseAnalytics.logAdRewardImpression(adUnitId: String) {
    logEvent(EVENT_AD_REWARD_IMPRESSION) {
        param(PARAM_AD_UNIT_ID, adUnitId)
    }
}

fun FirebaseAnalytics.logLevelSuccess(
    levelName: String,
    numberOfAttempts: Int,
    elapsedTimeSec: Int,
    hintUsed: Boolean
) {
    logEvent(EVENT_LEVEL_SUCCESS) {
        param(FirebaseAnalytics.Param.LEVEL_NAME, levelName)
        param(PARAM_NUMBER_OF_ATTEMPTS, numberOfAttempts.toLong())
        param(PARAM_ELAPSED_TIME_SEC, elapsedTimeSec.toLong())
        param(PARAM_HINT_USED, if (hintUsed) 1 else 0)
    }
}

fun FirebaseAnalytics.logLevelFail(
    levelName: String,
    numberOfAttempts: Int,
    elapsedTimeSec: Int,
    hintUsed: Boolean
) {
    logEvent(EVENT_LEVEL_FAIL) {
        param(FirebaseAnalytics.Param.LEVEL_NAME, levelName)
        param(PARAM_NUMBER_OF_ATTEMPTS, numberOfAttempts.toLong())
        param(PARAM_ELAPSED_TIME_SEC, elapsedTimeSec.toLong())
        param(PARAM_HINT_USED, if (hintUsed) 1 else 0)
    }
}

fun FirebaseAnalytics.logGameComplete(
    numberOfCorrectAnswers: Int
) {
    logEvent(EVENT_GAME_COMPLETE) {
        param(PARAM_NUMBER_OF_CORRECT_ANSWERS, numberOfCorrectAnswers.toLong())
    }
}

Analyseereignisse im Spiel protokollieren

Fügen Sie der Klasse GameViewModel eine neue Eigenschaft für die Instanz FirebaseAnalytics hinzu.

GameViewModel.kt

class GameViewModel(
    ...
    // TODO: Accept FirebaseAnalytics instance as a parameter (101)
    private val analytics: FirebaseAnalytics,
) : ViewModel() {
   ...
}

Fügen Sie als Nächstes in der Klasse AwesomeDrawingQuizViewModelFactory ein neues Attribut hinzu, wie Sie es zuvor in GameViewModel getan haben.

AwesomeDrawingQuizViewModelFactory.kt

class AwesomeDrawingQuizViewModelFactory(
    ...
    // TODO: Accept FirebaseAnalytics instance as a parameter (101)
    private val analytics: FirebaseAnalytics,
) : ViewModelProvider.Factory {
    ...
}

Fügen Sie als Nächstes in der Klasse AwesomeDrawingQuiz die Funktion provideFirebaseAnalytics() hinzu und aktualisieren Sie die Funktion provideViewModelFactory(), um die FirebaseAnalytics-Instanz an AwesomeDrawingViewModelFactory zu übergeben.

AwesomeDrawingQuiz.kt

class AwesomeDrawingQuiz : Application() {

    ...

    fun provideViewModelFactory() = AwesomeDrawingQuizViewModelFactory(
        this,
        provideGameSettings(),
        // TODO: Pass FirebaseAnalytics instance as a parameter (101)
        provideFirebaseAnalytics(),
    )

    // TODO: Provide FirebaseAnalytics instance (101)
    private fun provideFirebaseAnalytics() = Firebase.analytics

    ...

}

Jetzt können Sie benutzerdefinierte Ereignisse implementieren. Rufen Sie zuerst in der Funktion startGame() die Funktion logGameStart() auf, um anzugeben, dass ein Spiel gestartet wurde.

Da logGameStart() eine Erweiterungsfunktion der Klasse FirebaseAnalytics ist, können Sie sie über die Instanz der Klasse FirebaseAnalytics aufrufen.

GameViewModel.kt

fun startGame() {
    ...

    // TODO: Log game_start event (101)
    analytics.logGameStart()

    ...
}

Fügen Sie als Nächstes in der Funktion checkAnswer() die Ereignisse level_success und level_wrong_answer hinzu.

GameViewModel.kt

fun checkAnswer(userAnswer: String) {
    ...
    if (correct) {
        ...

        // TODO: Log level_success event (101)
        analytics.logLevelSuccess(
            levelName = drawing.word,
            numberOfAttempts = numAttempts,
            elapsedTimeSec = elapsedTimeInSeconds,
            hintUsed = isHintUsed,
        )

        ...
    } else {
        // TODO: Log level_wrong_answer event (101)
        analytics.logLevelWrongAnswer(levelName = drawing.word)

        ...
    }
}

Fügen Sie als Nächstes in der Funktion skipLevel() das Ereignis „level_fail“ hinzu, um das Level als fehlgeschlagen zu markieren.

GameViewModel.kt

fun skipLevel() {
   ...

    // TODO: Log level_fail event (101)
    analytics.logLevelFail(
        levelName = drawing.word,
        numberOfAttempts = numAttempts,
        elapsedTimeSec = elapsedTimeInSeconds,
        hintUsed = isHintUsed,
    )

    ...
}

Implementieren Sie als Nächstes die Funktionen logAdRewardPrompt() und logAdRewardImpression(), um das Nutzerverhalten in Bezug auf die Videoanzeige mit Prämie zu erfassen.

GameViewModel.kt

fun logAdRewardPrompt(adUnitId: String) {
    // TODO: Log ad_reward_prompt event (101)
    analytics.logAdRewardPrompt(adUnitId)
}

fun logAdRewardImpression(adUnitId: String) {
    // TODO: Log ad_reward_impression event (101)
    analytics.logAdRewardImpression(adUnitId)
}

Ändern Sie schließlich die Funktionen requestNewDrawing() und finishGame(), um die benutzerdefinierten Ereignisse „level_start“ und „game_complete“ hinzuzufügen.

GameViewModel.kt

private fun requestNewDrawing() {
    ...

    drawingRequestDisposable = drawingDao.getRandomDrawings(seenWords)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe { d ->
            ...

            // TODO: Log level_start event (101)
            analytics.logLevelStart(d.word)

            ...
        }
}

private fun finishGame() {
    // TODO: Log game_complete event (101)
    analytics.logGameComplete(numCorrectAnswers)

    ...
}

8. Analyseereignisse debuggen

Mit DebugView in der Firebase Console können Sie prüfen, ob Ereignisse richtig protokolliert werden. Mit DebugView können Sie die von Ihrer App auf Entwicklungsgeräten protokollierten Rohdaten von Ereignissen nahezu in Echtzeit ansehen.

Das ist für Validierungszwecke während der Instrumentierungsphase der Entwicklung sehr nützlich und kann Ihnen helfen, Fehler in Ihrer Analytics-Implementierung zu erkennen.

Debug-Modus aktivieren

In der Regel werden in Ihrer App erfasste Ereignisse über einen Zeitraum von etwa einer Stunde zusammengefasst und gemeinsam hochgeladen. Wenn Sie Ihre Analytics-Implementierung im Handumdrehen prüfen möchten, müssen Sie den Debug-Modus auf Ihrem Entwicklungsgerät aktivieren, damit Ereignisse mit minimalen Verzögerungen hochgeladen werden.

Führen Sie die folgenden Schritte aus, um den Debug-Modus zu aktivieren:

1. Öffnen Sie das Toolfenster Terminal in Android Studio (View > Tool Windows > Terminal).

2. Führen Sie den folgenden Befehl aus. Das Android-Testgerät muss dazu mit Ihrem Computer verbunden sein oder der Android-Emulator muss ausgeführt werden:

adb shell setprop debug.firebase.analytics.app com.codelab.awesomedrawingquiz

Der Fehlerbehebungsmodus ist aktiv, bis Sie ihn ausdrücklich beenden, indem Sie den folgenden Befehl ausführen:

adb shell setprop debug.firebase.analytics.app .none.

Analytics-Ereignisse mit DebugView debuggen

Nachdem Sie den Debug-Modus auf Ihrem Testgerät aktiviert haben, rufen Sie Ihr Projekt in der Firebase Console auf und wählen Sie im Menü Analytics > DebugView aus. Spielen Sie dann auf Ihrem Testgerät, um zu sehen, wie Ereignisse protokolliert und im DebugView-Bericht angezeigt werden.

Wenn Sie auf den Namen eines Ereignisses klicken, erhalten Sie detaillierte Informationen dazu. Der folgende Screenshot zeigt beispielsweise die Parameterdetails, die dem Ereignis level_start zugeordnet sind.

Weitere Informationen finden Sie in diesem Hilfeartikel.

9. Benutzerdefinierte Dimensionen und Messwerte aktivieren

Standardmäßig wird in Google Analytics for Firebase die Gesamtzahl der Ereignisse erfasst. Für jeden Ereignisparameter, der Sie interessiert, müssen Sie die Berichterstellung für diesen Parameter explizit aktivieren. In Google Analytics für Firebase können dann zusätzliche Karten mit Statistiken für benutzerdefinierte Parameter angezeigt werden.

Hinweis: Sie können pro Projekt bis zu 50 benutzerdefinierte Ereignisparameter angeben (40 numerische und 10 textbasierte).

So registrieren Sie benutzerdefinierte Dimensionen und Messwerte:

1. Rufen Sie die Firebase Console auf und wählen Sie das Projekt Awesome Drawing Quiz aus, das Sie zuvor erstellt haben.
2. Klicken Sie im Navigationsmenü auf Analytics > Ereignisse.

Wichtig:Es kann mehrere Stunden dauern, bis Ereignisdaten in Google Analytics for Firebase angezeigt werden. Wenn Sie Ihre Events nicht in der Konsole sehen, warten Sie eine Weile, bis die Ereignisdaten verfügbar sind.

3. Klicken Sie auf Benutzerdefinierte Definitionen verwalten.
4. Klicken Sie auf dem Tab „Benutzerdefinierte Dimensionen“ auf Benutzerdefinierte Dimensionen erstellen.
5. Geben Sie im Feld „Name des Ereignisparameters“ level_name ein und klicken Sie auf Speichern, um die Parameterregistrierung abzuschließen.

6. Wählen Sie dann den Tab Benutzerdefinierte Messwerte aus und klicken Sie auf Benutzerdefinierte Messwerte erstellen.
7. Geben Sie den Parameternamen und die Maßeinheit für die folgenden Parameter ein.

Parametername	Parametertyp	Maßeinheit
number_of_attempts	Zahl	Standard
hint_used	Zahl	Standard
elapsed_time_sec	Zahl	Sekunden
number_of_correct_answers	Zahl	Standard

10. Statistiken im Ereignisbericht

Hinweis: Es dauert einige Stunden, bis Daten in Google Analytics für Firebase angezeigt werden. Möglicherweise sind in Ihrem Diagramm derzeit noch keine Daten vorhanden. Wenn Sie das Dashboard mit echten App-Daten aufrufen möchten, können Sie auf das Firebase-Demoprojekt zugreifen. Es handelt sich um ein Standard-Firebase-Projekt mit voll funktionsfähigen Analytics- und Remote Config-Funktionen usw.

Da Sie einige Ereignisse im Spiel hinzugefügt haben, sollten Sie die Fragen zum Nutzerverhalten im Spiel beantworten können. Hier sind einige Statistiken, die Sie aus dem Firebase-Ereignisbericht erhalten können.

Bei welchem Niveau gibt es die meisten falschen Antworten?

Um diese Frage zu beantworten, müssen Sie herausfinden, wie viele level_wrong_answer-Ereignisse pro Ebene ausgelöst wurden.

Klicken Sie im Ereignisbericht auf level_wrong_answer. Suchen Sie im Ereignisbericht level_wrong_answer nach der Karte level_name. Auf dieser Karte sehen Sie die Werte, die dem Parameter level_name zugeordnet sind.

Im obigen Screenshot sehen Sie, dass der Horizont die meisten falschen Antworten aufweist. Das bedeutet, dass er im Vergleich zu den anderen Ebenen für Nutzer schwieriger ist.

Anhand dieser Informationen können Sie entscheiden, ob Sie Anfängern schwierige Levels anbieten möchten, um eine hohe Bindungsrate zu erzielen.

Wie viele Versuche wurden durchschnittlich unternommen, um ein Level zu schaffen?

Im Awesome Drawing Quiz können Nutzer die Antwort für jedes Level so oft wie gewünscht einreichen.

Da Sie die Berichterstellung für den Parameter number_of_attempts im Ereignis level_success aktiviert haben, können Sie die detaillierten Messwerte für diesen Parameter sehen.

Klicken Sie im Ereignisbericht auf das level_success-Ereignis. Suchen Sie im Ereignisbericht level_success nach der Karte number_of_attemps. Auf dieser Karte sehen Sie die durchschnittliche Anzahl der Versuche so:

Anhand dieser Informationen können Sie den durchschnittlichen Schwierigkeitsgrad des Spiels optimieren. Wenn die durchschnittliche Anzahl der Versuche beispielsweise zu nahe an 1 liegt, sollten Sie das Spiel vielleicht etwas schwieriger gestalten.

Haben Nutzer versucht, die Frage mithilfe eines Hinweises zu beantworten, obwohl sie das Level nicht geschafft haben?

Wenn ein Nutzer ein Level überspringt, wird ein level_fail-Ereignis ausgelöst. Die Entscheidung des Nutzers kann viele Gründe haben.

Da das Spiel dem Nutzer nach dem Ansehen einer Videoanzeige mit Prämie einen Hinweis geben kann, ist es wichtig zu wissen, ob der Nutzer versucht hat, das Level mit dem Hinweis zu bestehen.

Klicken Sie im Ereignisbericht auf das level_fail-Ereignis. Suchen Sie im Ereignisbericht level_fail nach der Karte hint_used. Sie sehen die durchschnittliche Anzahl der hint_used-Ereignisparameter. Der Wert des Parameters ist 1, wenn ein Hinweis verwendet wurde, und 0, wenn kein Hinweis verwendet wurde.

Wenn die Zahlen auf der Karte hint_used nahe null sind, ist das ein Zeichen dafür, dass die Belohnung (Hinweis) für diese Nutzer nicht hilfreich genug ist. Außerdem verpassen Sie die Gelegenheit, den Umsatz mit Videoanzeigen mit Prämie zu steigern.

Daher sollten Sie eine größere Prämie anbieten, damit Nutzer sich intensiver mit dem Spiel beschäftigen. So können Sie Ihren Umsatz mit Videoanzeigen mit Prämie steigern.

Wie viele Level wurden im Durchschnitt in jedem Spiel abgeschlossen?

Jedes Spiel im Awesome Drawing Quiz hat insgesamt sechs Level. Sobald der Nutzer 6 Level abgeschlossen hat (unabhängig davon, ob er jedes Level bestanden oder nicht bestanden hat), wird ein game_complete-Ereignis mit number_of_correct_answers als Parameter ausgelöst. Der Parameter number_of_correct_answers gibt die Anzahl der Stufen an, in denen der Nutzer eine richtige Antwort gegeben hat.

Klicken Sie im Ereignisbericht auf das game_complete-Ereignis. Suchen Sie im Bericht zum Ereignis „game_complete“ nach der Karte number_of_correct_answers. Sie sehen die durchschnittliche Anzahl der number_of_correct_answers-Ereignisparameter.

Wenn die durchschnittliche Anzahl der abgeschlossenen Level zu niedrig ist, sollten Sie die Level im Spiel neu anordnen, damit die Spieler die ersten Level leichter schaffen und Ihr Spiel nicht das Interesse verlieren.

11. Fertig!

Sie haben das Codelab „AdMob + Firebase 101 für Android“ abgeschlossen. Den vollständigen Code für dieses Codelab finden Sie im Ordner 101-complete_and_102-base.

Im nächsten Teil des AdMob+Firebase-Codelabs erfahren Sie, wie Sie einen Trichter verwenden, um den App-Ereignisfluss zu visualisieren. Im nächsten Teil wird auch beschrieben, wie Sie mit Remote Config und A/B-Tests den Parameterwert im Spiel ohne App-Update optimieren können.

Als Nächstes:

• AdMob+Firebase 102 Android: App-Verhalten ohne App-Update optimieren