Ta strona została przetłumaczona przez Cloud Translation API.

Zdarzenia z dziennika

Zdarzenia pozwalają stwierdzić, co dzieje się w aplikacji. Dostarczają informacji m.in. o działaniach użytkowników, zdarzeniach systemowych i błędach.

Google Analytics automatycznie rejestruje niektóre zdarzenia za Ciebie. Nie musisz dodawać żadnego kodu, aby je otrzymywać. Jeśli Twoja aplikacja musi zbierać dodatkowe dane, możesz zarejestrować w niej maksymalnie 500 różnych typów zdarzeń Analytics. Nie ma limitu łącznej liczby zdarzeń rejestrowanych przez aplikację. Pamiętaj, że w nazwach zdarzeń jest rozróżniana wielkość liter, a logowanie 2 zdarzeń, których nazwy różnią się tylko wielkością liter, powoduje powstawanie 2 różnych zdarzeń.

Zanim zaczniesz

Upewnij się, że masz skonfigurowany projekt i masz dostęp do Analytics w sposób opisany w artykule Pierwsze kroki z Analytics dla języka C++.

Zdarzenia w dzienniku

Po zainicjowaniu modułu firebase::analytics możesz używać go do rejestrowania zdarzeń za pomocą metody LogEvent().

Aby ułatwić Ci rozpoczęcie pracy, pakiet SDK Analytics definiuje kilka zalecanych zdarzeń, które są typowe w różnych rodzajach aplikacji, m.in. w aplikacjach zajmujących się handlem detalicznym i e-commerce, a także w aplikacjach podróżniczych i grach. Więcej informacji o tych zdarzeniach i ich zastosowaniach znajdziesz w artykułach Zdarzenia i właściwości w Centrum pomocy Firebase.

Szczegóły implementacji zalecanych zdarzeń znajdziesz w tych miejscach:

Sugerowane zdarzenia: zobacz listę stałych Event.
Zalecane parametry: patrz lista stałych Parameters.

Poniższy przykład pokazuje, jak zarejestrować sugerowane zdarzenie SELECT_CONTENT:

  const analytics::Parameter kSelectContentParameters[] = {
    analytics::Parameter(analytics::kParameterItemID , id),
    analytics::Parameter(analytics::kParameterItemName, "name"),
    analytics::Parameter(analytics::kUserPropertySignUpMethod, "Google"),
    analytics::Parameter("favorite_food", mFavoriteFood),
    analytics::Parameter("user_id", mUserId),
  };
  analytics::LogEvent(
    analytics::kEventSelectContent, kSelectContentParameters,
    sizeof(kSelectContentParameters) / sizeof(kSelectContentParameters[0]));

Oprócz określonych parametrów do każdego zdarzenia możesz dodać te parametry:

Parametry niestandardowe: parametry niestandardowe nie są odzwierciedlane bezpośrednio w raportach Analytics, ale można ich używać jako filtrów w definicjach odbiorców, które można stosować we wszystkich raportach. Parametry niestandardowe są też uwzględniane w danych eksportowanych do BigQuery, jeśli aplikacja jest połączona z projektem BigQuery.
VALUE Parametr VALUE to parametr ogólnego przeznaczenia, który przydaje się do gromadzenia kluczowych danych związanych ze zdarzeniem Analytics. Mogą to być na przykład przychody, dystans, czas i punkty.

Jeśli Twoja aplikacja ma konkretne potrzeby, których nie obejmuje sugerowany typ zdarzenia Analytics, możesz rejestrować własne niestandardowe zdarzenia Analytics, jak w tym przykładzie:

// Copyright 2016 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "firebase/analytics.h"
#include "firebase/analytics/event_names.h"
#include "firebase/analytics/parameter_names.h"
#include "firebase/analytics/user_property_names.h"
#include "firebase/app.h"

// Thin OS abstraction layer.
#include "main.h"  // NOLINT

// Execute all methods of the C++ Analytics API.
extern "C" int common_main(int argc, const char* argv[]) {
  namespace analytics = ::firebase::analytics;
  ::firebase::App* app;

  LogMessage("Initialize the Analytics library");
#if defined(__ANDROID__)
  app = ::firebase::App::Create(GetJniEnv(), GetActivity());
#else
  app = ::firebase::App::Create();
#endif  // defined(__ANDROID__)

  LogMessage("Created the firebase app %x",
             static_cast<int>(reinterpret_cast<intptr_t>(app)));
  analytics::Initialize(*app);
  LogMessage("Initialized the firebase analytics API");

  LogMessage("Enabling data collection.");
  analytics::SetAnalyticsCollectionEnabled(true);
  // App session times out after 30 minutes.
  // If the app is placed in the background and returns to the foreground after
  // the timeout is expired analytics will log a new session.
  analytics::SetSessionTimeoutDuration(1000 * 60 * 30);

  LogMessage("Get App Instance ID...");
  auto future_result = analytics::GetAnalyticsInstanceId();
  while (future_result.status() == firebase::kFutureStatusPending) {
    if (ProcessEvents(1000)) break;
  }
  if (future_result.status() == firebase::kFutureStatusComplete) {
    LogMessage("Analytics Instance ID %s", future_result.result()->c_str());
  } else {
    LogMessage("ERROR: Failed to fetch Analytics Instance ID %s (%d)",
               future_result.error_message(), future_result.error());
  }

  LogMessage("Set user properties.");
  // Set the user's sign up method.
  analytics::SetUserProperty(analytics::kUserPropertySignUpMethod, "Google");
  // Set the user ID.
  analytics::SetUserId("uber_user_510");

  LogMessage("Log current screen.");
  // Log the user's current screen.
  analytics::LogEvent(analytics::kEventScreenView, "Firebase Analytics C++ testapp", "testapp" );

  // Log an event with no parameters.
  LogMessage("Log login event.");
  analytics::LogEvent(analytics::kEventLogin);

  // Log an event with a floating point parameter.
  LogMessage("Log progress event.");
  analytics::LogEvent("progress", "percent", 0.4f);

  // Log an event with an integer parameter.
  LogMessage("Log post score event.");
  analytics::LogEvent(analytics::kEventPostScore, analytics::kParameterScore,
                      42);

  // Log an event with a string parameter.
  LogMessage("Log group join event.");
  analytics::LogEvent(analytics::kEventJoinGroup, analytics::kParameterGroupID,
                      "spoon_welders");

  // Log an event with multiple parameters.
  LogMessage("Log level up event.");
  {
    const analytics::Parameter kLevelUpParameters[] = {
        analytics::Parameter(analytics::kParameterLevel, 5),
        analytics::Parameter(analytics::kParameterCharacter, "mrspoon"),
        analytics::Parameter("hit_accuracy", 3.14f),
    };
    analytics::LogEvent(
        analytics::kEventLevelUp, kLevelUpParameters,
        sizeof(kLevelUpParameters) / sizeof(kLevelUpParameters[0]));
  }

  LogMessage("Complete");

  // Wait until the user wants to quit the app.
  while (!ProcessEvents(1000)) {
  }

  analytics::Terminate();
  delete app;

  LogMessage("Shutdown");

  return 0;
}

Wyświetlanie zdarzeń w dzienniku debugowania Android Studio

Możesz włączyć logowanie szczegółowe, aby monitorować logowanie zdarzeń przez pakiet SDK i sprawdzać, czy zdarzenia są prawidłowo logowane. Dotyczy to zarówno zdarzeń rejestrowanych automatycznie, jak i ręcznie.

Logowanie szczegółowe możesz włączyć za pomocą serii poleceń adb:

adb shell setprop log.tag.FA VERBOSE

adb shell setprop log.tag.FA-SVC VERBOSE

adb logcat -v time -s FA FA-SVC

Wyświetla zdarzenia w dzienniku Androida Studio, co pomaga od razu sprawdzić, czy zdarzenia są wysyłane.

Wyświetlanie zdarzeń analitycznych w panelu

Zbiorcze statystyki zdarzeń Analytics możesz wyświetlać w panelach konsoli Firebase. Panele są aktualizowane okresowo w ciągu dnia. Aby przeprowadzić natychmiastowe testy, użyj danych wyjściowych logcat zgodnie z opisem w poprzedniej sekcji.

Aby uzyskać dostęp do tych danych w konsoli Firebase:

W konsoli Firebase otwórz projekt.
W menu kliknij Analytics, aby wyświetlić panel raportowania Analytics.

Na karcie Zdarzenia wyświetlają się raporty zdarzeń, które są tworzone automatycznie dla każdego rodzaju zdarzenia Analytics rejestrowanego przez Twoją aplikację. Dowiedz się więcej o panelu.