Guía de implementación de aplicaciones para dispositivos móviles

Este documento está dirigido a desarrolladores de apps para dispositivos móviles y describe cómo usar Google Analytics para medir las interacciones de los usuarios y responder preguntas sobre el uso de apps.

Introducción

Google Analytics para apps de dispositivos móviles proporciona una plataforma para medir las interacciones de los usuarios, lo que te permite comprender y optimizar mejor la participación de los usuarios en tu app.

La implementación predeterminada de Google Analytics proporciona automáticamente la siguiente información sobre tu app:

  • La cantidad de usuarios y sesiones
  • Duración de la sesión
  • Sistemas operativos
  • Modelos de dispositivos
  • Geografía

En esta guía, se explica cómo implementar funciones adicionales de Google Analytics para comprender mejor a los usuarios y su comportamiento.

Antes de comenzar

Antes de revisar esta guía a fin de configurar Google Analytics para apps para dispositivos móviles, haz lo siguiente:

Descripción general

Cazador de dragones

En esta guía, se usa una app de muestra para guiarte en la implementación de funciones adicionales de Google Analytics. La app se llama Dragon Catcher y tiene las siguientes características:

  • Un nivel consiste en un jugador, dragones, un área cercada, un pozo y árboles
  • El objetivo del jugador es atrapar dragones al moverlos al área cercada.
  • El jugador puede visitar diferentes áreas del nivel y objetos, como un pozo o un árbol mágico.
  • Una vez que atrapa a todos los dragones, el jugador avanza al siguiente nivel.
  • El jugador inicia el juego en el primer nivel que se llama Barren Fields.

Con Google Analytics, algunas de las preguntas sobre el comportamiento del usuario que se pueden responder sobre Dragon Catcher:

En el resto de este documento, se ilustra cómo se pueden responder estas preguntas mediante la implementación de funciones de Google Analytics para el juego Dragon Catcher.

¿Qué acciones realizan mis usuarios? (Eventos)

Si quieres hacer un seguimiento de las acciones importantes en tu app, puedes usar los eventos para describir esta acción en Google Analytics. Un evento consiste en cuatro parámetros: category, action, label y value.

Por ejemplo, en Dragon Catcher, un usuario que rescata a un dragón o visita un área específica del nivel son acciones importantes que queremos medir mediante eventos. En el siguiente fragmento de código, se ilustra cómo medir esto en Google Analytics.

SDK de 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 de 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]];

Complemento de Google Analytics para 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);

Medir logros de los jugadores

Los logros de un jugador se pueden medir con eventos en Google Analytics. Por ejemplo, para medir un logro de rescatar 5 dragones, se registra la cantidad de dragones que rescató un jugador y, una vez que alcanzó el umbral, se envía un evento a Google Analytics:

SDK de 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 de 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]];
  }
}

Complemento de Google Analytics para 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);
  }
}

Guías para desarrolladores sobre eventos

Informes de eventos

Los datos de eventos están disponibles en los siguientes países:

¿Cuánto dinero gastan los usuarios en mi app? (Comercio electrónico mejorado)

Si deseas medir las compras directas desde la aplicación por parte de los usuarios, el seguimiento de comercio electrónico se puede usar para hacer un seguimiento de la compra y comprender el rendimiento del producto relacionado y el comportamiento del usuario. El seguimiento de comercio electrónico se puede usar para medir la compra de un artículo específico o una moneda virtual.

Por ejemplo, en Dragon Catcher, para medir la compra de algunos elementos, los datos de transacciones se envían a Google Analytics con un evento:

SDK de 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 de 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]];

Complemento de Google Analytics para 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 usuario compra moneda virtual, se recomienda que midas el intercambio de dinero real cuando envíes los datos de transacciones a Google Analytics. Cuando el usuario gaste la moneda virtual para comprar elementos, mida esto mediante eventos. Por ejemplo:

SDK de 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 de 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]];

Complemento de Google Analytics para 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);

Guías para desarrolladores sobre el comercio electrónico mejorado

Informes para el comercio electrónico mejorado

Los datos de comercio electrónico están disponibles en los siguientes países:

¿Los usuarios completan mis objetivos de la app? (Objetivos)

Si tienes objetivos específicos para tu app que quieres que los usuarios completen, puedes definirlos y medirlos con Objetivos en Google Analytics. Por ejemplo, un objetivo podría ser que los usuarios alcancen un nivel de juego determinado o compren un artículo. Para obtener más información sobre cómo funcionan los objetivos, consulta Acerca de los objetivos (Centro de ayuda).

En el juego Dragon Catcher, se puede configurar un objetivo para medir cuándo se realizan compras directas desde la aplicación si se envía un evento a Google Analytics para cada compra. El objetivo se puede definir en el administrador de la interfaz web, sin código adicional, mediante los siguientes parámetros:

  • Tipo de objetivo (igual a): Evento
  • Categoría (es igual a): Tienda en el juego
  • Acción (equivalente a): Purchase
  • Utilice el valor del evento como el valor del objetivo para la conversión:

Informes de objetivos

Los datos de los objetivos están disponibles en:

¿Cómo se comportan los usuarios con una característica específica? (Dimensiones y métricas personalizadas)

Si deseas realizar un seguimiento de los usuarios con atributos o atributos específicos, puedes usar las dimensiones personalizadas para enviar este tipo de datos a Google Analytics y en análisis. Consulta la referencia de la función Métricas y dimensiones personalizadas para obtener más información sobre cómo funcionan las dimensiones personalizadas.

Por ejemplo, en Dragon Catcher, para averiguar el porcentaje de usuarios que están en el primer nivel, el segundo nivel, etc., se puede establecer una dimensión personalizada con el nivel actual del usuario y enviarla a Google Analytics. Estos son los pasos:

  1. Crea una dimensión personalizada con un alcance User. Se utiliza el alcance User porque este valor debe conservarse en todas las sesiones de ese usuario. Consulta Cómo configurar o editar dimensiones personalizadas (Centro de ayuda).
  2. Actualiza el valor de la dimensión personalizada cuando cambia el nivel del usuario.

En el siguiente fragmento, se muestra cómo actualizar el estado del usuario en Google Analytics, en el que el índice de dimensión personalizada a nivel de usuario es 1 y el nivel del usuario cambió a Barren Fields:

SDK de 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 de 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]];

Complemento de Google Analytics para 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"));

Guías para desarrolladores sobre las dimensiones y métricas personalizadas

Informes de dimensiones y métricas personalizadas

Las dimensiones personalizadas se pueden incluir y aplicar como un segmento a los siguientes segmentos:

Si aplicas la dimensión personalizada como un segmento, podrás analizar a los usuarios que se encuentran en un nivel específico dentro del juego.

¿Cuánto tiempo lleva un usuario completar una tarea? (Tiempos personalizados)

Si deseas medir cuánto tiempo tarda algo en completarse en la app, se pueden usar los tiempos del usuario para las mediciones basadas en el tiempo en Google Analytics. Los tiempos de usuario son similares a los eventos, pero están basados en el tiempo y pueden incluir category, value, name (variable) y label. Para obtener información sobre cómo funcionan los tiempos de los usuarios, consulta Acerca de la velocidad del sitio.

Por ejemplo, en Dragon Catcher para medir cuánto tarda un usuario en rescatar a su primer dragón, puedes enviar algo como lo siguiente:

SDK de 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 de iOS

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

Complemento de Google Analytics para Unity

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

Guías para desarrolladores sobre tiempos personalizados

Informes de tiempos personalizados

Los datos de intervalos personalizados están disponibles en:

  • Analytics Academy: Mejora tus habilidades de Analytics con cursos gratuitos en línea que incluyen conceptos básicos sobre estadísticas de apps para dispositivos móviles.
  • API de recopilación y SDK: Obtén información sobre todas las formas en que puedes enviar datos a Google Analytics