Seguimiento de eventos dentro de la aplicación

Realice un seguimiento de los eventos dentro de la aplicación para analizar el rendimiento de la campaña y medir los indicadores clave de rendimiento (KPI), como inicios de sesión de usuarios, registros, finalización de tutoriales o hitos de progresión.

Eventos y atributos estándar

Tipos de eventos

Singular admite dos tipos de eventos para adaptarse a las necesidades de seguimiento universales y específicas de la aplicación.

• Eventos estándar: Eventos predefinidos (por ejemplo, sngLogin, sngContentView) reconocidos por Singular y admitidos por las redes publicitarias para la generación de informes y la optimización. El uso de eventos estándar simplifica la configuración, ya que Singular los añade automáticamente a la lista de eventos sin necesidad de definirlos manualmente. Consulte la Lista de eventos y atributosestándar para ver los nombres completos de los eventos y los atributos recomendados.
• Eventos personalizados: Eventos exclusivos de su aplicación (por ejemplo, Signup, AchievementUnlocked) que no coinciden con los eventos estándar de Singular.

Su equipo de UA, marketing o comercial debe compilar la lista de eventos basándose en los KPI de marketing de su organización. Consulte la guía How to Track In-App Events: Guía para clientes de Singular Attributionpara la planificación.

Limitaciones de los eventos personalizados

Los eventos personalizados tienen limitaciones específicas de caracteres y codificación para garantizar la compatibilidad con socios y soluciones de análisis de terceros.

Envío de eventos

Método de eventos

Realice el seguimiento de eventos simples sin atributos adicionales utilizando el método event().

// TurboModule direct API (React Native 0.76+ New Architecture)
import NativeSingular from 'singular-react-native/jsNativeSingular';

// Track a simple custom event
NativeSingular.event('SignUp');

// Track a standard event using constant
NativeSingular.event('sngLogin');

import { Singular } from 'singular-react-native';

// Track a simple custom event
Singular.event('SignUp');

// Track a standard event using constant
Singular.event('sngLogin');

Firmadel método:

static event(eventName: string): void

Para ver la lista completa de métodos, consulta la referencia de métodos de eventos.

Método EventWithArgs

Realiza el seguimiento de eventos con atributos personalizados adicionales para proporcionar un contexto más rico y permitir una segmentación detallada en los informes.

// TurboModule direct API (React Native 0.76+ New Architecture)
import NativeSingular from 'singular-react-native/jsNativeSingular';

// Track custom event with attributes
NativeSingular.eventWithArgs('LevelComplete', {
  level: 5,
  score: 1250,
  time_spent: 45.3
});

// Track standard event with recommended attributes
NativeSingular.eventWithArgs('sngTutorialComplete', {
  sngAttrContent: 'React Native Basics',
  sngAttrContentId: '32',
  sngAttrContentType: 'video',
  sngAttrSuccess: 'yes'
});

import { Singular } from 'singular-react-native';

// Track custom event with attributes
Singular.eventWithArgs('LevelComplete', {
  level: 5,
  score: 1250,
  time_spent: 45.3
});

// Track standard event with recommended attributes
Singular.eventWithArgs('sngTutorialComplete', {
  sngAttrContent: 'React Native Basics',
  sngAttrContentId: '32',
  sngAttrContentType: 'video',
  sngAttrSuccess: 'yes'
});

Firma del método:

static eventWithArgs(eventName: string, args: Record<string, any>): void

Para obtener la lista completa de métodos, consulte la referencia del método eventWithArgs.

Mejores prácticas

Seguimiento de los ingresos dentro de la aplicación

Realice un seguimiento de los ingresos procedentes de compras dentro de la aplicación (IAP), suscripciones y fuentes de ingresos personalizadas para medir el rendimiento de la campaña y el retorno de la inversión publicitaria (ROAS).

Los datos de ingresos fluyen a través de tres canales:

• Informes interactivos: Visualiza las métricas de ingresos en el panel de control de Singular.
• Registros de exportación: Acceso a datos ETL detallados para análisis personalizados
• Postbacks en tiempo real: Envíe eventos de ingresos a plataformas externas

¿Por qué realizar un seguimiento de los eventos de ingresos?

• Análisis enriquecidos: Capture datos detallados de transacciones para mejorar los informes de Singular
• Prevención del fraude: Incluya recibos de transacciones (por ejemplo, de Google Play o Apple App Store) para validar las compras y combatir el fraude dentro de la aplicación.
• Optimización de campañas: Mida el ROI vinculando los ingresos a los esfuerzos de marketing

Integración de compras dentro de la aplicación

Captura del objeto de compra IAP

Utilice las bibliotecas IAP específicas de la plataforma para recuperar el objeto de compra con los detalles completos de la transacción.

• iOS: Utiliza react-native-iapo similar para acceder a los detalles de compra de StoreKit.
• Android: Utiliza react-native-iapo la biblioteca de facturación de Google Play para obtener el objeto de compra

Método InAppPurchase

Realiza un seguimiento de los eventos de compra dentro de la aplicación con detalles de compra para la validación de ingresos y la prevención del fraude.

Firmas de métodos:

static inAppPurchase(eventName: string, purchase: SingularIOSPurchase | SingularAndroidPurchase): void
static inAppPurchaseWithArgs(eventName: string, purchase: SingularIOSPurchase | SingularAndroidPurchase, args: Record<string, any>): void

Para obtener la lista completa de métodos, consulta la referencia del método inAppPurchase.

Ejemplo de implementación de IAP completo

Implemente un receptor de compras completo que capture eventos de IAP y los envíe a Singular con objetos de compra específicos de la plataforma.

// TurboModule direct API (React Native 0.76+ New Architecture)
import { Platform } from 'react-native';
import NativeSingular from 'singular-react-native/jsNativeSingular';
import { 
  SingularIOSPurchase, 
  SingularAndroidPurchase 
} from 'singular-react-native';
import { 
  initConnection,
  getProducts,
  setPurchaseListener,
  finishTransaction,
  IAPResponseCode
} from 'react-native-iap';

// Helper function to convert price to a double
const getPriceAsDouble = (product) => {
  if (Platform.OS === 'android' && product.priceAmountMicros) {
    // Android: Convert priceAmountMicros to double
    return product.priceAmountMicros / 1000000.0;
  } else if (Platform.OS === 'ios') {
    // iOS: Parse price string (e.g., "$4.99" -> 4.99)
    const priceString = product.price.replace(/[^0-9.]/g, '');
    return parseFloat(priceString) || 0.0;
  }
  return 0.0; // Fallback
};

// Set up purchase listener
const handlePurchases = async () => {
  try {
    // Initialize connection
    await initConnection();

    // Set purchase listener
    setPurchaseListener(async ({ responseCode, results }) => {
      if (responseCode === IAPResponseCode.OK) {
        for (const purchase of results) {
          if (!purchase.acknowledged) {
            // Fetch product details
            const products = await getProducts({ skus: [purchase.productId] });
            const product = products.length > 0 ? products[0] : null;
            if (!product) return;

            // Create purchase object
            let singularPurchase = null;

            if (Platform.OS === 'ios') {
              singularPurchase = new SingularIOSPurchase(
                getPriceAsDouble(product),
                product.currency ?? 'USD',
                purchase.productId,
                purchase.transactionId ?? '',
                purchase.transactionReceipt
              );
            } else if (Platform.OS === 'android') {
              const jsonData = JSON.parse(purchase.transactionReceipt || '{}');
              const receipt = jsonData.purchaseToken || '';

              singularPurchase = new SingularAndroidPurchase(
                getPriceAsDouble(product),
                product.currency ?? 'USD',
                purchase.transactionReceipt,
                purchase.signatureAndroid
              );
            } else {
              return;
            }

            // Track in-app purchase
            NativeSingular.inAppPurchase('iap_purchase', singularPurchase);

            // Complete the purchase
            await finishTransaction(purchase, Platform.OS === 'ios');
          }
        }
      }
    });
  } catch (error) {
    console.error('Error handling purchases:', error);
  }
};

// Call handlePurchases when your app starts
handlePurchases();

import { Platform } from 'react-native';
import { 
  Singular, 
  SingularIOSPurchase, 
  SingularAndroidPurchase 
} from 'singular-react-native';
import { 
  initConnection,
  getProducts,
  setPurchaseListener,
  finishTransaction,
  IAPResponseCode
} from 'react-native-iap';

// Helper function to convert price to a double
const getPriceAsDouble = (product) => {
  if (Platform.OS === 'android' && product.priceAmountMicros) {
    // Android: Convert priceAmountMicros to double
    return product.priceAmountMicros / 1000000.0;
  } else if (Platform.OS === 'ios') {
    // iOS: Parse price string (e.g., "$4.99" -> 4.99)
    const priceString = product.price.replace(/[^0-9.]/g, '');
    return parseFloat(priceString) || 0.0;
  }
  return 0.0; // Fallback
};

// Set up purchase listener
const handlePurchases = async () => {
  try {
    // Initialize connection
    await initConnection();

    // Set purchase listener
    setPurchaseListener(async ({ responseCode, results }) => {
      if (responseCode === IAPResponseCode.OK) {
        for (const purchase of results) {
          if (!purchase.acknowledged) {
            // Fetch product details
            const products = await getProducts({ skus: [purchase.productId] });
            const product = products.length > 0 ? products[0] : null;
            if (!product) return;

            // Create purchase object
            let singularPurchase = null;

            if (Platform.OS === 'ios') {
              singularPurchase = new SingularIOSPurchase(
                getPriceAsDouble(product), // Price as double, e.g., 4.99
                product.currency ?? 'USD', // Currency code, e.g., "USD"
                purchase.productId, // e.g., "com.example.premium_subscription"
                purchase.transactionId ?? '', // e.g., "1000000823456789"
                purchase.transactionReceipt // JWS receipt from StoreKit
              );
            } else if (Platform.OS === 'android') {
              // Parse transactionReceipt to extract purchaseToken
              const jsonData = JSON.parse(purchase.transactionReceipt || '{}');
              const receipt = jsonData.purchaseToken || '';

              singularPurchase = new SingularAndroidPurchase(
                getPriceAsDouble(product), // Price as double, e.g., 4.99
                product.currency ?? 'USD', // Currency code, e.g., "USD"
                purchase.transactionReceipt, // Full JSON receipt from Google Play
                purchase.signatureAndroid // Signature from Google Play
              );
            } else {
              return; // Unsupported platform
            }

            // Track in-app purchase
            Singular.inAppPurchase('iap_purchase', singularPurchase);

            // Complete the purchase
            await finishTransaction(purchase, Platform.OS === 'ios');
          }
        }
      }
    });
  } catch (error) {
    console.error('Error handling purchases:', error);
  }
};

// Call handlePurchases when your app starts
handlePurchases();

Seguimiento manual de ingresos

Ingresos sin validación de compra

Realice un seguimiento de los ingresos pasando la divisa, el importe y los detalles opcionales del producto sin el objeto de compra. Tenga en cuenta que este método no proporciona recibos de transacción para su validación.

Método de ingresos

Seguimiento de eventos de ingresos simples con una divisa y un importe especificados.

// TurboModule direct API (React Native 0.76+ New Architecture)
import NativeSingular from 'singular-react-native/jsNativeSingular';

// Track revenue without product details
NativeSingular.revenue('USD', 4.99);

import { Singular } from 'singular-react-native';

// Track revenue without product details
Singular.revenue('USD', 4.99);

Firma del método:

static revenue(currency: string, amount: number): void

Para ver la lista completa de métodos, consulte la referencia del método revenue.

Método RevenueWithArgs

Realiza el seguimiento de eventos de ingresos con una divisa, un importe y atributos personalizados adicionales especificados.

// TurboModule direct API (React Native 0.76+ New Architecture)
import NativeSingular from 'singular-react-native/jsNativeSingular';

// Track revenue with attributes
NativeSingular.revenueWithArgs('USD', 9.98, {
  productSKU: 'coin_package_abc123',
  productName: 'Coin Pack 10',
  productCategory: 'Bundles',
  productQuantity: 2,
  productPrice: 4.99,
  transaction_id: 'T12345'
});

import { Singular } from 'singular-react-native';

// Track revenue with attributes
Singular.revenueWithArgs('USD', 9.98, {
  productSKU: 'coin_package_abc123',
  productName: 'Coin Pack 10',
  productCategory: 'Bundles',
  productQuantity: 2,
  productPrice: 4.99,
  transaction_id: 'T12345'
});

Firma del método:

static revenueWithArgs(currency: string, amount: number, args: Record<string, any>): void

Para obtener la lista completa de métodos, consulte la referencia del método revenueWithArgs.

Método CustomRevenue

Realiza el seguimiento de eventos de ingresos personalizados con un nombre de evento, moneda e importe especificados.

// TurboModule direct API (React Native 0.76+ New Architecture)
import NativeSingular from 'singular-react-native/jsNativeSingular';

// Track custom revenue event
NativeSingular.customRevenue('PremiumUpgrade', 'USD', 9.99);

import { Singular } from 'singular-react-native';

// Track custom revenue event
Singular.customRevenue('PremiumUpgrade', 'USD', 9.99);

Firma del método:

static customRevenue(eventName: string, currency: string, amount: number): void

Para obtener la lista completa de métodos, consulte la referencia del método customRevenue.

Método CustomRevenueWithArgs

Realiza el seguimiento de eventos de ingresos personalizados con un nombre de evento, divisa, importe y atributos personalizados adicionales especificados.

// TurboModule direct API (React Native 0.76+ New Architecture)
import NativeSingular from 'singular-react-native/jsNativeSingular';

// Track custom revenue event with attributes
NativeSingular.customRevenueWithArgs('PremiumBundlePurchase', 'USD', 99.99, {
  productSKU: 'premium_bundle_xyz',
  productName: 'Premium Bundle',
  productCategory: 'Bundles',
  productQuantity: 1,
  productPrice: 99.99,
  discount_applied: true
});

import { Singular } from 'singular-react-native';

// Track custom revenue event with attributes
Singular.customRevenueWithArgs('PremiumBundlePurchase', 'USD', 99.99, {
  productSKU: 'premium_bundle_xyz',
  productName: 'Premium Bundle',
  productCategory: 'Bundles',
  productQuantity: 1,
  productPrice: 99.99,
  discount_applied: true
});

Firmadel método:

static customRevenueWithArgs(eventName: string, currency: string, amount: number, args: Record<string, any>): void

Para obtener la lista completa de métodos, consulte la referencia del método customRevenueWithArgs.

Ingresos por suscripción

Seguimiento de suscripciones

Singular ofrece una guía completa sobre la implementación de eventos de suscripción utilizando Singular SDK. La guía cubre el seguimiento de eventos de suscripción dentro de la aplicación en varias plataformas.

• Lea la Guía de implementación técnica de eventosde suscripción si desea realizar un seguimiento de los ingresos por suscripción

Seguimiento de eventos híbridos (avanzado)

Singular recomienda enviar todos los eventos e ingresos a través del SDK de Singular integrado en su aplicación para una atribución óptima. Sin embargo, Singular puede recopilar eventos de otras fuentes cuando sea necesario.

Los eventos enviados fuera del SDK de Singular deben cumplir con los requisitos de documentación de eventos de servidor a servidor de Singular y proporcionar identificadores de dispositivo coincidentes para una atribución correcta.

Guías de seguimiento de eventos híbridos

Envío de eventos desde un servidor interno

Recopile datos de ingresos de su servidor interno para analizar el rendimiento de la campaña y el ROI.

Requisitos:

• Capturar identificadores de dispositivos: Desde un evento de registro o inicio de sesión dentro de la aplicación, capture y pase los identificadores de dispositivo y almacene estos datos con el ID de usuario en su servidor. Dado que los identificadores de dispositivo pueden cambiar para un usuario, actualice los identificadores cuando un usuario genere una sesión de aplicación. Esto garantiza que el evento del lado del servidor se atribuya al dispositivo correcto.
• Identificadores específicos de la plataforma: Los eventos del lado del servidor son específicos de cada plataforma y sólo deben enviarse con el identificador de dispositivo que coincida con la plataforma del dispositivo (por ejemplo, IDFA o IDFV para dispositivos iOS, GAID para dispositivos Android)
• Actualizaciones en tiempo real: Utilice el mecanismo Singular Internal BI postback para empujar un evento en tiempo real a su endpoint interno para que pueda actualizar el conjunto de datos en el lado del servidor. Consulte las preguntas frecuentes sobre postback de BIinterno
• Detalles de Implementación: Revise la sección de Seguimiento de Ingresos en la guía de Integración Servidor a Servidor para más detalles.

Envío de Eventos desde un Proveedor de Ingresos

Integre proveedores de ingresos de terceros como RevenueCat o adapty para enviar ingresos por compras y suscripciones a Singular.

Proveedores compatibles:

• RevenueCat: Más información en la documentación de RevenueCat
• adapty: Más información en la documentaciónde adapty

Envío de eventos desde Segment

Habilite Segment para enviar eventos a Singular en paralelo con el SDK de Singular añadiendo un destino "Cloud-Mode" en Segment.

Siga la guía de implementación Integración Singular-Segment para obtener instrucciones detalladas de configuración.