Documento

SDK de React Native - Referencia de Métodos

Esta completa referencia documenta todos los métodos disponibles en el SDK de Singular para aplicaciones React Native. El SDK proporciona funcionalidad para inicialización, seguimiento de eventos, informes de ingresos, atribución, cumplimiento de privacidad de datos y configuración. Cada método se presenta con una descripción, firma y ejemplos prácticos de uso para ayudar a los desarrolladores a integrar las capacidades del SDK de Singular en sus aplicaciones React Native.

adRevenue

Método Singular.adRevenue

Realiza un seguimiento de los eventos de ingresos publicitarios con información detallada de los datos publicitarios. Este método le permite informar de los ingresos generados por los anuncios mostrados en su aplicación con varios parámetros para categorizar y analizar el rendimiento de los anuncios.

Firma

static adRevenue(adData: {
  ad_platform: string; 
  ad_currency: string; 
  ad_revenue: number; 
  [key: string]: any;
}): void

Propiedades requeridas

ad_platform (cadena): La plataforma publicitaria desde la que se generan los ingresos publicitarios (por ejemplo, 'AdMob', 'Facebook', 'UnityAds').
ad_currency (cadena): El código de moneda (formato ISO 4217) en el que se declaran los ingresos publicitarios (por ejemplo, "USD", "EUR").
ad_revenue (número): El importe de los ingresos generados por la impresión del anuncio.

Propiedades opcionales

ad_unit_id (cadena): El identificador único del bloque de anuncios donde se mostró el anuncio.
ad_type (cadena): El tipo o formato del anuncio (por ejemplo, "Recompensado", "Intersticial", "Banner").
ad_placement_name (cadena): El nombre o identificador de ubicación donde se colocó el anuncio dentro de su aplicación (por ejemplo, 'nivel_completo', 'menú_principal').
ad_mediation_platform (cadena): La plataforma de mediación de anuncios utilizada para servir el anuncio (por ejemplo, 'admob', 'ironsource', 'max').
ad_impression_id (cadena): Un identificador único para el evento de impresión de anuncio específico.
ad_group_type (cadena): La clasificación de tipo o categoría del grupo de anuncios.
ad_unit_name (cadena): El nombre legible por humanos asignado al grupo de anuncios.
ad_group_id (cadena): El identificador único del grupo de anuncios asociado a esta impresión.
ad_group_name (cadena): El nombre legible por humanos del grupo de anuncios.
ad_group_priority (número): El nivel de prioridad numérico asignado al grupo de anuncios para el ordenamiento en cascada de la mediación.
ad_precision (cadena): El nivel de precisión o exactitud de los datos de ingresos publicitarios (por ejemplo, "estimado", "preciso", "definido_por_el_editor").
ad_placement_id (cadena): El identificador único para la ubicación de colocación de anuncios dentro de su aplicación.

Ejemplo de uso

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

const adData = {
  ad_platform: 'AdMob',
  ad_currency: 'USD',
  ad_revenue: 0.05,
  ad_unit_id: 'ca-app-pub-1234567890123456',
  ad_type: 'Rewarded',
  ad_placement_name: 'level_complete'
};

NativeSingular.adRevenue(adData);

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

// Track ad revenue event
const adData = {
  ad_platform: 'AdMob',
  ad_currency: 'USD',
  ad_revenue: 0.05,
  ad_unit_id: 'ca-app-pub-1234567890123456',
  ad_type: 'Rewarded',
  ad_placement_name: 'level_complete'
};

Singular.adRevenue(adData);

clearGlobalProperties

Singular.clearGlobalProperties Método

Elimina todas las propiedades globales establecidas previamente. Esto resulta útil cuando necesita restablecer las propiedades globales, por ejemplo, cuando un usuario cierra la sesión de su aplicación.

Firma

static clearGlobalProperties(): void

Ejemplo de uso

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

// Clear all global properties
NativeSingular.clearGlobalProperties();

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

// Clear all global properties
Singular.clearGlobalProperties();

createReferrerEnlaceCorto

Singular.createReferrerShortLink Método

Crea un enlace corto con información de referencia que puede utilizarse para compartir y atribuir. Este método genera enlaces rastreables que pueden compartirse con los usuarios, lo que permite atribuir instalaciones y actividades a fuentes de referencia específicas.

Firma

static createReferrerShortLink(
  baseLink: string,
  referrerName: string,
  referrerId: string,
  passthroughParams: Record<string, any>,
  completionHandler: (data: string | null, error?: string) => void
): void

Ejemplo de uso

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

// Create a short link for referral
NativeSingular.createReferrerShortLink(
  'https://sample.sng.link/B4tbmv8fp',
  'John Doe',
  'aq239897',
  { channel: 'sms', campaign: 'summer_promo' },
  (result: string, error: string) => {
    if (error) {
      console.error('Short link creation failed:', error);
    } else {
      console.log('Short link created successfully:', result);
    }
  }
);

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

// Create a short link for referral
Singular.createReferrerShortLink(
  'https://sample.sng.link/B4tbmv8fp',
  'John Doe',
  'aq239897',
  { channel: 'sms', campaign: 'summer_promo' },
  (link, error) => {
    if (error) {
      console.error('Error creating short link:', error);
    } else if (link) {
      console.log('Generated short link:', link);
      // Share the link with users
    }
  }
);

customRevenue

Singular.customRevenue Método

Realiza un seguimiento de los eventos de ingresos personalizados con un nombre de evento, moneda e importe especificados. Esto permite un seguimiento más específico de los ingresos con nombres de eventos personalizados.

Firma

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

Ejemplo de uso

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

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

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

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

customRevenueWithArgs

Método Singular.customRevenueWithArgs

Rastrea eventos de ingresos personalizados con un nombre de evento, moneda, importe y atributos adicionales especificados. Esto permite un seguimiento más detallado de los ingresos con parámetros personalizados.

Firma

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

Ejemplo de uso

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

// Track a custom revenue event with attributes
NativeSingular.customRevenueWithArgs(
  'in_app_purchase',
  'USD',
  5.99,
  {
    product_id: 'com.app.gems_pack_small',
    quantity: 1
  }
);

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

// Track a custom revenue event with attributes
Singular.customRevenueWithArgs(
  'in_app_purchase',
  'USD',
  5.99,
  {
    product_id: 'com.app.gems_pack_small',
    quantity: 1
  }
);

evento

Singular.event Método

Realiza un seguimiento de los eventos con el nombre especificado. Utiliza este método para realizar un seguimiento de las acciones y la participación de los usuarios en tu aplicación.

Firma

static event(eventName: string): void

Ejemplo de uso

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

// Track a simple event
NativeSingular.event('level_completed');

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

// Track a simple event
Singular.event('level_completed');

eventWithArgs

Singular.eventWithArgs Método

Realiza un seguimiento de los eventos con el nombre especificado y atributos personalizados adicionales. Utilice este método para realizar un seguimiento de las acciones del usuario con parámetros detallados.

Firma

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

Ejemplo de uso

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

// Track an event with additional parameters
NativeSingular.eventWithArgs('level_completed', {
  level_id: 5,
  score: 12500,
  time_spent: 120,
  difficulty: 'medium'
});

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

// Track an event with additional parameters
Singular.eventWithArgs('level_completed', {
  level_id: 5,
  score: 12500,
  time_spent: 120,
  difficulty: 'medium'
});

getGlobalProperties

Método singular.getGlobalProperties

Recupera todas las propiedades globales configuradas actualmente. Este método devuelve una promesa que resuelve a un objeto que contiene todas las propiedades globales que se han establecido para el SDK.

Firma

static getGlobalProperties(): Promise<Record<string, any>>

Ejemplo de uso

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

// Get all global properties
NativeSingular.getGlobalProperties();

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

// Get all global properties
Singular.getGlobalProperties();

getLimitDataSharing

Singular.getLimitDataSharing Método

Recupera el estado actual de la limitación del uso compartido de datos. Este método devuelve una promesa que se resuelve en un booleano que indica si la compartición de datos está actualmente limitada.

Firma

static getLimitDataSharing(): Promise<boolean>

Ejemplo de uso

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

// Check if data sharing is limited
NativeSingular.getLimitDataSharing();

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

// Check if data sharing is limited
Singular.getLimitDataSharing();

handlePushNotification

Singular.handlePushNotification Método

Procesa la carga útil de una notificación push para su atribución. Este método debe invocarse cuando la aplicación recibe una notificación push para que Singular pueda atribuirla correctamente. Este método es exclusivo de iOS.

Firma

static handlePushNotification(
  pushNotificationPayload: Record<string, any>
): void

Ejemplo de uso

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

// Handle a received push notification (iOS only)
if (Platform.OS === 'ios') {
  const userInfo = remoteMessage.data;
  NativeSingular.handlePushNotification(userInfo);
}

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

// Handle a received push notification (iOS only)
if (Platform.OS === 'ios') {
  const userInfo = remoteMessage.data;
  Singular.handlePushNotification(userInfo);
}

inAppPurchase

Método Singular.inAppPurchase

Informa de los ingresos a Singular y realiza la validación del recibo (si está activada) en el backend. El objeto de compra debe ser de tipo SingularIOSPurchase o SingularAndroidPurchase.

Firma

static inAppPurchase(
  eventName: string,
  purchase: SingularIOSPurchase | SingularAndroidPurchase
): void

Constructores de la clase de compra SingularIOSPurchase

constructor(
  revenue: number,
  currency: string,
  productId: string,
  transactionId: string,
  receipt: string
)

Constructores de la clase de compra SingularAndroidPurchase

constructor(
  revenue: number,
  currency: string,
  receipt: string,
  signature: string
)

Ejemplo de uso

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

// iOS Example
if (Platform.OS === 'ios') {
  const iosPurchase = new SingularIOSPurchase(
    99.99,              // revenue
    'USD',              // currency
    'premium_bundle',   // productId
    'trans_12345',      // transactionId
    'base64receipt...'  // receipt
  );
  
  // Convert to plain object for TurboModule
  NativeSingular.inAppPurchase('purchase', iosPurchase.toSpecObject());
}

// Android Example
if (Platform.OS === 'android') {
  const androidPurchase = new SingularAndroidPurchase(
    99.99,                    // revenue
    'USD',                    // currency
    'purchaseDataJSON',       // receipt
    'signatureString'         // signature
  );
  
  // Convert to plain object for TurboModule
  NativeSingular.inAppPurchase('purchase', androidPurchase.toSpecObject());
}

import { Singular, SingularIOSPurchase, SingularAndroidPurchase } from 'singular-react-native';
import { Platform } from 'react-native';

// iOS Example
if (Platform.OS === 'ios') {
  const iosPurchase = new SingularIOSPurchase(
    99.99,              // revenue
    'USD',              // currency
    'premium_bundle',   // productId
    'trans_12345',      // transactionId
    'base64receipt...'  // receipt
  );
  Singular.inAppPurchase('purchase', iosPurchase);
}

// Android Example
if (Platform.OS === 'android') {
  const androidPurchase = new SingularAndroidPurchase(
    99.99,                    // revenue
    'USD',                    // currency
    'purchaseDataJSON',       // receipt
    'signatureString'         // signature
  );
  Singular.inAppPurchase('purchase', androidPurchase);
}

inAppPurchaseWithArgs

Singular.inAppPurchaseWithArgs Método

Reporta el ingreso a Singular con atributos adicionales y realiza la validación del recibo (si está habilitado) en el backend. El objeto de compra debe ser de tipo SingularIOSPurchase o SingularAndroidPurchase.

Firma

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

Constructores de la clase de compra SingularIOSPurchase

constructor(
  revenue: number,
  currency: string,
  productId: string,
  transactionId: string,
  receipt: string
)

Constructores de la clase de compra SingularAndroidPurchase

constructor(
  revenue: number,
  currency: string,
  receipt: string,
  signature: string
)

Ejemplo de uso

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

// iOS Example - Track IAP with additional attributes
if (Platform.OS === 'ios') {
  const iosPurchase = new SingularIOSPurchase(
    99.99,              // revenue
    'USD',              // currency
    'premium_bundle',   // productId
    'trans_12345',      // transactionId
    'base64receipt...'  // receipt
  );
  
  // Convert to plain object for TurboModule
  NativeSingular.inAppPurchaseWithArgs(
    'purchase',
    iosPurchase.toSpecObject(),
    {
      product_category: 'premium_content',
      is_first_purchase: true,
      user_tier: 'gold'
    }
  );
}

// Android Example - Track IAP with additional attributes
if (Platform.OS === 'android') {
  const androidPurchase = new SingularAndroidPurchase(
    99.99,                    // revenue
    'USD',                    // currency
    'purchaseDataJSON',       // receipt
    'signatureString'         // signature
  );
  
  // Convert to plain object for TurboModule
  NativeSingular.inAppPurchaseWithArgs(
    'purchase',
    androidPurchase.toSpecObject(),
    {
      product_category: 'premium_content',
      is_first_purchase: true,
      user_tier: 'gold'
    }
  );
}

import { Singular, SingularIOSPurchase, SingularAndroidPurchase } from 'singular-react-native';
import { Platform } from 'react-native';

// iOS Example - Track IAP with additional attributes
if (Platform.OS === 'ios') {
  const iosPurchase = new SingularIOSPurchase(
    99.99,              // revenue
    'USD',              // currency
    'premium_bundle',   // productId
    'trans_12345',      // transactionId
    'base64receipt...'  // receipt
  );
  
  Singular.inAppPurchaseWithArgs('purchase', iosPurchase, {
    product_category: 'premium_content',
    is_first_purchase: true,
    user_tier: 'gold'
  });
}

// Android Example - Track IAP with additional attributes
if (Platform.OS === 'android') {
  const androidPurchase = new SingularAndroidPurchase(
    99.99,                    // revenue
    'USD',                    // currency
    'purchaseDataJSON',       // receipt
    'signatureString'         // signature
  );
  
  Singular.inAppPurchaseWithArgs('purchase', androidPurchase, {
    product_category: 'premium_content',
    is_first_purchase: true,
    user_tier: 'gold'
  });
}

init

Método Singular.init

Inicializa Singular SDK con la configuración proporcionada. Este es el primer método que debes llamar para empezar a utilizar Singular SDK.

Firma

static init(singularConfig: SingularConfig): void

Ejemplo de uso

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

// Create configuration object
const config: SingularConfig = {
  apikey: 'YOUR_API_KEY',
  secret: 'YOUR_SECRET',
  customUserId: 'user-123456',
  sessionTimeout: 60,
  enableLogging: true,
  logLevel: 3,
}

// Initialize the SDK
NativeSingular.init(config);

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

// Create configuration object
const config = new SingularConfig('YOUR_API_KEY', 'YOUR_SECRET');

// Configure additional options if needed
config.customUserId = 'user-123456';
config.sessionTimeout = 60;
config.enableLogging = true;
config.logLevel = 3;

// Initialize the SDK
Singular.init(config);

isAllTrackingStopped

Método Singular.isAllTrackingStopped

Comprueba si se ha detenido todo el seguimiento. Este método devuelve una promesa que se resuelve en un booleano que indica si el seguimiento se ha detenido.

Firma

static isAllTrackingStopped(): Promise<boolean>

Ejemplo de uso

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

// Check if tracking is stopped
NativeSingular.isAllTrackingStopped();

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

// Check if tracking is stopped
Singular.isAllTrackingStopped();

limitDataSharing

Singular.limitDataSharing Método

Establece el estado de limitación del uso compartido de datos. Utiliza este método para limitar el uso compartido de datos en función del consentimiento del usuario o de requisitos de privacidad.

Firma

static limitDataSharing(limitDataSharingValue: boolean): void

Ejemplo de uso

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

// To limit data sharing (e.g., when user opts out)
NativeSingular.limitDataSharing(true);

// To enable full data sharing (e.g., when user opts in)
NativeSingular.limitDataSharing(false);

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

// To limit data sharing (e.g., when user opts out)
Singular.limitDataSharing(true);

// To enable full data sharing (e.g., when user opts in)
Singular.limitDataSharing(false);

resumeAllTracking

Singular.resumeAllTracking Método

Reanuda todas las actividades de seguimiento que se detuvieron previamente. Utilice este método para volver a activar el seguimiento después de haberlo detenido.

Firma

static resumeAllTracking(): void

Ejemplo de uso

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

// Resume tracking when user opts back in
NativeSingular.resumeAllTracking();

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

// Resume tracking when user opts back in
Singular.resumeAllTracking();

ingresos

Singular.revenue Método

Rastrea eventos de ingresos con moneda e importe. Esto permite un seguimiento básico de los ingresos para su aplicación.

Firma

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

Ejemplo de uso

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

// Track revenue with currency and amount
NativeSingular.revenue('USD', 9.99);

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

// Track revenue with currency and amount
Singular.revenue('USD', 9.99);

revenueWithArgs

Método Singular.revenueWithArgs

Realiza un seguimiento de los eventos de ingresos con moneda, importe y atributos adicionales. Esto permite un seguimiento exhaustivo de los ingresos con parámetros personalizados.

Firma

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

Ejemplo de uso

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

// Track revenue with additional attributes
NativeSingular.revenueWithArgs('USD', 19.98, {
  product_id: 'premium_gems',
  quantity: 2
});

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

// Track revenue with additional attributes
Singular.revenueWithArgs('USD', 19.98, {
  product_id: 'premium_gems',
  quantity: 2
});

setCustomUserId

Singular.setCustomUserId Método

Establece un ID de usuario personalizado para el usuario actual. Esto le permite asociar los datos de Singular con su propio sistema de identificación de usuarios.

Firma

static setCustomUserId(customUserId: string): void

Ejemplo de uso

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

// Set custom user ID after user logs in
NativeSingular.setCustomUserId('user123456');

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

// Set custom user ID after user logs in
Singular.setCustomUserId('user123456');

setDeviceCustomUserId

Característica de empresa - Póngase en contacto con su Gestor de Éxito de Clientes para habilitar esta característica para su cuenta.

Singular.setDeviceCustomUserId Método

Establece un ID de usuario personalizado a nivel de dispositivo. Esto le permite asociar los datos de Singular con su propio sistema de identificación de usuarios a nivel de dispositivo.

Firma

static setDeviceCustomUserId(customUserId: string): void

Ejemplo de uso

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

// Set device-level custom user ID
NativeSingular.setDeviceCustomUserId('device_user_123456');

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

// Set device-level custom user ID
Singular.setDeviceCustomUserId('device_user_123456');

setGlobalProperty

Método setGlobalProperty de Singular

Establece una propiedad global que se enviará con todos los eventos. Esto te permite añadir atributos consistentes a todos los eventos sin tener que especificarlos cada vez.

Firma

static setGlobalProperty(
  key: string,
  value: string,
  overrideExisting: boolean
): Promise<boolean>

Ejemplo de uso

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

// Set a global property
NativeSingular.setGlobalProperty(
  'user_tier',
  'premium',
  true
);

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

// Set a global property
Singular.setGlobalProperty(
  'user_tier',
  'premium',
  true
);

setLimitAdvertisingIdentifiers

Singular.setLimitAdvertisingIdentifiers Método

Activa o desactiva el modo de identificadores publicitarios limitados. Esta opción afecta al modo en que el SDK recopila y utiliza los identificadores de dispositivo para el seguimiento.

Firma

static setLimitAdvertisingIdentifiers(enabled: boolean): void

Ejemplo de uso

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

// Enable limited identifiers mode
NativeSingular.setLimitAdvertisingIdentifiers(true);

// Disable limited identifiers mode
NativeSingular.setLimitAdvertisingIdentifiers(false);

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

// Enable limited identifiers mode
Singular.setLimitAdvertisingIdentifiers(true);

// Disable limited identifiers mode
Singular.setLimitAdvertisingIdentifiers(false);

setUninstallToken

Método setUninstallToken

Registra el token de notificación push para el seguimiento de la desinstalación. Este método debe invocarse con el testigo de notificación push para habilitar el seguimiento de la desinstalación.

Firma

static setUninstallToken(token: string): void

Ejemplo de uso

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

// Register device token for uninstall tracking
NativeSingular.setUninstallToken(token);

import { Singular } from 'singular-react-native';
import messaging from '@react-native-firebase/messaging';

// Register device token for uninstall tracking
Singular.setUninstallToken(token);

skanGetConversionValue

Singular.skanGetConversionValue Método

Recupera el valor de conversión actual de SKAdNetwork. Este método devuelve una promesa que resuelve el valor de conversión actual utilizado para la atribución de SKAdNetwork. Este método es exclusivo de iOS.

Firma

static skanGetConversionValue(): Promise<number | null>

Ejemplo de uso

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

// Get the current SKAdNetwork conversion value (iOS only)
if (Platform.OS === 'ios') {
  const conversionValue = await NativeSingular.skanGetConversionValue();
  console.log('Current conversion value:', conversionValue ?? 0);
}

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

// Get the current SKAdNetwork conversion value (iOS only)
if (Platform.OS === 'ios') {
  const conversionValue = await Singular.skanGetConversionValue();
  console.log('Current conversion value:', conversionValue ?? 0);
}

skanRegisterAppParaAtribuciónAdNetwork

Singular.skanRegisterAppForAdNetworkAttribution Método

Registra la aplicación para la atribución SKAdNetwork. Este método debe invocarse para activar la atribución SKAdNetwork en iOS. Este método es exclusivo para iOS.

Firma

static skanRegisterAppForAdNetworkAttribution(): void

Ejemplo de uso

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

// Register for SKAdNetwork attribution (iOS only)
if (Platform.OS === 'ios') {
  NativeSingular.skanRegisterAppForAdNetworkAttribution();
}

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

// Register for SKAdNetwork attribution (iOS only)
if (Platform.OS === 'ios') {
  Singular.skanRegisterAppForAdNetworkAttribution();
}

skanUpdateConversionValue

Singular.skanUpdateConversionValue Método

Actualiza el valor de conversión de SKAdNetwork. Este método permite actualizar manualmente el valor de conversión utilizado para la atribución SKAdNetwork. Este método es exclusivo de iOS.

Firma

static skanUpdateConversionValue(conversionValue: number): Promise<boolean>

Ejemplo de uso

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

// Update the SKAdNetwork conversion value (iOS only)
if (Platform.OS === 'ios') {
  const success = await NativeSingular.skanUpdateConversionValue(5);
  if (success) {
    console.log('Conversion value updated successfully');
  }
}

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

// Update the SKAdNetwork conversion value (iOS only)
if (Platform.OS === 'ios') {
  const success: boolean = await Singular.skanUpdateConversionValue(5);
  if (success) {
    console.log('Conversion value updated successfully');
  }
}

skanUpdateConversionValues

Singular.skanUpdateConversionValues Método

Actualiza los valores de conversión de SKAdNetwork 4.0 con el valor fino, el valor grueso y los parámetros de bloqueo. Este método es para iOS 16.1+ y es exclusivo de iOS.

Firma

static skanUpdateConversionValues(
  conversionValue: number,
  coarse: number,
  lock: boolean
): void

Ejemplo de uso

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

// Update SKAdNetwork 4.0 conversion values (iOS 16.1+)
if (Platform.OS === 'ios') {
  NativeSingular.skanUpdateConversionValues(
    5,     // fine value (0-63)
    1,     // coarse value (0=low, 1=medium, 2=high)
    false  // lock
  );
}

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

// Update SKAdNetwork 4.0 conversion values (iOS 16.1+)
if (Platform.OS === 'ios') {
  Singular.skanUpdateConversionValues(
    5,     // fine value (0-63)
    1,     // coarse value (0=low, 1=medium, 2=high)
    false  // lock
  );
}

stopAllTracking

Singular.stopAllTracking Método

Detiene todas las actividades de seguimiento. Utilice este método para desactivar el seguimiento cuando los usuarios opten por no participar o por motivos de privacidad.

Firma

static stopAllTracking(): void

Ejemplo de uso

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

// Stop tracking when user opts out
NativeSingular.stopAllTracking();

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

// Stop tracking when user opts out
Singular.stopAllTracking();

trackingOptIn

Método Singular.trackingOptIn

Indica que el usuario ha aceptado el seguimiento. Llame a este método cuando el usuario consienta explícitamente el seguimiento y la recopilación de datos.

Firma

static trackingOptIn(): void

Ejemplo de uso

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

// User has opted in to tracking
NativeSingular.trackingOptIn();

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

// User has opted in to tracking
Singular.trackingOptIn();

trackingUnder13

Método Singular.trackingUnder13

Indica que el usuario es menor de 13 años. Llame a este método para cumplir con COPPA y otras regulaciones para usuarios menores de 13 años.

Firma

static trackingUnder13(): void

Ejemplo de uso

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

// Notify Singular the user is under 13 years old
NativeSingular.trackingUnder13();

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

// Notify Singular the user is under 13 years old
Singular.trackingUnder13();

unsetCustomUserId

Singular.unsetCustomUserId Método

Elimina el ID de usuario personalizado establecido previamente. Llame a este método cuando el usuario cierre la sesión o cuando ya no desee asociar eventos al ID de usuario actual.

Firma

static unsetCustomUserId(): void

Ejemplo de uso

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

// Clear custom user ID when user logs out
NativeSingular.unsetCustomUserId();

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

// Clear custom user ID when user logs out
Singular.unsetCustomUserId();

unsetGlobalProperty

Singular.unsetGlobalProperty Método

Elimina una propiedad global establecida previamente. Llame a este método cuando ya no desee que una propiedad global específica se envíe con los eventos.

Firma

static unsetGlobalProperty(key: string): void

Ejemplo de uso

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

// Remove a global property
NativeSingular.unsetGlobalProperty('user_tier');

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

// Remove a global property
Singular.unsetGlobalProperty('user_tier');

SDK de React Native - Métodos de referencia

SDK de React Native - Referencia de Métodos

adRevenue

Método Singular.adRevenue

Firma

Propiedades requeridas

Propiedades opcionales

Ejemplo de uso

clearGlobalProperties

Singular.clearGlobalProperties Método

Firma

Ejemplo de uso

createReferrerEnlaceCorto

Singular.createReferrerShortLink Método

Firma

Ejemplo de uso

customRevenue

Singular.customRevenue Método

Firma

Ejemplo de uso

customRevenueWithArgs

Método Singular.customRevenueWithArgs

Firma

Ejemplo de uso

evento

Singular.event Método

Firma

Ejemplo de uso

eventWithArgs

Singular.eventWithArgs Método

Firma

Ejemplo de uso

getGlobalProperties

Método singular.getGlobalProperties

Firma

Ejemplo de uso

getLimitDataSharing

Singular.getLimitDataSharing Método

Firma

Ejemplo de uso

handlePushNotification

Singular.handlePushNotification Método

Firma

Ejemplo de uso

inAppPurchase

Método Singular.inAppPurchase

Firma

Constructores de la clase de compra SingularIOSPurchase

Constructores de la clase de compra SingularAndroidPurchase

Ejemplo de uso

inAppPurchaseWithArgs

Singular.inAppPurchaseWithArgs Método

Firma

Constructores de la clase de compra SingularIOSPurchase

Constructores de la clase de compra SingularAndroidPurchase

Ejemplo de uso

init

Método Singular.init

Firma

Ejemplo de uso

isAllTrackingStopped

Método Singular.isAllTrackingStopped

Firma

Ejemplo de uso

limitDataSharing

Singular.limitDataSharing Método

Firma

Ejemplo de uso

resumeAllTracking

Singular.resumeAllTracking Método

Firma

Ejemplo de uso

ingresos

Singular.revenue Método

Firma

Ejemplo de uso

revenueWithArgs

Método Singular.revenueWithArgs

Firma

Ejemplo de uso