Guía de recuperación de datos de dispositivos

Guía de recuperación de datos de dispositivos

Singular requiere que se incluyan identificadores de dispositivo específicos en todas las solicitudes de API para una atribución precisa. Estos identificadores incluyen:

  • Google Advertising ID (GAID) y Google App Set ID (ASID) para dispositivos Google Play
  • Amazon Advertising ID para dispositivos Amazon que no sean de Google Play
  • Open Advertising ID (OAID) para dispositivos Android fabricados en China
  • Y si ninguno de los anteriores está disponible, el Android ID (ANDI) para dispositivos que no sean de Google Play
  • Identificador para anunciantes (IDFA) e Identificador para vendedores (IDFV) para dispositivos iOS

Singular también requiere algunos Parámetros del dispositivo móvil:

  • Configuración regional (por ejemplo, en_US)
  • Marca del dispositivo (por ejemplo, Samsung)
  • Modelo del dispositivo (por ejemplo, iPhone 12, Samsung Galaxy S21)
  • Compilación (por ejemplo, Build/13D15)

Singular proporciona ejemplos de fragmentos de código para ayudarle a obtener estos identificadores, que puede encontrar a continuación.

Ejemplo de clase Device Info

Identificadores

Identificadores necesarios para iOS

  • El IDFV es obligatorio en todas las solicitudes S2S
  • Se debe proporcionar el IDFA si el usuario proporcionó el Consentimiento de transparencia de seguimiento de aplicaciones.
  • También se requiere el Estado de Autorización ATT.
Cómo recuperar datos de dispositivos iOS

Recuperación del Identificador para Anunciantes (IDFA)

El Identificador para Anunciantes (IDFA) ayuda a los anunciantes a rastrear y atribuir las acciones de los usuarios (por ejemplo, clics en anuncios, instalaciones de aplicaciones) a campañas específicas, lo que permite una orientación precisa de los anuncios y la optimización de las campañas.

A partir de iOS 14.5, los usuarios deben optar por el marco App Tracking Transparency (ATT) antes de que las aplicaciones puedan acceder a su IDFA. Si los usuarios no lo hacen, el IDFA no estará disponible, lo que limitará las capacidades de seguimiento.

Recuperación del identificador para proveedores (IDFV)

El identificador para proveedores (IDFV) es un identificador único asignado por Apple a un dispositivo, que es específico de un proveedor o desarrollador concreto. Permanece constante en todas las aplicaciones del mismo proveedor en un dispositivo determinado, lo que permite al proveedor realizar un seguimiento del comportamiento y las interacciones del usuario en todo su ecosistema de aplicaciones sin identificar al usuario personalmente.

  • Asegúrese de que se muestra y gestiona la solicitud de ATT antes de intentar acceder al IDFA.
  • Si utiliza ATT, capture el IDFA y páselo a su servidor para utilizarlo en solicitudes de API Singular.
  • Capture el IDFV y devuélvalo a su servidor para utilizarlo en solicitudes de API Singular.

Ejemplo: Solicitud de estado de autorización ATT para recuperar IDFA e IDFV con registros de consola

Aquí están los fragmentos de código Objective-C y Swift para recuperar tanto el IDFA (Identificador para Anunciantes) como el IDFV (Identificador para Vendedor) con registros de consola. Este código incluye la gestión de los permisos de App Tracking Transparency (ATT), necesarios para acceder al IDFA a partir de iOS 14.5.

Objective-CSwift
#import <AdSupport/AdSupport.h>
#import <AppTrackingTransparency/AppTrackingTransparency.h>
#import <UIKit/UIKit.h>

- (void)retrieveIdentifiers {
    // Request ATT authorization (iOS 14.5+)

    [ATTrackingManager requestTrackingAuthorizationWithCompletionHandler:^(ATTrackingManagerAuthorizationStatus status) {
        dispatch_async(dispatch_get_main_queue(), ^{
            switch (status) {
                case ATTrackingManagerAuthorizationStatusAuthorized: {
                    // ATT authorized, retrieve IDFA

                    NSUUID *idfa = [[ASIdentifierManager sharedManager] advertisingIdentifier];
                    NSLog(@"IDFA: %@", [idfa UUIDString]);
                    break;
                }
                case ATTrackingManagerAuthorizationStatusDenied:
                case ATTrackingManagerAuthorizationStatusRestricted:
                case ATTrackingManagerAuthorizationStatusNotDetermined:
                    // ATT not authorized or not determined

                    NSLog(@"Tracking not authorized or not determined.");
                    break;
                default:
                    NSLog(@"Unknown ATT status.");
                    break;
            }

            // Retrieve IDFV (always available)

            NSUUID *idfv = [[UIDevice currentDevice] identifierForVendor];
            if (idfv != nil) {
                NSLog(@"IDFV: %@", [idfv UUIDString]);
            } else {
                NSLog(@"Unable to retrieve IDFV.");
            }
        });
    }];
}

// Call the method to retrieve identifiers

[self retrieveIdentifiers];
  • IDFA: Requiere autorización ATT a partir de iOS 14.5. Sin el consentimiento del usuario, el IDFA devolverá todos ceros.
  • IDFV: Siempre disponible y debe proporcionarse siempre en las solicitudes de API singulares.

Identificadores Android requeridos (dispositivos Google Play)

  • El ASID es obligatorio en todas las solicitudes S2S
  • El AIFA (GAID) debe proporcionarse si está disponible.
Cómo recuperar datos de dispositivos Android (Google Play)

Recuperación del identificador de publicidad de Google (GAID)

El identificador de publicidad de Google (GAID), también conocido como AIFA en singular o ID de publicidad de Android (AAID), es un identificador único y reajustable por el usuario que se asigna a los dispositivos Android. Ayuda a los anunciantes y a los desarrolladores de aplicaciones a rastrear y atribuir las acciones de los usuarios (por ejemplo, clics en anuncios, instalaciones de aplicaciones) a través de aplicaciones a campañas específicas, lo que permite una orientación precisa de los anuncios y la optimización de las campañas, al tiempo que se mantiene la privacidad del usuario.

JavaKotlin
Dependencias

Asegúrate de haber añadido la dependencia necesaria para Google Play Services en tu archivo build.gradle:

dependencies {
    implementation 'com.google.android.gms:play-services-ads-identifier:17.0.0'
}

 

Si la compilación de tu aplicación está orientada a Android 12/API nivel 31 o superior, añade permisos en AndroidManifest.xml para acceder al ID de publicidad de Google:

<uses-permission android:name="com.google.android.gms.permission.AD_ID" />

 

Uso

Para utilizar este método, simplemente llámalo desde tu actividad o clase de aplicación:

AdIdUtils.getGoogleAdId(getApplicationContext());

 

Código Java para recuperar el ID de publicidad de Google (GAID)
import android.content.Context;
import android.os.AsyncTask;
import android.util.Log;

import com.google.android.gms.ads.identifier.AdvertisingIdClient;
import com.google.android.gms.ads.identifier.AdvertisingIdClient.Info;

public class AdIdUtils {

    // Method to retrieve the Google Advertising ID (GAID)

    public static void getGoogleAdId(Context context) {
        // Running the task in a background thread

        AsyncTask.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    // Retrieve the Advertising ID info

                    Info adInfo = AdvertisingIdClient.getAdvertisingIdInfo(context);
                    
                    // Get the GAID (Google Advertising ID)

                    String adId = adInfo.getId();
                    
                    // Check if "Limit Ad Tracking" is enabled by the user

                    boolean isLimitAdTrackingEnabled = adInfo.isLimitAdTrackingEnabled();
                    
                    // Log the results

                    Log.d("GoogleAdID", "Advertising ID: " + adId);
                    Log.d("GoogleAdID", "Limit Ad Tracking Enabled: " + isLimitAdTrackingEnabled);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

Recuperación del App Set ID (ASID)

El App Set ID de Android permite a los desarrolladores realizar un seguimiento de los usuarios a través de sus propias aplicaciones de una manera respetuosa con la privacidad. Resulta especialmente útil para el análisis y la prevención del fraude, pero no puede utilizarse con fines publicitarios, como los anuncios personalizados o la medición.

JavaKotlin
Dependencias

Asegúrese de haber añadido la dependencia necesaria para Google Play Services en su archivo build.gradle:

dependencies {
    implementation 'com.google.android.gms:play-services-appset:16.1.0'
}

 

Uso

Para utilizar esta función, simplemente llámala desde tu actividad o clase de aplicación:

AppSetIdUtils.getAppSetId(getApplicationContext());

 

Código Java para Recuperar App Set ID
import android.content.Context;
import android.util.Log;
import com.google.android.gms.appset.AppSet;
import com.google.android.gms.appset.AppSetIdClient;
import com.google.android.gms.appset.AppSetIdInfo;
import com.google.android.gms.tasks.OnSuccessListener;
import com.google.android.gms.tasks.Task;

public class AppSetIdUtils {

    // Method to retrieve the App Set ID

    public static void getAppSetId(Context context) {
        // Get the AppSetIdClient instance

        AppSetIdClient client = AppSet.getClient(context);

        // Retrieve the App Set ID information asynchronously

        Task<AppSetIdInfo> task = client.getAppSetIdInfo();

        task.addOnSuccessListener(new OnSuccessListener<AppSetIdInfo>() {
            @Override
            public void onSuccess(AppSetIdInfo info) {
                // Get the App Set ID and its scope

                String appSetId = info.getId();
                int scope = info.getScope();

                // Log the results

                Log.d("AppSetID", "App Set ID: " + appSetId);
                Log.d("AppSetID", "Scope: " + (scope == AppSetIdInfo.SCOPE_DEVELOPER ? "Developer" : "App"));
            }
        }).addOnFailureListener(e -> {
            // Handle any errors that occur during retrieval

            Log.e("AppSetID", "Failed to retrieve App Set ID", e);
        });
    }
}

Identificadores de Android necesarios (dispositivos que no sean de Google Play)

Si no hay ASID o AIFA disponibles:

  • Se debe proporcionar el AMID (Identificador de Amazon). Sólo dispositivos Amazon.
Cómo recuperar el identificador de publicidad de Amazon (dispositivos que no sean de Google Play)

Cómo recuperar el identificador de Amazon (AMID)

Para capturar el identificador de publicidad de Amazon en tu aplicación Android, puedes utilizar la clase Settings.Secure para recuperar el identificador y comprobar las preferencias de seguimiento de anuncios del usuario. Aquí tienes un ejemplo de código limpio y sencillo basado en la información proporcionada por la documentación de Amazon:

Asegúrate de manejar escenarios en los que el identificador de publicidad podría no estar disponible (por ejemplo, en dispositivos que no sean Fire OS o en versiones antiguas de Fire OS).

Respete siempre la preferencia de Limitar seguimiento de anuncios del usuario cuando utilice este identificador con fines publicitarios o analíticos. Este código debería funcionar en dispositivos Amazon Fire con Fire OS 5.1 o posterior, según las directrices de Amazon.

JavaKotlin
Uso

Puede llamar a este método desde su actividad o servicio pasando el identificador ContentResolver:

// Example usage in an Activity

AdvertisingIdHelper.getAmazonAdvertisingId(getContentResolver());

 

Código Java para Recuperar el ID de Publicidad de Amazon (AMID)
import android.content.ContentResolver;
import android.provider.Settings;
import android.provider.Settings.SettingNotFoundException;
import android.util.Log;

public class AdvertisingIdHelper {

    public static void getAmazonAdvertisingId(ContentResolver contentResolver) {
        String advertisingID = "";
        boolean limitAdTracking = false;

        try {
            // Get user's ad tracking preference

            limitAdTracking = (Settings.Secure.getInt(contentResolver, "limit_ad_tracking") == 0) ? false : true;

            // Get the Amazon Advertising ID

            advertisingID = Settings.Secure.getString(contentResolver, "advertising_id");

            // Log the values for demonstration purposes

            Log.d("AdvertisingID", "Amazon Advertising ID: " + advertisingID);
            Log.d("LimitAdTracking", "Limit Ad Tracking: " + limitAdTracking);

        } catch (SettingNotFoundException e) {
            // Handle case where settings are not available (e.g., non-Fire OS devices)

            Log.e("AdvertisingID", "Advertising ID not supported on this device", e);
        }
    }
}
  • Se debe proporcionar el OAID (Open Advertising Identifier). Dispositivos nacionales de China.
Cómo recuperar el Open Advertising ID (No Google Play)

Cómo recuperar el identificador de publicidad abierta (OAID)

El Open Advertising Identifier (OAID) es un identificador único y anónimo utilizado con fines publicitarios en dispositivos Android, especialmente los fabricados en China. Fue introducido por la Mobile Security Alliance (MSA) como alternativa al identificador de publicidad de Google (GAID) para dispositivos en los que Google Play Services no está disponible o no es compatible, como en el mercado chino.

El OAID se utiliza principalmente para la atribución de publicidad y el seguimiento de usuarios en entornos en los que los servicios de Google Play están restringidos, lo que permite a los anunciantes y desarrolladores realizar un seguimiento del comportamiento de los usuarios manteniendo el anonimato.

El OAID está disponible en la mayoría de los dispositivos Android fabricados en China, incluidos los de marcas como Huawei, Xiaomi y otras. Se puede acceder a él mediante el SDK MSA o Huawei Mobile Services (HMS).

JavaKotlin
Dependencias

Asegúrese de que su archivo build.gradle incluye las dependencias necesarias para el SDK MSA.

dependencies {
    implementation 'com.bun.msa.sdk:msa:1.0.26'  // Example version; check for the latest one

}

 

Código Java para recuperar el OAID
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import com.bun.msa.sdk.DeviceId;
import com.bun.msa.sdk.DeviceIdSupplier;
import com.bun.msa.sdk.IIdentifierListener;

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "OAIDExample";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Initialize and request OAID

        getOAID();
    }

    private void getOAID() {
        try {
            // Create a DeviceId instance and request OAID asynchronously

            DeviceId deviceId = new DeviceId(this);
            deviceId.getDeviceIds(new IIdentifierListener() {
                @Override
                public void onSupport(boolean isSupport, DeviceIdSupplier supplier) {
                    if (isSupport && supplier != null) {
                        // Retrieve OAID from supplier

                        String oaid = supplier.getOAID();
                        Log.d(TAG, "OAID: " + oaid);
                    } else {
                        Log.e(TAG, "OAID not supported on this device");
                    }
                }
            });
        } catch (Exception e) {
            Log.e(TAG, "Error retrieving OAID", e);
        }
    }
}
  • Si no existe ningún otro identificador de dispositivo, entonces puedes proporcionar el ANDI (Android ID).
Cómo recuperar el Android ID (No Google Play)

Cómo recuperar el Android ID (ANDI)

El Android ID es un identificador único de 64 bits generado por el sistema operativo Android cuando se configura un dispositivo por primera vez. Está diseñado para ser persistente durante toda la vida útil del dispositivo, pero se puede restablecer en determinadas condiciones, como un restablecimiento de fábrica.

El Android ID es único para cada dispositivo y, a partir de Android 8.0 (Oreo), tiene un alcance por app y por usuario. Esto significa que diferentes apps en el mismo dispositivo recibirán diferentes Android ID a menos que compartan la misma clave de firma.

El Android ID permanece constante a menos que el dispositivo se someta a un restablecimiento de fábrica o si una app se desinstala y se vuelve a instalar después de una actualización OTA (over-the-air).

JavaKotlin
Uso

Para recuperar el Android ID en una aplicación Android, puede utilizar el siguiente fragmento de código:

import android.provider.Settings;
import android.content.Context;

String androidId = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID);

Identificadores Web Requeridos

  • El SDID es requerido en todas las peticiones S2S
Cómo recuperar el identificador de dispositivo (SDID) de Singular Web SDK

Cómo recuperar el identificador de dispositivo (SDID) de Singular Web SDK

Descripción

Dependencias

Debe tener implementado el SDK de Singular Web.

Uso

Para utilizar este método, simplemente llámelo desde el código de su sitio web después de que Singular SDK se haya inicializado:

window.singularSdk.getSingularDeviceId()

Parámetros necesarios del dispositivo móvil

  • La configuración regional, la marca del dispositivo, el modelo del dispositivo y la construcción son obligatorios en todas las solicitudes S2S.
Cómo recuperar la configuración regional, la marca, el modelo y la compilación del dispositivo

Recuperación de la configuración regional, la marca, el modelo y la compilación del dispositivo

Objective-CSwiftJavaKotlin
#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>
#import <sys/sysctl.h>

// Retrieve the Locale

NSString *retrieveLocale() {
    NSString *locale = [[NSLocale currentLocale] localeIdentifier];
    NSLog(@"Locale: %@", locale);
    return locale;
}

// Retrieve the Manufacturer

NSString *retrieveManufacturer() {
    // Set the Device Make to Apple    

    return @"Apple";
}

                            
// Retrieve the Device Model

NSString *deviceModel() {
    size_t bufferSize = 64;
    char model[bufferSize];
    int status = sysctlbyname("hw.machine", model, &bufferSize, NULL, 0);
    
    if (status == 0) {
        NSString *deviceModel = [NSString stringWithCString:model encoding:NSUTF8StringEncoding];
        NSLog(@"Device Model: %@", deviceModel);
        return deviceModel;
    } else {
        NSLog(@"Unable to retrieve device model.");
        return nil;
    }
}

// Retrieve the Build Version

NSString *buildVersion() {
    size_t bufferSize = 64;
    char build[bufferSize];
    int status = sysctlbyname("kern.osversion", build, &bufferSize, NULL, 0);
    
    if (status == 0) {
        NSString *buildVersion = [NSString stringWithCString:build encoding:NSUTF8StringEncoding];
        NSLog(@"Build Version: %@", buildVersion);
        return buildVersion;
    } else {
        NSLog(@"Unable to retrieve build version.");
        return nil;
    }
}

// Example usage

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // Retrieve Locale

        NSString *locale = retrieveLocale();

        // Retrieve Device Make

        NSString *make = retrieveManufacturer();
              
        // Retrieve Device Model

        NSString *model = deviceModel();
        
        // Retrieve Build Version

        NSString *build = buildVersion();
        
        // Log results

        if (locale) {
            NSLog(@"Locale: %@", locale);
        }
        
        if (make) {
            NSLog(@"Device Make: %@", make);
        }
              
        if (model) {
            NSLog(@"Device Model: %@", model);
        }
        
        if (build) {
            NSLog(@"Build Version: %@", build);
        }
    }
    return 0;
}