Guide d'implémentation d'applications mobiles

Ce document s'adresse aux développeurs d'applications mobiles. Il explique comment utiliser Google Analytics pour mesurer les interactions des utilisateurs et répondre aux questions sur l'utilisation des applications.

Introduction

Google Analytics pour les applications mobiles fournit une plate-forme permettant de mesurer les interactions des utilisateurs, ce qui vous permet de mieux comprendre et d'optimiser l'engagement utilisateur vis-à-vis de votre application.

L'implémentation par défaut de Google Analytics fournit automatiquement les informations suivantes sur votre application:

  • Nombre d'utilisateurs et de sessions
  • Durée de la session
  • Systèmes d'exploitation
  • Modèles d'appareils
  • Zone géographique

Ce guide vous explique comment mettre en œuvre des fonctionnalités Google Analytics supplémentaires pour mieux comprendre vos utilisateurs et leur comportement.

Avant de commencer

Avant de parcourir ce guide afin de configurer Google Analytics pour les applications mobiles:

Présentation

Dragon receveur

Ce guide utilise un exemple d'application pour vous guider tout au long de la mise en œuvre d'autres fonctionnalités Google Analytics. L'application s'appelle Dragon Catcher et présente les caractéristiques de jeu suivantes:

  • Un niveau se compose d'un joueur, de dragons, d'une zone clôturée, d'un puits et d'arbres
  • L'objectif du joueur est d'attraper des dragons en les déplaçant dans une zone clôturée
  • Le joueur peut visiter différentes zones du niveau et des objets, comme un puits ou un arbre magique
  • Le joueur passe au niveau suivant une fois qu'il a attrapé tous les dragons
  • Le joueur commence le jeu au premier niveau, qui s'appelle Barren Fields.

Voici quelques-unes des questions sur le comportement des utilisateurs qui peuvent être résolues à propos de Dragon Catcher, grâce à Google Analytics:

Le reste de ce document montre comment répondre à ces questions en implémentant les fonctionnalités Google Analytics pour le jeu Dragon Catcher.

Quelles actions mes utilisateurs effectuent-ils ? (Événements)

Si vous souhaitez suivre des actions importantes dans votre application, vous pouvez utiliser des événements pour les décrire dans Google Analytics. Un événement comprend quatre paramètres: category, action, label et value.

Par exemple, dans Dragon Catcher, un utilisateur qui sauve un dragon ou visite une zone spécifique d'un niveau est une action importante que nous souhaitons mesurer à l'aide d'événements. L'extrait de code ci-dessous montre comment mesurer cela dans Google Analytics.

SDK Android

// To determine how many dragons are being rescued, send an event when the
// player rescues a dragon.
tracker.send(new HitBuilders.EventBuilder()
    .setCategory("Barren Fields")
    .setAction("Rescue")
    .setLabel("Dragon")
    .setValue(1)
    .build());

// To determine if players are visiting the magic tree, send an event when the
// player is in the vicinity of the magic tree.
tracker.send(new HitBuilders.EventBuilder()
    .setCategory("Barren Fields")
    .setAction("Visited")
    .setLabel("Magic Tree")
    .setValue(1)
    .build());

// To determine if players are visiting the well, send an event when the player
// is in the vicinity of the well.
tracker.send(new HitBuilders.EventBuilder()
    .setCategory("Barren Fields")
    .setAction("Visited")
    .setLabel("Well")
    .setValue(1)
    .build());

SDK iOS

// To determine how many dragons are being rescued, send an event when the
// player rescues a dragon.
[tracker send:[[GAIDictionaryBuilder createEventWithCategory:@"Barren Fields"
                                                      action:@"Rescue"
                                                       label:@"Dragon"
                                                       value:@1] build]];

// To determine if players are visiting the magic tree, send an event when the
// player is in the vicinity of the magic tree.
[tracker send:[[GAIDictionaryBuilder createEventWithCategory:@"Barren Fields"
                                                      action:@"Visited"
                                                       label:@"Magic Tree"
                                                       value:@1] build]];

// To determine if players are visiting the well, send an event when the player
// is in the vicinity of the well.
[tracker send:[[GAIDictionaryBuilder createEventWithCategory:@"Barren Fields"
                                                      action:@"Visited"
                                                       label:@"Well"
                                                       value:@1] build]];

Plug-in GA pour Unity

// To determine how many dragons are being rescued, send an event when the
// player rescues a dragon.
googleAnalytics.LogEvent("Barren Fields", "Rescue", "Dragon", 1);

// To determine if players are visiting the magic tree, send an event when the
// player is in the vicinity of the magic tree.
googleAnalytics.LogEvent("Barren Fields", "Visited", "Magic Tree", 1);

// To determine if players are visiting the well, send an event when the player
// is in the vicinity of the well.
googleAnalytics.LogEvent("Barren Fields", "Visited", "Well", 1);

Mesure des réussites des joueurs

Les "succès" des joueurs peuvent être mesurés à l'aide d'événements dans Google Analytics. Par exemple, pour mesurer un succès de sauvetage de cinq dragons, le nombre de dragons qu'un joueur a sauvés est enregistré. Une fois le seuil atteint, un événement est envoyé à Google Analytics:

SDK Android

if (numDragonsRescued > 5) {
  if (!user.hasAchievement(RESCUED_ACHIEVEMENT) {
    tracker.send(new HitBuilders.EventBuilder()
        .setCategory("Achievement")
        .setAction("Unlocked")
        .setLabel("5 Dragons Rescued")
        .setValue(1)
        .build());
  } else {
    tracker.send(new HitBuilders.EventBuilder()
        .setCategory("Achievement")
        .setAction("Earned")
        .setLabel("5 Dragons Rescued")
        .setValue(1)
        .build());
  }
}

SDK iOS

if (numDragonsRescued > 5) {
  if (![user hasAchievement:RESCUED_ACHIEVEMENT]) {
    [tracker send:[[GAIDictionaryBuilder createEventWithCategory:@"Achievement"
                                                          action:@"Unlocked"
                                                           label:@"5 Dragons Rescued"
                                                           value:@1] build]];
  } else {
    [tracker send:[[GAIDictionaryBuilder createEventWithCategory:@"Achievement"
                                                          action:@"Earned"
                                                           label:@"5 Dragons Rescued"
                                                           value:@1] build]];
  }
}

Plug-in GA pour Unity

if (numDragonsRescued > 5) {
  if (!user.HasAchievement(RESCUED_ACHIEVEMENT)) {
    googleAnalytics.LogEvent("Achievement", "Unlocked", "5 Dragons Rescued", 1);
  } else {
    googleAnalytics.LogEvent("Achievement", "Earned", "5 Dragons Rescued", 1);
  }
}

Guides du développeur pour les événements

Rapports sur les événements

Les données d'événement sont disponibles dans les langues suivantes:

Combien les utilisateurs dépensent-ils dans mon application ? (E-commerce amélioré)

Si vous souhaitez mesurer les achats via une application par les utilisateurs, vous pouvez utiliser le suivi de l'e-commerce pour suivre les achats, et comprendre les performances des produits et le comportement des utilisateurs. Le suivi de l'e-commerce permet de mesurer l'achat d'un article spécifique ou d'une devise virtuelle.

Par exemple, dans Dragon Catcher, pour mesurer l'achat de certains articles, les données de transaction sont envoyées à Google Analytics avec un événement:

SDK Android

Product product = new Product()
    .setName("Dragon Food")
    .setPrice(40.00);

ProductAction productAction = new ProductAction(ProductAction.ACTION_PURCHASE)
    .setTransactionId("T12345");

// Add the transaction data to the event.
HitBuilders.EventBuilder builder = new HitBuilders.EventBuilder()
    .setCategory("In-Game Store")
    .setAction("Purchase")
    .addProduct(product)
    .setProductAction(productAction);

// Send the transaction data with the event.
tracker.send(builder.build());

SDK iOS

GAIEcommerceProduct *product = [[GAIEcommerceProduct alloc] init];
[product setName:@"Dragon Food"];
[product setPrice:@40.00];

GAIEcommerceProductAction *productAction = [[GAIEcommerceProductAction alloc] init];
[productAction setAction:kGAIPAPurchase];
[productAction setTransactionId:@"T12345"];

GAIDictionaryBuilder *builder = [GAIDictionaryBuilder createEventWithCategory:@"In-Game Store"
                                                                       action:@"Purchase"
                                                                        label:nil
                                                                        value:nil];
// Add the transaction data to the event.
[builder setProductAction:productAction];
[builder addProduct:product];

// Send the transaction data with the event.
[tracker send:[builder build]];

Plug-in GA pour Unity

// Note: Using Android SDK v3 and standard Ecommerce tracking.

googleAnalytics.LogItem("T12345", "Dragon Food", "Food_SKU", "Items", 40.00, 1);
googleAnalytics.LogTransaction("T12345", "In-Game Store", 40.00, 0.00, 0.00);

Si un utilisateur achète de la monnaie virtuelle, nous vous recommandons de mesurer l'échange d'argent réel lorsque vous envoyez les données de la transaction à Google Analytics. Lorsque l'utilisateur dépense la monnaie virtuelle pour acheter des articles, mesurez-la à l'aide d'événements. Exemple :

SDK Android

/**
 * When the user purchases the virtual currency (Gems) measure the transaction
 * using enhanced ecommerce.
 */
Product product = new Product()
    .setName("2500 Gems")
    .setPrice(5.99);

ProductAction productAction = new ProductAction(ProductAction.ACTION_PURCHASE)
    .setTransactionId("T67890");

// Add the transaction to the screenview.
HitBuilders.ScreenViewBuilder builder = new HitBuilders.ScreenViewBuilder()
    .addProduct(product)
    .setProductAction(productAction);

// Send the transaction with the screenview.
tracker.setScreenName("In-Game Store");
tracker.send(builder.build());


/**
 * When the user purchases an item using the virtual currency (Gems) send an
 * event to measure this in Google Analytics.
 */
HitBuilders.EventBuilder builder = new HitBuilders.EventBuilder()
    .setCategory("In-Game Store")
    .setAction("Purchase")
    .setLabel("Sword")
    .setValue(35);
tracker.send(builder.build());

SDK iOS

/**
 * When the user purchases the virtual currency (Gems) measure the transaction
 * using enhanced ecommerce.
 */
GAIEcommerceProduct *product = [[GAIEcommerceProduct alloc] init];
[product setName:@"2500 Gems"];
[product setPrice:@5.99];

GAIEcommerceProductAction *productAction = [[GAIEcommerceProductAction alloc] init];
[productAction setAction:kGAIPAPurchase];
[productAction setTransactionId:@"T67890"];

GAIDictionaryBuilder *viewBuilder = [GAIDictionaryBuilder createScreenView];

// Add the transaction data to the screenview.
[viewBuilder setProductAction:productAction];
[viewBuilder addProduct:product];

// Send the transaction with the screenview.
[tracker set:kGAIScreenName value:@"In-Game Store"];
[tracker send:[viewBuilder build]];


/**
 * When the user purchases an item using the virtual currency (Gems) send an
 * event to measure this in Google Analytics.
 */
GAIDictionaryBuilder *eventBuilder = [GAIDictionaryBuilder createEventWithCategory:@"In-Game Store"
                                                                       action:@"Purchase"
                                                                        label:@"Sword"
                                                                        value:@35];
[tracker send:[eventBuilder build]];

Plug-in GA pour Unity

// Note: Using Android SDK v3 and standard Ecommerce tracking.

/**
 * When the user purchases the virtual currency (Gems) measure the transaction
 * using enhanced ecommerce.
 */

googleAnalytics.LogItem("T12345", "2500 Gems", "GEM2500_SKU", "Items", 5.99, 1);
googleAnalytics.LogTransaction("T12345", "In-Game Store", 5.99, 0.00, 0.00);

/**
 * When the user purchases an item using the virtual currency (Gems) send an
 * event to measure this in Google Analytics.
 */
googleAnalytics.LogEvent("In-Game Store", "Purchase", "Sword", 35);

Guides du développeur pour l'e-commerce amélioré

Rapports sur l'e-commerce amélioré

Les données d'e-commerce sont disponibles dans les pays suivants:

Les utilisateurs atteignent-ils les objectifs de mon application ? (Objectifs)

Si vous souhaitez que les utilisateurs atteignent des objectifs spécifiques pour votre application, vous pouvez définir et mesurer ces objectifs à l'aide des objectifs dans Google Analytics. Par exemple, un objectif peut être que les utilisateurs atteignent un certain niveau de jeu ou achètent un article. Pour en savoir plus sur le fonctionnement des objectifs, consultez la page À propos des objectifs (centre d'aide).

Dans le jeu Dragon Catcher, vous pouvez configurer un objectif pour mesurer le moment où des achats via l'application sont effectués si un événement est envoyé à Google Analytics pour chaque achat. L'objectif peut être défini dans l'administration de l'interface Web, sans code supplémentaire, à l'aide des paramètres suivants:

  • Type d'objectif (est égal à): Événement
  • Catégorie (égal à): boutique dans les jeux
  • Action (égal à): Purchase
  • Utiliser la valeur de l'événement comme valeur de l'objectif pour la conversion: Oui

Rapports sur les objectifs

Les données d'objectif sont disponibles en:

Comment les utilisateurs ayant une caractéristique spécifique se comportent-ils ? (Dimensions et métriques personnalisées)

Si vous souhaitez suivre des utilisateurs avec des attributs/caractéristiques/métadonnées spécifiques, vous pouvez utiliser des dimensions personnalisées pour envoyer ce type de données à Google Analytics et les analyser. Pour en savoir plus sur le fonctionnement des dimensions personnalisées, consultez la documentation de référence sur la fonctionnalité Dimensions et métriques personnalisées.

Par exemple, dans Dragon Catcher, pour connaître le pourcentage d'utilisateurs situés au premier, au deuxième niveau, etc., vous pouvez définir une dimension personnalisée avec le niveau actuel de l'utilisateur et l'envoyer à Google Analytics. Voici la procédure à suivre :

  1. Créez une dimension personnalisée de portée User. Le champ d'application User est utilisé, car cette valeur doit persister dans toutes les sessions de cet utilisateur. Consultez Configurer ou modifier des dimensions personnalisées (centre d'aide).
  2. Mettez à jour la valeur de la dimension personnalisée lorsque le niveau de l'utilisateur a changé.

L'extrait de code suivant montre comment mettre à jour l'état de l'utilisateur dans Google Analytics, lorsque l'index de la dimension personnalisée au niveau de l'utilisateur est 1 et que celui-ci est passé à Barren Fields:

SDK Android

// Set the user level custom dimension when sending a hit to Google Analytics
// such as a screenview or event.
tracker.setScreenName("BarrenFields");
tracker.send(new HitBuilders.ScreenViewBuilder()
    .setCustomDimension(1, "Barren Fields")
    .build()
);

SDK iOS

// Set the user level custom dimension when sending a hit to Google Analytics
// such as a screenview or event.
[tracker set:kGAIScreenName value:@"BarrenFields"];
[tracker send:[[[GAIDictionaryBuilder createScreenView]
         set:@"Barren Fields"
      forKey:[GAIFields customDimensionForIndex:1]] build]];

Plug-in GA pour Unity

// Set the user level custom dimension when sending a hit to Google Analytics
// such as a screenview or event.
googleAnalytics.LogScreen(new AppViewHitBuilder()
    .SetScreenName("BarrenFields").SetCustomDimension(1, "Barren Fields"));

Guides du développeur sur les dimensions et métriques personnalisées

Rapports sur les dimensions et métriques personnalisées

Vous pouvez inclure des dimensions personnalisées et les appliquer en tant que segment aux éléments suivants:

En appliquant la dimension personnalisée en tant que segment, vous pourrez analyser les utilisateurs qui se trouvent actuellement à un niveau spécifique du jeu.

Combien de temps faut-il à un utilisateur pour accomplir une tâche ? (Durées personnalisées)

Si vous souhaitez mesurer le temps nécessaire à une action dans l'application, vous pouvez utiliser le temps utilisateur pour effectuer des mesures temporelles dans Google Analytics. La chronologie utilisateur est semblable aux événements, mais elle est basée sur l'heure et peut inclure un category, un value, un name (variable) et un label. Pour en savoir plus sur le fonctionnement du temps utilisateur, consultez À propos de la vitesse du site.

Par exemple, dans Dragon Catcher, pour mesurer le temps nécessaire à un utilisateur pour sauver son premier dragon, vous pouvez envoyer un message semblable à celui-ci:

SDK Android

// Build and send a timing hit.
tracker.send(new HitBuilders.TimingBuilder()
    .setCategory("Barren Fields")
    .setValue(45000)  // 45 seconds.
    .setVariable("First Rescue")
    .setLabel("Dragon")
    .build());

SDK iOS

[tracker send:[[GAIDictionaryBuilder createTimingWithCategory:@"Barren Fields"
                                                     interval:@45000   // 45 seconds.
                                                         name:@"First Rescue"
                                                        label:@"Dragon"] build]];

Plug-in GA pour Unity

// Build and send a timing hit.
googleAnalytics.LogTiming("Barren Fields",45000,"First Rescue","Dragon");

Guides du développeur pour les codes temporels personnalisés

Rapports sur des codes temporels personnalisés

Les données temporelles personnalisées sont disponibles dans les langues suivantes:

  • Analytics Academy : améliorez vos compétences Analytics grâce à des cours en ligne sans frais, y compris sur les principes de base de l'analyse d'applications mobiles.
  • API et SDK de collecte : découvrez les différents moyens d'envoyer des données à Google Analytics.