Guia de recuperação de dados do dispositivo

Guia de recuperação de dados do dispositivo

A Singular exige que identificadores de dispositivos específicos sejam incluídos em todas as solicitações de API para uma atribuição precisa. Esses identificadores incluem:

  • Google Advertising ID (GAID) e Google App Set ID (ASID) para dispositivos Google Play
  • ID de publicidade da Amazon para dispositivos Amazon que não sejam do Google Play
  • Open Advertising ID (OAID) para dispositivos Android fabricados na China
  • E se nenhuma das opções acima estiver disponível, o Android ID (ANDI) para dispositivos que não sejam do Google Play
  • Identificador para anunciantes (IDFA) e Identificador para fornecedores (IDFV) para dispositivos iOS

A Singular também requer alguns parâmetros do dispositivo móvel:

  • Localidade (por exemplo, en_US)
  • Marca do dispositivo (por exemplo, Samsung)
  • Modelo do dispositivo (por exemplo, iPhone 12, Samsung Galaxy S21)
  • Compilação (por exemplo, Build/13D15)

O Singular fornece exemplos de trechos de código para ajudá-lo a obter esses identificadores, que podem ser encontrados abaixo.

Exemplo de classe de informações do dispositivo

Identificadores

Identificadores iOS necessários

  • O IDFV é necessário em todos os pedidos S2S
  • O IDFA deve ser fornecido se o consentimento de transparência do rastreio da aplicação tiver sido fornecido pelo utilizador.
  • O Estado de Autorização ATT também é necessário.
Como recuperar dados do dispositivo iOS

Recuperar o Identificador para Anunciantes (IDFA)

O Identificador para Anunciantes (IDFA) ajuda os anunciantes a controlar e atribuir acções dos utilizadores (por exemplo, cliques em anúncios, instalações de aplicações) a campanhas específicas, permitindo uma segmentação precisa dos anúncios e a otimização das campanhas.

A partir do iOS 14.5, os utilizadores têm de aderir através da estrutura App Tracking Transparency (ATT) para que as aplicações possam aceder ao seu IDFA. Se os utilizadores não optarem por aderir, o IDFA não estará disponível, limitando as capacidades de rastreio.

Recuperação do identificador para fornecedores (IDFV)

O IDFV (Identifier for Vendors) é um identificador único atribuído pela Apple a um dispositivo, que é específico de um determinado fornecedor ou programador. Permanece consistente em todas as aplicações do mesmo fornecedor num determinado dispositivo, permitindo ao fornecedor seguir o comportamento e as interações do utilizador no seu ecossistema de aplicações sem identificar o utilizador pessoalmente.

  • Certifique-se de que a solicitação ATT é apresentada e tratada antes de tentar aceder ao IDFA.
  • Se estiver a utilizar ATT, capture o IDFA e transmita-o de volta ao seu servidor para utilização em pedidos de API Singular.
  • Capture o IDFV e transmita-o de volta ao seu servidor para utilização em pedidos de API Singular.

Exemplo: Solicitação de status de autorização ATT para recuperar IDFA e IDFV com logs do console

Aqui estão os trechos de código Objective-C e Swift para recuperar o IDFA (Identificador para anunciantes) e o IDFV (Identificador para fornecedor) com logs do console. Este código inclui a manipulação das permissões de App Tracking Transparency (ATT), que são necessárias para aceder ao IDFA a partir do 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: Requer autorização ATT a partir do iOS 14.5+. Sem o consentimento do utilizador, o IDFA devolverá todos os zeros.
  • IDFV: sempre disponível e deve ser sempre fornecido em solicitações de API singulares.

Identificadores Android necessários (dispositivos Google Play)

  • O ASID é necessário em todos os pedidos S2S
  • O AIFA (GAID) deve ser fornecido se estiver disponível.
Como recuperar dados do dispositivo Android (Google Play)

Recuperar o identificador de publicidade do Google (GAID)

O Identificador de publicidade do Google (GAID), também conhecido como AIFA no singular ou ID de publicidade do Android (AAID), é um identificador exclusivo e redefinível pelo utilizador atribuído a dispositivos Android. Ajuda os anunciantes e os programadores de aplicações a rastrear e atribuir acções de utilizadores (por exemplo, cliques em anúncios, instalações de aplicações) em aplicações a campanhas específicas, permitindo uma segmentação precisa de anúncios e a otimização de campanhas, mantendo a privacidade do utilizador.

JavaKotlin
Dependências

Certifique-se de que adicionou a dependência necessária para o Google Play Services no seu ficheiro build.gradle:

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

 

Se a compilação da aplicação tiver como alvo o Android 12/API nível 31 ou superior, adicione permissões no AndroidManifest.xml para aceder ao ID de publicidade do Google:

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

 

Utilização

Para utilizar este método, basta chamá-lo a partir da sua atividade ou classe de aplicação:

AdIdUtils.getGoogleAdId(getApplicationContext());

 

Código Java para recuperar o ID de publicidade do 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();
                }
            }
        });
    }
}

Recuperar a ID do conjunto de aplicações (ASID)

O ID do conjunto de aplicações do Android fornece uma forma de os programadores acompanharem os utilizadores nas suas próprias aplicações de uma forma consciente da privacidade. É particularmente útil para análises e prevenção de fraudes, mas não pode ser utilizado para fins publicitários, como anúncios personalizados ou medições.

JavaKotlin
Dependências

Certifique-se de que adicionou a dependência necessária para o Google Play Services no seu ficheiro build.gradle:

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

 

Utilização

Para utilizar esta função, basta chamá-la a partir da sua atividade ou classe de aplicação:

AppSetIdUtils.getAppSetId(getApplicationContext());

 

Código Java para recuperar o ID do App Set
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 Android necessários (dispositivos que não são do Google Play)

Se não houver ASID ou AIFA disponíveis:

  • O AMID (Amazon Identifier) deve ser fornecido. Apenas dispositivos Amazon.
Como recuperar o ID de publicidade da Amazon (não-Google Play)

Recuperar o Amazon ID (AMID)

Para capturar o identificador de publicidade da Amazon na sua aplicação Android, pode utilizar a classe Settings.Secure para recuperar o identificador e verificar as preferências de monitorização de anúncios do utilizador. Aqui está um exemplo de código simples e limpo com base nas informações fornecidas pela documentação da Amazon:

Certifique-se de que lida com cenários em que o ID de publicidade pode não estar disponível (por exemplo, em dispositivos não Fire OS ou versões mais antigas do Fire OS).

Respeite sempre a preferência do utilizador de Limitar o rastreio de anúncios quando utilizar este identificador para fins publicitários ou analíticos. Este código deve funcionar em dispositivos Amazon Fire com Fire OS 5.1 ou posterior, de acordo com as diretrizes da Amazon

JavaKotlin
Utilização

Pode chamar este método a partir da sua atividade ou serviço, passando o ContentResolver:

// Example usage in an Activity

AdvertisingIdHelper.getAmazonAdvertisingId(getContentResolver());

 

Código Java para recuperar o Amazon Advertising ID (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);
        }
    }
}
  • O OAID (Open Advertising Identifier) deve ser fornecido. Dispositivos domésticos da China.
Como recuperar o Open Advertising ID (não-Google Play)

Recuperar o Open Advertising ID (OAID)

O Open Advertising Identifier (OAID) é um identificador único e anónimo utilizado para fins publicitários em dispositivos Android, especialmente os fabricados na China. Foi introduzido pela Mobile Security Alliance (MSA) como uma alternativa ao GAID (Advertising ID) da Google para dispositivos em que o Google Play Services não está disponível ou não é suportado, como no mercado chinês.

O OAID é utilizado principalmente para atribuição de publicidade e rastreio de utilizadores em ambientes onde o Google Play Services é restrito, permitindo aos anunciantes e programadores rastrear o comportamento dos utilizadores mantendo o anonimato.

O OAID está disponível na maioria dos dispositivos Android fabricados na China, incluindo os de marcas como a Huawei, a Xiaomi e outras. Pode ser acedido através do MSA SDK ou dos Huawei Mobile Services (HMS).

JavaKotlin
Dependências

Certifique-se de que o seu ficheiro build.gradle inclui as dependências necessárias para o SDK MSA.

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

}

 

Código Java para recuperar o 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);
        }
    }
}
  • Se não existir outro identificador de dispositivo, então pode fornecer o ANDI (Android ID).
Como recuperar o Android ID (não-Google Play)

Recuperar o ID do Android (ANDI)

O ID do Android é um identificador único de 64 bits gerado pelo sistema operativo Android quando um dispositivo é configurado pela primeira vez. Foi concebido para ser persistente ao longo da vida útil do dispositivo, mas pode ser reposto em determinadas condições, como uma reposição de fábrica.

O ID Android é único para cada dispositivo e, a partir do Android 8.0 (Oreo), tem um âmbito por aplicação e por utilizador. Isto significa que diferentes aplicações no mesmo dispositivo receberão diferentes IDs Android, a menos que partilhem a mesma chave de assinatura.

O ID Android permanece constante, a menos que o dispositivo seja reiniciado de fábrica ou se uma aplicação for desinstalada e reinstalada após uma atualização OTA (over-the-air).

JavaKotlin
Utilização

Para recuperar o ID Android numa aplicação Android, pode utilizar o seguinte 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 necessários

  • O SDID é necessário em todos os pedidos S2S
Como recuperar o ID do dispositivo (SDID) do Singular Web SDK

Recuperar o ID do dispositivo do Singular Web SDK (SDID)

Descrição

Dependências

É necessário ter o Singular Web SDK implementado.

Utilização

Para utilizar este método, basta chamá-lo a partir do código do seu web site após a inicialização do Singular SDK:

window.singularSdk.getSingularDeviceId()

Parâmetros necessários do dispositivo móvel

  • Locale, Device Make, Device Model e Build são necessários em todas as solicitações S2S
Como recuperar a Localidade, a Marca do Dispositivo, o Modelo e a Construção

Recuperação de Localidade, Marca do Dispositivo, Modelo e Construção

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;
}