Podstawy AdMob dla Androida: konfiguracja Podstawy Analytics

1. Wprowadzenie

Reklamy są kluczowym elementem ogólnej wygody użytkowników aplikacji. Dobre wdrożenia reklam mogą poprawić ogólne wrażenia użytkowników z aplikacji, a nawet zwiększyć ich zaangażowanie i utrzymanie użytkowników. Na przykład reklamy z nagrodą umożliwiają nagradzanie użytkowników walutą lub elementami dodawanymi w aplikacji w zamian za oglądanie reklam wideo. Dzięki temu użytkownicy mogą osiągać nowe poziomy, na których w innych okolicznościach mogliby utknąć i zrezygnować z aplikacji.

Zapewnienie doskonałych wrażeń związanych z reklamami nie jest jednak łatwe. Możesz mieć pytania takie jak: jak często wyświetlać te reklamy? Gdzie i kiedy należy je wyświetlać? Jaka powinna być nagroda? Niestety odpowiedź różni się w zależności od aplikacji i miejsca docelowego. Nie ma jednej uniwersalnej odpowiedzi.

Dzięki Google Analytics dla Firebase, AdMob i kilku innym zaawansowanym, ale łatwym w obsłudze narzędziom, które oferuje Firebase, precyzyjne dostrajanie aplikacji na podstawie danych stało się znacznie prostsze i bardziej efektywne. Dziś pokażemy Ci, jak zacząć.

Co utworzysz

Te ćwiczenia z programowania są pierwszymi z trzech, które pomogą Ci stworzyć aplikację Awesome Drawing Quiz, czyli grę, w której gracze zgadują nazwę rysunku. Pokazuje, jak w grze można wykorzystać reklamy z nagrodą i usługi Firebase.

W tym laboratorium kodowania zintegrujesz Google Analytics dla Firebase, aby rejestrować ważne zdarzenia w aplikacji. Dowiesz się też, jak odczytywać dane analityczne aplikacji wyświetlane w konsoli Firebase.

Jeśli podczas wykonywania tego laboratorium napotkasz jakiekolwiek problemy (błędy w kodzie, błędy gramatyczne, niejasne sformułowania itp.), zgłoś je, klikając link Zgłoś błąd w lewym dolnym rogu laboratorium.

Czego się nauczysz

Jak skonfigurować Google Analytics dla Firebase w aplikacji
Jak rejestrować zdarzenia w aplikacji
Jak odczytywać dane analityczne aplikacji wyświetlane w konsoli Firebase

Czego potrzebujesz

Android Studio w wersji 4.1 lub nowszej
konto Google,
Urządzenie testowe z Androidem w wersji 5.0 lub nowszej i kabel USB do podłączenia urządzenia albo Android Emulator z urządzeniem wirtualnym z Androidem (AVD) z obrazem systemu, który obsługuje Sklep Play lub interfejsy API Google.

Jak oceniasz swoje doświadczenie z AdMob?

Początkujący

Średnio zaawansowany

Zaawansowany

Jak oceniasz swoje doświadczenie z Firebase?

Początkujący

Średnio zaawansowany

Zaawansowany

2. Konfigurowanie środowiska programistycznego

Pobieranie kodu

Aby pobrać cały kod do tych ćwiczeń, kliknij ten przycisk:

Rozpakuj pobrany plik ZIP. Spowoduje to rozpakowanie folderu głównego o nazwie admob-firebase-codelabs-android.

…lub sklonuj repozytorium GitHub z poziomu wiersza poleceń.

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

Repozytorium zawiera 4 foldery:

101-base – kod początkowy, który będziesz rozwijać w tych ćwiczeniach z programowania.
101-complete_and_102-base – ukończony kod do tych ćwiczeń z programowania i kod początkowy do ćwiczeń z programowania 102.
102-complete – ukończony kod do ćwiczeń z programowania 102.

Importowanie aplikacji startowej

Uruchom Android Studio i na ekranie powitalnym wybierz „Importuj projekt”. Następnie wybierz katalog 101-base z pobranego kodu.

Projekt powinien być teraz otwarty w Android Studio.

3. Konfigurowanie jednostki reklamy wideo z nagrodą (opcjonalnie)

Aplikacja startowa zawiera już specjalną jednostkę reklamy wideo z nagrodą. Jeśli nie chcesz tworzyć nowego konta podrzędnego na koncie AdMob, możesz pominąć ten krok.

Aby utworzyć nową aplikację w AdMob na swoim koncie, wykonaj te czynności:

Otwórz konsolę AdMob.
W menu Aplikacje kliknij Dodaj aplikację.
Na pytanie „Czy aplikacja została opublikowana w Google Play lub App Store?” odpowiedz „NIE”.
Nazwij aplikację „Awesome Drawing Quiz”,jako platformę wybierz „Android”, a potem kliknij „Dodaj”.

Po utworzeniu aplikacji w AdMob na koncie wykonaj opisane poniżej czynności, aby utworzyć nową jednostkę reklamy wideo z nagrodą.

W interfejsie AdMob kliknij menu Aplikacje, a potem na liście aplikacji wybierz „Awesome Drawing Quiz”.
Kliknij DODAJ JEDNOSTKĘ REKLAMY, aby utworzyć nową jednostkę reklamy wideo z nagrodą.
Wybierz Reklama z nagrodą jako format reklamy.

Podaj dowolną nazwę jednostki reklamowej. Następnie ustaw liczbę nagród na 1, a nagrodę na „podpowiedź” (jest to nagroda, którą aplikacja obecnie przyznaje użytkownikom). Kliknij UTWÓRZ JEDNOSTKĘ REKLAMY, aby utworzyć nową jednostkę reklamy wideo z nagrodą.

Po utworzeniu zobaczysz instrukcje podobne do tych:
Wróć do projektu aplikacji na Androida i zmień stałe identyfikatora aplikacji w AdMob i identyfikatora jednostki reklamowej na te, które zostały utworzone w poprzednim kroku.

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. Konfigurowanie projektu Firebase

Tworzenie nowego projektu w konsoli Firebase

Otwórz konsolę Firebase.
Kliknij Dodaj projekt i nadaj mu nazwę „Super quiz rysunkowy”. Sprawdź, czy przycisk Włącz Google Analytics w tym projekcie jest włączony.
Wybierz konto Google Analytics, którego chcesz używać. W większości przypadków wystarczy wybrać opcję Konto domyślne dla Firebase, ale jeśli chcesz używać innego konta Google Analytics, wybierz je tutaj.
Kliknij Utwórz projekt.

Dodawanie aplikacji na Androida

Na ekranie przeglądu nowego projektu kliknij Dodaj Firebase do aplikacji na Androida.
Wpisz nazwę pakietu codelabu: com.codelab.awesomedrawingquiz
Ustaw pseudonim aplikacji: Świetny quiz rysunkowy
Pozostaw pole SHA-1 puste, ponieważ w tym projekcie nie jest wymagany SHA-1.
Aby zarejestrować aplikację, kliknij Zarejestruj aplikację.

Dodawanie pliku google-services.json do aplikacji

Następnie pojawi się ekran, na którym możesz pobrać plik konfiguracyjny zawierający wszystkie niezbędne metadane Firebase dla Twojej aplikacji. Kliknij Pobierz google-service.json i skopiuj plik do katalogu app w projekcie.

Deklarowanie wersji zależności

Zacznijmy od dodania wersji każdej zależności wymaganej do zintegrowania Firebase z projektem. Otwórz plik dependencies.gradle znajdujący się w katalogu głównym projektu, a następnie dodaj wtyczkę google-services oraz wersje pakietów SDK Firebase Analytics i Firebase Core.

dependencies.gradle

ext {
    ...

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

    ...

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

    ...
}

Stosowanie wtyczki google-services w aplikacji

Wtyczka usług Google używa pliku google-services.json do konfigurowania aplikacji pod kątem korzystania z Firebase.

Dodaj google-services jako ścieżkę klasy w pliku build.gradle znajdującym się w katalogu głównym projektu.

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"

        ...
    }
}

...

Następnie zastosuj wtyczkę google-services, dodając wiersz w pliku app/build.gradle w ten sposób:

app/build.gradle

apply plugin: 'com.android.application'

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

android {
    ...
}

dependencies {
    ...
}

Dodaj pakiet SDK Firebase do projektu.

W pliku app/build.gradle dodaj pakiet SDK Analytics do zależności aplikacji.

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'

    ...
}

...

Synchronizowanie projektu z plikami Gradle

Aby mieć pewność, że wszystkie zależności są dostępne dla aplikacji, zsynchronizuj projekt z plikami Gradle. Aby zsynchronizować projekt z plikami Gradle, wybierz menu File > Sync Project with Gradle Files (Plik > Synchronizuj projekt z plikami Gradle).

5. Łączenie AdMob z projektem Firebase

Aby połączyć aplikacje z Firebase, wykonaj podane niżej czynności.

Zaloguj się na konto AdMob na stronie https://apps.admob.com.
Na pasku bocznym kliknij „Aplikacje”.
Wybierz „Awesome Drawing Quiz” (Super quiz rysunkowy). Jeśli nie widzisz jej na liście ostatnio używanych aplikacji, możesz kliknąć Zobacz wszystkie, aby wyświetlić listę wszystkich aplikacji dodanych przez Ciebie do AdMob.
Na pasku bocznym kliknij Ustawienia aplikacji.
Kliknij Połącz z Firebase.
Wybierz opcję „Połącz z istniejącym projektem w Firebase i utwórz nową aplikację w Firebase”. Następnie w menu wybierz projekt „Awesome Drawing Quiz”.
Po kliknięciu przycisku „DALEJ” zobaczysz komunikat „Połączono”. Aby zakończyć, kliknij przycisk „GOTOWE”.

Po połączeniu aplikacji w AdMob z projektem w Firebase odblokujesz dodatkowe funkcje w konsolach AdMob i Firebase:

Karta przychodów (AdMob)

Na karcie Przychody możesz w jednym miejscu sprawdzić wszystkie możliwe źródła przychodów. Obsługiwane źródła przychodów to:

AdMob (szacunkowe)
Sieci reklamowe z zapośredniczeniem (zaobserwowane)
Zakupy w aplikacji
Zakupy e-commerce

Karta danych o użytkownikach (AdMob)

Na karcie danych o użytkownikach możesz sprawdzić, jak zmiany w reklamach mogą wpływać na zachowania użytkowników.

Raport dotyczący reklam z nagrodą (AdMob)

Raport dotyczący reklam z nagrodą zawiera różne dane, które pomagają wydawcom zrozumieć, jak użytkownicy wchodzą w interakcje z ich reklamami z nagrodą.

Karta Łączne przychody (Firebase)

Po połączeniu aplikacji AdMob z Firebase na karcie Łączne przychody na panelu Firebase będą wyświetlane przychody z AdMob oraz przychody z zakupów w aplikacji i zakupów e-commerce.

Raportowanie zdarzeń związanych z reklamami (Firebase)

Zdarzenia związane z reklamami (zdarzenia kliknięcia, wyświetlenia i nagrody) są zbierane automatycznie i dostępne do użycia w Google Analytics dla Firebase.

6. Uruchamianie projektu

Po skompilowaniu i uruchomieniu projektu zobaczysz ten ekran po uruchomieniu aplikacji.

Gdy klikniesz ROZPOCZNIJ GRĘ,na ekranie pojawi się rysunek. Twoim zadaniem jest odgadnięcie nazwy rysunku na podstawie wskazówki wyświetlanej u góry, z której możesz wywnioskować pierwszą literę i długość nazwy rysunku.

Jeśli nie masz pomysłu na nazwę rysunku, możesz pominąć poziom, klikając przycisk „POMIŃ”.

Możesz potrzebować dodatkowej wskazówki, która pomoże Ci odgadnąć odpowiedź. Dodatkową wskazówkę możesz uzyskać, klikając przycisk „PODPOWIEDŹ” i oglądając reklamę wideo z nagrodą. Po obejrzeniu reklamy otrzymasz dodatkową literę jako nagrodę.

7. Dodawanie zdarzeń w aplikacji

Aby dokładnie poznać ścieżkę użytkownika w Awesome Drawing Quiz, zdefiniujesz kilka zdarzeń niestandardowych, które będą śledzić zachowania użytkowników w grze w ten sposób:

Nazwa zdarzenia	Aktywowano…	Parametry
game_start	gdy użytkownik rozpoczyna nową grę.	brak
level_start	gdy użytkownik rozpoczyna nowy poziom (nowy quiz rysunkowy) w ramach etapu. (na jednym etapie jest 6 poziomów)	level_name
level_wrong_answer	gdy użytkownik prześle błędną odpowiedź.	level_name
ad_reward_prompt	gdy użytkownik naciśnie przycisk podpowiedzi i zostanie poproszony o obejrzenie reklamy wideo z nagrodą.	ad_unit_id
ad_reward_impression	gdy użytkownik zaczyna oglądać reklamę wideo z nagrodą.	ad_unit_id
level_success	gdy użytkownik prześle prawidłową odpowiedź (ukończy poziom).	level_name, number_of_attempts, elapsed_time_sec, hint_used
level_fail	gdy użytkownik pominie poziom.	level_name, number_of_attempts, elapsed_time_sec, hint_used
game_complete	po zakończeniu gry.	number_of_correct_answers

Opis każdego parametru powiązanego z poszczególnymi zdarzeniami:

Nazwa zdarzenia	Nazwa parametru	Opis
level_start	level_name	Nazwa rysunku widoczna na poziomie (np. „banan”).
level_wrong_answer	level_name	gdy użytkownik prześle błędną odpowiedź.
ad_reward_prompt	ad_unit_id	Identyfikator jednostki reklamowej używany do wyświetlania reklamy wideo z nagrodą.
ad_reward_impression	ad_unit_id	Identyfikator jednostki reklamowej używany do wyświetlania reklamy wideo z nagrodą.
level_success	level_name	Nazwa rysunku widoczna na poziomie (np. „banan”).
level_success	number_of_attempts	Liczba prób przejścia poziomu
level_success	elapsed_time_sec	Czas potrzebny na ukończenie poziomu w sekundach
level_success	hint_used	Czy użytkownik skorzystał z podpowiedzi (obejrzał reklamę wideo z nagrodą), aby przejść poziom (1 – skorzystał z podpowiedzi, 0 – przeszedł poziom bez podpowiedzi).
level_fail	level_name	Nazwa rysunku widoczna na poziomie (np. „banan”).
level_fail	number_of_attempts	Liczba prób przejścia poziomu
level_fail	elapsed_time_sec	Czas potrzebny na ukończenie poziomu w sekundach
level_fail	hint_used	Czy użytkownik skorzystał z podpowiedzi (obejrzał reklamę wideo z nagrodą), aby przejść poziom (1 – skorzystał z podpowiedzi, 0 – przeszedł poziom bez podpowiedzi).
game_complete	number_of_correct_answers	Liczba poziomów ukończonych w grze

Tworzenie klasy pomocniczej do rejestrowania zdarzeń niestandardowych

Aby łatwo rejestrować zdarzenia Analytics, utwórz klasę pomocniczą do zarządzania zdarzeniami niestandardowymi.

Najpierw utwórz nowy plik Kotlin (nie klasę Kotlin) i nadaj mu nazwę QuizAnalytics.kt w pakiecie com.codelab.awesomedrawingquiz. Utwórz pola, które określają nazwę zdarzeń niestandardowych i ich parametry.

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"

Następnie dodaj funkcje rozszerzenia, które pomogą Ci rejestrować zdarzenia niestandardowe w grze. Pamiętaj, że większość zdarzeń niestandardowych zawiera parametry, które dostarczają więcej informacji o każdym zdarzeniu. Pamiętaj też, że kilka nazw i parametrów zdarzeń (FirebaseAnalytics.Event.LEVEL_NAME i FirebaseAnalytics.Event.LEVEL_START) jest już zdefiniowanych przez Analytics, więc będziemy ich używać.

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())
    }
}

Rejestrowanie zdarzeń analitycznych w grze

W klasie GameViewModel dodaj nową właściwość dla instancji FirebaseAnalytics.

GameViewModel.kt

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

Następnie w klasie AwesomeDrawingQuizViewModelFactory dodaj nową właściwość, tak jak wcześniej w klasie GameViewModel.

AwesomeDrawingQuizViewModelFactory.kt

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

Następnie w klasie AwesomeDrawingQuiz dodaj funkcję provideFirebaseAnalytics() i zaktualizuj funkcję provideViewModelFactory(), aby przekazywać instancję FirebaseAnalytics do AwesomeDrawingViewModelFactory.

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

    ...

}

Teraz możesz zaimplementować zdarzenia niestandardowe. Najpierw w funkcji startGame() wywołaj funkcję logGameStart(), aby wskazać, że gra się rozpoczęła.

Ponieważ logGameStart() jest funkcją rozszerzającą klasy FirebaseAnalytics, możesz ją wywołać z instancji klasy FirebaseAnalytics.

GameViewModel.kt

fun startGame() {
    ...

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

    ...
}

Następnie w funkcji checkAnswer() dodaj zdarzenia level_success i level_wrong_answer.

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)

        ...
    }
}

Następnie w funkcji skipLevel() dodaj zdarzenie level_fail, aby oznaczyć poziom jako nieudany.

GameViewModel.kt

fun skipLevel() {
   ...

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

    ...
}

Następnie zaimplementuj funkcje logAdRewardPrompt() i logAdRewardImpression(), aby śledzić zachowania użytkownika związane z reklamą wideo z nagrodą.

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)
}

Na koniec zmodyfikuj funkcje requestNewDrawing() i finishGame(), aby dodać zdarzenia niestandardowe level_start i game_complete.

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. Debugowanie zdarzeń Analytics

Aby sprawdzić, czy zdarzenia są prawidłowo rejestrowane, możesz użyć raportu DebugView w konsoli Firebase. DebugView umożliwia wyświetlanie w czasie zbliżonym do rzeczywistego nieprzetworzonych danych o zdarzeniach rejestrowanych przez aplikację na urządzeniach programistycznych.

Jest to bardzo przydatne do celów weryfikacji na etapie implementacji w trakcie tworzenia aplikacji. Pomaga wykrywać błędy w implementacji Analytics.

Włączanie trybu debugowania

Zdarzenia logowane w aplikacji są zwykle grupowane w ciągu około godziny i przesyłane razem. Aby na bieżąco sprawdzać poprawność implementacji Analytics, musisz włączyć tryb debugowania na urządzeniu używanym do programowania, aby przesyłać zdarzenia z minimalnymi opóźnieniami.

Aby włączyć tryb debugowania, wykonaj te czynności:

Otwórz okno narzędziowe Terminal w Android Studio (Widok > Okna narzędziowe > Terminal).

Wykonaj to polecenie (sprawdź, czy testowe urządzenie z Androidem jest podłączone do komputera lub czy Android Emulator jest uruchomiony):

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

Tryb debugowania pozostanie włączony, dopóki nie wyłączysz go tym poleceniem:

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

Debugowanie zdarzeń Analytics za pomocą DebugView

Gdy włączysz tryb debugowania na urządzeniu testowym, otwórz projekt w konsoli Firebase i w menu wybierz Analytics > DebugView. Następnie na urządzeniu testowym uruchom grę, aby zobaczyć, jak zdarzenia są rejestrowane i wyświetlane w raporcie DebugView.

Aby uzyskać szczegółowe informacje o poszczególnych zdarzeniach, kliknij ich nazwy. Na przykład na tym zrzucie ekranu widać szczegóły parametrów powiązanych ze zdarzeniem level_start.

Więcej informacji znajdziesz w tym artykule w Centrum pomocy.

9. Włączanie wymiarów i danych niestandardowych

Domyślnie Google Analytics dla Firebase zbiera łączną liczbę zdarzeń. W przypadku każdego parametru zdarzenia, który Cię interesuje, musisz włączyć raportowanie tego parametru. Google Analytics dla Firebase może wtedy wyświetlać dodatkowe karty z informacjami o statystykach parametrów niestandardowych.

Aby zarejestrować wymiary i dane niestandardowe:

Otwórz konsolę Firebase i wybierz utworzony wcześniej projekt Awesome Drawing Quiz.
W menu nawigacyjnym kliknij Analytics > Zdarzenia.

Kliknij Zarządzaj niestandardowymi definicjami.
Na karcie Wymiary niestandardowe kliknij Utwórz wymiary niestandardowe.
W polu Nazwa parametru zdarzenia wpisz level_name i kliknij Zapisz, aby zakończyć rejestrację parametru.

Następnie wybierz kartę Dane niestandardowe i kliknij Utwórz dane niestandardowe.
Wpisz nazwę parametru i jednostkę miary dla tych parametrów:

Nazwa parametru	Typ parametru	Jednostka miary
number_of_attempts	Liczba	Standardowe
hint_used	Liczba	Standardowe
elapsed_time_sec	Liczba	Sekundy
number_of_correct_answers	Liczba	Standardowe

10. Wyświetlanie statystyk z raportu Zdarzenie

Po dodaniu kilku zdarzeń w grze powinna być możliwość udzielenia odpowiedzi na pytania dotyczące zachowania użytkowników w grze. Oto kilka informacji, które możesz uzyskać z raportu o zdarzeniach w Firebase.

Na którym poziomie jest najwięcej błędnych odpowiedzi?

Aby odpowiedzieć na to pytanie, musisz sprawdzić, ile level_wrong_answer zdarzeń zostało wywołanych na każdym poziomie.

W raporcie o zdarzeniach kliknij level_wrong_answer. W raporcie zdarzenia level_wrong_answer odszukaj kartę level_name. Na tej karcie zobaczysz wartości powiązane z parametrem level_name w ten sposób:

Z powyższego zrzutu ekranu wynika, że najwięcej błędnych odpowiedzi uzyskano w przypadku horyzontu, co oznacza, że jest on trudniejszy dla użytkowników niż pozostałe poziomy.

Na podstawie tych informacji możesz zdecydować, aby nie udostępniać trudnych poziomów początkującym użytkownikom, aby utrzymać wysoki wskaźnik utrzymania.

Ile prób przejścia poziomu podejmowano średnio?

W Awesome Drawing Quiz użytkownicy mogą przesyłać odpowiedzi na każdym poziomie tyle razy, ile chcą.

Ponieważ w przypadku parametru number_of_attempts w zdarzeniu level_success masz włączone raportowanie parametrów, możesz wyświetlać szczegółowe dane o tym parametrze.

W raporcie o zdarzeniach kliknij zdarzenie level_success. W raporcie zdarzenia level_success odszukaj kartę number_of_attemps. Na karcie zobaczysz średnią liczbę prób w ten sposób:

Na podstawie tych danych możesz zoptymalizować średni poziom trudności gry. Jeśli na przykład średnia liczba prób jest zbyt bliska 1, możesz nieco utrudnić grę.

Czy użytkownicy próbowali rozwiązać pytanie, korzystając z podpowiedzi, mimo że ostatecznie nie udało im się przejść poziomu?

Gdy użytkownik zdecyduje się pominąć poziom, wywoływane jest level_failzdarzenie. Decyzja użytkownika może być spowodowana wieloma czynnikami.

Ponieważ jednak gra może podać wskazówkę po obejrzeniu przez użytkownika reklamy wideo z nagrodą, ważne jest, aby wiedzieć, czy użytkownik próbował przejść poziom z pomocą wskazówki.

W raporcie o zdarzeniach kliknij zdarzenie level_fail. W raporcie zdarzenia level_fail odszukaj kartę hint_used. Zobaczysz średnią liczbę parametrów zdarzeń hint_used. Pamiętaj, że wartość parametru wynosi 1, jeśli użyto wskazówki, a 0, jeśli nie.

Jeśli liczby na karcie hint_used są bliskie 0, oznacza to, że nagroda (wskazówka) nie jest wystarczająco pomocna dla tych użytkowników. Tracisz też możliwość zwiększenia przychodów z reklamy wideo z nagrodą.

Warto więc rozważyć zaoferowanie większej nagrody, aby użytkownicy mogli bardziej zaangażować się w grę, co przełoży się na wzrost przychodów z reklam wideo z nagrodą.

Ile etapów gracze ukończyli średnio w każdej grze?

W przypadku każdej gry w Awesome Drawing Quiz jest łącznie 6 poziomów. Gdy użytkownik ukończy 6 poziomów (niezależnie od tego, czy udało mu się je przejść), wywoływane jest zdarzenie game_complete z parametrem number_of_correct_answers. Parametr number_of_correct_answers wskazuje liczbę poziomów, na których użytkownik udzielił prawidłowej odpowiedzi.

W raporcie o zdarzeniach kliknij zdarzenie game_complete. W raporcie o zdarzeniu game_complete odszukaj kartę number_of_correct_answers. Zobaczysz średnią liczbę parametrów zdarzeń number_of_correct_answers.

Jeśli średnia liczba ukończonych poziomów jest zbyt niska, rozważ zmianę kolejności poziomów w grze, aby ułatwić graczom pokonywanie wcześniejszych poziomów. Dzięki temu będą mogli kontynuować grę bez utraty zainteresowania.

11. Wszystko gotowe

Ukończono ćwiczenia AdMob+Firebase 101 na Androida. Ukończony kod tego ćwiczenia znajdziesz w folderze 101-complete_and_102-base.

W kolejnej części tego laboratorium poświęconego AdMob i Firebase dowiesz się, jak używać ścieżki do wizualizacji przepływu zdarzeń w aplikacji. W następnej części omówimy też, jak używać Zdalnej konfiguracji i testów A/B do optymalizacji wartości parametru w grze bez aktualizacji aplikacji.